HarnessMM: Recursive Self-Improvement for Harness Token Efficiency

Abstract: Agent harnesses repeatedly invoke reasoning after tool feedback, even when an earlier call has already fixed the next action. We introduce HarnessMM (Harness Minus Minus), a method for improving harness token efficiency through guarded decision reuse and recursive self-improvement (RSI). RSI iteratively refines companion harness configurations from training feedback, with validation selecting the configuration for deployment. A controller at the model-tool boundary reuses resolved decisions to replace later reasoning callbacks while actor weights remain fixed. Executable Decision Graphs store exact actions, literal arguments, causal dependencies, and public guards. Guarded Decision Reuse activates these persistent decisions from observed receipts; Certified Callback Substitution executes them through the native interface and records removal of the registered slow callback. New semantic decisions, unsupported evidence, and selector abstention invoke the original actor again. The representation restricts what feedback may change, while complete-task measurements establish quality and cost. On HumanEval, HarnessMM preserves Codex success at 90.82\% while reducing Tokens/task (k) from 66.72 to 47.02 (29.54\% saving). For DeepSeek Harness, success rises from 71.43\% to 85.71\% while Tokens/task (k) fall from 96.28 to 11.62 (87.93\% saving). A separate MBPP ablation measures 26.91\% lower cost than single-use graphs and 19.52\% lower cost than retained callbacks. These results establish guarded decision reuse as a practical way to reduce repeated reasoning in existing harnesses.

• HarnessMM, a recursive self-improvement mechanism, targets token inefficiency by treating reasoned actions as executable commitments, eliminating repeated reasoning calls. It is optimized for token efficiency across a complete task population, including failed workflows.
• HarnessMM's architecture includes three key components: executable decision graphs, guarded decision reuse, and certified callback substitution, enabling reconstruction of arguments without altering executions semantics. The Exit of Replaced reasoning calls are certified,

The paper studies a specific source of inefficiency in tool-using agents: repeated invocation of a reasoning model after tool feedback even when a previous reasoning call has already determined the next action. “HarnessMM: Recursive Self-Improvement for Harness Token Efficiency” (2610.32813) proposes to treat such actions as persistent, executable commitments rather than regenerating them at every reasoning boundary. The central claim is that token efficiency can be improved without changing actor weights, tools, task interfaces, or native execution semantics, provided that the harness can distinguish unresolved semantic decisions from resolved actions whose readiness depends only on subsequently observed public feedback.

Problem formulation and central claim

The paper frames harness optimization as a constrained computation-substitution problem. Let the original harness invoke a fixed actor and tool interface over a task execution graph. HarnessMM modifies the execution policy so that some reasoning nodes are not invoked when a previously authored action can be safely reused. The optimization target is complete episode cost, including input and output tokens for authorship, routing, selectors, fallback, recovery, finalization, failed calls, and shared authoring. This accounting is important because a short selector or fast path does not provide a saving unless the computation it introduces is smaller than the reasoning callback it removes.

The paper calls this accounting issue the “Substitution Paradox.” A fast decision mechanism can increase cost if it is appended to the original reasoning path rather than substituting for it. Consequently, the claimed efficiency gain requires both a capability constraint and actual callback elimination. Quality is evaluated on the complete task population, including unsuccessful tasks, while cost is measured over the same population. This avoids attributing savings only to successful trajectories or to a subset of locally favorable substitutions.

The method therefore makes a relatively narrow claim. It does not assert that arbitrary future actions can be predicted from earlier reasoning, nor that a guard certifies task correctness. Instead, it assumes that a previous actor call can sometimes produce an action whose literal arguments and semantic role are already resolved, while later observations determine only whether the action is ready.

HarnessMM architecture

HarnessMM consists of three principal components: Executable Decision Graphs, Guarded Decision Reuse, and Certified Callback Substitution. Recursive self-improvement supplies an offline procedure for refining the surrounding harness configuration, but it is distinct from the online execution mechanism.

Executable Decision Graphs

An Executable Decision Graph (EDG) is an acyclic continuation authored by a slow reasoning call. Each node stores a native action, complete literal arguments, predecessor dependencies, and a public execution guard. For a coding task, a single actor call might specify a file-writing operation, a compilation command, and a test command. The tool receipt after compilation determines whether the test command is admissible, but it need not cause the actor to regenerate the test command and its arguments.

