Unreal Agent is an open-source harness for coding agents, released on September 22, 2026 by Unreal Labs Inc., a US-based company. A harness sits between an LLM and its tools (running commands, editing files and so on), handling how calls are passed along and how their execution is managed. What sets Unreal Agent apart is its “async-first” design: tool calls run in the background, so the model can plan its next step without waiting for them to finish. It is distributed in three forms — a Go library, an executable, and a benchmark runner — under the MIT license.
Key Features
- Asynchronous tool execution: The harness validates and dispatches the model’s tool calls and runs them in the background. Polling, waiting and managing multiple operations running in parallel are handled by the harness, so the model does not have to spend steps on them
- Forkable persistent sessions: Sessions are stored in an append-only way, and you can branch (fork) the history from a midpoint or restore it. Tool-call state and operation records are kept together
- Context builder: It assembles the model input in memory and returns a record of what was omitted, truncated or compacted. The benefit is that you can trace afterwards what was cut
- Multiple model providers: You can switch between OpenAI, OpenRouter, Fireworks, Ollama and others. Cloud models and local models can be tried through the same mechanism
- Standalone executable:
unreal-agent-runneris a runner used much likeclaude -porcodex exec, letting you check its behavior without embedding it as a library - Harbor-compatible benchmark runner: It ships with a runner compatible with the Harbor evaluation framework, so you can reproduce benchmarks such as Terminal-Bench locally
Pricing
| Plan | Price | Key Features |
|---|---|---|
| Open source (MIT) | Free | Go library, executable and benchmark runner |
Pricing is as of September 2026. Unreal Agent itself has no paid plans or managed service. However, API fees for the model providers you use (such as OpenAI) are charged separately. For the latest information, see the official GitHub repository.
Pros & Cons
✅ Pros
- When embedding it into your own agent product, you do not have to write wait and polling control from scratch, so you can focus on the agent’s core logic
- The official blog states that it cut inference cost by up to around 40% compared with Codex without lowering accuracy, which makes it worth considering for long-running tasks where API costs pile up (these are Unreal Labs’ own measurements; no independent third-party verification has been confirmed)
- The MIT license lets you embed and modify it in commercial products without hesitation
- You can swap providers and compare them under the same conditions, gathering your own evidence for model selection
⚠️ Cons
- It has only just been released (as of September 2026, releases are in the v0.1 series), has little production track record, and its API may change
- There is no dedicated documentation site; the README is the main source of information
- CONTRIBUTING.md states that the maintainers do not have the capacity to review and merge external pull requests. This makes it harder to use if you expect bug fixes to be accepted upstream
- It is described as components selected from a large internal codebase and published, so not every feature Unreal Labs uses internally is included
- It assumes embedding in Go, so it is not suited to non-engineers or no-code use
Comparison with Similar Services
| Service | Difference from Unreal Agent |
|---|---|
| Codex (OpenAI) | A coding agent CLI you use as is. Unreal Agent uses it as the comparison point in its own benchmarks; it is not primarily meant to be embedded as a harness |
| Claude Agent SDK (Anthropic) | An official SDK for building agents. Tool execution is handled along the model’s turns, and it does not position itself as async-first |
| OpenHands | An autonomous coding agent platform that includes its own execution environment. It is feature-rich, but heavier than a lightweight standalone Go harness |
| LangGraph | A graph-based orchestration framework for general-purpose agents. It does not focus on coding or on asynchronous tool execution |
Who Is It For
- Development teams building their own coding agents who want to avoid writing a tool-execution foundation themselves
- Engineers looking for ways to lower an agent’s inference cost
- Researchers and evaluators who want to reproduce and compare agent performance on benchmarks such as Terminal-Bench
- People who want to read the code of an agent foundation written in Go and learn from its design
Summary
At the core of Unreal Agent is the idea that the model should not have to think about time spent waiting for tools to finish. The cost-reduction figures are the provider’s own measurements, so the reliable way to know whether you get the same effect on your tasks is to check with the included benchmark runner. Since it has just been released and does not accept outside contributions, a sensible way to start is with evaluation and as a design reference rather than production deployment.