Your Agent Runs on a Split, Not a Model: Why the Cheap Tier Does 97% of the Tokens for Half the Bill

Deck: In Meta's own published agent run, the cheap model did almost all the work and less than half the bill. That tells you the money in your agent is set by how you split the work — not by which model you pick.

---

You shipped an agent. It runs. And every week the token bill gets a little easier to notice and a little harder to explain. So you do the obvious thing: you go looking for the one model your agent should run on. Maybe you read that a new small model "matches the frontier at a third the cost" and think, fine — swap the cheap one in everywhere and watch the bill drop.

That is the mistake, and it is worth naming precisely: operators treat an agent as a single-model choice. One model for planning, one for coding, one for subtasks, one for the whole thing. So they optimize the object that the bill is not actually set by.

The bill is set by the split — which work goes to the expensive model, which goes to the cheap one, and how often the expensive one has to fire. Optimize "the model" and you are tuning the wrong dial. Meta shipped its own numbers for this, and they are the cleanest evidence we have that the frame is wrong. (All figures below are a snapshot as of early November 2026.)

The result first: the cheap tier did 97% of the tokens for about half the money

On November 9, 2026, Meta released Muse Ember, which it calls its "smallest and most efficient" model, built for "the work agents repeat all day: tool calls, coding subtasks, routing, extraction, and long document parsing." (Meta AI Research)

Then Meta did something more useful than a launch post: it shipped a two-tier recipe with run numbers. In a Python-to-Rust port of 16 Pygments lexers, a frontier planner model (Muse Wonder) wrote the plan and supervised, and 16 parallel Ember workers each ported one lexer. Meta's own sentence:

"Muse Ember handled 158M input tokens to Muse Wonder's 4.4M, and the run cost about $3.96 at pay-as-you-go prices: $2.12 for Muse Wonder and $1.84 for Muse Ember." (Meta Developer blog)

Read that twice, because it is the whole piece.

The cheap tier ran roughly 97% of the input tokens — and accounted for about 47% of the run's cost. It did almost all the work and less than half the bill. The expensive tier ran a handful of tokens and still landed at more than half the bill.

The reason is not subtle once you see it: the two tiers are roughly 40x apart in list price. Meta's published rates have Muse Wonder at $4 per million input and $20 per million output, against Ember at $0.10 input and $0.50 output. (Meta AI Research; VentureBeat)

At a 40x price gap, the planner's few tokens are a first-class budget line, not a rounding error. And token count — the number every dashboard shows you — is a terrible proxy for cost. The tier with the fewest tokens can carry the biggest share of the dollars.

The lever is the split, not the model

Here is the reframe in one line: your agent does not run on a model. It runs on a two-tier split, and the tier that does the volume is not the tier that sets the bill.

So the decision you actually control is:

• Which work goes to the planner tier (the expensive one)?
• Which work goes to the volume tier (the cheap one)?
• How often does the planner have to re-plan?
• What check gates each cheap worker call before you trust its output?

Those are all versionable, measurable decisions. "Pick the best model" is not — it is a vibe with a leaderboard attached.

Why the obvious fix does not hold

The obvious fix is "swap to the cheap model everywhere." Meta's own numbers, and the one independent evaluation that exists, both refuse to support that.

The independent evaluator Artificial Analysis scored Ember (max) 36 on its Intelligence Index at $0.14 per task — "the cheapest model scoring 36 or higher" — against Claude Haiku 5.5 (max) at $0.41 for the same score (almost 3x more). (Artificial Analysis) That is a stunning cost result. It is also exactly the sentence people misread.

Because the same evaluation shows where the cheap tier loses:

