Muse Ember Pricing: $0.10/M Input and the Benchmark Fine Print

Muse Ember Pricing: $0.10/M Input and the Benchmark Fine Print

Meta shipped Muse Ember 1.0 on November 9, and the Muse Ember pricing is the headline: $0.10 per million input tokens and $0.50 per million output. Meta calls it its smallest and most efficient Muse model, built for the boring, high-volume jobs inside agents: tool calls, routing, extraction, coding subtasks and long-document parsing.

The benchmark chart says it edges out Claude Haiku 5.5. Read the footnotes, though. Several of those wins come with asterisks Meta printed in small type.

We haven't run our own evals yet, so everything below comes from Meta's page, read closely.

Muse Ember Pricing and Limits

Here's what's on Meta's launch page, per million tokens:

Two things jump out. Cached input is 25x cheaper than fresh input, so agents that resend the same system prompt and tool schemas all day get a real discount.

And crossing 200K tokens triples every rate. The 1M-token context window is real, but filling it costs three times as much per token.

Here's what that means for a typical sub-agent call. Say each step sends a 20K-token cached system prompt and tool schema, 5K tokens of fresh context, and gets 1K tokens back. That's $0.00008 cached, $0.0005 fresh input and $0.0005 output, about $0.0011 per call.

A million calls comes to roughly $1,080. Skip the caching and the same million calls cost about $3,000. Prompt stability is worth almost 3x on your bill.

Other specs:

• Context: 1M tokens, with up to 512K output tokens.
• Inputs: text, image, audio and video.
• Model ID: muse-ember-1.0 on the Meta Muse Ember API, with Responses API support.
• Where it runs: the Meta Model API, Muse Code, Google Cloud and Oracle Cloud.

Meta says Ember is the first model trained using Muse Wonder Full. The page doesn't mention parameter count, open weights, rate limits, a free tier or regional availability. Don't assume any of them.

Muse Ember Benchmarks: Technical Breakdown

All numbers below are Meta-reported, run at max reasoning, for Muse Ember vs Haiku 5.5 and Muse Ember vs GPT-6 Luna.

Now the fine print.

Terminal-Bench isn't apples to apples. Ember ran in mini-swe-agent, Haiku in Claude Code, Luna in Codex. A 1.7-point lead across three different harnesses tells you very little about the models themselves.

OSWorld has two scores. The 69.5 headline uses partial credit. Under binary pass/fail scoring it's 33.8. Ember still leads, but finishes a third of desktop tasks is a very different pitch than nearly 70%.

Some results are Meta-internal. Agents' Last Exam (a Linux subset), OSWorld 2.1 and PerceptionBench weren't independently checked. The -AA rows and the Intelligence Index come from Artificial Analysis, which is the better signal.

Haiku still wins on hard code. FrontierCode 2.0-AA is the one row where Ember loses clearly, 27.2 to 34.9. On the overall Intelligence Index they tie at 36.

Muse Ember vs Haiku 5.5 on Cost Per Task

Meta's strongest claim is cost: about $0.14 per Artificial Analysis task, versus $2.39 for Muse Spark 1.3 at max settings. The chart plots Ember at $0.116 and $0.136 depending on settings.

Here's the catch. That chart labels Ember's costs as estimates at proposed pricing, while the footnote says list pricing. Treat $0.14 as Meta's estimate, not a measured bill.

And look at the competitors' ranges on the same chart. Haiku 5.5 runs $0.092 to $0.411 per task. GPT-6 Luna runs $0.073 to $0.152.

So at low settings, both rivals can be cheaper per task than Ember. Ember's case is the score-per-dollar at max reasoning, not the absolute lowest bill.

Real-World Use Cases

• Sub-agent worker. Your planner model breaks a job into steps. Ember handles the tool calls and coding subtasks underneath. That's exactly the role Meta designed it for.
• Routing and extraction at volume. Pulling fields out of invoices, tickets or logs, where cached system prompts make the $0.004 rate matter.
• Long-document parsing. Contracts and specs up to 200K tokens stay at the base rate. Past that, budget for 3x.
• Multimodal triage. It takes audio and video input, so screenshots and call recordings can go into the same pipeline.

One honest counterpoint for pure classification work. On the same day Ember launched, Amazon's Strands team posted that it replaced Claude Sonnet 4.6 with Strands Decider, a constrained picker running a Gemma 4 E4B build, for ticket labelling across 20 labels plus a none option.

Cost per ticket dropped from $0.0222 to $0.0005 and latency from 4,215 ms to 897 ms. Amazon didn't publish an accuracy number. Still, if your task is pick one of N, you may not need a general model at all, even a cheap one.

Hard Limitations & Flaws

• No independent coding win. The harness mismatch on Terminal-Bench and the FrontierCode loss mean you shouldn't swap Ember into a coding agent on faith.
• Long context gets pricey. The 3x jump past 200K tokens hits exactly the long-document jobs Meta advertises.
• Unknowns. No published rate limits, free tier, regions or deprecation policy. Weights aren't on the page either. Secondary reports say they're private.
• Partner numbers are partner numbers. Cloudflare's up to 30% faster at the tail and You.com's 2.2s p95 are self-reported.
• Cost chart hedge. Proposed pricing estimates can drift from what you actually pay.

Verdict: Developer Action Plan

Muse Ember is a credible cheap worker model, not a Haiku killer. The real wins are AutomationBench and the Coding Agent Index from Artificial Analysis. The flashier numbers lean on partial credit and mixed harnesses.

1. Run your own eval. Pull 200 real sub-tasks from your agent logs and score Ember against Haiku 5.5 on pass/fail, not partial credit.
2. Cache aggressively. Keep system prompts and tool schemas stable so you hit the $0.004 cached rate.
3. Stay under 200K. Chunk documents if you can. It's the difference between $0.10 and $0.30 input.
4. Keep a fallback. Route hard code generation to a stronger model until FrontierCode-style results improve.
5. Check if you need an LLM at all. For fixed-label classification, a constrained decider may beat every model on cost.