Meta Muse Ember at 10 Cents per Million Tokens: What a Cheap Worker Model Changes
Meta's Muse Ember is the fourth model in the Muse family and the cheapest yet at 10 cents per million input tokens. It is built to sit under a planner and absorb the repetitive work agents do all day. Here is where the planner-worker split pays off, where it quietly fails, and how to test it before routing real traffic.
Key takeaways
- Ember is priced at 10 cents per million input tokens, roughly an order of magnitude below frontier mid-tier models, and Meta positions it as the worker in a planner-worker pair with Muse Wonder.
- The saving only materializes when the planner produces explicit rules and the worker applies them at volume. Ambiguous instructions push work back to the expensive tier.
- Ember handles text, images, and audio, which means screenshot reading, scanned document parsing, and voice memo transcription can stay in the cheap tier instead of calling a separate model.
- Meta's cost-per-task claims come from a composite benchmark. Validate them on your own task mix, because composite scores hide the long tail of failures that cost the most.
In this article
Every agent architecture we ship eventually converges on the same shape: one expensive model that decides what to do, and a fleet of cheap calls that do it. The expensive part is not the decision. It is the twenty thousand repetitive steps that follow.
Meta Superintelligence Lab released Muse Ember on Monday specifically for that second half. It is the lightest and most cost-efficient model in the Muse family, priced at 10 cents per million input tokens, and Meta's own framing is unusually direct: "Muse Wonder plans, Muse Ember handles the volume."
That sentence is the whole product thesis. The question for teams building agents is whether the economics actually change, and under what conditions they do not.
Where Ember sits in the Muse family
Ember is the fourth Muse model. Spark arrived in April as the mid-weight option, Glimmer in August as Spark's open-source twin, and Wonder in October as the frontier model. Ember is the volume tier underneath all of them.
Meta describes it as designed for "complex reasoning execution and the work agents repeat all day: tool calls, coding subtasks, routing, extraction, and long document parsing." That list is not the glamorous part of agent work. It is the part that shows up on the invoice.
The pricing claim is the sharp edge. At 10 cents per million input tokens, Ember undercuts frontier mid-tier competitors like Anthropic's Haiku and OpenAI's Luna, and Meta positions it as cost-competitive with open-weight options including DeepSeek V4.1 Flash and GLM 5.3 Flash. Competing with open weights on price matters because open weights usually win on cost and lose on operational overhead. If a hosted model matches the price, the hosting argument gets weaker.
One caution before the math: Meta led with input pricing. Output tokens are usually the larger line item in agent workloads, and the announcement did not make output price the headline. Check it before you build a business case on the 10 cent figure.
The planner-worker split, now with a real price gap
The architecture Meta is describing is what most production teams already run, just with less extreme price separation.
[Business goal]
|
v
[Planner: frontier model]
breaks goal into rules + tasks
|
+-----------------+-----------------+
| | |
v v v
[Worker: Ember] [Worker: Ember] [Worker: Ember]
extract fields parse document route ticket
| | |
+-----------------+-----------------+
|
v
[Validator: rules or frontier]
The planner decides. The workers execute. A validator checks before anything irreversible happens.
The economics only work if the planner hands down something a cheap model can follow without judgment. "Reconcile unpaid Q3 vendor invoices against receiving dock slips" is a plan, not a task. The worker needs the rules: which fields to extract, which tolerance counts as a match, what to do when the PO number is missing, and when to escalate.
When those rules are explicit, a cheap model applies them at volume with high reliability. When they are implicit, the worker guesses, the guesses are wrong, and the retries or escalations flow back to the expensive tier. You end up paying frontier prices with extra steps.
The arithmetic, with assumptions stated
Meta's claim is about cost per task. The mechanism is simpler: the same token volume costs less. Here is illustrative math, not a benchmark, for a workload of 100,000 extraction tasks at 20,000 input tokens and 1,000 output tokens each.
| Line item | At $0.80 / 1M input | At $0.10 / 1M input |
|---|---|---|
| Input tokens (2B total) | $1,600 | $200 |
| Output tokens (100M total) | depends on output price | depends on output price |
| Retry overhead at 5% | $80 | $10 |
| Human review of failures | unchanged | unchanged |
On input alone the gap is 8x. That is real money at volume, and it is the reason teams route extraction and parsing to the cheap tier even when the frontier model is more capable.
But notice the last row. Human review does not get cheaper. If a cheaper model fails 3 percent more often on your task and each failure costs a person ten minutes, the labor line can erase the token saving entirely. This is why cost-per-completed-task, not cost per token, is the only number worth putting in a business case.
Where the cheap worker actually helps
Based on the task types Meta names, four categories are worth testing immediately:
- Structured extraction. Pulling fields from invoices, purchase orders, and forms where the schema is fixed and the source format is stable.
- Routing and classification. Deciding which queue, team, or downstream agent a request belongs to.
- Tool call formatting. Emitting valid JSON for an API call when the arguments are already decided by the planner.
- Long document parsing. Reading a 60-page contract to locate specific clauses, where the answer is a span rather than a synthesis.
These tasks share a property: correctness is checkable. You can assert that a field matches a regex, that a category is in an enum, or that a tool call validates against a schema. Cheap models are safest where validation is deterministic.
Where it does not
Three categories we would keep on the expensive tier for now:
- Ambiguous intent. When the request is underspecified, a cheap model picks a plausible interpretation and proceeds. A frontier model asks.
- Planning. The planner is where errors compound. A bad plan executed flawlessly at scale is worse than a good plan executed slowly.
- Final validation before irreversible actions. Payments, deletions, outbound emails, and anything touching production data should be checked by the strongest available model or by deterministic rules.
Ember is built to execute, and that is precisely why it should not be the last line of defense.
Multimodal in the worker tier is the underrated part
Ember handles text, images, and audio. Meta's framing: agents can read screenshots, charts, and scanned documents, or work from voice memos, meeting recordings, and video without a separate model.
This matters more than it sounds. Most agent pipelines we audit have a patchwork of specialist models: one for OCR, one for audio transcription, one for vision, each with its own latency, cost, and failure mode. Collapsing those into the worker tier removes integration surface. A single call that reads a screenshot and returns a structured field is easier to validate than a chain of three models passing intermediate text.
It also changes the cost profile for document-heavy workflows. Parsing a scanned invoice used to mean a vision call at vision prices. If the same model handles it at worker prices, the unit economics of document automation improve even when the extraction volume is modest.
Treat the benchmark chart as a hypothesis
Meta's cost-per-task chart uses Artificial Analysis's composite intelligence index, and it shows Ember as cheaper and smarter than Haiku and Luna. Composite indices are useful for a first cut and misleading for a final decision.
Two reasons. First, a composite averages across tasks, and your workload is not the average. A model that wins on aggregate can lose on the one task you run a million times. Second, cost-per-task on a benchmark assumes the same number of attempts. In production, failure rate drives retries, and retries drive cost. A model that is marginally less accurate but much cheaper can win, or lose, depending on where it fails.
How to test it without betting the workflow
Run Ember in shadow mode for a week:
- Capture a representative set of at least 500 real worker tasks, including the ugly ones.
- Run both your current worker model and Ember on the same inputs.
- Score with deterministic validators first, then human review on a sample.
- Compute cost per completed task including retries, not cost per token.
- Compare failure modes, not just failure rates. A model that fails loudly is easier to operate than one that fails silently.
If Ember wins on cost per completed task and its failures are loud and catchable, move a bounded slice of traffic and keep the validator. If the failures are quiet, keep it in the low-stakes tier.
The bottom line
Muse Ember is the clearest statement yet that model pricing is splitting into a planner tier and a worker tier. At 10 cents per million input tokens, the worker tier is now cheap enough that routing decisions matter more than model selection.
That is good news for anyone building agents, and it moves the engineering problem to where it belongs: writing rules precise enough that a cheap model can follow them, and building validators strong enough to catch it when it cannot.
At Foundrysoft, we design planner-worker agent architectures with deterministic validation at every boundary, so cheaper worker models reduce cost without moving risk onto your operations team.
Estimate your project cost, token budget, and automation ROI
We built free, production-calibrated tools to help engineering leaders forecast token consumption, compare build vs buy scenarios, and audit code security.
Work with us on this
Stop burning money on unnecessary LLM tokens. We optimize your Vercel AI SDK implementation to reduce latency and cut inference costs.
AI Consulting Services in IndiaExpert AI Consulting in India. We help enterprises and startups identify high-ROI AI use cases, select the right models, and design scalable architectures.
Related reading
Monitor the business journey, failures, integrations, and usage charges in a vibe-coded app so the team can detect problems and explain the monthly bill.
Calculate whether AI subscriptions and automation pay for themselves using review time, completed work, full operating costs, and a realistic break-even example.
Anthropic cut Fable 5.1 cache-read costs 75% on 1 September 2026. Here is who actually saves money, how to structure prompts so the cache hits, and when Opus 5 is still the right spend.
Let's build something great.
Have a project in mind? We are an elite software and AI development studio ready to bring your ideas to production. Let's talk about your roadmap.