Stop Re-Running to the Boss's Office: How HarnessMM Eliminates Wasted Agent Re-Reasoning
*(English adaptation of a zhichai.net forum post.)*
Every meeting attendee has seen this scene: at the end of the meeting the boss reads out action items — "Zhang drafts the plan, Li runs the data, first draft by Friday" — everyone nods. Half an hour later, Li knocks on the boss's door: "Data's done, what next?" An hour later, Zhang: "Plan's written, what's the next step?" The boss already laid out all the follow-up steps. But nobody treated the action-item list seriously, and everyone ran back for fresh instructions. Each re-request forces the boss to mentally reconstruct the whole project from scratch.
On an Agent's bill, this is real money: every re-request is a full LLM call that re-reads context, recomputes, and regenerates. There's no error, no failure — the task completes normally — but the bill grows numbingly thick. Today's AI Agent is the most anxious new hire in that company.
How This Company Runs
An Agent is, plainly, an LLM that works in a loop — the ReAct cycle: think, act; observe the result, think again, act again. "Thinking" is done by the model; "acting" by tools — calling an API, running code, reading a file. This loop is called the harness. The name is apt: the model is a horse, strong but unaware of where to run; the harness is the rider's reins and route map.
In a coding agent, the loop looks like: the model decides "write file A", the tool writes it, returns "file A written". The model then starts a new thinking round: what next? Run make. Then: "make exit code 0". Think again: run pytest.
Spot the problem? From the moment "write file A" was decided, the next two steps — make, pytest — and all their parameters were already determined. The harness, however, mandates a fresh model inference after every tool receipt. Like the boss re-reviewing the entire project context each time only to reach the same conclusion.
What You're Actually Repeating
Agent decisions split into two kinds:
- Semantic decisions: genuinely creative judgments — "How should this function be implemented?" "What does the user really mean?" "Search the web or query the database?" Worth every token.
- Execution readiness: pure condition-checking — "File written? Run make." "make returned 0? Run pytest." The answer sits in the just-received receipt. Asking a hundred-billion-parameter model to do this is like sending the chief engineer with a wrench to tighten a screw whose torque is already labeled.
- HumanEval (98 problems), Codex: success steady at 90.82%; tokens per task 66.72k → 47.02k (−29.54%); ~18 certified bypasses per task. DeepSeek harness: success 71.43% → 85.71%; tokens 96.28k → 11.62k (−87.93%); tool calls 954 → 415.
- MBPP-sanitized (257 problems): DeepSeek 90.27% → 91.83%, tokens 53.98k → 10.61k (−80.35%); Codex 91.83% → 90.66% (acceptable), tokens 129.55k → 49.22k.
- Ablations: persistent GDR saves 26.91% more than single-use EDG; CCS saves 19.52% more than keeping callbacks — empirical rebuttal of the Substitution Paradox.
- MiMo-v2.6-pro: DeepSeek harness 96.94% → 97.96%, tokens 11.62k → 4.40k (−62.12%); Codex 93.88% → 94.90%, tokens 62.60k → 10.09k.
- Six general-agent benchmarks (Qwen3.5-9B / Qwen3.8-27B): ALFWorld (2133 tasks) 66.20% @ 31.12k vs. skill-less baseline 42.29% @ 34.05k; SearchQA (3395) 76.76% @ 0.99k vs. 69.81% @ 1.23k; LiveMath (160) 29.38% @ 0.83k vs. 19.38% @ 4.10k; AIME (560) 87.14% @ 5.90k; Terminal-Bench 2: 26.03% @ 57.67k vs. 20.63% @ 178.19k; GAIA2 (480) 43.96% @ 639.64k.
Existing agent systems treat both identically: every tool feedback triggers a full inference. Per the paper's observation, many rounds produce conclusions identical to the previous round — the follow-up steps were fully determined last time. This is the hidden waste: re-reasoning already-decided matters. It produces no failures, no errors — just wasted tokens.
The Substitution Paradox
The intuitive fix is a fast path: fast-slow architecture. But Tsinghua University and Microsoft Research Asia researchers identified a deep trap: the Substitution Paradox. Many "optimizations" bolt on a fast path without truly removing the slow callback — you pay for the new road and keep paying the old road's toll.
The break-even condition is harsh: the slow-reasoning cost the fast path eliminates must exceed its added costs: C_create (authoring the decision graph) + C_select (checking applicability each step) + C_recover (safely falling back when the fast path fails). Most fast-slow methods have a tiny n (few bypassed steps) while all three added costs remain. HarnessMM's components map to these costs: EDG handles creation, Typed Selector handles selection, GDR's fallback handles recovery.
Executable Decision Graphs (EDG)
When slow reasoning makes a decision, it also writes down an Executable Decision Graph: future action nodes, each recording the action, literal parameters, predecessor, and a public guard condition. For the coding example: node 1 writes file A; node 2 runs make (guard: file A exists); node 3 runs pytest (guard: make returns 0).
Guards are boolean functions over public state — only receipt-visible facts like "does the file exist" or "is the exit code 0". An adapter evaluates them at near-zero cost, with no extra model calls. Thinking happens once, at graph-writing time; execution becomes a check-the-box chore.
Guarded Decision Reuse (GDR)
On each tool receipt, each node gets an eligibility score: predecessor complete × guard true × parameters closed (no unbound variables). All three pass → the node executes directly, no model consultation. If nothing is eligible — guard unsatisfied, missing parameters, unexpected situation — GDR abstains and the system falls back to slow reasoning, which is then justified because a genuinely new semantic decision has appeared.
A fast path that never abstains is a disaster; one that abstains constantly is useless. GDR's boundary is drawn on publicly verifiable state. Notably, the graph persists across tool transitions — one graph serves many transitions, so longer pipelines save more.
Certified Callback Substitution (CCS)
How do you prove the savings are real? Every guard-bypassed action generates a replacement certificate κ_t recording: the graph's fingerprint, the executed decision ID, predecessor receipts, exact execution parameters, the tool receipt, and — crucially — the ID of the bypassed slow callback. The paper's hard rule: each substitution must eliminate at least one slow call (N_slow,t^parent − N_slow,t^HarnessMM ≥ 1). In a field where "claiming savings" is easy, certificates are the vaccine against the Substitution Paradox.
Typed Selector
Input: observed receipt. Output: the eligible decision ID or an explicit ABSTAIN. No ambiguity. Exactly one eligible node → deterministically emit that ID — a lookup-and-compare job, no model, no probability. Empty set → ABSTAIN, fall back. Knowing when it doesn't know matters as much as knowing.
Recursive Self-Improvement (RSI)
The improved object is not the model — weights untouched — but the harness configuration: prompts, context management, finalization rules. Don't teach the horse to run faster; make the rider better. The loop: run the current harness, generate feedback, propose configuration candidates, pick the best on a validation set, freeze, evaluate on a test set. The freeze step prevents self-improvement from becoming self-deception. Editing configurations is orders of magnitude cheaper than training models, and iteration cycles shrink from weeks to hours.
Honest Accounting
HarnessMM's Complete-Task Accounting itemizes: graph authoring cost, selector input/output, added context (the graph's window tokens), remaining slow calls, fallbacks, and failed executions — with development cost reported separately and amortized per deployment task, in tokens (per 1000). No hiding costs in "per-task averages".
The Numbers
The Deeper Point
Past agent-efficiency levers targeted the model: bigger models, distillation, quantization, speculative decoding. HarnessMM's path is different: the waste isn't in the model, it's in the harness. Each round's output already contains several fully determined future decisions, but old harnesses consume one step and discard the rest — then pay the model to regenerate them. It's decision inventory backlog: manufacturing decisions costs orders of magnitude more than executing them, and old systems discard them as fast as they're made. EDG turns consumables into reusable stock, with GDR as automated inventory management and CCS as anti-counterfeit auditing.
The same pattern likely lurks in any generate–discard–regenerate architecture: histories re-read from long context, background re-narrated each turn, documents re-retrieved repeatedly. Limits remain: EDG requires slow reasoning to write a sufficiently complete graph up front (highly interactive tasks yield short graphs); guards cover only public state, not implicit quality like semantic correctness of code; GAIA2's 639.64k per scene shows complex scenarios still need many genuine semantic decisions. These aren't flaws — the method draws its boundary at the fallback mechanism, not in marketing claims.
The unread action-item list in the meeting room and the discarded follow-up decisions in an agent are the same thing: judgment already paid for, zeroed out by process. HarnessMM makes already-thought-out thinking count.
References
Yuhua Jiang, Chang Xu, Feifei Gao (Tsinghua University), Li Zhao (Microsoft Research Asia). *HarnessMM: Recursive Self-Improvement for Harness Token Efficiency*. arXiv:2610.32813, 2026-10-23.
https://arxiv.org/abs/2610.32813