The model is not the product

The application layer — not the model — decides what people actually get from AI. On what a harness owes the model, what it owes the human, and why the iteration loop is the real interface.

Andriy Kudelya · 2026-07-11 · 8 min

Give two people the same frontier model and watch what happens. One lands a working refactor, a triaged inbox, a report their team actually reads. The other gets a wall of plausible text and a vague feeling of having been flattered. For a while we explained this gap as “prompting skill,” as if there were an incantation one person knew and the other didn't.

That explanation has aged badly. The gap increasingly lives somewhere else: in the software around the model. The clearest evidence comes from agentic coding benchmarks, where results are reported as a pair — model plus scaffold — because the same weights swing dramatically depending on the harness driving them. Tools like Claude Code and Cursor don't make the model smarter. They change what a given level of smart can accomplish. Calling them “LLM wrappers” misreads where the engineering actually is.

The model sets the ceiling. The harness decides how much of that ceiling a person actually reaches.

Name the layer

By harness we mean everything between a person's intent and the model's forward pass: what context gets assembled and what gets left out, which tools exist and how they are described, when the model is asked to check its own work and against what, what the human is shown, and what a retry costs. Every AI application is a set of answers to these questions — most of them implicit, many of them accidental.

The interesting engineering of the past two years has been making those answers deliberate. A coding agent that reads the failing test before proposing a fix; a research assistant that is forced to cite what it fetched; a workflow tool that shows you its plan before spending your tokens — these are harness decisions, and they routinely matter more than the next model version.

What the harness owes the model

Context as a budget, not a dump. The intuition “give it everything, let it figure it out” fails in practice: attention degrades as context grows, and relevance beats completeness long before the window is full. The harness's first job is editorial — deciding what the model will not see. This is why context engineering is displacing prompt engineering as the load-bearing discipline: the prompt is one paragraph of a much larger, mostly machine-assembled document, and the quality of that assembly is the quality of the answer.

Tools as contracts. A tool description is a prompt. A vague tool produces vague behavior; a tool that swallows errors teaches the model a false picture of the world it is acting in. The well-run harnesses treat every tool like a public API: precise inputs, honest failures, documented when-to-use — because the model reads nothing else.

Something external to check against. A model's confidence in its own output is not a signal; models grade their own work kindly. The harness must supply ground truth from outside the generating context — a test run, a schema validation, a rubric applied by fresh eyes. Where such a check exists, quality compounds across retries. Where it doesn't, retries just resample.

Bounded iteration. Room to retry with new information is what separates an agent from an autocomplete. But unbounded retrying is not persistence, it's divergence — the loop needs a budget and a stop condition, decided by the harness, not by the model's own enthusiasm.

What the harness owes the human

Assumptions out loud. Every real request is underspecified, and models fill gaps by guessing rather than stalling — that's the correct behavior, and the harness should let them. What it must not do is hide the guesses. A hidden assumption becomes a silently wrong artifact discovered a day later; a visible one costs a single correction. Surfacing assumptions converts requirements-gathering from an interrogation into a review — the person corrects one line instead of answering twenty questions they can't yet answer.

A plan you can judge at a glance. Humans are slow at auditing prose and fast at judging structure. Ask someone to read a 2,000-word description of a workflow and they will skim it and say “looks good.” Show them the same workflow as a shape — steps, handoffs, loops — and they will spot the missing review step in five seconds. Legibility is not presentation polish; it is what makes human oversight real instead of ceremonial.

A cheap rerun. Here is our strongest claim: the true interface of an AI application is not the chat box or the diagram — it is the iteration loop. Nobody's first brief is right. The number that decides whether a tool feels magical or exhausting is the cost, in minutes and attention, of converting a wrong guess into a right one. Harness design is loop design.

An artifact that outlives the session. What the person walks away with should be portable — inspectable text they can carry into any model or tool, not an opaque run history inside someone's proprietary state. Lock-in through artifacts is a business model; portability through artifacts is a design principle. We think the second one wins trust, and trust is the currency this layer runs on.

The shape everything is converging on

Look across the serious harnesses — coding agents, research assistants, workflow tools — and the same skeleton keeps emerging: understand → plan → execute → verify, with a human checkpoint placed where the plan is cheapest to correct. Anthropic's own guidance to builders says start with simple, composable patterns and add autonomy only where it earns its keep; the tools people actually rely on converged on the same answer independently.

We don't think that's fashion. It's the shape of delegating work under ambiguity — the same protocol a good senior engineer runs when handed a fuzzy brief: play it back, state your assumptions, propose a plan, do the work, show evidence it's done. The harness layer is rediscovering, in software, the etiquette of competent delegation.

Where we stand

Prowrit is our running experiment on one specific piece of this layer: what should the artifact between human intent and agent execution look like? Our bet is an inspectable workflow — sectioned prompts with explicit contracts, declared assumptions, bounded review loops — drawn so a person can judge its shape in seconds and correct it in one move. This lab exists to publish what we learn while testing that bet, including the parts that prove us wrong.

Model releases will keep raising the ceiling, and that work belongs to the labs training them. But the distance between the ceiling and what a person on a Tuesday afternoon actually gets — that distance belongs to the harness. Closing it is the most interesting engineering problem in this field right now, and it is nowhere near solved.