Daily digest

An external controller cuts coding-agent tokens by up to 31% across Claude Code, Codex and Copilot CLI

Oct 19, 2026 · 🎧 13 min

agentic codingevalsmulti agent orchestrationagent reliabilitysemantic governance

TokenEconomizer cut coding-agent token cost 18.4 to 30.9% by injecting micro-skills, pruning idle tools and breaking failure loops, while DeskCheck's mandatory code-reasoning phases raised SWE-bench Pro resolution 6.29 to 10.53% for $0.14 an instance. Self-HPO co-evolves harness and policy and Doc2Harness finds the best of 19 models builds a harness that passes only 53.05% of tests; on the multi-agent side, broken coordination mechanisms often still produce correct answers, Annotrace makes step-level trace labeling reusable, and AgentOnto writes confirmed feedback back into an enterprise ontology.

Highlights

  • TokenEconomizer cut average token cost 18.4 to 30.9% across Claude Code, Codex and Copilot CLI with comparable task success, and the savings held in every repository tested.
  • DeskCheck beat mini-SWE-agent and Claude Code by 6.29 to 10.53% on 731 SWE-bench Pro instances at $0.14 extra per instance, with McNemar p < 1e-10 for every model.
  • Self-HPO lifted Qwen3.5-35B-A3B from 57.8% to 64.8% average resolve rate; on Doc2Harness the best of 19 models built a harness passing only 53.05% of 328 tests.
  • Multi-agent systems with deliberately broken mechanisms often still answered correctly, and a near-perfect diagnoser degraded on an independently built workflow.
  • Annotrace reproduced a prior manual effort's 235 annotation units exactly; AgentOnto writes confirmed feedback into an enterprise ontology but reports no figures in its abstract.

An external controller sitting outside the agent cut average token cost by 18.4 to 30.9 percent across Claude Code, Codex and GitHub Copilot CLI, with comparable task success, and it never touched a model weight. That result, from TokenEconomizer (Li, Xu, Singh, Stoica, Galley, Gao and colleagues), arrived in the last day alongside three other papers that treat the harness around a coding model as the thing to measure and change.

The setup is the useful part. Most token-efficiency numbers come from isolated tasks, while developers run agents over long sequences of work in one repository, and in that setting the authors find agents paying the same environment-dependent costs over and over. TokenEconomizer learns from the sequence and makes three kinds of decision: which operational micro-skills to inject, which persistently irrelevant tools to prune from the menu, and when to intervene in an unproductive failure loop. Savings held in every repository under every agent-model pairing tested, and carried over to sequential web development and security auditing at 6.4 to 21.2 percent depending on task structure. The question for anyone running agents at volume is how the savings split across those three levers, since tool pruning is the one a team could approximate by hand with a static allowlist.

Enforcing Code Reasoning in Agentic Scaffold (Liu, Kim, Ghazanfari, Nallu and Jabbarvand) goes after accuracy instead. It starts from 7,955 issue-resolution trajectories across six single- and multi-agent scaffolds, four languages and three SWE-bench variants. Agents reasoned about code in 66.95 percent of trajectories, in 12 distinct forms, and more reasoning went with higher resolution, but nothing guided it: localization chased surface symptoms, near-correct patches went unrefined, issue requirements were skipped and generated tests lacked behavioral diversity. Their scaffold, DeskCheck, makes that reasoning a required step in each phase, simulating execution paths to localize root causes, simulating candidate patches to repair near-misses, auditing each patch against the issue, and working out corner-case inputs and expected outputs before writing tests. On 731 SWE-bench Pro instances it beats mini-SWE-agent and Claude Code by 6.29 to 10.53 percent at an average added cost of $0.14 per instance, with exact McNemar tests at p < 10⁻¹⁰ for every subject model and repeated runs to rule out nondeterminism. That level of statistical reporting is rare in coding-agent papers, and it is the main reason to take the gain at face value.

