PRO-LONG — programmatic memory for long-horizon agent reasoning

Source: arXiv — 2026-07-22

Summary

PRO-LONG is a minimal context-management framework for LLM agents operating in long-horizon, exploratory settings, where sustained perception, reasoning, and exploration break most existing memory schemes. Instead of compressing or embedding past experience, it appends every observation, action, and outcome to a complete interaction log ("write") and retrieves from that log using programmatic, code-based search rather than embedding similarity ("read"), leaning on coding agents' native ability to grep and script over structured history. On the full ARC-AGI-3 public game set, PRO-LONG improves over a base coding agent by an average of 18.0 percentage points across frontier models and matches or exceeds specialized state-of-the-art harnesses (up to 76.1% pass@1) while using 4.2-5.8x fewer tokens.

Key Takeaways

• Core design principle is losslessness: nothing is summarized or compressed at write time, so no heuristic or learned decision about "what's worth keeping" is made upfront — the full log is preserved.
• Retrieval is programmatic (regex/code search over the log) rather than embedding-similarity based, exploiting the fact that modern coding agents are already good at searching structured text and code.
• Evaluated on long-horizon, continual-learning benchmarks including the full ARC-AGI-3 public game set, a domain that stresses memory across many sequential steps rather than single-shot recall.
• Reports up to 76.1% pass@1 while using 4.2-5.8x fewer tokens than specialized harnesses, and 97.4% best@2 with Fable 5 at a reported total cost of $1,750 — suggesting the efficiency gain, not just accuracy, is the headline result.
• Framing context management as three principles (simplicity, losslessness, coding-agent compatibility) positions this as an architecture pattern applicable beyond ARC-AGI-3 to any long-running agent harness.

Reel Script

This item has a diagrammable write/read architecture and benchmark evaluation — likely reel_eligible: true.

Hook

Picture an agent fifty steps into a task. It solved a puzzle piece ten minutes ago, but it can't remember how — because whatever "memory" it had already got summarized into mush. That's the failure mode killing long-horizon agents right now, and a new paper called PRO-LONG has a stupidly simple fix.

Core Concept

Most agent memory systems today work like a lossy notebook — you jot down what happened, then compress it, summarize it, or store it as an embedding so you can "search by meaning" later. The problem is compression throws away exactly the details you'll need three steps down the line. PRO-LONG throws that whole approach out. Think of it less like a diary and more like a server access log: you write down every single observation, every action, every outcome, in full, no summarizing, no filtering. Then, when the agent needs to recall something, it doesn't do a fuzzy "what's semantically similar to this" embedding search. It does what a programmer does — it greps. It writes actual code to query its own history: find the last time I saw this object, filter every action that touched this variable, that kind of thing. Programmatic search over a complete log, instead of vector search over a compressed one. It's a bet that coding agents are already great at searching structured text, so why not just hand them their own memory as structured text.

Hands-On

The architecture is genuinely just two verbs: write and read. Write is dead simple — every observation, action, and outcome the agent produces gets appended to one continuous log, nothing held back, nothing scored for importance. Read is where the trick lives — instead of embedding that log and doing similarity lookup, the agent uses code-based search, essentially treating its own history like a codebase it can query with regex or short scripts. No fine-tuning, no learned retrieval policy, no vector database. They tested this on long-horizon and continual-learning benchmarks, headlined by the full ARC-AGI-3 public game set — a benchmark built specifically to punish agents that can't hold state across dozens of sequential steps. Against a base coding agent, PRO-LONG picked up an average 18 percentage points across frontier models. More striking: it matched or beat specialized state-of-the-art harnesses, hitting up to 76.1% pass at one, while burning four to six times fewer tokens to get there. And with a Fable 5 setup, it reportedly hit 97.4% best-of-two for about $1,750 total. That token efficiency number matters as much as the accuracy — lossless logging sounds expensive until you realize programmatic search means you're not re-feeding the whole log through the model every time.

Takeaway

If you're building anything that needs to remember what it did an hour or a hundred steps ago, stop reaching for embeddings by default — log everything, search it like code, and you may get better recall for a fraction of the tokens. Worth reading if you're designing agent memory this quarter.

Discussion

(No questions yet — ask follow-ups via a Claude Code chat session on this repo; answers get appended here.)