Unreal Agent Cut Agent Costs 39% Without Touching the Model

Unreal Labs open-sourced Unreal Agent on September 21, an async-first coding agent harness written in Go under MIT. It claims Terminal-Bench 4.0 at a score of 57.9 for $1,428, which is 39% under Codex at the same score. The comparison runs both harnesses on the same model, GPT-6 Astra at extra-high effort, so the saving comes from orchestration rather than a cheaper model. The design is deliberately small: one bash tool, compact prompts, no subagents, plus tool calls that run asynchronously so the model never spends tokens waiting. It took 1,597 stars in its first day. Anthropic cut Opus 5.5 running costs roughly 40% the same week by shipping a new model. Sessions are append-only plus forkable. Independent A and B testing is already under way. Best for teams whose agent bills are dominated by tool-heavy loops. Not ideal for anyone wanting a desktop app.

Two ways to cut your agent bill by 40% landed within a day of each other this week.

Anthropic shipped Opus 5.5, a new frontier model that costs around 40% less to run than Opus 5 on typical workloads.

Unreal Labs shipped a harness. Same models, same benchmarks, 39% less money.

One of those required training a frontier model. The other required thinking harder about what happens between model calls.

What Unreal Agent Actually Is

Verified through the GitHub API plus the source on September 23.

A harness is the layer around a model. It manages prompts, tool calls, execution state plus results. It does not supply a new model, which is what makes the cost claim interesting.

The Comparison Is Actually Fair

Most vendor benchmarks fall apart when you check what ran against what. This one holds up better than most.

Same model, both sides

The chart plots the Artificial Analysis Coding Agent Index against cost per task. The Unreal Agent point is hosted GPT-6 Astra at extra-high effort. Codex runs the same model.

So the variable under test is the harness. That is the correct way to measure a harness, plus it is exactly what the LangChain experiment we covered did when it held the model constant then moved its benchmark score from 52.8% to 66.5% by changing the surrounding scaffolding.

The number cross-checks

Unreal Agent reports 57.9 on Terminal-Bench 4.0.

Anthropic published GPT-6 Astra at 57.9 on Terminal-Bench 4.0 in its Opus 5.5 comparison this week. Same model, same benchmark, same score.

So Unreal Agent reproduces Astra’s own Terminal-Bench result for $1,428. At 39% under, the implied Codex figure is around $2,340. Unreal Labs publishes the percentage rather than the absolute, so treat that second number as derived.

Where it still needs outside checking

These are the vendor’s numbers. Unreal Labs ran them.

Somebody is already working on that. An independent operator has opened two issues to A and B Unreal Agent against OpenCode on separate hardware. Both label the claims as unverified and the vendor’s own. That is the right posture, plus it is faster scrutiny than most launches attract.

Why Asynchronous Tool Calls Save Money

The mechanism is simple enough to explain without a diagram, which is usually a good sign.

What normally happens

An agent calls a tool. The model waits. Waiting is not free. The model sits in the conversation managing polls, heartbeats plus status checks. Every one of those costs tokens.

Run a long build, a test suite or a slow network call, then multiply that overhead across hundreds of turns.

What Unreal Agent does

Long-running tools execute as asynchronous operations. The model submits several independent calls in one turn, then carries on. The harness handles waits, polls plus heartbeats without involving the model.

Unreal Labs describes two effects. Users can steer the agent without waiting for tool calls to finish. The agent schedules more useful tool work between model calls.

The deliberate smallness

One bash tool rather than a wide tool surface. Compact prompts. Token-efficient outputs. No subagents. Batched calls encouraged.

Every one of those choices removes tokens the model would otherwise spend describing its own bookkeeping. None of them make the model smarter.

The Local Model Gap

One thing the chart leaves out, plus it matters for a project pitched on cost.

The native ollama provider

The harness ships a native ollama provider whose default base is a local address, overridable through an environment variable. So running Unreal Agent against a model on your own hardware is supported out of the box.

It does not appear in the benchmark

The cost chart contains hosted GPT-6 Astra. No local model appears anywhere in it.

That is reasonable for a comparison against Codex, since Codex runs hosted models. It leaves one question open though. What happens when an efficient harness meets a model you are not paying per token for?

Every provider speaks one API

Reading the source, every provider talks to the OpenAI Responses API through a single endpoint shape. That keeps the harness small. Any provider you want has to speak that dialect or sit behind a proxy that does.

Somebody has already forked it to add a pay-per-request provider settling micropayments per call. The provider layer is evidently easy to extend.

