the year of harnesses

For most of the last few years, the way you got a better coding agent was simple: wait for a better model. Each release moved the frontier, everyone re-benchmarked, and the leaderboard reshuffled. The model was the product, and the model was the constraint. If your agent was weak, the fix was upstream, in someone else's training run.

That has quietly stopped being true. The frontier models converged — they are now close enough in raw ability that, for most real coding work, swapping one for another changes the result at the margins, not in kind. And when the models stop being the differentiator, the interesting question moves to what wraps around them. The trade press started calling 2026 the year of harnesses. The name is right, even if the idea is underexplained. This is what it actually means, and why it changes where the work goes.

agent = model + harness

An agent harness is the scaffolding around a model that turns it into something that can actually do work: the control loop that decides what to do next, the tools it can call, the way context is gathered and pruned so the model sees the right things, and the verification that checks the output before anyone trusts it. The model supplies raw capability. The harness supplies structure. Neither ships software on its own.

The tell is in the benchmarks. Increasingly, the headline agentic results do not come from a raw model answering once — they come from a model run inside an orchestration: planning, spawning sub-tasks, checking its own work, retrying. The record numbers are harness numbers. The weights got the field to the doorstep; the scaffolding walks it through. Once you see it that way, "which model is best" becomes a much less interesting question than "what is it wrapped in."

The model is the engine. The harness is the car. A better engine in no car still goes nowhere — and 2026 is the year everyone finally noticed they'd been shipping engines.

the fight moved up a layer

When the models were far apart, the harness looked like plumbing — necessary, unglamorous, not where the advantage lived. Convergence inverts that. If every serious model is roughly as capable, the advantage cannot come from the model anymore, so it has to come from everything around it. The differentiator became the harness: how work is decomposed, where the run pauses for a human, and what gets checked before code ships.

This is why the same base model can feel brilliant in one tool and maddening in another. Same weights, different harness. One decomposes a task into reviewable steps and stops at the right moments; the other fires a single mega-prompt and hopes. The gap between them is not intelligence. It is engineering — harness engineering, specifically, and it is becoming its own discipline.

what harness engineering actually is

If the harness is where the leverage moved, it is worth being concrete about what a good one does. Most of it is unglamorous, and that is the point:

• Decomposition. Breaking work into units small enough that a model can do them well and a human can review them quickly — instead of one prompt that produces a plausible wall of code nobody can vet.
• Human checkpoints. Deciding where the run pauses for judgment. Not every step — that is just slow — but the high-consequence ones: scope, design, the merge. Control at the decisions that matter, autonomy everywhere else.
• Context management. Making sure each step sees what it needs and not the noise. Carrying decisions forward across a long task is most of the difference between an agent that stays coherent and one that loses the thread halfway through.
• Verification. Checking output before it is trusted — review passes, tests, isolation so a bad run cannot corrupt the main line. When production is cheap, the scarce thing is confidence that what was produced is safe to ship.

None of that is model work. All of it is harness work. And it is where the reliability of an agentic system now comes from — the difference between a demo that impresses and a tool a team ships on every day.

the implication: stop chasing the engine

If you build with agents, the practical consequence is a reprioritization. The model-of-the-month race is largely settled at the top, and chasing it is a treadmill — you will swap engines every few weeks for diminishing returns. The durable investment is the harness: the workflow, the checkpoints, the review, the way context and decisions are carried. That is the part that compounds, and the part that stays yours when the underlying model changes again next month.

Put bluntly: the engine changes monthly; the harness is what's portable. A team that has invested in how it decomposes, reviews, and ships work keeps that value across every model swap. A team that only ever chased the best model has to re-learn its workflow each time the leaderboard moves.

where this leaves us

This is the bet defract was built on, so read it as one approach rather than the verdict. defract is an opinionated harness for Claude Code: it runs work through a gated lifecycle — story, design, architecture, implementation, review, release — with human checkpoints at the decisions that matter and agent review before anything merges. The model underneath can be whatever is best this month. The structure around it is the part designed to last.

Whatever you build with, the shift is the thing to internalize. The model is no longer the constraint, which means it is no longer where the advantage lives. The advantage moved into the harness — and 2026 is the year that stopped being a detail and became the whole game.