• All-or-nothing coding. On FrontierCode 2.0, which grades whether a real engineering change is mergeable, Ember scores 27.2% against Haiku's 34.9%.** When correctness is binary — the change works or it does not — the cheap tier is behind. (Artificial Analysis)
• Knowledge and abstention. Ember's AA-Omniscience accuracy is 21.1% against Haiku's 34.7% — "the lowest of the similarly intelligent models," and mostly because it declines to answer 64% of questions.* Its hallucination rate is low (17.4%, half Haiku's) in part because* it abstains. (Artificial Analysis)

A model that abstains is cheap and safe behind a check on routing and extraction. It is expensive in the wrong way on anything that needs coverage. And VentureBeat's own read of the results is blunt: they "make a stronger case for giving Ember a bounded job with a clear check than for handing it an entire engineering ticket or a desktop workflow unattended." (VentureBeat)

So "small models are replacing frontier models" is refuted by the same tables that make Ember the cost leader. And "cheap model everywhere" mistakes a split for a swap. The defensible claim is a tiering claim, not a replacement claim.

Two honesty notes, because we do not hide soft spots:

• Every Meta benchmark and dollar figure is self-reported, priced at proposed rates. Only Artificial Analysis is independent, and it is a single evaluator using its own composite index — which is why its counterpoints carry the "where it loses" section above.
• The token counts in Meta's run do not reconcile with naive list-price arithmetic (cached input, the >200K-input step-up, and output-token accounting dominate). Treat the token-vs-dollar split as directional, not exact — which is fine, because the directional point is the one that changes your decisions.

The smaller fix that holds: a two-tier routing rule

Meta's routing rule is explicit and short:

"The plan affects every port, so it goes to the larger model. The ports are bounded, file-owned work, so they go to many small agents running at once." (Meta Developer blog)

Unpack that into a rule you can apply today:

Route by blast radius and checkability, not by volume.

• If a decision's consequences reach everything downstream — the plan, the shared interface, the taxonomy — it goes to the expensive tier.
• If a step is bounded, file-owned, and has its own acceptance check — it goes to the cheap tier.
• The tier follows how far the decision reaches and whether a check can catch a miss — never how many tokens it costs.

And crucially, the operator owns the handoff, because the harness — not the model — picks the tier per call: "Your application or agent harness chooses the model for each call and carries that context between steps." (Meta Developer blog)

So what you write down is not "which model" but the routing policy plus the worker contract. Meta's own worker contract is worth stealing almost verbatim: owned files, acceptance checks with exact expected lines, a status line that reads STATUS: COMMITTED <hash> or STATUS: BLOCKED <reason>, stop after three repeats, and — the line that matters most — "Never claim a result you did not run." (Meta Developer blog)

When a run goes wrong, you fix the brief or the route — not "the model." That is the versionable, testable part.

A worked example, and the ones you have to watch

The Pygments port (the clean anchor). 16 lexers, one planner, 16 parallel cheap workers, ~$3.96 total with the planning and the volume nearly evenly split ($2.12 / $1.84). It worked: all 16 lexers matched Python on 383/383 test inputs and 62/62 held-out real files, and the Rust commands ran 3.0–7.3x faster. (Meta Developer blog)

The 10,000-photo job (handle with care). Meta's page reports this run two different ways — first "$1.59 in total, and only $0.50 of that was Muse Ember," then later "$1.33: $0.81 for Muse Wonder and $0.52 for Muse Ember." Same page, two totals. Do not quote a precise photo figure as if it were settled; lean on the Pygments run when you need a single number. (Meta Developer blog)

The unit-inversion trap. Artificial Analysis has Muse Wonder (max) at roughly 50x Ember's cost per Intelligence Index task ($6.95 vs $0.14) — yet in the port run the two tiers were near-even ($2.12 vs $1.84), because the planner made few calls. Both are true, at different units. That is precisely the point: "the ratio" depends on how often your planner fires, so neither number is the ratio for your workload.

The label trap. Meta's numbers and Artificial Analysis's numbers measure different things — Terminal-Bench 4.0 for Haiku reads 39.2 (Meta) vs 32.8 (AA); AutomationBench-AA is "37.8% fully completed on first attempt" (Meta) vs 68.1% objective-credit (AA). Name the metric or the piece contradicts its own sources.

One more honest limit: the two-tier recipe was run inside Meta's own Muse Code harness with Meta's own cookbook. No third party has published an independent two-tier cost measurement. Do not assume Meta's dollar figures transfer to your workload — measure them.

The reusable object: the two-tier ledger

Before you change a single model, write this down.

Part 1 — the routing table. One row per agent step:

| Step | Tier | Reach | Check | Escalation |

|---|---|---|---|---|

| e.g. "port lexer #7" | volume | bounded, file-owned | pytest tests/test_7.py passes + output matches Python | broader dependency or unclear spec → back to planner |

• Tier** — planner or volume.
• Reach** — does this decision affect everything downstream, or is it bounded and file-owned?
• Check** — the exact acceptance test (a command, a schema, a fixed expected output).
• Escalation** — what sends the step back to the planner (a broader dependency, an unclear requirement, a BLOCKED status after N repeats).

Part 2 — the ledger. Per tier, record:

• price per million tokens (input / cached / output);
• the tokens and the dollars the tier actually consumed in your last run;
• cost per accepted result** — including retries and escalations.

Then read which tier the money is really in before you optimize either one.

The rule that holds: expensive model for the plan and anything whose mistake propagates; cheap model only behind a check, with one escalation path back to the planner; never hand the cheap tier an open-ended ticket, or the shared interface it cannot verify.

What to do first

Do not change a model yet. Take your last agent run and price it per tier using Part 2 above. Fill in tokens and dollars for the planner and the volume worker separately, and compute cost per accepted result for each.

You will probably learn one of two things: either the planner's few expensive calls are quietly carrying more of the bill than you assumed — in which case the fix is to fire it less and push bounded steps down; or your volume tier is doing unchecked work — in which case the fix is a check and an escalation path, not a cheaper model. Either way you will have found the dial that actually moves your bill, and it was never "which model."

The compressed version

An agent is a two-tier portfolio: a planner that touches few tokens and a volume worker that touches most of them, roughly 40x apart in price. Token count is not a cost signal — the cheap tier ran 97% of the tokens for less than half the money. Route by blast radius and checkability, gate every cheap call with a check and one escalation path, and measure cost per accepted result, not per token. The model choice is a portfolio decision. The split is the product decision.

---

Sources

• Meta AI Research, "Introducing Our Smallest, Most Efficient Model: Muse Ember" (Nov 9, 2026) — https://research.meta.ai/blog/muse-ember
• Meta Developer blog, "Start building with Muse Ember" (Nov 9, 2026) — https://dev.meta.ai/resources/blog/build-with-muse-ember
• Artificial Analysis, "Meta's Muse Ember is the cheapest model scoring 36 on the Intelligence Index" (Nov 9, 2026) — https://artificialanalysis.ai/articles/meta-s-muse-ember-is-the-cheapest-model-scoring-36-on-the-intelligence-index
• VentureBeat, "Meta's proprietary Muse Ember nearly matches Claude Haiku 5.5 at 1/3 the estimated per-task cost" (Nov 9, 2026) — https://venturebeat.com/technology/metas-proprietary-muse-ember-nearly-matches-claude-haiku-5-5-at-1-3-the-estimated-per-task-cost
• TechCrunch, "Meta releases Muse Ember, a new lightweight model for agent execution" (Nov 9, 2026) — https://techcrunch.com/2026/11/09/meta-releases-muse-ember-a-new-lightweight-model-for-agent-execution/
• @AIatMeta launch post (Nov 9, 2026) — https://x.com/AIatMeta/status/2119853591703998787

Quotes from Mark Zuckerberg ("our smallest model that delivers higher intelligence per dollar than others in its class") and Alexandr Wang ("Wonder can plan, ember can handle the volume") are quoted in VentureBeat; the underlying X posts could not be extracted directly.

---

X entryways (not posts yet)

Named from the angle brief. Each is a separate reason to consume — none is "here is the article, shortened." The post itself is written after the editor approves these entryways.

• Proof* — "In Meta's own published agent run, the cheap model did ~97% of the work and less than half the bill: 'Muse Ember handled 158M input tokens to Muse Wonder's 4.4M ... $2.12 for Muse Wonder and $1.84 for Muse Ember.' Token count is not a cost signal — the tiers are ~40x apart in price."*
• Claim carried: the cheap tier ran almost all the tokens for about half the money.
• Links to article: yes, as a bonus. The proof point stands alone (it is a self-contained stat that changes the reader's model); the link is for the reader who wants the routing rule that follows from it.

• Mechanism* — "Your agent's bill is set by the split, not the model. A planner at $4/$20 per M and a volume worker at $0.10/$0.50 per M are ~40x apart, so the planner's few tokens can carry as much of the bill as the cheap tier's many. The lever is which work goes to which tier and how often the planner fires."*
• Mechanism: price-per-token asymmetry, not volume, sets the bill.
• Links to article: yes, as a bonus. The mechanism is the post; the link carries the ledger for readers who want to price their own run.

• Workflow* — "Route by blast radius, not volume: 'The plan affects every port, so it goes to the larger model. The ports are bounded, file-owned work, so they go to many small agents.' Give the cheap tier only a bounded step with its own acceptance check and one escalation path back to the planner — never an open-ended ticket or the shared interface it cannot verify."*
• Carries: the routing rule (reach + checkability → tier).
• Links to article: bonus. The rule is usable on its own; the link points to the full routing table template.

• Risk* — "The cheap tier is cheap partly because it abstains. Independent evaluation: Ember's knowledge accuracy is the lowest of its class (21.1% vs Haiku's 34.7%) 'mostly because it declines to answer 64% of questions' — fine behind a check on routing and extraction, wrong wherever coverage matters. It also trails Haiku exactly where correctness is all-or-nothing (FrontierCode 2.0, 27.2% vs 34.9%)."*
• Carries: the cheap tier's two failure modes (abstention, all-or-nothing coding).
• Links to article: bonus. This is the counterpoint post; the link is for the "where it loses" section and the full evidence.

• Result* — "A two-tier run is not a small saving on a big bill — it is a different bill. Meta's port job: 16 lexers, 383/383 test inputs and 62/62 held-out files matched, Rust 3.0–7.3x faster, for ~$3.96 with the planning and the volume roughly evenly split. Price your own last run per tier before you 'optimize the model.'"*
• Carries: the concrete before-and-after (the port worked, and the bill looks nothing like a token-count reading would predict).
• Links to article: bonus. The result is the post; the link invites the reader to run their own per-tier ledger.