The one framework that lets AI agents remember what they did 47 steps ago

The standard way to build an AI agent is to give it a prompt, a tool set, and a running transcript of everything it has done so far. That transcript grows with every step, and eventually the model either forgets what it read early on or wastes tokens re-reading the whole thing. It is a problem the ARC-AGI-3 benchmark exposes ruthlessly: models that ace isolated puzzles fall apart when the puzzles chain together across dozens of steps. The same pattern shows up in office-work agents, where a 15-step spreadsheet task collapses if the assistant cannot recall the column headers it parsed at step 2, according to a separate analysis of agent working memory.

The context wall

Existing agent harnesses deal with this by compressing or pruning the history. Summarize older turns. Drop the ones that look irrelevant. The problem is that a detail that seems useless at step 12 can be critical at step 47, and once it is gone the agent cannot recover it. The tradeoff is baked in: preserve more context and retrieval gets expensive; preserve less and the agent works blind. As a harness-focused benchmark recently demonstrated, the failure mode is often the scaffolding, not the brain.

PRO-LONG, introduced in a July 2026 arXiv preprint, takes a different approach. Instead of deciding what to keep, it keeps everything, but structures the log as a searchable interaction record and leans on a code-generation model to query it programmatically. The idea is that recent improvements in code agents make the search step cheap enough that you do not need to prune the history at all.

How it works

The framework does not alter the underlying LLM. It wraps it with two pieces: a structured logger that writes every observation and action into a versioned, JSON-like store, and a retrieval module that, when the agent needs to refer to past context, generates a Python snippet to filter, join, or aggregate the stored log. Because the log is complete and machine-readable, the retrieval can be precise: the agent asks for "the third grid state from the puzzle I was solving two steps ago" and gets exactly that, not a fuzzy summary. The LiveBench leaderboard suggests that even across closely matched frontier models, the cost of running them at long context is brutal, so every token saved matters.

The authors tested the setup on the full public ARC-AGI-3 game set, which runs 200 training puzzles that require pattern extraction, rule induction, and multi-step transformation. They compared a coding agent running with and without PRO-LONG across four frontier model families: GPT-4o, Claude 4 Sonnet, Gemini 2.5 Pro, and Fable 5 (an Anthropic model version not yet publicly detailed at time of writing).

The numbers

The average improvement was 18.0 percentage points in pass@1 across models. The best single result came with Fable 5: a best@2 score of 97.4%, achieved at a total inference cost of $1,750. Against state-of-the-art specialized harnesses that are hand-tuned for ARC, PRO-LONG matched or exceeded their pass@1 (up to 76.1%) while consuming 4.2 to 5.8 times fewer tokens per run. A separate study on AI inference economics argues that such cost differences can rewrite the entire unit economics of a model deployment.

Those token savings matter because token cost is the practical ceiling on how long a run a lab can afford. If a harness burns through $50 per episode on a frontier model, systematic testing stays out of reach. PRO-LONG's efficiency comes from offloading the retrieval work to a cheap code-generation call rather than passing the entire history back into the expensive reasoning model.

What this means for agent design

PRO-LONG is not a new model. It is a scaffolding trick that exploits the fact that coding models are now good enough to write a SQL-like query over their own memory. The implication is that the bottleneck in long-horizon agents may not be model capability but context management strategy.

That lines up with findings elsewhere. The structured state plus verifier workflow proposed in the StructAgent paper shares PRO-LONG's diagnosis: do not let history decay passively; make it queryable. And a game-engine-style state tracking approach makes a similar case for treating agent memory as an explicit, searchable structure rather than a streaming transcript.

Caveats

The PRO-LONG result is strong on ARC-AGI-3, which is a puzzle benchmark. Whether the same approach holds up on open-ended code generation, multi-turn web navigation, or long-document analysis is an open question. The authors released code and logs with the paper, which should help others test the portability claim quickly.

A second caveat is that the framework leans on the model's code-generation ability. On models that are weak at writing correct Python, smaller open-weight models, for instance, the retrieval step itself could fail. The paper tested only frontier-class models.

Still, the framing is provocative. If the cheapest path to better agents is better memory management rather than bigger models, then a lot of the field's current direction (train longer, scale harder) may be optimized for the wrong thing. PRO-LONG is one data point in that argument, and it is a strong one.