Harness Engineering: Why the Model Was Never the Product

The same model scores up to six times differently depending on what you wrap around it. A plain-language tour of what an agent harness is, why Stripe, a Swedish legal company and a slide-deck company each built their own, why a general-purpose coding agent cannot be your legal harness, and what a harness for verifying software would look like.

A glowing sphere of light held inside an elaborate harness of straps, reins, gauges and a gate, pulling a cart of finished documents, with a person at the reins. To the left, an identical bare sphere floats alone in the dark, attached to nothing, producing nothing.
Same model, two outcomes. The sphere on the left is as intelligent as the one on the right. Only one of them gets any work done.

In February this year a group of researchers took nine AI models, pointed them at the same mobile-app tasks in the same real codebase, and ran each one through four different coding agents. The best combination solved 12 percent of the tasks. One model scored 12 percent inside one agent and 2 percent inside another: a six-fold gap with nothing changed but the software around the model. Not the model. The wrapper.

I saw a smaller version of that a few days ago, in a demo of an in-house knowledge-work agent. The agent was told it was acting for an engineer, and engineers were not allowed to see revenue. Asked an engineering question, it quietly ran four searches through the workspace looking for a revenue file anyway. Nothing leaked, because the file was not there. But the model had done exactly what models do: it reasoned, it was curious, it went looking. Stopping it was the harness’s job. This harness had tried, by hiding the revenue tool from the engineering role, and hiding a tool is not the same as access control.

That distinction, model versus everything around it, has a name now: harness engineering. This post is my attempt to explain it from the ground up, for anyone who has used ChatGPT, maybe Copilot or Claude Code, has heard “agents” a hundred times and still cannot say what a harness is or why their company suddenly wants to build one.

If you would rather watch than read, there is a companion video for this post on my YouTube channel, The Agentic Engineer: twenty two minutes covering the same ground, with the best pushbacks from the LinkedIn debate on this post built in. The video makes the case. This post is the reference, with every source.

Why Every Company Is Building Its Own Agent Harness, the companion episode on The Agentic Engineer

The short version

An agent is a model plus a harness. The model reasons and picks the next step. The harness is everything that lets it see, act, remember, stay inside the lines, and be checked. The model is rented from a lab, and the labs leapfrog each other every few months, so whichever model you choose today, a rival will match it within a quarter or two. The harness is the part you own, and the part that stays yours when the model underneath changes.

Claude Code, Codex and Copilot proved the pattern for one kind of work: programming. The pattern is now leaving programming. A legal company in Stockholm, a presentation company in San Francisco and a payments company with hundreds of millions of lines of code have each spent the last year building their own, and each of them can explain why the general-purpose tools could not have done the job. I think the next harnesses will be built for a kind of work rather than for everyone, and I will end with the one I am working on: a harness for verifying software.

Where the word comes from

Before it was jargon, a harness was a set of straps. A horse is an extraordinary engine: strong, fast, tireless compared with a person. It is also, without a harness, nearly useless for work. You cannot steer it, you cannot stop it on demand, you cannot attach anything to it, and it will spend its strength on whatever catches its attention. The collar, the reins, the bit, the blinders and the shafts of the cart do not add a single unit of strength. They turn strength into directed work: this far, this direction, this load, stop here.

A powerful horse in full working harness pulling a loaded cart along a lit path with a calm driver holding the reins, while in the dark background the same horse, wild and unharnessed, rears and goes nowhere.
The harness adds no strength. It decides where the strength goes.

That is exactly the relationship between a language model and the software around it. The model is strength. Left alone it will produce a paragraph about anything, confidently, and then stop. It has no hands, no memory beyond the conversation, no idea what it is allowed to touch, and no way to check its own work. Every one of those gaps is filled by a harness, and the quality of the filling decides whether you get a cart that arrives or a horse that bolts.

Software engineers have used “test harness” for decades for the scaffolding that runs code under test and reports back. The agent sense is a close cousin: the scaffolding that runs a model and reports back. The term was pinned to agents in February 2026, by Mitchell Hashimoto and, six days later, by the OpenAI Codex team. By March LangChain had the slogan (“Agent = Model + Harness”), and by April Birgitta Boeckeler had written the framework on martinfowler.com that most serious discussions now borrow from.

The road here: prompt, context, agent, harness

It helps to see how we arrived, because each step explains the next.

