The Model Gets the Headlines. The Harness Does the Work.

The model gets the headlines. The harness does the work.

Two teams can run the exact same frontier model and ship two completely different agents. One is trustworthy. The other quietly guesses. In healthcare, that gap is the whole job.

Every model release triggers the same reflex. Everyone reads the benchmark table, argues about which lab is ahead this month, and rewires their agents to point at the new leader.

I understand the pull. I also think it's aimed at the wrong number.

Here's a data point that reframed how my team builds. On the public GAIA agent leaderboard, one frontier model scores about 75% in one agent setup and about 31% in another. Same model. Same weights. The only thing that changed was the software wrapped around it.

Sit with that for a second. A 44-point spread is not a rounding error. It's the difference between an agent you'd put in front of a prior-auth queue and one you'd never let near a patient record. And none of it came from the model.

So when someone asks me whether our agents run on the smartest model, I tell them that's not the question that keeps me up at night. The question is what the model is allowed to do between the moment a nurse asks and the moment something happens in the EHR. That answer lives in the harness, and the harness is ours to engineer.

Where the agent line actually sits

People treat "agent" like a property of the model. It isn't. It's a property of the runtime. The same model becomes an assistant or an autonomous agent depending on five things you decide in code, not in the prompt.

What can it do without a human in the loop. How many steps does it get before it has to stop. What does it remember across those steps. Which tools and systems can it actually reach. And how is every one of its moves graded and caught.

Change any of those and the same model slides from "helpful chat" to "does things in your systems." No model swap. No fine-tune. Just a different set of rules around it.

Agency isn't something the model has. It's something the harness grants, one permission at a time.

This is why I get uneasy when a vendor pitches an agent by naming the model underneath it. That tells me almost nothing about how it'll behave in production. It's like judging a surgeon by the brand of scalpel.

The permission surface is the part that matters most

Of those five levers, one carries more weight than the rest in healthcare: what the agent is allowed to do on its own.

There's a hard line between an agent that drafts a prior-authorization letter and one that submits it. Between an agent that flags a possible contraindication and one that changes an order. On one side, the human stays in control and the agent is a very fast assistant. On the other, you've handed real authority to a system that can be wrong.

That line is not a personality trait of the model. It's a policy you write. In KORA, it's explicit: every tool an agent can touch carries a rule about whether it runs on its own or waits for a sign-off, and that rule is enforced by infrastructure, not by hoping the model behaves. You decide, per action, where "suggestion" ends and "delegated action" begins.

Get this wrong in either direction and you pay for it. Too locked down and the agent is a glorified autocomplete nobody bothers to use. Too loose and a single bad inference reaches somewhere it shouldn't. The craft is putting each individual action on the right side of that line, and being able to move it as trust is earned.

Full autonomy is the wrong goal

The industry keeps selling autonomy like more of it is always better. In healthcare it isn't. The agent I want isn't the one that never asks for help. It's the one that knows exactly when to stop and escalate.

The benchmarks back this up. When instructions get ambiguous, even the best models don't reliably know when to hand off to a human, and their performance falls off a cliff. The failure isn't that the model got dumber. It's that nobody built it a way to say "I'm not sure, check me."

So we treat escalation as a feature we design, not an accident we hope for. Knowing when to defer is a capability. We build it into the harness on purpose, because in clinical and payer work the cost of a confident wrong answer is not symmetric with the cost of asking.

The five layers we actually build

When we design an agent, the model is one line in a much longer spec. The parts that decide whether it's trustworthy break into five layers, and four of them have nothing to do with which lab trained the weights.

Persona, tools, and reasoning are non-negotiable in any real agent. Memory earns its place the moment the work runs longer than a single turn. And evaluation is the one everybody treats as optional in the demo and mandatory the day it touches a patient.

Notice what's missing from that list: "pick the best model." The model plugs into this structure. It isn't the structure.

Why we optimize the harness, not the model

There's a strategic reason we build this way, beyond safety.

The model is the most commoditized, fastest-moving, least controllable piece of the stack. A better one ships every few months, and you don't own any of them. If your agent's reliability lives inside a specific model's weights, it resets every time you switch, and you're renting the one thing you most need to trust.

The harness is the opposite. It's the part you own, the part that accumulates your policies and your hard-won judgment, and the part that keeps a powerful, imperfect model inside the lines. So that's where we put the engineering. When a stronger model ships next quarter, our customers repoint the router and keep everything that made their agent trustworthy: the permissions, the evals, the escalation rules, the audit trail, the memory of what worked.

Grade the harness, not the model. The model is a component you'll replace. The harness is the product.

None of this is a knock on the frontier labs. Their models are remarkable, and we route to several of them. But the next time you're evaluating a healthcare agent, don't start with which model it runs. Start with what that model is allowed to do without asking, how it's caught when it's wrong, and what happens when it isn't sure.

The model gets the headlines. The harness does the work. In healthcare, the harness is the work.