This representation imposes a structural separation between action semantics and execution readiness. Literal closure is enforced syntactically: the selector cannot fill in missing arguments or construct a new command. Semantic closure is an assumption about the authoring call and the adapter: the authored action must remain appropriate whenever its public guard passes. The paper explicitly acknowledges that a passing guard proves only the declared public condition, not general task correctness.

Guarded Decision Reuse

Guarded Decision Reuse (GDR) retains an EDG across tool transitions. After each receipt, the controller updates predecessor completion and evaluates public guards. A node is eligible only when its predecessor is complete, its guard is true, and its arguments are closed. Unsupported observations, unmet dependencies, ambiguous states, or arguments requiring new inference cause the controller to defer to the original actor.

The selector is constrained to return an eligible node identifier or abstain. It cannot revise arguments, invent actions, or reinterpret the graph. When there is exactly one eligible node, execution can be deterministic and incur no selector-model tokens. When multiple nodes are eligible, a typed selector may choose among them. Abstention and empty candidate sets preserve the original slow path.

This design makes reuse conservative by construction. Feedback is used to activate an existing commitment, not to generate a new semantic decision. The distinction is central to the paper’s safety and attribution arguments: the controller can guarantee that it executed an authored action under a declared public condition, but it cannot guarantee that the authored action was substantively correct.

Certified Callback Substitution

Certified Callback Substitution (CCS) is the mechanism that turns reuse into an actual efficiency intervention. At a registered reasoning boundary, the controller dispatches the stored action through the original native interface and omits the corresponding slow callback. The substitution certificate binds the graph hash, decision identifier, predecessor receipt, exact arguments, tool receipt, and the identifier of the bypassed callback.

The certificate is not a correctness proof. It verifies that the native action was executed with the authored arguments and that the registered callback was absent from the physical request sequence. Task scoring separately determines whether this substitution helped or harmed the task. This separation is methodologically sound: execution omission is an observable structural property, whereas the quality of the counterfactual reasoning call is unavailable because it was never made.

Recursive self-improvement

Recursive self-improvement (RSI) operates offline over harness configurations. A current harness produces training feedback, candidate edits are proposed, disjoint validation selects a candidate, and the selected harness is frozen before test evaluation. The search can modify author prompts, context handling, adapter rules, and related configuration, but actor weights, tools, task interfaces, evaluators, and deployment limits remain fixed.

The paper carefully separates RSI from runtime decision reuse. RSI determines the configuration that will be deployed; GDR and CCS determine, within an episode, whether an authored decision can replace a future actor callback. This distinction matters because some reported benchmark gains combine multiple interventions, including prompt changes, context compaction, finalization changes, and executable reuse. The MBPP ablations are consequently more informative for attributing the core mechanism than the integrated harness comparisons.

The visual RSI study on MiniWoB++ provides a direct illustration of iterative harness development.

Figure 1: Eight training-guided HarnessMM RSI iterations on MiniWoB++, showing increasing success and decreasing complete episode token cost under persistent decision reuse.

Across eight iterations on the same 32 training tasks, HarnessMM success increases from 34.38% to 90.63%, while Tokens/task decreases from 3.26k to 1.06k. At iteration eight, both the single-use and persistent-reuse arms solve 29 of 32 tasks, but persistent reuse reduces cost from 1.51k to 1.06k tokens per task, a 29.83% saving. Calls per task fall from 1.47 to 1.03, with 16 second-or-later executions occurring inside retained graphs. These results demonstrate iterative improvement of a fixed execution contract, although they are training-task measurements rather than held-out test results.

Experimental design and accounting

The experiments compare HarnessMM against native Codex and DeepSeek Harness configurations, as well as against targeted ablations. The principal coding comparisons use the same task sets, backbone, tools, evaluator, task limits, and complete-task accounting within each harness pair. HumanEval uses all 98 test tasks, and MBPP-sanitized uses all 257 test tasks.

The paper distinguishes three kinds of evidence:

1. Integrated harness comparisons measure the quality and cost of a deployed HarnessMM configuration relative to its native parent.
2. Mechanism ablations vary graph persistence and callback substitution while holding the coding execution environment fixed.
3. Certificates and request ledgers verify that stored actions were executed natively and that specified reasoning callbacks were omitted.

This separation is necessary because reduced total model-call counts in an integrated comparison need not equal the number of certified substitutions. Context management, fallback behavior, finalization, and changes in trajectory can also alter the number of physical requests.

Main coding results

The strongest results concern HumanEval and MBPP-sanitized. They show substantial token reductions, but the quality effects differ by harness and model.

