CTXAgent lets frontier models manage their own context and matches Claude Code success at far lower cost

Compaction used to be a harness dial: cross a token threshold, summarise, continue. CTXAgent hands the dial to the model.

Busch and colleagues posted arXiv:2610.34425 with a prompt-only design: two tools, one paragraph of guidance, seven frontier models, and long mixed sessions that look like a user chaining different jobs in one chat. The result that travels is that the strongest models can own when to compact and what to keep, and that self-management can match a production coding harness on success while cutting spend.

Frontier's reading after Compact-Bench is that retention loss and policy ownership are different levers. CTXAgent only earns a desk slot if the model can set the second lever without burning the first.

Two tools and a paragraph replace a fixed compaction threshold

CTXAgent exposes compact_context and curate_context. The model decides when to call them, what to retain, and what to write as the hand-off. Guidance is a single paragraph rather than a heavy controller policy. Sessions interleave coding exercises, multi-step SciCode problems, and SWE-bench Pro and Terminal-Bench 4.0 tasks with planted facts, ephemeral observations, and standing instructions, all checked deterministically, across 35 to 212 turns.

The comparison runs each model with and without the context tools under identical conditions, then puts the self-managed harness beside three widely used harnesses on two of the models. For Claude Opus 5.5, self-managed context matches Claude Code on task success at 34% lower cost than Claude Code's explicit 200k-window configuration and 49% lower than its default, with no fixed window for operators to pick.

Compact-Bench measured retention loss; CTXAgent asks who sets the policy

Earlier work showed that open-weight models struggled to manage their own context without scaffolding. Compact-Bench and related retention studies asked how much detail summarisers keep. CTXAgent flips the question: once frontier models are strong enough, can the model itself choose compaction policy inside a thin harness?

That question lands as coding agents push sessions past hundred-thousand-token live contexts and as teams pay for oversized windows "just in case." A harness that keeps live context mostly under 100k without a large score drop changes the cost conversation from window shopping to tool design.

Preprint plus agent, benchmark, and result rows on GitHub

Paper: arXiv:2610.34425, Busch et al. Evaluation covers seven frontier models on the mixed long-session benchmark. Strong models compact and curate regularly; live context on the mixed sessions stays mostly below 100k tokens; benchmark scores mostly hold. Cost reduction is substantial and model-dependent, because some models compact so often that other costs rise.

Release artefacts include the agent, the benchmark, and all result rows on the paper's public repository. Treat this as a research harness and reproduction pack, and read licence terms from that repository. This line of work is distinct from Compact-Bench's retention protocol: Compact-Bench scores what a summary keeps; CTXAgent scores whether the model can own the compaction decision.

Reach for self-managed context when strong models already carry the session

Pick CTXAgent-style tools when you run long multi-task chats on models that already compact usefully in the paper's class, and when window configuration or default harness cost is the pain. Opus 5.5 is the clearest published win against Claude Code on the authors' success-and-cost comparison.

Stay on fixed thresholds or mechanical extraction when you are on weaker compactors. Sol manages context yet can over-summarise. Haiku and Muse Wonder fail to compact usefully in the reported runs. If your incident class is lost paths and SHAs after summarisation, pair any self-managed policy with Compact-Bench-style retention checks rather than trusting token curves alone.

Teams already paying for a default large window should treat the Opus 5.5 rows as a reason to A/B self-managed tools against their current Claude Code configuration, with success and dollar cost on the same scorecard.

Weak compactors and over-eager summarisers still break the bet

Self-management assumes the model will call the tools at useful times and write hand-offs that preserve task state. Models that rarely compact, or that compact into vague summaries, recreate the retention failures Compact-Bench measured. Over-frequent compaction can erase the cost win even when scores look fine.

Absolute cost deltas are tied to the authors' pricing assumptions, harness baselines, and mixed-session mix. A production stack with different tool taxonomies, cache behaviour, or task length needs its own rows. Planted-fact checks catch some silent drops; they do not cover every buyer workflow.

Start from the arXiv protocol, then clone the public rows

Operators who want the self-managed cost claim should read the paper's Opus 5.5 versus Claude Code comparison, then reproduce with the released agent and result tables before changing a production window default. Retention-sensitive teams should keep Compact-Bench on the same desk: one paper answers who decides; the other answers what survives the cut.