Unreal Agent: The Go Runtime That Stops Treating Tool Calls Like Blocking I/O
An async-first harness for durable agent work, forkable history, and crash-proof tool execution.
- Unreal Agent’s core idea is that tool calls should behave like durable operations, not blocking chat turn delays.
- The coordinator, session store, and context builder split orchestration, persistence, and prompt assembly into separate layers that are easier to reason about and recover.
- Forkable session history turns logs into a workspace, so crashes, retries, and alternate paths are part of the design instead of failure modes.
- Its real competition is not another model, but synchronous harnesses that pay a polling tax in latency, tokens, and reliability.
Most agent frameworks still behave like an expensive conversation with a stopwatch running. They ask the model to call a tool, then they wait, poll, and hope nothing important changes before the result comes back. Unreal Agent takes a harder line: the tool call is not the center of the system. The runtime is.
The Unreal Agent harness manages tool calls in a completely asynchronous way, relieving the underlying model of the need to manage waits, polls, and heartbeats for tools.
The agent that does not wait
That difference sounds small until you have a five-minute build, a slow test suite, or a flaky shell command in the middle of a turn. In a synchronous harness, the model is stuck paying for inactivity. In Unreal Agent, the work gets promoted into an operation that can continue off to the side while the coordinator keeps its head clear.
The practical result is a shift in mental model. Tool calls become operations. Operations become history. History becomes durable state. Once you accept that sequence, the rest of the design starts to look less like LLM plumbing and more like systems engineering.
Why the coordinator is the real product
The brain of the system lives in harness/coordinator/loop.go. That file is not a simple request handler. It is an event loop that keeps pulling from the inbox and from operation updates, batching them through a slurp pattern before deciding what to do next.
for {
events := slurpChannel(inbox, operationUpdates)
turn := startOrResumeTurn(events)
result := coordinator.Step(turn)
if result.HasRunningOperation() {
persistRunningState(result)
continue
}
emitNextEvents(result)
}
That structure matters because it lets a turn behave like a lifecycle object rather than a single response. The coordinator can dispatch work, persist status, and re-enter the model with a running-state message when the operation is still in flight. The agent is still doing useful orchestration while the slow part finishes elsewhere.
History is the state machine
The session store is not just a log. It is the state machine. Unreal Agent records immutable items such as fork, input, turn, model_response, and tool_call_status, so the system can reconstruct what happened without guessing.
| Traditional harness | Unreal Agent | |
|---|---|---|
| Tool call model | Blocking request-response | Async operation with durable status |
| While the tool runs | The model waits and polls | The coordinator can keep orchestrating |
| Crash recovery | Often partial or manual | Replayable from append-only history |
| History representation | Logs or ephemeral context | Immutable session items |
| Branching | Usually discarded | Forkable into alternate paths |
| Long waits | Token and latency waste | Work continues without idle loop cost |
| Core logic testability | Mixed with I/O and side effects | Pure layers are easier to test |
The important move is that persistence is not an afterthought. When a tool call is still running, the store records that fact explicitly. If the process dies, the next run does not have to infer the last known state from a pile of logs. It can resume from the exact operation boundary.
Forking turns the log into a workspace
Fork is the feature that pushes the project from reliability into agency. A recoverable log is useful. A branchable log is much more interesting. It means the agent can preserve one line of reasoning while trying another, or retry a failed path without destroying the original context.
That is a more serious idea than it first looks. In many systems, history exists so humans can audit what happened. Here, history exists so the agent can use it as working memory with alternate futures attached.
The pure layer that keeps side effects at the edge
The cleanest part of the design is also the easiest to miss. contextbuilder and tool.Translator stay pure. They interpret state and produce prompts or operation specs, but they do not do I/O. That keeps the edge of the system narrow and the center easy to reason about.
The builder also injects an explicit running-state message into the prompt when work is still pending. The model gets told, in plain language, that a tool is still executing and that it can continue with independent work or wait. That is a subtle but important piece of control. The runtime is not just moving data around. It is shaping the model’s next decision.
Unreal Agent's published runs cost 39% less than Codex on Terminal-Bench 4.0: $1,428 against $2,350 for the same 57.9% pass rate.
The boring Unix code that makes the whole thing credible
A lot of agent software sounds clever until it touches the operating system. Unreal Agent leans into the unglamorous parts instead. Its primitives deal with processes, signals, and file sync, which is exactly where reliability usually gets won or lost.
// Conceptually, the runtime has to do three unglamorous things well:
// 1. start and supervise processes
// 2. persist state before acknowledging completion
// 3. survive signals without corrupting history
if err := flushToDisk(path); err != nil {
return err
}
if err := superviseProcess(ctx, cmd); err != nil {
return err
}
That is the point. A serious agent harness is not defined by how poetic its prompts are. It is defined by whether it can survive the real world, where shells hang, file writes lag, and processes get killed.
What Unreal Agent is really competing with
The nearest comparison is not a model. It is a synchronous harness. Think Claude Code, Codex-style CLI agents, and other terminal wrappers that keep the model waiting while they poll for completion. Unreal Agent argues that this pattern wastes both money and time when tasks are long-running.
| Dimension | Synchronous harnesses | Unreal Agent |
|---|---|---|
| Tool call model | Ask, wait, then continue | Dispatch, persist, and keep orchestrating |
| Long-running work | Idle polling tax | Background operations |
| Crash handling | Often ad hoc | Append-only recovery path |
| History | Mostly incidental | First-class state machine |
| Forking | Rare or manual | Built into the session store |
| Cost behavior | Charges for waiting | Reduces token waste on idle loops |
| Test surface | Mixed with side effects | Cleaner separation of pure logic and execution |
That makes the strategic bet pretty clear. As agent tasks get longer and less predictable, the runtime matters more. The harness stops being glue and starts being product.
Why this matters now
Unreal Agent is not promising that every agent needs this exact stack. It is making a narrower claim. Once tasks stretch into minutes, when failures are normal and retries are expected, the system around the model becomes part of the model’s usefulness.
That is the real shift here. Unreal Agent treats orchestration as a durable system, not a chat loop with nicer packaging. In a field obsessed with model capability, that is a useful reminder: sometimes the biggest gain comes from refusing to wait.