In 2023 we learned how to ask. Prompt engineering was the discovery that how you phrase a request changes what you get, and for a year it was a job title. In 2024 we learned what to feed the model: retrieval, documents, tools, so it could look things up instead of guessing. By 2025 that had a better name, context engineering, and a new shape: the model in a loop, calling tools, reading results, deciding what to do next. The loop is the whole trick behind Claude Code. Give a good model a shell and a file system, let it run until it decides it is done, and it will fix your bug.

Then two things happened at once. The models got good enough that the loop became easy, and the loop turned out to be a small part of what you need to trust an agent with real work. The rest is what it is allowed to see, what it may do, whose permissions it acts with, where its work is saved when the laptop sleeps, and how anyone knows it did the job. Jediah Katz, who worked on Cursor’s agent harness, gives the naming arc in his AI Engineer talk: prompt engineer in early 2023, context engineer in mid 2025, harness engineer at the start of 2026. Each title is the previous one with more of the surrounding system pulled into scope.

What a harness does, in one loop

Here is the smallest possible description. The model asks to read some files. The harness runs the read tool and returns the contents. The model asks to make an edit. The harness applies it. The model asks to run the tests. The harness runs them, and the tests say the export is missing a record. The failure goes back to the model, which revises and tries again. At some point the tests pass, or the model gives up, or it asks you a question. The harness decides which of those three things happens, and when.

Flow diagram of the agent loop: you ask for a CSV export; the model reasons and picks the next step; the harness runs the tool (read files, edit, run tests) and returns the result or the failing test; the harness then decides: tests pass, stop and hand over; retry budget left, back to the model; budget spent, ask for help.
One loop. The model picks the step, the harness runs it, feeds the result back, and decides when to stop.

Annie Wang, in Google’s short crash course on the subject (the written version is at g.dev/ai/ai-harness), puts the deciding part in one sentence: the harness manages “when to continue, when to stop, and when to ask for help.” Everything else in this post is an elaboration of what the loop needs around it to be trusted.

The loop itself is genuinely small. Stripped of everything, it is this:

while True:
    step = model.next_step(context)          # the model reasons
    if step.is_final:
        return step.answer                   # stop
    result = harness.run(step.tool, step.args)   # the harness acts
    context.append(result)                   # and feeds back

Mario Zechner’s pi, a deliberately minimal coding agent, is close to that in production form: four tools (read, write, edit, bash), a system prompt that came in under a thousand tokens including the tool definitions when he first described it, and everything else as extensions you write yourself. In the Berkeley study I will come to, those four tools were enough to put pi on the cost-quality frontier next to Claude Code. The point of showing the loop is not that it is trivial to get right. It is that the loop is not where the work is. The work is in the words context, run and is_final, which hide every hard decision.

The five parts of a harness

Every harness I have looked at this year, from the ones labs ship to the ones companies build, has the same five parts. Aish Reganti’s talk on harness engineering gave me four of them and Google’s crash course added the fifth, and I now cannot unsee the shape.

Diagram of the five parts of a harness around a model: the model in the centre, labelled the intelligence that reasons and picks the next step; around it, numbered 1 to 5, context (what the model sees), actions (what it can do), boundaries (what it may do), persistence (what survives) and evaluation (how you know it did the job), with a dashed loop running through all five.
The model in the middle, the five parts of the harness around it, numbered in the order the sections below take them. The loop runs through all five.

1. Context is what the model sees. Always-on instructions (the AGENTS.md or CLAUDE.md file that every coding agent now reads), skills loaded on demand when a task matches, documents retrieved from your systems, and memory. Google’s framing of memory is the clearest I have found: the session is the transcript; state is a scratchpad of structured fields your own code reads without searching the transcript (the current plan, the approval status, a retry counter); long-term memory is distilled facts carried into the next conversation. You decide what to save and what to bring back. Most “the agent forgot” complaints are really a harness that saved nothing.

2. Actions are what the model can do. Tools, which are functions the harness exposes; MCP servers, which are tools living in someone else’s service; subagents, which are whole loops the main loop can delegate to. And execution flow, the under-appreciated one. Sometimes the model picks the next step. Sometimes you need a fixed order. Sometimes independent steps should run in parallel: change the code, run the unit tests and the browser tests at the same time, and only when both pass move on to review. Stripe calls these mixed sequences blueprints: deterministic steps and agent steps in one recipe.

