# You're Optimizing the Part of Your Agent You Don't Own

> Source: <https://dev.to/agentiknet/youre-optimizing-the-part-of-your-agent-you-dont-own-b69>
> Published: 2026-07-14 01:36:40+00:00

Disclosure up front: I build

[agentproto], one of the

tools in this market. Every fact below is dated and sourced; the tool-by-tool

review lives in

[9 coding-agent orchestrators, compared]where

competitors' strengths are named. Corrections welcome — file an issue.

Open any dev feed this week and count how many arguments are about the model.

Which one codes best. Which one dropped. Which benchmark moved two points.

It's the wrong fight. Here's the receipt that should end it:

The receipt.LangChain took a coding agent fromrank 30 to the top 5 on— the wins came from the scaffolding

Terminal-Bench without changing the model

around it, not a better brain. Same weights, thirty places, harness only.

Sit with that. The single biggest jump they got came from the part you can

actually edit — and most people spend their attention on the part they can't.

You did not train the model. You can't change its weights, you can't see its

training data, and next quarter the vendor swaps it for a new one and your

carefully-tuned prompts quietly stop meaning what they meant. The model is a

**rental**. It's a good rental — but it's not yours, and it moves under you.

The *harness* is everything you wrap around that rental to turn a raw

token-predictor into something that ships work: the system prompt, the tools, the

memory, the loop, the checks, the sandbox it runs in. Anthropic's own harness

team defines it exactly this way — the harness is "everything wrapped around a

model that turns raw capability into completed work."

The one idea, if you remember nothing else:

You rent the model. You own the harness. Stop optimizing the rental.

And it turns out the harness is the bigger lever anyway. LangChain's own writeup

is one data point; the broader pattern is that harness-only changes repeatedly

beat model swaps. The field even has a name for the discipline now —

"harness engineering" — with a whole awesome-list of tools for it. The model got

commoditized while you weren't looking. The scaffolding is where the craft moved.

There's a clean way to place yourself, and it's basically the history of this job

in three steps. Anthropic's context-engineering post lays out the first two; the

long-running-agent writeups add the third. Find the one that sounds like your

week.

**Era 1 — prompt engineering.** You get better results by wording the ask

better. Few-shot examples, "think step by step," role-play framing. This still

matters, but it's table stakes now, and it's the most fragile layer — a model

upgrade can silently rewrite what your clever phrasing does.

**Era 2 — context engineering.** You realized the bottleneck isn't the wording,

it's *what's in the window*. Anthropic's framing: treat context as a finite

attention budget, because recall degrades as the window fills — "context rot,"

where attention spreads thinner across every added token. You curate what the

model sees, load facts just-in-time, and keep state on disk instead of in the

transcript.

**Era 3 — harness engineering.** You stopped tuning any single call and started

designing the *system* the model runs inside: the loop, the tools, the roles, the

gates, the sandbox. The model became one swappable component in a machine you

built.

Where are you?If your honest answer is"I write really good prompts,"

you're in Era 1 — doing real work on the most rented, most fragile layer. Every

rung past here is about moving leverage into the part you keep.

Most teams are stuck somewhere in Era 1, blaming the model for failures the

harness was supposed to catch. So let's climb.

The minimal harness is almost embarrassingly small. Anthropic's "Building

effective agents" reduces it to one line: an agent is a tool-using model in a

loop, grounded in feedback from the real environment. Not a framework. A loop

that checks reality.

Start there and resist the urge to add. The same post is blunt about it: begin

with the simplest thing and add complexity **only when it measurably helps**,

because frameworks bury the actual prompts and responses under abstraction and

make failures harder to debug. Most "my agent is dumb" bugs are a harness that

grew faster than it earned.

The tell.If you can't name what each piece of your scaffolding isfor—

which specific model weakness it patches — that piece is probably cargo. The

loop grounded in ground truth is the only part you always need.

Once the loop works, the next failure is the model drowning in its own history.

This is the Era-2 move made structural. The long-running-agent playbooks compress

it to three verbs — **Reduce, Offload, Isolate**:

`NOTES.md`

, a task list), not the transcript. State outside the context
window survives a reset; state inside it evaporates.The knowledge you feed it is part of this budget too — and *whose* knowledge

decides how much of the internet's average you're stuck with, which is

