An opencode Alternative That Cost 40 Percent Less on the Same Bug Fix

If you are looking for an opencode alternative, the question underneath is usually money. Coding agents all read files, run tests and write patches. What separates them is how many tokens they burn getting there, and tokens are the bill. So we measured it instead of arguing about it, because "cheaper than opencode" is a claim that either survives a wire log or it does not.

On 22 August 2026 we ran the same bug fix through opencode three times and through the LU Labs coding agent, on the same model, through the same API, priced from the same list. This post is the result, including the parts that do not flatter us.

How the runs were set up

Everything that could be held constant was held constant.

• Same task. A clone of a small JavaScript repo pinned to one commit, tests red at the start, a single wrong line in add.js. Success meant npm test passing, exactly one commit, only that file touched, and a clean working tree afterwards. All four runs met that bar.
• Same prompt. Byte identical, checksummed before each run.
• Same model. deepseek-ai/DeepSeek-V3.2 for every run.
• Same API and same prices. opencode was wired to https://lu-labs.ai/api/inference/v1 as an OpenAI compatible provider, so both agents drew on the same account, the same credit ledger and the same per token rate.
• Same measurement. Requests and token counts came off a wire proxy sitting in front of the API. Credits were read from the account before and after each run.

opencode was version 1.18.21, installed from npm and run as opencode run --auto with its own defaults otherwise. We did not tune it.

The numbers

Run	Credits	Requests	Prompt tokens	Task solved
opencode, run 1	1679	8	98789	yes
opencode, run 2	2433	11	146058	yes
opencode, run 3	2358	11	146387	yes
LU Labs 2.6.6	1298	16	74629	yes
LU Labs 2.6.5	4395	30	257270	yes

Averaged over the three opencode runs, the same fix came out about 40 percent cheaper than opencode on LU Labs 2.6.6. Put the other way round, opencode cost 1.66 times as much. Even its cheapest run, the eight request one, still landed 29 percent above our number.

Where the difference comes from

Not from pricing, and we can show that. Credits per prompt token came out at 0.01739 on LU Labs and 0.01700, 0.01666 and 0.01611 on the three opencode runs. That is the same meter, reading the same rate. The whole gap is token volume.

The two agents get there differently. opencode needs fewer turns, eight to eleven against our sixteen. But it carries roughly three times as much on every single one: 12349 to 13308 prompt tokens per request against 4664 for LU Labs 2.6.6. More turns of a small payload beat fewer turns of a large one, and it is not close.

Two things drive the payload size.

The tool catalogue. Every request has to describe the tools the model may call. That block is 21188 bytes in opencode and 7703 bytes in LU Labs 2.6.6. It is fixed cost, paid on every request, before the model has read a single line of your code.

Context decay. From the third turn onwards, LU Labs truncates the output of older tool calls, so a file the agent read six steps ago stops being resent in full. Without that, a transcript compounds: each step pays for every step before it. That is the difference between a run that gets cheaper per step and one that gets more expensive.

Most of that saving is recent, and it came out of our own numbers being bad first.

What changed between our own 2.6.5 and 2.6.6

This next number is a separate measurement, and it has nothing to do with opencode. Across our own set of tool using runs, LU Labs 2.6.6 spent about 78 percent fewer credits than LU Labs 2.6.5, our own previous release. That is a version to version figure for our own agent. It is not the gap to opencode, which is the roughly 40 percent above.

Those two numbers also come from different sets. The 78 percent is averaged over our internal tool driven runs. On the single task in the table above, our own 2.6.5 would have cost 4395 credits against 1298, which is 70 percent, and still above every opencode run in the table.

Limits of this benchmark

This is one measurement, not a verdict, and it is worth being precise about what it does not cover.

• One scenario. A tiny repo and a one line bug. It says nothing about a large codebase, a multi file refactor, or a task where the agent has to search hard before it can start. We did not run the long tail against opencode.
• An uneven sample. opencode ran three times, LU Labs once. The spread within opencode alone is 45 percent, from 1679 to 2433 credits. Our own spread on this scenario is unknown, and a single run can be a lucky one.
• Defaults, not a tuned setup. opencode ran as it ships. Someone who trims its tool set or changes its context handling would get a different, probably better, number. That comparison is fair to the out of the box experience and unfair to the ceiling.
• What still holds it up. The arithmetic is hard to escape. With a fixed block pushing every request over 13000 tokens, six agent steps already approach the total that LU Labs 2.6.6 spent on the whole task. opencode would have to change shape, not just get lucky, to land underneath.

And to be plain about it: opencode solved the task cleanly three times out of three, with one commit and a clean tree each time. This is a cost comparison between two tools that both work, not a quality one.

What that means if you are choosing

If you run an agent occasionally, none of this matters much. If you run one all day, per request overhead is the line item that decides your monthly bill, and it is the one nobody publishes. Ask any agent you are evaluating how large its tool block is and what it does with old tool output. Those two answers predict the invoice better than any benchmark chart.

Our own pricing, including what a credit costs and what the plans include, is on the pricing page. If you would rather not pay per token at all, the coding agent runs against a local model too: our roundup of the best open weight models you can run at home in 2026 is the place to start, and Qwen 3.8 27B is the current sweet spot for a coding agent on a single graphics card.

The full run logs, the checksummed prompt and the end state of the scenario are kept with our internal benchmark evidence. If you want to reproduce it, everything above is enough to rebuild the setup.