3. Boundaries are what the model may do. Permissions on tools, approvals before sensitive actions, a sandbox that limits which files and which network the agent can reach, and identity: whose permissions is this agent acting with? The revenue search from the opening lives here. The demo had hidden the revenue tool from the engineering role, and the model went looking anyway. Hiding a tool is a hint. Access control is enforcement in the data layer, tied to the identity of the person the agent is working for. Google’s crash course makes the same point from the security side: controls must be “enforced by software, not by asking the model to be careful,” and a sandbox “doesn’t solve prompt injection by itself.”

4. Persistence is what survives. The workspace, checkpoints so a crashed run can resume, compaction so a long run does not drown in its own history, and increasingly a machine that is not your laptop. Katz’s prediction is that within six months 90 percent of agent work runs off the laptop, because a task that takes hours cannot live on a machine that sleeps.

5. Evaluation is how you know it did the job. This is the part the early harness talks left out, and it is where I spend most of my attention because it is the testing problem in new clothes. Google describes three evaluators for three different questions. Deterministic code checks the result: does the downloaded CSV contain the same ten customers with the right names, compared record by record, not just by count. A model acting as judge, given a rubric and the evidence, checks the explanation: did the agent’s final message say where the button is and what it downloads. A human checks the experience: the CSV is correct, but is the button where anyone would look for it. Each judge is only good at its own question.

I run a small harness of my own and it has all five parts, which is how I know the shape is real rather than a diagram. An instructions file and a set of skills are its context. A searchable knowledge base, a few command-line tools and some scheduled agents are its actions. Approvals that arrive on my phone before anything is sent anywhere are its boundaries. Everything it does is committed to git, which is its persistence. And when it drafts something, I read it back against the source before it goes out, which is the human evaluator doing the job code cannot. It is a modest harness. It is still the reason the model underneath it is useful to me rather than merely entertaining.

Does the harness really matter that much?

The evidence says yes, with an honest caveat.

The six-times result is from a benchmark called SWE-Bench Mobile, published at KDD 2026: 22 agent and model combinations on industrial iOS tasks, with “the same model shows up to 6x performance gap across agents” and the best configuration at 12 percent. LangChain, keeping the model fixed, raised its Deep Agents harness from 52.8 to 66.5 percent on Terminal-Bench by changing only the harness: a checklist before the agent may declare itself finished, loop detection on files edited too many times, warnings when time is running out, and a bigger reasoning budget for planning and verifying than for building. Thirteen points, no new model.

It cuts the other way too. A security firm, Lasso, red-teamed the same models through two different harnesses and found one model’s attack success rate went from about 1 percent to about 24 percent with nothing changed but the harness. The low number was partly an illusion: a format-translation layer on that path was silently dropping tool calls, so the attacks never got to run. Red-team results do not transfer between harnesses. And Anthropic’s own write-up on harness design reports a solo model run that took 20 minutes, cost nine dollars and produced a broken game, against a planner-generator-evaluator harness that took six hours, cost 200 dollars and produced a playable one. More harness is not free. It is a trade.

Now the caveat, because it matters for the rest of the argument. Two studies this autumn point the other way. HarnessTax, from UC Berkeley, ran seven models through Claude Code, Codex and pi on two well-known coding benchmarks and found that “harness choice has little effect on task success rate, but can significantly affect the cost”: the same model reached a similar score at up to five times the price. A study from Apple and EPFL found that elaborate machine-learning harnesses gave no advantage over a single session of a minimal coding agent on the same model. Katz’s explanation for why yesterday’s harness tricks stop mattering is a flywheel: a harness makes a hard task possible, people do more of it, the labs see the data, the next model does it natively, and the harness deletes the scaffolding it no longer needs. The parts of the harness that once made models better at coding are, in his words, dead.

I think both findings are true and they point at the same place. On well-trodden tasks that the labs train on, the model has eaten the harness. On your tasks, your codebase, your data, your process, your regulations, the harness still decides, and no lab will ever train on those. The enterprise value of a harness sits exactly where the public benchmarks cannot see.

The harnesses you already use, and the one you own

Claude Code, Codex, Copilot, Cursor, Gemini CLI, Claude Cowork. If you have used any of them you have used a harness: a loop, a shell, file tools, a permission prompt, a mechanism to compact history. They are very good, and they are general-purpose by design, which is both their strength and the reason this post exists.