[its own piece](https://dev.to/agentiknet/your-coding-agent-knows-the-internets-average-heres-how-to-make-it-know-yours-1aeg). The rule underneath all of it:

the best context is the *smallest* set of high-signal tokens that lets the model

take its next step — even when the window could hold a thousand times more.

Here's the harness component people skip, and it's the one that fails silently.

An agent asked *"are you done?"* says yes too early — models grade their own

output too leniently, seeing a button render and calling the feature shipped.

Anthropic's harness team found the fix isn't a smarter prompt; it's a

**structural split**, a generator-and-evaluator loop where the two roles are

separate and the evaluator is tuned to be skeptical.

The mature version splits three ways — planner, generator, evaluator — because

each targets a *different* failure: the planner fixes under-scoping, the generator

does the work, the evaluator catches the lie. This is the whole spine of the

[supervision ladder](https://dev.to/agentiknet/your-agent-says-the-tests-passed-it-didnt-run-them-15j); the point here is narrower —

**the evaluator is a harness component you install, not a mood the model gets
into.** Bolt it outside the working agent's loop, or it grades itself and passes.

Receipt.This is also why "just loop until done" isn't reliability. A loop

gives the agent persistence, not correctness — the completion check has to live

outsidethe loop or it rubber-stamps a wrong turn fifty times. That argument

has[its own piece].

The resilient harness treats the model as a component, not the center of gravity.

Addy Osmani's long-running-agent writeup names the split cleanly — **decouple the
Brain, the Hands, and the Session**:

Decoupled, each part upgrades on its own clock. Your rented Brain changes every

quarter; your Hands and Session don't have to. This is also what makes cost

routing possible at all — plan on an expensive Brain, execute on a cheap one, and

[the routing math](https://dev.to/agentiknet/cheaper-per-token-is-not-cheaper-per-outcome-3b9b) only works because the harness let you

swap the engine without rebuilding the car.

There's an interop tax hiding here, though: today every tool speaks its own

dialect of "agent behavior as files" — `CLAUDE.md`

, `AGENTS.md`

, `SKILL.md`

, all

mutually invisible — so a capability you built for one Brain doesn't travel to the

next. Fixing that with contracts instead of yet another framework is

[a companion piece](https://dev.to/agentiknet/your-claude-skill-is-invisible-to-codex-heres-how-to-fix-it-3l74).

Now the counterintuitive top of the ladder, and the part almost nobody says out

loud. **Every piece of your harness encodes an assumption that the model is bad at
something. When the model gets good at it, that piece becomes dead weight.**

Multiple harness writers land on the same warning independently — it's the Bitter

Lesson arriving at the application layer. The context resets, the sprint

decomposition, the elaborate verification dance: each one exists to patch a

weakness in *this* model generation. LangChain's own history shows it — the same

scaffolding that lifted an agent to the top 5 becomes drag once a stronger model

ships and no longer needs it.

The move most teams miss.On every model upgrade, don't just enjoy the

bump —re-audit your harness and rip out the scaffolding the new model madeThe harness that wins in 2026 is lighter than the one that won in

pointless.

- Growing your harness forever is how you end up slower than someone running a plain loop on a better model.

That's the discipline in one sentence: build the scaffolding the model needs

today, and be ruthless about deleting it the day it doesn't.

Here's the fair part, because the whole argument depends on it. The model vendors

are shipping harnesses too, and they're good. Claude Code *is* a harness. Managed

Agents is Anthropic's hosted meta-harness — session, sandbox, and loop

virtualized behind a stable interface, April 2026. If you want the harness to be

someone else's problem, that is a genuine, less-work answer, and I won't pretend

otherwise.

Two things you're trading away, though, and they're exactly the two the whole

piece has been about. A hosted harness is **their** harness, wrapped around

**their** model, on **their** plan — so you can't prune it (Rung 5 isn't yours to

do), and you can't swap the Brain for a cheaper or open one (Rung 4 is off the

table). You've rented the model *and* the harness. The one part that was supposed

to be yours went back to being a rental.

The alternative is to own the harness as portable infrastructure — the checks,

the contracts, the roles living in *your* repo and running on *your* machine,

around any model. That's the whole design of what I build:

[agentproto](https://agentproto.sh) is a local daemon with adapters for Claude

Code, Codex, and open models via OpenRouter or Hermes, so the harness you tune

travels when you swap the engine, and no vendor holds the keys. Concede the

hosted route is less setup. Just know what you gave up to skip it.

So the feed has it backwards. The model you're all arguing about is the one thing

in the whole system you can't change and won't keep. The harness — the loop, the

context budget, the evaluator, the swappable parts, the scaffolding you're brave

enough to delete — is the part that's yours, the part that moved a coding agent

thirty places without a new model, and the part your competitors are ignoring

while they refresh the benchmark leaderboard.

Two questions turn this into Monday's work. When your agent fails, do you reach

for a better prompt, or do you ask which harness component was supposed to catch

it? And when the next model drops, do you just feel faster — or do you open your

harness and delete what it made obsolete?

Rent the best engine you can. Then go build a car worth putting it in.

If your harness beats this framing — or you've found a scaffold worth keeping that

I'd have told you to cut — tell me where. I'll fix the piece.

Ten pieces, one argument. Start anywhere; each one cross-links the rest.

| Piece | The one idea | |
|---|---|---|
| 1 |
|

*Written by the maintainer of agentproto (Apache-2.0, source). Same contract as our /compare page — dated facts, named strengths, corrections by issue. Got something wrong? File an issue.*

*Building agentproto in the open — follow @theagentproto and @agentik_ai on X.*