Two more papers turn the harness from fixed infrastructure into something optimized or built. Self-HPO (Wei, Yao, Peng, Wang, Wu, Cheng, Meng and Gao) starts from a problem anyone who has carried an agent setup across model upgrades will recognize: a harness tuned for one checkpoint misses the failure modes of the next, and RL on the policy only sees trajectories the fixed harness happens to elicit. So it alternates. The current policy reads its own failures and proposes harness candidates, RL updates the policy under the selected harness, and the hard tasks from training become the next round’s harness search set. Across three coding benchmarks Qwen3.5-35B-A3B’s average resolve rate rose from 57.8 to 64.8 percent, ahead of harness-only and policy-only baselines, and the joint gain exceeded the sum of the individual ones. Each optimized component kept its gain when paired with the other’s base version, so the evolved harness is usable without running any RL, and swapping in Opus 4.8 as the harness proposer added a further boost.

Doc2Harness (Ge, Liu and colleagues, Institute of Computing Technology, Chinese Academy of Sciences) asks whether a model can write the harness at all. A build model working inside OpenCode gets an interface-only contract skeleton and a development document consolidating the behavior of twelve frontier harnesses, and must produce a complete harness in an isolated container. The frozen result then runs 328 test cases, each in its own container and driven by a scripted mock model, scored on what is observable from outside: requests sent to the model, files on disk, exit code and command output, with positive controls against vacuous passes. Across nineteen frontier models with three builds each, GPT-6 Astra leads at 53.05 percent and the weakest model reaches 27.44, and the failures cluster where functionality cuts across modules, in categories such as session state, permissions and headless operation. One design choice deserves copying: OpenCode is the builder because Claude Code and Codex CLI are co-developed with their vendors’ models and could tilt results toward those families, a confound most harness comparisons never report.

On the multi-agent side, the sharpest result of the day is that a correct answer says little about whether the system worked. Where Do Multi-Agent Systems Fail? (Zhengye Han, revised version in today’s feed) defines a diagnostic contract for collective mechanisms, the rules for how agents route, admit, store and act on shared information. The contract separates what counts as a violation from which execution records can establish one and returns supported, ruled out or unknown; removing records can push a verdict to unknown but never reverse it. Replaying executions from the step where a mechanism acts, once intact, once broken and once restored, the author found that broken mechanisms often left the final answer correct. An LLM diagnoser caught many more violations from internal records than from public outputs, and with identical records a generic prompt often claimed certainty the records did not support, which prompts stating the contracts largely avoided. The transfer result is the warning label: a diagnoser that was nearly perfect on the paper’s own benchmark degraded on an independently developed workflow.

That analysis assumes someone has the records and can label them, which is the gap Annotrace (Arokiaraj, Huang, Bulathwela, Wu and Wu) targets. It reads six trace formats, including OpenTelemetry GenAI, LangSmith and Langfuse, and turns each run into an ordered, nested list of steps where delegations and tool calls are labelable units. The annotator writes the codebook, a frontier model proposes a starting set from a sample of the annotator’s own traces, and the model answers each labeling question first, asked exactly what the human is asked. On a multi-agent QA corpus it reproduced a previous manual effort’s 235 annotation units exactly, and two models labeling the same traces agreed 91 percent of the time at κ = 0.82. Model-model agreement can run high when two models share blind spots, so the number to ask for next is human-model agreement on traces the proposing model never saw.

For semantic governance, AgentOnto (Pan, Zuo, Wang, Zhang and Wang) is a direct charter hit. It organizes knowledge scattered across databases, business documents and prior example tasks into an ontology, uses that ontology to guide analysis, and writes confirmed feedback back into it, so a correction lands in the organization’s represented meaning rather than in one session. An Iterative Ontology Preparation stage has the agent generate its own analysis tasks to find and fill gaps before users arrive. The abstract claims the system substantially outperforms representative methods on two public data sources and describes a real deployment, but it gives no figures. When the full text lands, the things to check are which baselines it beat, whether those baselines saw the same business documents, and whether anyone measured drift or conflicting definitions as feedback accumulates in the ontology.

What to watch: whether TokenEconomizer’s ablations show tool pruning carrying most of the savings, and whether someone runs DeskCheck’s mandatory reasoning phases inside a Self-HPO loop, where the policy would get to decide which of those phases it still needs as it improves.

Feed note: the code-intel mirror’s status endpoint reported its last sync as 2026-09-01, yet the feed carried items ingested through the morning of 2026-10-19; the status timestamp appears stale rather than the data.

In this issue

← All digests