Benchmark and harness	Success baseline	Success with HarnessMM	Tokens/task baseline	Tokens/task with HarnessMM	Token change
HumanEval, Codex	90.82%	90.82%	66.72k	47.02k	−29.54%
HumanEval, DeepSeek Harness	71.43%	85.71%	96.28k	11.62k	−87.93%
MBPP-sanitized, Codex	91.83%	90.66%	129.55k	49.22k	−61.99%
MBPP-sanitized, DeepSeek Harness	90.27%	91.83%	53.98k	10.61k	−80.35%

The Codex HumanEval result satisfies the paper’s zero-regret objective at the observed population level: success remains 90.82% while token use falls by 19.70k per task. The DeepSeek Harness result is more pronounced and contradictory in the relevant sense: HarnessMM both reduces cost by 87.93% and raises success by 14.28 percentage points. Paired outcomes contain 22 improvements, eight regressions, and 68 unchanged tasks; the reported exact McNemar test gives $p=0.0161$. This establishes a statistically detectable paired difference for that comparison, although it does not by itself identify which component of the integrated configuration caused the quality increase.

The MBPP results show that the effect is not limited to HumanEval. DeepSeek Harness improves from 90.27% to 91.83% while reducing cost by 80.35%. Codex loses 1.17 percentage points while reducing cost by 61.99%, demonstrating that substantial efficiency gains do not guarantee zero quality regret across all actor-harness combinations.

The paper also reports a separate MiMo-v2.6-pro evaluation. On HumanEval, DeepSeek Harness improves from 96.94% to 97.96% while reducing cost from 11.62k to 4.40k tokens per task, a 62.12% saving. Codex improves from 93.88% to 94.90% while reducing cost from 62.60k to 10.09k. On MBPP-sanitized, Codex changes from 96.50% to 97.28% at 47.56k versus 11.00k tokens, while DeepSeek Harness changes from 97.67% to 98.05% at 6.20k versus 5.11k. These results suggest that the substitution mechanism can remain useful when the underlying actor is already substantially more capable, although the relative saving is smaller when the parent harness is already efficient.

The integrated coding comparison is summarized visually below.

Figure 2: HarnessMM quality and token-cost comparisons across native harnesses and selected benchmark configurations; lower token cost is obtained without uniformly sacrificing task success.

Mechanism attribution through MBPP ablations

The most direct test of GDR and CCS is the MBPP-sanitized ablation with 257 test tasks. Full HarnessMM is compared with single-use EDGs, retained callbacks, and disabled EDG execution.

Condition	Success	Tokens/task	Certified bypasses
Full HarnessMM	93.77%	13.17k	407
Without GDR: single-use EDG	93.00%	18.03k	212
Without CCS: callbacks retained	93.39%	16.37k	0
Without EDG execution	95.33%	16.19k	0

Persistent reuse is the clearest isolated effect. Relative to single-use graphs, GDR lowers cost by 26.91% and increases success by 0.78 percentage points. The adjusted bootstrap interval for cost savings is reported as $[4.01,45.57]\%$, while the correctness interval includes zero. Thus, the evidence supports a robust cost advantage for persistence in this experiment, but not a statistically established quality advantage.

CCS also matters. Retaining callbacks while preserving graph execution increases cost from 13.17k to 16.37k tokens per task, corresponding to a 19.52% saving for full HarnessMM. The full system solves one additional task in this comparison. However, the reported cost interval includes zero, so the paper appropriately treats the measured callback-removal advantage as supportive but less statistically decisive than the GDR contrast.

Disabling EDG execution yields the highest observed success, 95.33%, at 16.19k tokens per task. Full HarnessMM is therefore 18.62% cheaper but solves four fewer tasks. This result is important because it prevents an overly strong interpretation of the method: the lowest-cost configuration is not uniformly best on quality, and the quality-cost trade-off can favor a slower non-executing control on a finite benchmark.

The ablation also provides concrete reuse coverage. Full HarnessMM performs 407 certified bypasses, including repeated bypasses in 201 graphs. The single-use control performs 212 bypasses and discards the remaining graph after its first execution. The difference directly operationalizes the paper’s claim that retaining a graph across multiple feedback transitions is necessary for sustained savings.

Broader benchmark evidence

The paper includes companion studies on ALFWorld, SearchQA, LiveMath, AIME, Terminal-Bench 2, and GAIA2. These results should not be interpreted as homogeneous evidence for the same mechanism because the adapters and surrounding configurations differ.