Boeckeler’s most useful distinction is between the harness the vendor builds and the one you build around it. The vendor’s harness, which I will call the inner loop from here on, is the loop, the built-in tools, the compaction, the prompt you cannot see. Around it you build an outer harness for your own codebase and company: the instruction files, the purpose-built tools, the checks that run after the agent acts. She splits those controls into guides, “feedforward controls” that “anticipate the agent’s behaviour and aim to steer it before it acts” (conventions, templates, instruction files), and sensors, “feedback controls” that “observe after the agent acts and help it self-correct” (tests, linters, review). Use only guides and you get an agent that follows rules but never finds out whether they worked. Use only sensors and you get one that keeps repeating the same mistakes. Hashimoto describes the same practice from the inside: every time the agent makes a mistake, engineer a fix so it never repeats, either a line in the instructions or a small purpose-built tool such as a filtered test runner. Addy Osmani calls it the ratchet. The outer harness only ever tightens.

That outer harness is already yours, whether you noticed or not. Every CLAUDE.md you have written, every script so the agent could see a screenshot, every hook that runs the linter before a commit, is harness engineering. The question is when the outer harness gets big enough, and different enough, that the general-purpose inner loop stops being the right fit.

The coding companies went first

Stripe’s answer was Minions. Each run gets a pre-warmed developer box in about ten seconds, isolated from production and from the internet. A central tool server offers around 500 internal tools, and each agent gets a curated subset. Deterministic steps such as linting and pushing are mixed with agent steps in blueprints. The agent runs with full permissions and no prompts, because the blast radius is one disposable box. Human review of the pull request is the last gate. Stripe reports over a thousand merged pull requests a week from this, and gives its reasons plainly: hundreds of millions of lines of code, an unusual stack, and regulatory obligations that a general tool does not know about.

Ramp built Inspect on an open-source terminal agent running in cloud sandboxes with the full application stack inside each one, and reported that roughly half of its merged pull requests started there by February and three quarters by the middle of the year. Spotify’s Honk, which Anthropic says runs on its agent SDK, is reached from Slack and GitHub and had over 1,500 merged pull requests by last November. Coinbase reportedly built Forge around a model router, largely to control cost. Shopify’s River refuses direct messages: every agent conversation happens in a public Slack channel so people learn by watching, and one in eight merged pull requests across the company now has the agent as co-author. LangChain looked at all of this and packaged the common shape as an open-source template, because the shape was the same every time: a sandbox per task, a small curated toolset rather than a large one, instruction files, chat as the front door, middleware as the safety net, a human at the end.

Notice what none of them did. None of them trained a model. All of them still pay Anthropic, OpenAI or Google, and several run a rented inner loop as well. “Build your own harness” has never meant “build your own Claude Code.” It means owning the outer layer: the tools, the context, the identity and permissions, the workflow entry point and the checks.

So far this is a story about coding, and a skeptic could say: fine, coding agents for coding companies. The interesting cases are the ones that have nothing to do with code, and I watched two founders describe theirs this week: Legora’s CTO on Latent Space and Gamma’s co-founder with Greg Isenberg.

Legora is a legal AI company that started in a basement in Stockholm and closed a round at an 8.8 billion dollar valuation last month. Gamma makes presentations, documents and websites, passed 100 million dollars in annual recurring revenue late last year, and relaunched as an agent in October. Both rebuilt their products as agents in 2026. Both rent their models. Neither could have used a general-purpose coding harness, and when you line up their explanations, they give the same seven reasons.

One enormous general-purpose multitool with dozens of blades fanned out, in shadow on the left. On the right, lit, a row of purpose-built professional instruments on a workbench: a lawyer’s scales and seal, a designer’s layout grid and swatches, an inspector’s precision gauge, a stethoscope, an accountant’s ledger.
A multitool is a marvel until you have one job to do all day.

The tools are different. Claude Code’s hands are files, a shell, a test runner and git. Legora’s hands are precedent search, a tabular review that asks one question across ten thousand contracts and fills a spreadsheet with cited answers, Word edits that keep track of changed definitions, and a citation system in which every statement links to a bounding box in the source PDF. Gamma’s hands are template search over thousands of designs, image and diagram generation, layout, and a vision model that inspects every slide. Jon Noronha, Gamma’s co-founder, gives the design rule: “an agent harness is just a bunch of tools that an agent uses to complete a task,” so ask “what are the unique tools that either I already have or I can build that are not already out there.”

