An agent harness is everything around a language model that turns single model calls into finished work: what starts each agent, what it is given to read, what it may do and where its output goes. To build one, write those answers down for each agent and move them out of prompts into schedules, events, tickets and reviews that hold when nobody is at the keyboard.
What an agent harness is
A language model takes text and returns text. An agent is a model that calls tools in a loop until a task is done. The harness is the system around that loop. It decides when the agent runs, which context and tools it receives, where its state is kept and who checks the result.
The word has a second use. An evaluation harness runs a set of cases against an agent and scores the answers. I built one for a higher-education group. On integration it runs a smoke set, and before promotion it runs the full golden regression. This guide is about the first kind, the harness that runs the work. The second kind is one of its layers, and the guide on automated LLM evaluation covers it.
How an agent harness works
For every agent, the harness settles the same points.
What wakes it. My own agents do not all start the same way. Some wake on a schedule. Some react to an event such as a ticket, a comment or a build. There are loops that keep looking for useful work, and there are sessions that pursue one goal for 24 or 36 hours at a time.
What it reads. The harness gives each agent a skill for the kind of input it handles and a tool surface with clear limits. One example from my own work is mentu-navigator, a read-only tool for repository navigation that people and agents use through a CLI or an MCP server. Its contract is pinned to four primitives: locate, read_range, open and handles.
Where the work goes. The output becomes a durable record, such as a ticket with tags or a file in a repository. Other agents react to that record.
Who checks it. Another agent can review the result, and a person reviews the output that matters. The harness keeps what each run did, including what it refused to do.
Static workflow or dynamic planner: how to describe your harness
The usual labels for agent systems are static workflow, dynamic planner and hybrid. My preprint The Agent Graph Runtime, listed under Research, treats them as answers to four separate questions. When is the graph of steps built? Where does it become fixed and addressable? Who authors it? What runs it? Answer each one for your own system, and the label matters less.
The model separates the stages of a run: construction, lowering, qualification, freezing, requalification, admission, execution and evidence. It keeps five properties apart, because they are easily read as one: the identity of the executable graph, the identity of its execution environment, the reproducibility of the output, the adequacy of the plan and the outcome. A run that ends well still says nothing about whether its plan was adequate.
When you need an agent harness: decision rules
- If the same explanation is given twice, once in a meeting and again to an agent, that boundary is a candidate. So is any work that sits idle until you are back at the computer.
- If a rule must hold, put it in the coordination system. Who owns what, the permissions, the durable state and the required reviews cannot be left to the memory of an agent.
- If several agents share the work, record two things outside the prompt: which work is free and which is already claimed, and which result is only proposed and which is accepted.
- If a check is hard to automate, add a layer and keep a person on the important output. Judging whether an interface feels wrong is an example. A design-review agent with a browser can be that layer.
- If the output of the harness is promoted to production, bind the evaluation to the exact candidate. The guide on agentic workflow integrity explains how.
How to build an agent harness step by step
- Write down the path of one piece of work as it happens today, from the human conversation to the finished result.
- Mark every point where you carry something by hand: notes, context, a ticket, an instruction to an agent.
- Choose the boundary that repeats most. Fix where its input lands, for example a folder in a repository, and add a process that notices new files.
- Write a skill for that kind of input, and give the agent only the tools the step needs.
- Make the output a durable record with tags that other agents can react to.
- Decide how each agent starts: on a schedule, on an event or in a loop.
- Make states explicit. Queued, attempted and completed are three different states of an action.
- Add a review that names the version it examined. Keep the objections that stay open.
- Stop a run halfway on purpose and check how it recovers.
What goes wrong in an agent harness
- A person stays as the integration layer. The agents run all day, and every meeting still ends with someone who writes notes, copies context and creates the ticket.
- Parallel work is mistaken for collaboration. When nobody owns a task and handoffs are loose, several agents repeat the same work, make changes that conflict or review an artifact that is already stale.
- A review repeats the assumption it should test. Agreement between two agents can be one assumption stated twice. A useful review adds a test that the work might not have passed.
- A status message is taken as proof. What an agent said in a transcript is not the evidence that the work is done.
- Recovery asks the model to guess. After an interruption, the run should resume from durable state, not from a guess about how far it got.
- The evaluation layer shares state. In the higher-education harness, the cases shared user state through the memory of the agent, and the early pass rates were wrong without anyone noticing.
A worked example: a meeting that becomes tickets
My agents could keep working while I was away from the computer, and my meetings could not. After each call I opened the laptop, wrote notes, copied context, created a ticket, explained the conversation again and pointed an agent at the right repository. I was the integration layer.
My answer is a physical agent harness, which I am still building. It sits where human activity meets the system of agents, and it is made of hardware. The parts are an iPad mini, an external camera, a microphone, a light, a USB-C hub and a battery, mounted as one portable station for meetings. The framing, the light and the sound are the same in my office or on a trip.
The software side is designed as a chain. The conversation is transcribed. The transcript lands in a repository, under a path such as /docs/meetings/. A monitoring process notices it. An agent reads it with a specialized skill and works out which client and workspace it belongs to, which decisions were made and which commitments were created. Decisions and tasks become tickets, and the tickets are tagged. Another agent environment reacts to the tags. Documentation is updated by one agent, the implementation is done by a second and the result is reviewed by a third. A monitoring session keeps watching the ticket.
With this chain, a meeting is no longer a text that waits for me. The system receives it as one more event, like a ticket or a build. The hardware covers the part of the world that agents do not normally see: conversation, intent, decisions and nuance. The software covers everything after that.
What the evidence on agent harnesses does not show
The essay behind the example describes a setup that I am building and the way my own agents run. It reports no measurement of time saved or of reliability, so I state none. Full autonomy is not what it claims. The aim is that each repeated manual boundary becomes a candidate for a system, while I define intent, review important output and make decisions.
The Agent Graph Runtime is a model. It reports a mechanical invariant exercise on a frozen historical pilot and certifies its own novelty as uncertified. It excludes by design any claim that the model is better or more general than others, and it certifies no deployment.
The description of mentu-navigator says that every performance-relevant default traces to a registered, mechanically adjudicated study, and that one default was already retired by its frozen prediction. That evidence is about the defaults of one retrieval tool, not about a whole harness. The evaluation harness for the higher-education group is evidence about evaluation, and its case study gives the details.