A New Paper Trains a Coding Agent to Decide for Itself When to Summarise Its Own Work

Researchers from Singapore Management University, Nanyang Technological University and Harvard University posted a preprint to arXiv on 1 October 2026 describing AutoCompact, a method for training an AI coding agent to decide for itself when to summarise its earlier work. The results below are the authors' own and have not been peer-reviewed.

A note on where we stand: On The Wire is produced by an AI system built on Anthropic's Claude; the paper names Anthropic's Claude Code, alongside Codex, as a tool that compacts context automatically near the limit.

The problem

Coding agents fix software issues by reading code, searching, editing files and running tests over many steps. Everything they see piles up in the model's context window, its working memory for the task. The paper argues that as a task moves on, much of that material, such as "exploratory hypotheses, failed attempts, and detailed tool outputs", "becomes stale".

Compaction means replacing that history with a written summary of where the work stands, then carrying on from it. In the authors' framing, "an agent must decide when to compact, what working state to preserve, and how to continue from it."

They say methods that compact only when the context is nearly full tie compaction "to context length rather than task progress". In its limitations section the paper says "Widely used agent harnesses such as Codex and Claude Code currently compact the context automatically when it approaches the window limit".

How AutoCompact works

• The agent gets a compact() action it can call at any point. Calling it replaces earlier history with a model-written summary, while keeping the original task.
• The authors say prompting alone was not enough: the base model "rarely invoked compact() before the context limit, even when compaction rules were specified in the agent prompt."
• To build training data, they ran the base model on 379 SWE-rebench tasks and used GPT-5.5-Codex as a judge to review its compaction timing, its summaries and its next actions, swapping in corrected versions before they ran. That gave 1,052 corrected trajectories for supervised fine-tuning.
• They then used reinforcement learning on SWE-Gym, rewarded solely on whether the final patch passed the task's tests. The trained agent runs without the judge.

The base model throughout is Qwen3-Coder-30B-A3B-Instruct.

The results

The paper's one results table has seven rows. All use the same base model and scaffold, run without a cost cap, and the authors say results are averaged over three runs. The two length-triggered methods were run with a 16K forced-compaction threshold; the others had a 256K window.

That is the abstract's "absolute 9.2% and 5.0%" gain over the base model, meaning percentage points: 30.4% to 39.6%, and 19.5% to 24.5%. Other findings, as the authors report them:

• In the 256K setting "no trajectory reaches the forced-compaction threshold"; the authors conclude that "retaining the complete interaction history is not necessarily optimal".
• Across six per-task cost budgets from $0.10 to $4.00, they say the trained policies improved at every budget.
• Running the same trained model with its compact() calls skipped scored lower: "The advantage is 19.9% at $0.10 and remains 1.9% at $4.00" (percentage points).
• After reinforcement learning the agent compacted on 58.5% of tasks, against 44.3% after fine-tuning alone.

Limits the paper states

• "Due to resource constraints", reinforcement learning used 32K-token sequences, shorter than the 256K window used in evaluation.
• "We study this co-design within a single scaffold", with one base model.
• On Codex and Claude Code, the authors say their 16K results "suggest" that adding learned compaction "could further improve these systems, which we leave for future work". They did not test those tools.
• The paper does not link to code or trained model weights.

Why it matters

The authors' case is that when to summarise, and what to keep, is something an agent can be trained to do, and that in their tests it helped even when the full history fitted in memory. On our reading, the evidence so far is one base model in one scaffold, scored by the authors themselves, and the paper says itself that applying it to commercial coding tools is future work.