The Harness Is the Routing Layer

The Harness Is the Routing Layer

The model is the part of an agent stack that gets compared in public. The harness is the part that decides what the model can actually do.

That distinction is becoming infrastructure. HarnessRouter has open-sourced the Unified Harness Protocol, an Apache 2.0 contract for driving complete agent runtimes through one interface. Its Community Edition runs harnesses including Codex, Claude Code, Hermes, DeepSeek Harness, Gemini CLI, and Pi through a self-hosted service.

The important claim is not that every harness is interchangeable today. UHP is explicitly a draft standard, versioned as 2026-10-19. The important claim is that harness selection deserves its own routing layer, separate from model selection.

A model API gives you a turn. A harness gives you a task.

A model endpoint normally answers a narrow question: send messages in, receive tokens out, run tools yourself, and assemble the next request.

A harness owns the loop around that model. It plans, calls tools, edits files, manages a session, streams progress, handles cancellation, and returns artifacts. Those are not cosmetic differences. They define the execution environment in which a model’s output becomes an action.

UHP describes the boundary plainly: its unit of exchange is a task, not a completion. The protocol standardizes the application-to-harness surface for tasks, events, sessions, files, artifacts, errors, and capabilities. The protocol README also separates UHP from a model API. UHP does not replace the model provider. It tells a product how to drive the runtime that uses one.

That gives the stack a more useful shape:

product
  |
  v
UHP task contract
  |
  +-> Codex
  +-> Claude Code
  +-> Hermes
  +-> DeepSeek Harness
  +-> the next harness

The adapter is not the product. The lifecycle is.

The N x M problem is real, but the API is not the hard part

HarnessRouter’s YC launch write-up frames the problem as N products multiplied by M harnesses. Each pairing otherwise needs its own task execution, session, streaming, file, artifact, and error-handling integration.

The first instinct is to standardize the request shape. That helps, but it is the easy part.

The hard part is preserving meaning across runtimes. What does cancellation mean if a tool call is already running? Which files belong to a task after a retry? Can a session continue after a process restart? Which capabilities are available before the task starts? What is safe to replay when a network connection dies after the harness acted?

UHP puts those questions into the contract instead of leaving them as undocumented adapter behavior. Its specification includes separate chapters for lifecycle, environments, memories, tasks, streaming, sessions, files, errors, security, and schemas. The protocol’s task documentation also defines an Idempotency-Key path for retries, so a conformant server can return the first result rather than starting a second execution.

That last detail is where infrastructure starts. A retry that duplicates a tool action is not a transport bug. It is a control-loop bug.

Harness choice changes cost and latency

HarnessRouter reports a controlled comparison of eight harness and model configurations on the same task and input. In that test, total cost varied by 475 times and latency by 3.2 times. Holding the model fixed while changing the harness moved cost by 1.5 to 2.1 times and latency by up to 1.95 times.

Those figures are vendor-reported results from one benchmark, not a universal ranking. They are still useful because they expose a dimension most teams do not measure on their own workload.

Routing decisionWhat it changes
ModelReasoning behavior, token price, knowledge, output quality
HarnessTool loop, context handling, retries, state, permissions, artifacts
Task policyApproval gates, time limits, data access, stop conditions
ProviderCapacity, network path, rate limits, price, operational controls

A model leaderboard cannot answer which harness is cheaper for a repository migration, which one resumes cleanly after a runner restart, or which one exposes enough trace data to audit a destructive tool call.

Those are routing questions. They belong above the model.

The uncomfortable trust boundary

Interchangeability is not the same as equivalence.

The protocol website says that UHP standardizes how applications connect to harnesses, while each harness keeps its own permission model. That is the correct warning. A common request shape does not mean a common security boundary.

If a product swaps the backend from one harness to another, it must not silently swap its governance with it. Permissions, data egress rules, approval requirements, human stop controls, and decision records should live above the selected harness. Otherwise a routing change can also become a policy change.

Capability discovery matters here. A caller needs to know whether the selected runtime supports the controls the task requires before sending sensitive work. A harness router that hides differences in pause, approval, filesystem scope, or network access is not abstracting risk. It is concealing it.

The protocol can standardize the interface. It cannot make an unsafe harness safe by placing it behind one.

What operators should measure

Do not start by asking whether a harness supports the same endpoint. Start by testing the lifecycle that your product depends on.

At minimum, measure:

  • whether a task can be cancelled while a tool is active
  • whether a retry with the same idempotency key avoids duplicate side effects
  • whether files and artifacts survive a process or container restart
  • whether a session can continue without losing context
  • whether the trace preserves tool calls, failures, and provider identity
  • whether capability differences are visible before task execution
  • whether the permission and approval policy remains unchanged after routing

Run those checks against the same task and the same model. Otherwise model quality and harness behavior get mixed into one result and the routing decision remains guesswork.

UHP’s conformance suite is a useful starting point because it treats lifecycle behavior as testable contract surface. It is not a substitute for workload-specific evaluation or a security review, but it points evaluation at the parts of an agent system that ordinary completion benchmarks ignore.

The standard still has to earn its name

UHP is a draft standard, not a guarantee that every major harness will adopt it. A protocol becomes durable when independent implementations pass the same tests, preserve semantics under failure, and expose their differences instead of flattening them into a happy-path demo.

The open repository is moving quickly. Its GitHub project lists an Apache 2.0 license, a machine-readable schema, and a runnable conformance suite. Those are the right ingredients. The next proof is operational: can a task resume across implementations, can retries stay idempotent, and can a product keep its security policy stable while the backend changes?

The model is only one component in an agent decision. The harness controls the loop that turns the model into a system.

That loop is now becoming routable.

Sources

Keep reading