The checks are different. Code has a test suite that says pass or fail. Law has a due-diligence report that a lawyer judges against what a good one looks like, and Legora’s evaluation team is three engineers, three lawyers and a pool of about a hundred “legal engineers,” former big-law lawyers who often have computer science degrees. They keep a heat map of every model’s performance across practice areas and tasks, because, in Jacob Lauritzen’s words, model releases “improve some and regress in others” far more often than you would think. Slides have a vision pass for cropped heads and bad padding, and for the part no rubric captures, taste, Gamma runs A/B tests on its user base and watches hard-to-fake signals: how long you edit, whether you export, whether you pay. “Nike should have a different one than Adidas,” Noronha says, “because they have a different perspective on taste.” The evaluator is the most domain-specific part of the whole harness. Verification, again, is the moat.

The users are different, so the harness must hide more. Engineers read diffs and pick models. Lauritzen, Legora’s CTO, on why his lawyers do not want a model picker: ask a lawyer whether drafting this contract is a Sonnet task or an Opus task and “they won’t know… My hourly rate is 1,000 dollars an hour, just make it work.” So the loop is expressed as a spreadsheet, a Word add-in, a Slack intake, a generated form that asks whether this deck is for children or adults. Gamma tested a fast mode that skipped the clarifying questions and the outline review, expecting it to win. It lost. Users who went through the slower path were more satisfied, edited more and converted to paying at a higher rate. The less technical the user, the more of the loop has to become interface, and the more harness there is.

The data and the rules are different. Legora cannot look at a single trace of what its agent does, because the documents are client-confidential and often not even the law firm’s own. The evaluation team approximates what users do and classifies failures into a known list of ten or twenty modes. All infrastructure runs on Azure because law firms had already approved Microsoft; the data processing agreement lists a handful of vendors; audit logs and retention are product features. Google’s crash course makes the general version of this point: even when execution is local, tool output flows into a hosted model’s context and persists in logs and memory, so privacy is a harness decision, separate from security. A general-purpose harness decides for itself where data goes.

The workflow is the product. At Legora a request arrives in Slack, becomes an item in a list, kicks off an agent, lands in review, and goes back to Slack when a lawyer marks it done. At Gamma the sequence is ask, outline, template, generate, inspect, fix, serve. “The way that we edit files is important,” Lauritzen says. “The way that we do an analysis is important. The way you do legal research is all baked into it. And then of course there’s all the governance stuff around it as well.”

The economics are different. One model per session is the wrong shape for most work. In the sixty seconds after you paste your notes into Gamma, a cloud sandbox spins up with your files, the agent works out what is missing and asks, connectors pull context, an outline and a template are chosen with vision models, slides are generated in parallel, and a visual inspection pass sends fixes back. By Noronha’s count that is about 20 different models and about 200 calls for what looks to you like one answer, each job on its own curve of cost against quality, and a new model tried within an hour of release. Legora post-trains small open-weight models for fan-out legal research because it is fast and cheap, and says plainly it is “not trying to train our own Fable” because it would not win that against Anthropic.

Codified judgment is the asset. Lauritzen’s long-term pitch to law firms is that they can finally build durable capital: “the X law firm way of doing things,” encoded in a system, instead of human capital that walks out of the door when a partner leaves. That is the deepest reason to own a harness. It is where an organisation’s judgment lives once the model is a commodity.

The best plain-language illustration in either conversation is Noronha’s couch. Image models will happily render a couch you are considering into a photo of your living room, and it looks wonderful. What they cannot tell you is whether a 68-inch couch fits a 58-inch wall. A harness can: render it, then “use some good old-fashioned programming to draw a line across in pixels and measure how long it is,” and tell the model to try again until it is right. “I don’t see the labs doing that anytime soon.”

Put the seven together and the pattern is clear. Coding got its harness first because tests made the feedback loop cheap. Law and slides came next because their checks could be built: citations and lawyers, vision models and A/B tests. The same will happen, one job at a time, to development, verification, customer support, finance operations and clinical documentation. The general tools do not die; they become the inner loop, or the enterprise front door. Lauritzen expects large companies to run something like Claude Cowork and call Legora from it, while law firms simply live in Legora. For a 400-million-dollar deal, he says, you are going to want the specialist.

Two harnesses I would build

