Reasoning Retention and Compaction: The Token Economics Behind OpenAI's ARC-AGI-3 Gain

OpenAI reported that retaining reasoning between turns and compacting context substantially improved GPT-5.6 Sol on ARC-AGI-3 while reducing output-token use. The lesson for coding agents is not that one benchmark setting guarantees savings. It is that session architecture can determine both capability and cost.

Long tasks repeatedly face a choice: resend a growing transcript, discard state, or transform state into a smaller representation. Poor implementations pay twice. They buy tokens to rediscover prior reasoning, then buy more tokens to recover from contradictions. Retention and compaction can preserve useful progress without carrying every word forever.

What the Result Demonstrates

OpenAI's July 29 research summary says two API settings improved GPT-5.6 performance on ARC-AGI-3 by retaining reasoning and enabling compaction. The reported experiment is about a demanding interactive benchmark, so its exact score and token ratio should not be copied into a coding budget.

The transferable mechanism is clearer. Retained reasoning lets a model build on prior work instead of reconstructing it. Compaction prevents the accumulated state from consuming the entire context window. Used together, they can extend the useful life of a session and reduce repeated output.

Model the Break-Even Point

Measure a baseline workflow's input tokens, output tokens, success rate, and number of restarts. Then enable state retention and compaction. Add the tokens used to create compacted state and any quality checks. Savings occur when avoided re-reading, repeated reasoning, and failed restarts cost more than compaction.

For example, a coding task that resends 80,000 input tokens across six turns carries 480,000 tokens of gross context exposure. If compaction reduces the later turns to 30,000 tokens and costs 12,000 output tokens to create, calculate both at their actual rates. Output is often much more expensive, so a smaller token total is not automatically a smaller bill.

Keep Evidence Separate From Conclusions

A dangerous compacted state blends facts, guesses, and abandoned plans into polished prose. Store durable evidence separately: file paths, commit SHAs, failing commands, test output, user constraints, and unresolved questions. Let the compacted narrative reference those records instead of paraphrasing everything.

Use explicit labels such as verified, inferred, attempted, rejected, and pending. When the session resumes, the agent can revisit uncertain items without rerunning proven work. This reduces both hallucination risk and tool cost.

Compact at Stable Boundaries

• After discovery: preserve the root cause, relevant files, and constraints.
• After a patch: record changed files, intended behavior, and unrun gates.
• After verification: keep commands, results, and remaining failures.
• Before handoff: separate completed work from the next atomic action.

Avoid compacting in the middle of an unresolved debugging branch unless the context window demands it. Premature summaries can erase the small contradictions that reveal a root cause. Trigger compaction by stage and context pressure rather than a fixed number of messages.

Evaluate Fidelity, Not Just Compression

Create replay tests with known long-running coding tasks. After compaction, ask the agent to identify constraints, reproduce the current plan, locate evidence, and choose the next safe action. Score omissions and false additions. A compact state that saves 60% of tokens but causes 20% more failed patches is not economical.

Track cost per accepted task, compaction frequency, recovery rate after resume, repeated tool calls, and contradictions with the pre-compaction record. Compare models separately because some use retained state more reliably than others. Version the compaction prompt or schema so regressions can be traced.

Set a Compaction Service Level

Define the maximum state size, time allowed to compact, required fields, and recovery behavior when validation fails. The agent should continue with the original context when safe or pause with a clear error, not discard history silently. Store the source range and compaction version beside the result.

Review compacted state like any derived artifact. Automated checks can require current objective, user constraints, changed files, tests, errors, decisions, and pending work. Periodically compare it with the source session using a separate evaluator and human samples. This assurance has a cost, but it protects the much larger downstream spend of a long autonomous run.

Account for Handoffs

Compaction becomes especially valuable when work moves across agents, machines, or days. A handoff should state capabilities and permissions that may differ in the new environment. Do not carry assumptions that a tool, credential, or network path remains available. Revalidation tokens are cheaper than executing an obsolete plan with stronger permissions.

Bottom Line

Reasoning retention and compaction are economic controls for long-horizon agents, not mere context-window tricks. Preserve evidence, compact at stable boundaries, and price input and output separately. Adopt the pattern when it lowers cost per successful task while maintaining state fidelity.