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.

8 to 10 min read • View on GitHub • More from unreallabsai

A wide editorial scene shows a control room split between waiting and orchestration. One side stalls at a blocked terminal and an hourglass, while the other routes several operations into separate chambers and stamps a ledger as events land. It explains that Unreal Agent treats tool work as durable background execution instead of a blocking chat loop.
Unreal Agent shifts the center of gravity from waiting on tools to coordinating work that can persist, resume, and keep moving.
Key Takeaways

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.

Unreal Labs, Project Author · Unreal Agent — Unreal Labs

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.

A close-up view of a paper log split into two branches on a desk. One branch continues as the current session, while another peels off into a new path labeled as an alternate route. Small stamped entries mark input, turn, running tool call, and completion, showing that history can branch into a workspace for exploration.
A forked session log is not just recoverable history. It is a workspace for retries, alternatives, and parallel reasoning.

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.

The coordinator is built around event flow, not a blocking request-response loop. The model can keep moving because the runtime records progress as part of the turn itself.

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 harnessUnreal Agent
Tool call modelBlocking request-responseAsync operation with durable status
While the tool runsThe model waits and pollsThe coordinator can keep orchestrating
Crash recoveryOften partial or manualReplayable from append-only history
History representationLogs or ephemeral contextImmutable session items
BranchingUsually discardedForkable into alternate paths
Long waitsToken and latency wasteWork continues without idle loop cost
Core logic testabilityMixed with I/O and side effectsPure 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.

Unreal Labs, Project Author · unreallabsai/unreal-agent GitHub

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.

DimensionSynchronous harnessesUnreal Agent
Tool call modelAsk, wait, then continueDispatch, persist, and keep orchestrating
Long-running workIdle polling taxBackground operations
Crash handlingOften ad hocAppend-only recovery path
HistoryMostly incidentalFirst-class state machine
ForkingRare or manualBuilt into the session store
Cost behaviorCharges for waitingReduces token waste on idle loops
Test surfaceMixed with side effectsCleaner 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.