If harnesses follow the job, the question for anyone who knows a job deeply is: what would mine look like? Here are two I think about, one that I am working on and one that most engineering teams are already halfway to.

A verification harness

I have argued at conferences this year that verification is the work that survives when agents write code at machine speed, because defects now ship at machine speed too. So the harness I am working on is one for verifying a software change: not a test-generation tool, a harness whose entire loop is “was this built as specified, and how sure are we?”

A machine with two inputs on the left, a specification document with checkboxes and a glowing software build. Inside, probes test the build through a browser, an API connector and a database, each producing evidence cards. On the right a large dial reads a confidence level and a stamped report lists checkpoints with ticks and one cross.
Spec and build in. Evidence and a confidence score out.

The inputs are the specification (a story, a requirements document, acceptance criteria) and the product (a repository, a running build, a URL). The loop reads the spec and turns it into verification checkpoints; plans how each one can be checked; writes and runs the checks through whatever hands it has (an API client, a browser, a database connection, the test runner); collects evidence for each one (responses, screenshots, logs, traces); judges each checkpoint with a rubric; and reports a single number with its working: built to spec with 0.82 confidence, these three checkpoints failed, here is the evidence for each.

Pipeline diagram of the verification harness: a spec and a product feed in; the harness derives checkpoints, plans a check per checkpoint, runs checks in parallel through API, browser, data and tests, collects evidence, judges each checkpoint against a rubric, and emits a confidence score with a report. Low confidence or gaps loop back to the checkpoints.
The verification loop. Every stage after the inputs is a station the harness owns; the model only works inside them.

Map it onto the five parts and the design writes itself. Context is the spec, the product documentation and the team’s testing conventions. Actions are the runners and probes. Boundaries are the strictest in any harness I can think of: test environments only, never production, no personal data in the evidence store. Persistence is the plans and the evidence, kept across runs so the second verification of a feature is faster than the first. Evaluation is the whole point, with all three of Google’s judges present: deterministic checks for results, a model with a rubric for whether the explanation is honest, a human for whether the thing is usable. And the harness needs a golden set of its own, so that when I change it I can tell whether it got better or worse at verifying, which is the question nobody asks of their test tooling and everybody should.

It is general-purpose in the sense that it does not care what the software does. It is a specialist harness in every other sense: its tools, its checks, its users and its output are all about one job, and a coding agent that happens to be able to write tests is not it.

A development harness

The second one is what Stripe, Ramp and Spotify have already built, described for a team of fifty rather than five thousand. A ticket arrives in the tracker. A deterministic step gathers context: the relevant part of the codebase, the service’s conventions file, the last three similar changes. An agent step implements in a sandbox that has the whole stack inside it. Deterministic steps run the linter, the type checker and the tests, and a verification harness like the one above runs against the acceptance criteria. An agent step addresses review comments, capped at two rounds. A human merges. Every step is logged against the identity of the person who filed the ticket, not a shared service account.

Pipeline diagram of the development harness: a ticket enters; a deterministic step gathers context; an agent implements in a sandbox; deterministic steps run lint, types and tests; a verification gate checks the acceptance criteria; pass goes to human review and merge, fail with rounds left goes back to the sandbox.
Rented loop in the middle, owned steps around it. The deterministic stations are what make the output mergeable.

Nothing in that recipe is exotic. The agent step is a rented loop. Everything around it is yours, and everything around it is what makes the output mergeable.

Build or rent

You should not need to write the loop. The question is which loop to rent and how much of the outer harness to own, and the market has sorted itself into recognisable options.

Option What you get What it locks
Claude Agent SDK The same tools, loop and context management that power Claude Code, as a library: file and shell tools, permissions, subagents, hooks, MCP, compaction Anthropic models only
GitHub Copilot SDK The engine behind the Copilot CLI, with custom agents, skills, tools and hooks, in six languages GitHub’s auth and model management (bring-your-own-key exists)
OpenAI Agents SDK and Codex SDK A loop with native sandboxes you can snapshot and restore, with the harness kept separate from the compute so credentials stay out of the box OpenAI-first, Python-first
Vercel AI SDK TypeScript agent classes, including one that runs an established harness such as Claude Code, Codex, pi or Copilot as the inner loop, and one that makes every tool call a durable, resumable step TypeScript; harness adapters still marked experimental
LangChain Deep Agents and Open SWE A model-agnostic harness with filesystem, subagents, middleware, memory and skills (planning is opt-in), plus an open-source template of the Stripe-shaped enterprise agent More assembly
Google ADK Sessions, state, memory, graph workflows, sandboxed execution, evaluation, tied to Google’s platform Google-first
pi, goose, OpenCode Minimal or forkable open-source agents; Stripe forked goose, Ramp runs OpenCode You maintain the fork