It Is Headless on Purpose

The interface choice tells you who this was built for, plus it is the opposite of everything else shipping this month.

What you actually get

A command line runner. It takes a prompt or a JSON request, writes JSONL events to standard output, then exits when the task ends.

There is no terminal UI, no desktop app plus no browser interface.

Compare that to the week’s other releases

ZCode arrived as a desktop app plus a browser interface plus a terminal agent, all in one repository. Claude Code plus Codex both ship rich terminal experiences people sit inside for hours.

Unreal Agent assumes something else is sitting in front of it.

Why that fits the company

Unreal Labs builds agent products. The blog post describes the problem they hit while deploying agents in the wild, wanting them to respond quickly plus run cheaply.

A harness emitting structured events over standard output is a component, not a product. You embed it in something, then your thing has the interface.

That makes this useful to a narrower group than a star count suggests. If you want an agent to sit in your editor, this is not that. If you are building a product with an agent inside it, this is exactly that.

The Session Model Is the Underrated Part

Cost gets the headline. The session design is what would keep me using it.

Append-only plus forkable

Sessions are append-only, forkable plus versioned. Crash recovery runs through a swappable operation manager.

Append-only means the record of what happened does not get rewritten. Forkable means you can branch from any point rather than restarting. Versioned means you can tell which version of the harness produced which behaviour.

Why that matters for anything long-running

Agents fail. A four-hour refactor dies at hour three, plus the usual outcome is starting over.

With forkable sessions you branch from before the failure. With crash recovery through a manager you can swap, you decide how that recovery behaves instead of accepting whatever the vendor chose.

The debugging angle

JSONL events on standard output means every turn is a line you can grep, diff plus replay. Compare that with reconstructing what an agent did from a scrollback buffer.

For anyone running agents unattended, that difference matters more than 39%. You cannot improve what you cannot inspect, plus most harnesses make inspection an afterthought.

Somebody Is Already Checking the Numbers

This deserves its own section, because it is how benchmark claims should get handled.

What is being run

An independent operator opened two issues within a day of the launch, one for a DGX box plus one for an M5 Max laptop. Both A and B Unreal Agent against OpenCode using models already known good on that hardware.

The plan is specific. Ten excision tasks, three trials each, same server, same tasks, same reasoning setting, with only the client changing plus the server restarted between arms.

The framing is correct

Both issues open by labelling the claims as unverified and the vendor’s own, then quote the exact post plus timestamp. Both note that the cost chart’s Unreal Agent point is hosted GPT-6 Astra at extra-high effort, with no local model anywhere in it.

That is the posture we keep asking for. State what the vendor said, state what you are testing, then run it.

Why this is faster than usual

Jev launched on September 15 plus waited a week for an independent benchmark. Unreal Agent got somebody planning A and B runs inside 24 hours.

The difference is that a harness claim is cheap to test. You need the same model, two clients plus a task set. No training run, no gated access, no waitlist.

What to watch for

Whether the saving holds on local models, since that is the case the vendor did not measure. Whether it holds on tasks with fewer long tool calls, since the mechanism targets waiting specifically.

A harness optimised for asynchronous tool work should show smaller gains on workloads that barely use tools. Nobody has published that curve either.

The Other Comparison Nobody Quoted

The 39% against Codex travelled. A second figure did not.

Up to 20% against Pi

Unreal Labs’ own blog reports up to 40% savings against Codex plus up to 20% against Pi on real workloads and agentic benchmarks.

Twenty percent is a smaller number, which is presumably why it did not make the tweet. It is also the more informative one.

Why the smaller number says more

Codex is a full product with a terminal experience, safety layers plus features unrelated to cost. Comparing a minimal harness against it measures partly the cost of being a product.

Pi is closer to a like-for-like harness comparison. A 20% gap there is a cleaner read on what the async design buys you, stripped of the difference between a component plus a shipped application.

The general lesson

When a launch quotes two numbers against two competitors, the smaller one is usually measured against the closer comparison. We saw the same shape with TypeSafe’s 193.6x, where the headline figure carried a handicapped baseline the vendor disclosed themselves.

Unreal Labs published both figures openly. Only one of them spread.

Two Roads to the Same 40%

Put this week’s releases side by side, because they answer the same question differently.

Anthropic’s route

Opus 5.5 delivers roughly 40% lower cost on typical workloads against Opus 5. Token prices dropped 20% to $4 and $20 per million. Cache reads fell 60% to $0.20 per million. The model also uses fewer tokens per task.