On ALFWorld, HarnessMM’s selected instruction configuration reaches 66.20% success at 31.12k tokens per task, compared with 63.29% at 101.33k for SkillOpt and 61.74% at 40.30k for AutoSaddler. The paper’s instruction ablations show that task-family guidance is the dominant component: removing it reduces success to 49.21% while increasing cost to 38.94k. These are instruction-content results under a common actor, not independent demonstrations of EDG persistence.

On SearchQA, HarnessMM reaches 76.76% exact match at 0.99k tokens per task on the stated validation population. It saves 19.08% relative to No Skill, with a reported paired 95% interval of $[16.57,21.23]\%$. The improvement is obtained through a terminal-answer adapter involving source selection, draft generation, acceptance checks, and paid fallback rather than the multi-action coding graph. It therefore supports the broader commit-or-defer interface, but not the specific causal contribution of persistent executable action graphs.

AIME reveals a negative cost case. HarnessMM reaches 87.14% accuracy, close to No Skill at 86.96%, but costs 5.90k tokens per task, above No Skill’s 4.59k and AutoSaddler’s 4.90k. Shared authorship contributes 1.08k tokens per task, and output savings do not offset additional input and authoring cost. This result directly validates the Substitution Paradox: a method that reduces some generated reasoning can still be more expensive when the workload has few reusable action transitions.

On GAIA2, HarnessMM reaches 43.96% success at 639.64k tokens per task, versus 42.71% and 730.22k for No Skill. The 12.41% cost reduction is accompanied by a 1.25-point success increase, but 99.47% of HarnessMM actor cost is input. Only 146 verified fast executions occur among 10,424 native action attempts. The result therefore measures a combined configuration involving literal banks and context handling, and does not isolate fast execution from input-context reduction.

The paper also reports negative or incomplete cases. On Terminal-Bench development snapshots, token reductions are accompanied by quality declines. A CoT/Jev-style configuration executes fast actions in most episodes but costs more than the original harness and loses success. These cases reinforce the paper’s requirement that callback substitution, not merely fast-path activation, must be evaluated with complete accounting.

Limitations and open questions

The method depends on a task-specific public-state adapter, a native callback boundary, a serialization scheme for literal actions, and guards that sufficiently characterize readiness. The paper does not provide a general procedure for discovering semantically valid guards. Its key implication, $$\operatorname{eligible}(d,s) \Rightarrow \operatorname{valid}(d,s)$$, remains an adapter-dependent assumption evaluated indirectly through benchmark performance.

The actor’s earlier decision can also be wrong even when all structural checks pass. Certificates establish exact execution and callback omission, not semantic correctness, safety, or equivalence to the omitted reasoning trajectory. The system therefore preserves a fallback to slow reasoning for unsupported evidence, abstention, unmet dependencies, and new semantic decisions, but the quality of this defer policy is task dependent.

The integrated comparisons combine EDG reuse with context management, author-prompt changes, finalization rules, and harness-specific configuration. The MBPP ablation improves causal attribution, but it still does not isolate every implementation detail, including certificate overhead and selector behavior. Several benchmark results are single-seed or one-execution-per-task measurements, and the paper notes runtime nondeterminism, provider accounting assumptions, incomplete historical cost records, and previously exposed public data in some companion studies.

A further open question is whether the large savings persist after amortizing RSI development and validation costs over realistic deployment volumes. The paper reports development cost separately and correctly avoids conflating deployment savings with optimization expenditure. However, a complete economic break-even analysis requires measured provider pricing, latency, caching behavior, and energy use, none of which follows from token savings alone.

Conclusion

HarnessMM presents a constrained execution transformation for agent harnesses: slow reasoning authors episode-specific executable continuations, public receipts activate guarded actions, and certified native dispatch removes redundant reasoning callbacks. Its strongest evidence is the combination of complete-task accounting, request-level omission audits, and mechanism ablations.

On HumanEval, the method preserves Codex success at 90.82% while reducing token use by 29.54%, and raises DeepSeek Harness success from 71.43% to 85.71% while reducing cost by 87.93%. On MBPP-sanitized, persistent graph reuse lowers cost by 26.91% relative to single-use EDGs, while callback substitution yields an additional measured advantage over retained callbacks. The results support guarded decision reuse as a practical harness-level optimization, but they do not establish a general correctness guarantee or uniform quality dominance. Its effectiveness depends on the prevalence of semantically resolved actions, the fidelity of public guards, and whether authorship and control overhead remain below the reasoning computation they replace.