The decision rule I would give a team: rent the inner loop, own the outer harness, and keep the two separable so you can swap the loop when the next one is better. Build your own loop only when you need something a vendor will not give you, such as telemetry on every decision, an unusual model mix, or a runtime that cannot touch the internet.

The counter-argument, and why you should build anyway

Here is the case against everything above, and I think it deserves a fair hearing. In three years we have had prompt engineering, context engineering, loop engineering and now harness engineering, each with its own job titles, and each absorbed within a year or two by the next model release. Why would this one be different? A former Cursor engineer says the parts of the harness that made models better at coding are already dead. Anthropic’s own advice on harness design is to remove components one at a time to find which are still load-bearing, because every component encodes an assumption about what the model cannot do, and those assumptions expire. One widely shared critique calls production scaffolding “a 90-day artifact” and argues for a thin harness and fat skills.

I think the critics are right about the scaffolding and wrong about the conclusion. What gets absorbed is the part that made the model smarter at a task the labs can see: how to explore a codebase, when to run the tests, how to persist on a long problem. What does not get absorbed is everything that is yours rather than the model’s: your tools, your data, your identity and permission model, your checks, your users’ tolerance for a terminal. Katz’s list of what a lab can never train away is infrastructure and runtime, trust and security, and efficiency. I would add the enterprise’s own context, because no lab will ever see it.

So build harnesses that are easy to shrink. Log every guardrail that fires and delete the ones that stop firing. Keep the orchestration thin and move the knowledge into skills and evals, which survive model changes. Treat every rule as provisional.

And then build anyway, for a reason that has nothing to do with whether the term survives. Each of those fads left behind people who understood something real. Prompt engineering taught a generation how models fail. Context engineering taught them what models need. Harness engineering is teaching, right now, how to turn a model into a system you can trust with a job, and the only way to learn it is to build one, break it, and watch which parts turn out to matter. If the word is gone in eighteen months, the intuition will not be. In a field moving this fast, intuition about what works is the only durable skill there is.

What this means for you

If you write code, your outer harness already exists. It is just untidy. Put your conventions in the instructions file, write one purpose-built tool for the thing the agent keeps getting wrong, and add one sensor that runs after it acts. That is harness engineering, and you will feel the difference in a week.

If you test, the verification harness is your seat, and nobody is sitting in it. Start with the evaluation set: ten changes you know were built right and ten you know were not, and a way to score any agent’s verdict against them. Everything else grows from there.

If you run a team, decide what you own and what you rent, and put identity and evaluation first, because those are the two things every vendor will leave to you and the two things that decide whether anyone trusts the output.

The model was never the product. The horse was never the cart. The strength was always there. The harness is what turns it into work that arrives.


The videos and papers referenced here are Aish Reganti’s talk on harness engineering, Jediah Katz’s “Is the Agent Harness Dead?” at AI Engineer, Annie Wang’s AI harness crash course for Google Cloud Tech, Jacob Lauritzen’s Latent Space interview and Jon Noronha’s conversation with Greg Isenberg; Birgitta Boeckeler’s “Harness engineering for coding agent users” on martinfowler.com; Stripe’s two Minions posts (one, two); LangChain’s “Anatomy of an Agent Harness”; Anthropic’s harness design posts; and SWE-Bench Mobile (KDD 2026). Company figures are as the companies report them. The hero and the four concept illustrations were generated with Nano Banana; the three flow diagrams with GPT Image and the five-parts diagram with Gemini 3 Pro Image, both through OpenRouter.

Keep reading

My Agents Don't Care About My Spelling: Why I Built My Own Voice Dictation App
Oct 17, 2026 · 19 min

My Agents Don't Care About My Spelling: Why I Built My Own Voice Dictation App

Signalfeed: I Stopped Letting the Algorithm Choose What I Read, and Built My Own Timeline
Oct 12, 2026 · 37 min

Signalfeed: I Stopped Letting the Algorithm Choose What I Read, and Built My Own Timeline