That required training a new frontier model, which is available to exactly one company.

Unreal’s route

Same models everyone already has, reorganised around them. 39% less spend at an equal score.

That required a design decision about where waiting happens, which is available to anyone.

Why both matter to you

If your agent bill is dominated by model pricing, the Anthropic route helps automatically the moment you switch models.

If your bill is dominated by long tool calls inside agent loops, the harness route helps more, plus the two stack. A cheaper model inside a more efficient harness compounds.

Our Claude Pro review covers the subscription side. This is the other half of the same equation.

Who Unreal Labs Is

Short section, because the company is small plus the details matter for reading the claim.

What they do

Unreal Labs builds agentic products. The harness came out of that work rather than arriving as the product itself, which the blog post says directly: while deploying agents in the wild, they wanted them fast plus cheap to run.

They also describe evaluating popular agent SDKs along the way, noting that vendor SDKs carry trade-offs that are not obvious until you are deep in one.

The account is small, the post was not

The launch came from an account with roughly 4,100 followers. It reached over 670,000 views with 4,852 bookmarks.

That ratio is unusual. Bookmarks mean saving something to act on, plus a save rate that high from an unknown account means the claim landed on a real problem rather than an audience.

Brett Berson of First Round amplified it, which explains some of the reach without explaining the bookmarks.

The commercial position

MIT harness, open repository, then an invitation to contact them about frontier cost efficiency for your agents.

That is a consulting funnel or a future product, which is fine plus worth naming. The same shape as Z.ai giving away ZCode to sell model access, or Nous giving away Hermes with a paid Portal behind it.

Open source as distribution is now the default posture in this category. Three companies in two weeks.

Harness Engineering Keeps Being Right

This is the third release in a month arguing the same thing, which stops being a coincidence.

The pattern so far

Hermes crossed 246,000 stars as an open harness that runs on whatever model you point at it. ZCode arrived from Z.ai as a full open workbench with 1,539 forks on day one. Now Unreal Agent claims frontier cost efficiency from orchestration alone.

None of them trained a model. All three compete on the layer around one.

What that implies about the stack

If a harness can move cost 39% at constant capability, then harness choice is a first-class decision rather than a detail. Most teams currently pick one by installing whatever their editor suggests.

Unreal Labs states the case directly, describing harness design as a research area in its own right with many ideas still unexplored. On the evidence of the past month, that is hard to argue with.

The commercial shape

Unreal Labs is a company, plus the blog post ends with an invitation to get in touch about frontier cost efficiency. The harness is MIT, so the open release is distribution for a consulting or product relationship.

That is the same bargain behind ZCode, where Z.ai gives away the client to sell model access. Open harness, paid something else.

What You Should Actually Do

If your agent bill is mostly tool calls

Try it. The saving mechanism targets exactly your problem, plus at MIT with a headless CLI the cost of testing is an afternoon.

Run your own workload through both harnesses on the same model, then compare spend. That measurement is the only one that matters for your stack.

If you are running local models

The ollama provider exists, though no local model appears in the published benchmark. You are testing something the vendor has not measured.

That is worth doing plus worth publishing, since nobody has that number yet.

If you are evaluating harnesses generally

Insist on the same model on both sides. A harness comparison across different models measures nothing. That is the failure we found reading TypeSafe’s own benchmark caveats, where competing models ran through a wrapper the vendor admitted was slower.

Unreal Labs got this part right, which is worth saying plainly.

If you maintain a harness

Read the async tool design. The mechanism is not proprietary, plus nothing stops Claude Code, Codex or any open harness adopting the same approach.

A 39% saving available to anyone who restructures where waiting happens is a strong argument that the rest of the field has been leaving money on the table.

If you are just watching

Two open issues on a repo with 1,597 stars means almost nobody has hit a wall yet, or almost nobody is running it in anger. Check again in a week. Fresh Commits tracks whether these things survive their first fortnight.

The Part Worth Keeping

A model that costs 40% less to run is a thing one company can build.

A harness that costs 39% less to run is a thing anyone can build. Unreal Labs just gave theirs away under MIT.

The numbers are the vendor’s own, so wait for the independent A and B tests already in progress before betting a budget on them. The mechanism holds up under reading though. Tokens spent waiting for tool calls are tokens spent on nothing, plus every harness that keeps the model in the loop during a slow build is burning them.

Anthropic’s answer required a frontier training run. This one required noticing where the waiting happens.

Charts and Blocks

Two routes to the same saving

What the harness changes