Battle of the cheap LLM subagent models

I wanted to know whether cheap coding models were saving money or handing the missing work back to me.

So I gave seven models the same production task in the same repository. Each started from the same Git commit. Each got the same ten-step packet, its own worktree, a 600-second limit, and hard ceilings of 12 files and 900 changed lines. Then I reran MiMo V2.5, MiMo V2.5 Pro and DeepSeek V4 Flash through a second coding client to see how much the harness changed the result.

The short answer: GPT-5.6 Luna wrote the best code. Base MiMo V2.5 was close enough at a small fraction of the direct cost that it is the better everyday worker. MiMo Pro was not worth its premium. DeepSeek improved sharply when moved from Cline to Command Code. MiMo barely moved.

The job

The task was not a toy function or greenfield demo. It was a React and TypeScript feature inside CodeRight: build a session-context bar from existing live stores, derive uncertain state without inventing facts, insert it at the correct place in the app, wire its actions, add tests, and update the changelog.

That small surface had several traps. A missing driver kind could not become Native just because that looked tidy. A branch label could not expose an absolute path. A remote environment could not become Local without evidence. The component had to disappear during onboarding and new-chat state. Store values had to update when the user changed the selected environment. Passing a test written around the wrong assumption still counted as wrong.

I scored each result out of 100:

• Correctness and tests: 45
• Requirement coverage: 25
• Code quality and security: 15
• Elapsed time: 10
• Token and cost efficiency: 5

Focused frontend tests, TypeScript checks and diff checks were rerun independently. I also read the production paths, not just the tests. No candidate got credit for a test that merely confirmed its own mistake.

Results

There were seven unique models and ten scored runs because three models also ran through Command Code.

These scores describe one bounded engineering task. They are not a general intelligence ranking.

Luna wrote the best code

Luna produced the smallest implementation and the strongest result. It put the bar in the right part of AppBody, suppressed it during the right states, kept derivation logic small, filtered unsafe environment labels and passed both its focused tests and the existing AppBody suite.

It was not merge-ready. It collapsed typed store errors into a generic Error, hard-coded one delivery load to local, let raw branch text reach a visible title, and did not render enough complete, error and remote states in component tests. Still, its defects were narrower than the rest. I would rather repair Luna's result than discover that a larger test suite had blessed a false runtime state.

That difference matters. Luna scored 68. It did not score 95. Even the winner needed review.

MiMo was the useful surprise

Base MiMo finished fastest among the successful runs and cost $0.0351 through Cline. It produced sensible component scaffolding, a broad focused suite and clean TypeScript.

Its errors were serious: it treated absent driver evidence as Native, ignored daemon health in runtime derivation, could keep a stale environment after selection changed, and exposed an environment label without a path guard. The tests passed because they encoded some of those assumptions.

The Command Code rerun landed one point lower, 61 versus 62. It fixed some wiring details and produced a real completion receipt, but failed to call the existing store load actions. A fresh session could remain Checking or Unavailable until another panel happened to load the same state.

That near tie is useful evidence. Base MiMo did not need a special client to look competitive. Its result was stable across both harnesses.

The price gap was much larger than the quality gap

Luna used 5.60 million input tokens and 22,869 output tokens. At OpenAI's current Luna rates, the run works out to roughly $0.166 to $0.318 depending on whether long-context pricing applied. Base MiMo used 4.34 million input tokens and 24,362 output tokens. Its measured charge was $0.0351, consistent with Xiaomi's current MiMo V2.5 rates.

Luna therefore cost about 4.7 to 9.1 times as much for a six-point score advantage. If Luna is already included in a subscription you pay for, its marginal cash cost may be zero until plan limits bite. If you are buying fresh coding capacity, MiMo is the easier choice.

Command Code's GOAT plan currently lists $70 in monthly credits for $10 and a boosted $30 MiMo allowance. Its “up to 99% off” language needs care: the detailed rate page shows 99% for MiMo Pro cache reads, 78% for input and 86% for output. Base MiMo is listed as up to 98% off, with current rates matching Xiaomi's price cut. It is not a blanket 99% reduction on every token.

Pro lost twice

MiMo V2.5 Pro scored 59 through Cline and 54 through Command Code. Both runs reached or exceeded the time limit. The Command Code version exceeded the line ceiling, left two focused tests failing and never produced a completion receipt.

Pro's measured Cline cost was $0.0862, about 2.5 times base MiMo's cost. The extra spend did not buy better contract fidelity, cleaner evidence handling or faster completion. On this task, “Pro” was a worse purchase.

The client changed DeepSeek, not MiMo

DeepSeek V4 Flash scored 52 through Cline and 59 through Command Code. The Cline result had 25 passing tests but failed production typecheck with five errors. The Command Code result compiled, passed all 27 focused tests and was much more useful, though still not merge-ready.

This does not tell us which internal client behavior caused the difference. Tool exposure, context packing, edit loops, permissions and stopping behavior can all matter, but this test did not isolate them. It tells us only that DeepSeek's result changed materially while MiMo's did not.

There was also a client-routing failure worth recording. Command Code 1.1.1 ignored its documented --model override when a persisted model existed. A smoke test requested MiMo but its own receipt said DeepSeek at max effort. I stopped that run with zero edits and excluded it. Passing --config model=<id> changed the actual route, and every scored Command Code request was checked against its receipt.

If a coding client cannot prove which model ran, its comparison data is suspect before anyone reads the diff.

Passing tests hid bad implementations

Several candidates wrote many tests and still got the feature wrong.

MiniMax passed 21 tests and typecheck, yet exceeded the line cap, put the component in the wrong place, invented Local from health data, selected the first environment without an explicit selection and could show the bar during new-chat.

Laguna passed 13 focused tests at zero model cost, then failed production typecheck. Step passed 18 of 20 but never loaded live stores and placed the bar above the workbench. DeepSeek through Cline passed 25 of 25 focused tests while production TypeScript still failed.

A generated test suite is evidence about what the model remembered to assert. It is not independent proof that the requirements were met.

What I would pay for

For routine implementation volume, I would use base MiMo V2.5 behind a strict orchestrator. It was cheap, fast and stable across two clients. I would use Luna for final review, repair of trust boundaries and changes where a fabricated state can do real damage. If Luna capacity is already inside a subscription, I would use more of it; if I were buying new capacity only for coding, I would buy MiMo throughput.

I would not pay the MiMo Pro premium for this workload. I would keep DeepSeek V4 Flash on the list, but only in a client that exposes reliable route receipts and under an independent compile and source review. Laguna can draft at zero model cost, but its output needs a stronger supervisor. MiniMax M3 and Step 3.5 Flash gave back too much review and repair work.

The practical pairing is cheap implementation plus better review. It is not glamorous, but it follows the receipts: MiMo writes most code, Luna handles the final risky pass, and neither grades itself.

Limits of this result

This was one frontend production slice in one repository. Every candidate had about ten minutes. Verification covered focused tests, TypeScript and source diffs; it did not include Cargo, a full desktop build, installed-app behavior or visual acceptance. Some clients reported aggregate input that included cache reads or repeated context, so token totals are useful for billing comparison but not a pure measure of reasoning efficiency.

The test answers a narrow question: which worker gave me the best starting point for this exact job under the same constraints?

On 8 August 2026, that answer was Luna for code quality and base MiMo V2.5 for money. MiMo cost $0.0351 and finished six points behind Luna.