Your Agent Harness Is Probably Overengineered: What to Strip Out
Your agent harness is probably overengineered. As models improve, scaffolding turns into dead weight. How review bloat and context cost add up, and what to cut.
This article is published in English.
As agents get smarter, the useful work shifts toward taking things out of them. That cuts against most of what teams have done for the past year, which is bolt on more skills and more capabilities.
Nearly all progress with agents so far has come from scaffolding: planning steps, verification loops, skills, memory, hooks. When models were weaker that made sense, because the scaffolding covered for what the model couldn't do alone. The catch is that nobody tears it down once the model catches up. A limitation shows up, a workaround is built, and the workaround stays for good. This is technical debt specific to agents, and it frequently makes results worse.
When the harness fights the model
Consider a setup tuned on the 4.5 and 4.6 generations of a model family. It planned, checked its own work and ran extra review passes before answering, which was a fair trade then. Move the same setup to a newer generation and it works against you. The model already reasons that way unprompted, yet the harness still tells it to doubt itself, review everything and start over. It plans and then reconsiders the plan. It executes and then challenges the execution. It verifies and then argues with the verification. Soon the agent is stuck in analysis paralysis and spends tokens questioning decisions that were fine. That's one step forward and one step back, with more reasoning that doesn't produce a better answer and sometimes produces a worse one.
So far that's only a feeling, so here's something measurable. One engineer keeps a pre-push review prompt that has been edited for months. It began at 22 lines and now runs to 37, growing from two kinds of review to three. Nothing was ever removed. Each addition was a rule, and each rule was added because something really did go wrong in a pull request. From the inside, that's what slop looks like. Good intentions are how a harness gets bloated. Every change fixed a real problem on the day it was made, but the second step is missing: nobody returns later to check whether the rule still pays for itself. Nobody is sharpening the axe.
Anthropic has run into the same thing. Its April 2026 engineering post on scaling managed agents says harnesses encode assumptions about what a model can't do by itself, and those assumptions go stale as models improve. Their example is Sonnet 4.5 wrapping up early when it sensed the context limit approaching, a behaviour they call context anxiety. They added context resets to deal with it. On Opus 4.5 the behaviour had vanished and the resets had become dead weight.
A practical habit follows from that. When a new model arrives, begin by asking it to audit its existing harness before it takes on new tasks.
More analysis isn't more signal
Asking an agent for extra analysis quietly drains signal, and that happens more readily than people expect.
Code review shows this well. Point an agent at some code and tell it to hunt for problems, and problems are what it returns. A few are important. Others are style nitpicks, hypothetical edge cases, or statements that are technically true and beside the point. The agent isn't failing here, because you asked for problems and it supplied them. Some findings are plain wrong, which is its own trouble, but the costly ones are findings that are correct and don't matter.
Trouble starts when they accumulate. With ten plausible issues on the table, the question stops being whether each one holds up and becomes which ones matter. A review system can therefore hand you more information and less signal at once.
A real case makes it concrete. A ticket asked for an endpoint to return a 409 where it returned a 500. The smallest correct fix was two lines in one file. The pull request that came back touched 13 files and nearly 500 lines across three services. Much of that was tests, so it wasn't all waste, but it was big. Six specialised review subagents had gone over the change, each doing its job and finding genuine issues, and the main agent applied all of them, so the PR ballooned. A human saw the bloat, wrote the two-line fix, and that version merged. The oversized one was closed.
No single reviewer failed. Thirteen files was never one decision. It was thirteen defensible ones that nobody added up. Every reviewer asked whether the code was correct, and none asked whether it should exist.
Dropping a reviewer wasn't the answer. The team gave a new one the opposite instruction instead: treat the diff as something that probably shouldn't exist, and make the author defend every file to keep it. CUT was the default. What it reports is a single ratio, files submitted versus the minimum needed, and that one figure shows whether the change has the right size.
Analysis in bulk costs nothing. Signal is the scarce part, and a stronger model doesn't hand it over for free.
Anthropic hit a version of this too. Its March 2026 post on harness design for long-running apps explains why the coding agent and its evaluator were split. When asked to judge work they produced themselves, agents tend to praise it confidently, even when a human would call the quality plainly mediocre. A separate evaluator can be told to be sceptical, while a self-reviewing one can't. How much that evaluator was worth depended on the task, though. On easy work it turned into overhead, and on the hard parts it kept giving real lift.
The gap between busy and useful widens once an agent runs all day.
An always-on agent shouldn't always be thinking
Take an agent built for an on-call rotation. It watches engineering channels and surfaces anything the on-call person ought to hear about. Those channels are chatty and no human on shift reads every one, so an agent that sits there around the clock can catch what a human misses.
The first version was overbuilt: maintenance-window tooling, service introspection, escalation-policy queries and a manual on when to use each. The builder called it on-call maxxing and stopped midway. The actual requirement was two things: acknowledge incidents quickly enough that nobody gets paged, and keep enough of an eye on the channels that a genuine problem gets looked at early. Acknowledging needed one command without arguments. The rest added nothing and was cut.
Not long after, the same error surfaced a layer down, in the architecture itself. A timer fired the loop every ten minutes across each shift, and one session carried on collecting context. Each pass therefore re-read a transcript that kept getting longer, billed as Opus cache reads, and by the close of a shift that was beyond 150k tokens. Across the measured stretch the account was reportedly 2.1 billion cache-read tokens, worth about $1,050 at the team's pricing. A flat-rate plan meant no direct bill, but the weekly limit was being exhausted even with a promotion adding 50 percent. Tracing the consumption pointed straight at the culprit.
A sharper prompt wasn't the cure. A different design was. On each pass the loop now spawns a short-lived Sonnet agent whose task is simple: read anything new, record a last-seen timestamp for every channel in a small file, and give back one line. Because the loop's own session stays flat, the costly model only runs when the small one escalates. In code terms it removed 79 lines and a whole component. The next shift passed with nothing important missed, and the watching goes on.
The projection had been that a routine iteration would fall from roughly $0.25 to about $0.03. Measuring 433 iterations of the old design against a full shift of the new one gave the right ratio at a different scale: about $1.85 per iteration before and about $0.19 after, roughly ten times cheaper. The shape of the problem had been judged correctly and its size underestimated.
Just as telling is what didn't cause the cost. The original design already used a cheap model, Haiku, for the actual channel reading, and it accounted for under 1 percent of the cache reads. The cost sat in the parent session re-reading its own growing transcript on every pass. The cheap model did the work and the expensive one had to read it all again.
Two lessons come out of this. First, make sure the expensive model doesn't repeat work the cheap one already did. Second, on a high-frequency, low-stakes task a stronger model buys almost nothing, and it earns its keep when you dig into a complex production incident. The smartest model doesn't need to be the busiest one.
Context isn't free
The urge to overengineer grows as context windows grow. When context was scarce, selection was forced. Now it's easy to treat context as storage: toss in the conversation, the documents, the tool descriptions, the history and every skill that might help, then let the model sort it out. The model doesn't experience context as storage. All of it is part of the problem to be worked through. Each instruction is one more thing to interpret and each tool one more thing it might reach for. A smarter agent, like a smarter person, needs more focus and not more input.
Which leaves a question to put to any agent: what could come out without making it worse? Rather than writing another skill, delete one. Run with less context than feels safe. Remove a verification loop. Poll at a slower rhythm. Then let the outcome speak. If nothing degrades, the agent got cheaper at no cost and likely better, since the model has less to wade through. If it degrades, you've learned that piece earns its place for this model.
From everything-maxxing to agentic engineering
Underneath all of this sits one habit. Teams have become excellent at everything-maxxing: more tokens, context, skills, tools, memory, hooks, reasoning, verification and subagents. Piling things on feels like advancing since the system grows more intricate, yet intricate and useful aren't synonyms. At some stage you've put a bureaucracy around the agent, and bureaucracies are usually wasteful.
Think of every piece of a harness as a hypothesis, such as:
- This skill makes the agent write better code.
- This hook stops real failures.
- A further review pass will catch bugs the main agent overlooked.
- More subagents will get the work done sooner.
Something that sounds useful is a guess about your system and not a fact. There's no avoiding the dull part, which is to experiment. Run the flow with and without the skill, then with and without the hook, and measure.
Anthropic's harness design post states the principle directly: each component in a harness embeds a guess about what the model can't manage alone, and those guesses should be stress tested. Its team assembled an elaborate harness that worked, then took parts out one by one to see which mattered. Sprint decomposition was dropped, because with the gains in Opus 4.6 there was good reason to think the model could take that job on natively.
That teaches more than the slogan that simple agents win. Treat a harness as something you measure and tune. A few parts become unnecessary, others remain since the model still can't do that job. Removing a component and showing that nobody missed it is tougher than adding one, and this marks the line between everything-maxxing and agentic engineering. One maximises what the system does. The other maximises useful signal for each token spent.
Sharpen the axe
As models improve, the list of things to remove grows. Work that used to need scaffolding gradually turns native, review loops stop justifying their cost, and part of what looked fundamental will turn out to patch a model that's gone. A harness is never done. Ask only whether a piece still improves results for this model and task, measure it, cut it, and bring it back solely when the evidence says it matters.
A saying often pinned on Lincoln goes that given six hours to fell a tree, he'd spend the first four sharpening the axe. Sharpen the axe.