The direct answer
What the agent harness layer is
The agent harness layer is the part of the agent stack that runs complete agent tasks: the execution loop, tool calls, session state, files, and results that turn a model into a working agent.
An AI agent has two halves. A model reasons about what to do next. A harness does it: it holds the loop that plans, calls tools, edits files, recovers from failures, and carries state from one step to the next. Agent harnesses such as Codex, Claude Code, and Hermes are complete implementations of that second half, built and continuously improved by the labs behind them.
Through 2026 this half has been separating into a layer of its own. Labs keep shipping complete harnesses, products keep embedding them, and the stack is sorting itself the way stacks tend to: models below, applications above, and a distinct layer in between whose job is running the work.
This article makes one argument: agreement on the concept is not what makes a layer real. A shared contract is. The agent harness layer already has the agreement; this article is about the contract.
The evidence
The industry is converging on the harness
The vocabulary settled first. In the months leading up to August 2026, Databricks, Red Hat, Builder.io, and Parallel each published their own definition of an agent harness. A compact formulation now circulates in developer communities: an agent is a model plus a harness. Community-curated GitHub lists now collect tools and patterns for the practice under a name contributors coined themselves: harness engineering.
The products followed. In August 2026 Microsoft's Agent Framework brought its harness and hosted agents to general availability. Anthropic's Claude Managed Agents offer a hosted path for running managed agents. The major labs and open-source contributors keep investing in complete harnesses, so capabilities that product teams once assembled themselves now arrive built in.
The demand signal is visible too: on Google Trends, search interest in the term agent harness has climbed through 2026, and a May 2026 Hacker News thread debated where the harness belongs relative to the sandbox. When practitioners argue about where something sits in the stack, it has become a real part of the stack.
The gap
Shared definitions do not make a layer
Here is the catch: the industry broadly agrees agents need a harness, and each vendor defines the harness differently. One vendor's harness is an in-process library. Another's is a hosted runtime. Another's is whatever wraps the model in their own product. Each definition is internally consistent, and none of them is interchangeable with the others.
Compare that with the layers we take for granted. Operating systems became a dependable layer for applications when POSIX standardized the interface to them. Networking became a layer anyone could build on when TCP/IP standardized how packets move. The analogy is explanatory rather than proof, and the histories differ in detail, but the pattern holds: a layer becomes real infrastructure when there is a shared contract at its boundary, so that what sits above can swap what sits below.
By that test, the agent harness layer is still forming. Harnesses exist, excellent ones. What has been missing is the contract: a common way for an application to drive any of them, so that choosing a harness is a decision you can revisit instead of an architecture you marry.
The mechanism
What the layer's contract has to cover
Running a harness is not one interface but several surfaces that have to hold together. A contract for the layer has to cover all of them, because an application depends on every one:
- Task and run: how work is submitted and how each execution is identified, so results are traceable.
- Session: how work opens, persists, and resumes, so a follow-up request continues instead of starting over.
- Streaming: how progress and events flow back while the harness works, including the tool calls it makes.
- Files and artifacts: how inputs enter the workspace and how finished, reviewable outputs come back out.
- Rendering: how an artifact is described so the application's own UI can present it to a user.
- Cancellation and failure: how work stops cleanly and how errors are reported in one vocabulary.
Miss any one surface and the layer leaks: the application must reach around the contract into harness-specific behavior, and portability is gone. That is why a definition is not enough. Definitions describe the harness; a contract binds the boundary above it.
The contract
A contract for the layer, and an interface that implements it
HarnessRouter is the world's first unified interface for agent harnesses. Unified interface here means the full product-backend contract: task execution, sessions, files, streaming, and results, across different vendors' complete harnesses rather than a client library or a model gateway.
The contract underneath it is the Unified Harness Protocol (UHP): an open, versioned contract for the layer, defined with OpenAPI 3.1 and JSON Schema 2020-12 and published at unifiedharnessprotocol.org. The specification is public, anyone can implement it, and a conformance suite runs locally so compatibility is a verifiable property rather than a promise. HarnessRouter open-sourced the protocol and the Community Edition server that runs it on your own infrastructure.
In practice the layer feels simple from above: your app sends one task; HarnessRouter runs the best harness in a sandbox and returns renderable artifacts to your UI. The sandbox is part of the layer, not the layer itself: isolation is where the work executes, while the harness contract is what your product talks to.
The implications
What a real layer changes for builders
Once the layer has a contract, the build-or-adopt decision gets cleaner. If you assemble your own agent system, you own every surface above: the loop, sessions, streaming, files, recovery. That is a reasonable choice when the agent is your product. When the agent powers a feature inside your product, running through the layer means those surfaces come bundled, and your engineering goes into what users see.
It also changes how you evaluate harnesses. Behind one contract, harnesses become comparable: the same task can run on different harness and model combinations, and success, latency, and cost can be measured instead of assumed. Model routers and AI gateways keep their own jobs in this picture: a model router selects model calls, an AI gateway governs model traffic, and the harness layer executes complete tasks. The layers compose rather than compete.
Layered maps of the broader stack are covered in our AI product infrastructure article; this piece is the argument for the layer itself.
The conclusion
The layer is forming; the contract makes it real
The agent harness layer is no longer a prediction. The definitions, the products, and the search curves all point the same way: running agents is becoming its own layer of the stack. What turns that consensus into infrastructure is a shared contract at the boundary, covering tasks, sessions, streaming, files, artifacts, and failure, openly specified so no single vendor can lock it in.
That contract now exists, and it is open. The fastest way to understand a layer is to build on it.
FAQ
Agent harness layer FAQ
What is the agent harness layer?
It is the emerging middle of the agent stack: models reason below it, applications live above it, and this layer executes the work, the loop, tool calls, sessions, streaming, files, and artifacts. It becomes dependable infrastructure once a shared contract covers that boundary.
How is the agent harness layer different from an orchestration layer?
Orchestration coordinates multiple agents or steps into a workflow. The harness layer runs each unit of work itself: one task, on one harness, through one contract. An orchestrator can sit above the harness layer and call it repeatedly; the two are complementary rather than competing.
Is the harness part of the sandbox?
No. The sandbox is where an agent's actions execute in isolation; the harness is the loop driving those actions and reporting back to your application. A complete harness layer bundles sandboxed execution, but isolation by itself gives you no sessions, no streaming, no artifacts, and no contract.
Build on the agent harness layer
Integrate once against an open contract, run harnesses like Codex, Claude Code, and Hermes behind it, and keep the choice of harness a decision instead of an architecture.
Start building on the layer