← WTF is Agent?

The harness: a loop that survives

Part 4 of 13 · Aug 14, 2026 · 6 min read

In short Keep the model's loop, change where it runs: durable, one active turn per conversation, interrupts as signals. Let the model steer and delete the routers, lanes and planners that tried to help.Full verdict ↓

The harness is everything between "a message arrives" and "the reply is delivered": the loop that calls the model, runs its tools, folds in new input, stops, and survives a crash on the way. I did not invent the loop. I started from an existing open-source agent and changed where it runs.

1active turn per conversation, by construction
4helper layers deleted: classifier lanes, routing, planning, session modes
2layers: a long-lived guard and a short-lived turn
1unit of delegated work: the task

The design

One turn, in time A tool call starts, the process dies, the turn resumes where it was. A new message arrives mid-turn and is folded in at the next safe point.
PersonHarnessTools message model tool call process dies resumes here finished work is not replayed new message folded in reply

The journey

  1. Extend, don't replace. Keep an existing agent's loop and tools; fix where it runs. Its loop ran inside the chat process and kept state in one local file.
  2. Leverage, don't rebuild. Stop writing file and web tools. Delegate coding to coding agents and orchestrate them.
  3. Delete the helpers. Classifier-driven lanes, routing and a planner were removed. The model decides how to handle a request.
  4. Delete the modes. A conversational skill and session-mode idea was removed outright.
  5. One kind of delegated work. Tasks replaced subagents.
  6. An agent chooses its harness. The platform can host a coding agent for an agent and translate its events, instead of copying it.

Decisions that held

Decision What changed Why
Keep the loop, move it out of the chat process The loop became a durable workflow; state moved from one local file to a shared database One process held the only copy of the conversation guard, and one file serialized every write
One active turn per conversation A long-lived guard per conversation holds only a pointer to the running turn A new message is forwarded into the running turn, or starts one, with no in-memory lock
Interrupt by cancelling, not abandoning In-flight work is asked to stop and clean up Abandoned work keeps running unseen. The cost is honest: interrupt latency is bounded, not instant
The model steers, code only guards A handful of rails: approvals, spend, context size, recall A router or planner decides worse than the model reading the request
A failed tool is an observation The error goes back to the model The model can reason about a failure like any other result
Tasks, not subagents Delegated work has a durable record, can be cancelled and reports back "Needs this result first" is a dependency between tasks, not an inline wait
Host a harness, don't copy it A coding agent runs in a sandbox and its events are translated A dedicated coding agent is better at coding than anything I would write

What already exists

Option What it gives What it leaves
Agent frameworks (LangGraph, OpenAI Agents SDK) A way to express the loop and its branches. LangGraph checkpoints between steps Crash recovery is lighter than full replay, or comes from a runtime you add
Durable runtimes (Temporal, Restate, Inngest, DBOS) Resume after a crash, retries, long waits They run work, they do not know what an agent is
The agent I started from (Hermes Agent) A good loop and tools, gateways to many chat platforms Its loop runs in the chat process and its state is one SQLite file
Mine A durable loop with a conversation guard, interrupts and tasks A thin layer I maintain myself

Most comparisons I found are written by the vendors, so I leaned on the design problem and not on their rankings: single-service agents are often fine on a framework's checkpointer, and a durable runtime pays for itself when you need long waits, interruption and recovery across services.

Where it stands, and my verdict

Component Status
Memory (post 2) Built, traceable; two memory journeys pass thin
Tools (post 3) Running; journey suite measures discovery, chaining and failure measured
Loop, durability, interrupts Running through every later change stable
Failure handling A tool that fails once is retried; one that stays down is disclosed checked
Router, lanes, planner Removed. A classifier now only suggests a label the model may ignore deleted
Hosting a coding agent Designed and partly built; the platform only translates new

Verdict: the harness got smaller every time I touched it. Each rewrite moved intelligence out of the harness and into the model, and kept the harness for the things that must be guaranteed: not losing work, not running two turns at once, not spending without limit. The journey suite now exercises the failure path: a flaky tool is retried, and a tool that stays down is disclosed rather than invented. Next: what the model actually reads on each turn.