Three models built for the same job landed inside 48 hours. Grok 4.5 on July 8; GPT-5.6's Terra tier and Meta's Muse Spark 1.1 on July 9. All three are sub-frontier by design, all three point at agentic and coding workloads, and all three exist to undercut the flagships. If you run agents, this is a routing decision, not a headline — and the model with the lowest sticker price is not automatically the cheapest to run.
Here is the whole comparison in one screen, then the one number that should actually drive the choice.
The prices, side by side#
| Terra (GPT-5.6) | Muse Spark 1.1 | Grok 4.5 | |
|---|---|---|---|
| Input / 1M | $2.50 | $1.25 | $2.00 |
| Output / 1M | $15.00 | $4.25 | $6.00 |
| Cached input | 90% off | — | $0.50 (75% off) |
| Context | large | 1M, self-managing | 500k |
| Status | GA | preview (US) | GA |
By output price alone the ranking is clean: Muse Spark ($4.25) < Grok ($6) < Terra ($15). Terra's output token costs about 3.5x what Muse Spark's does. If you stop reading here you route everything to Meta and call it a day. Don't stop reading here.
Output is the number that bills an agent#
Two facts change the picture. First, all three price output far above input — Terra by 6x ($15 vs $2.50), Grok by 3x, Muse Spark by ~3.4x. Second, an agent is an output-heavy workload. A chat app sends a long prompt and gets a short answer back; it's input-dominated, and cache discounts do most of the work. An agent loop does the opposite: it emits tool calls, reasoning, code, plans, and retries, turn after turn. The tokens it generates are what pile up, so the output rate dominates the bill — and the input-side cache discounts (Terra's 90%, Grok's 75%) only ever touch the smaller half of the invoice.
That's why output price, not the blended headline number, is the first thing to rank on. But it's not the last.
Sticker price per token is not price per task#
Cost per completed task = the tokens the model emits × the output rate. A terser model at a higher per-token price can be cheaper per finished job than a chatty model at a lower one.
This is the part the comparison tables miss. What you actually pay to finish a task is how many output tokens the model spends getting there, multiplied by its rate. Two models can invert on cost-per-task versus cost-per-token if one is disciplined and the other rambles.
And discipline is trainable. Grok 4.5 was co-trained on Cursor's agent telemetry — real traces of agents doing real work — which pushes it toward emitting fewer tokens per step. That terseness compounds across a long run: a per-step saving multiplied by dozens of steps, which is the whole tokens-per-task argument in miniature. So even though Grok's output token ($6) costs more than Muse Spark's ($4.25), on a verbose task Grok can still land a lower bill by spending fewer tokens. Muse Spark's verbosity on your workload is simply unknown until you measure it — Meta publishes a price, not a token budget.
The only honest way to rank them is to run the same eval task through all three, count output tokens, and multiply by each rate. That is a ten-minute experiment, and it will disagree with the sticker prices often enough to be worth doing every time.
The tie-breakers that aren't price#
Once you've measured cost-per-task and the numbers are close, the non-price differences decide it:
- Muse Spark 1.1 ships a self-managing 1M-token context — it compacts and retrieves its own history across a long run, which is plumbing (summarization, retrieval, compaction) you'd otherwise build and own yourself. It also speaks both the OpenAI and Anthropic SDK formats, so trialing it is a base-URL-and-key swap. The catch: it's a US-only public preview with no SLA, and Meta's own eval puts it below the leaders on the hardest coding.
- Grok 4.5 lives natively in Cursor on every plan and carries a 75% cache discount ($0.50 cached input) and a 500k window — with a higher-context surcharge above ~200k tokens to watch. If your agent runs in an editor, distribution alone may decide it.
- Terra is the priciest output token here, so it wins on the things that aren't the token: the deepest cache discount (90% on reads), the most mature tooling, and a clean in-vendor ladder — drop to Luna ($1/$6) for routing and classification, climb to Sol ($5/$30) for the hardest reasoning — without leaving the OpenAI SDK.
The decision#
Don't route on the sticker price. Measure output-tokens-per-task on your own eval, multiply by each output rate, add cache-adjusted input, and let that number choose. As a starting map:
- High-volume, cost-sensitive, long-context agentic work → Muse Spark 1.1, and let its self-managing context delete some of your plumbing.
- In-editor coding loops, especially in Cursor, where terseness compounds → Grok 4.5.
- Cache-heavy workloads, or anything already on OpenAI tooling → Terra, with Luna and Sol one line of config away.
- Your hardest coding and reasoning → a frontier tier (Sol, Opus). None of these three are built to be that, and their own vendors don't claim they are.
The week's real lesson isn't that a new cheapest model arrived. It's that "cheapest" stopped being a property of the price sheet and became a property of your workload — and the only way to read it is to run the tokens.
