Muse Ember: Why the Price Triples Past 200K Tokens
Adding 1,000 input tokens can turn a $0.025 Muse Ember request into a $0.0753 request. The difference comes from crossing one line in Meta’s pricing table. I’d watch that line more closely than the million-token context window on the model card.
Meta released Muse Ember on November 9, 2026 in the US, November 10 in Korea. It’s a hosted reasoning model for the small jobs an agent does repeatedly, from classifying a ticket to pulling fields out of a PDF. You can use it through Muse Code or the Meta Model API as muse-ember-1.0. The weights are proprietary. The consumer Muse app is a separate product with its own rollout. Meta’s launch announcement · API model card · Artificial Analysis model profile
Where Ember fits inside an agent
Picture a support queue with 400 incoming tickets. The repeated work is reading each ticket, identifying its product and issue, and attaching a short summary. A small model can handle those bounded calls. The agent can escalate the cases where it has to reconcile policy, check several records, or decide which action to take.
That’s how I’d think about Ember. The model can suggest tool calls and produce structured output. Your application still decides which tools it exposes, executes the calls, validates returned fields, and handles failures. For instance, a ticket router can send an unknown product ID to review and keep working on the rest of the queue. That makes the repeated step easy to inspect before any action is taken.

Meta says Ember is the first model trained using Muse Wonder Full. Its docs describe pairing a larger model such as Spark or Wonder with Ember. I’d start with a small job and clear acceptance criteria. For coding, that might mean locating the files involved in a failing test and reporting the relevant lines, with the larger model deciding how to change the code. The example is an architecture sketch. There were no live inference calls for this article. Meta’s launch announcement · Ember developer guide
What changes at 200,000 input tokens?
For Meta’s own API, input length selects the rate for the entire request. At 200,000 input tokens, you pay the lower rates. At 200,001, you pay the higher rates for all input and output. Cached input still counts toward the threshold, and a request that continues a stored conversation with previous_response_id includes that history in its input. Meta also bills hidden reasoning tokens as output. A short visible answer can therefore consume more billed output than it appears to. Meta’s rate card · Reasoning and billing
| USD / 1M tokens | Up to 200K input | Over 200K input |
|---|---|---|
| Uncached input | $0.10 | $0.30 |
| Cached input | $0.004 | $0.012 |
| Output | $0.50 | $1.50 |

Hold the billed output at 10,000 tokens and assume the entire prompt is uncached. A 200K-input request is $0.025. At 201K it’s $0.0753. Run each scenario 10,000 times and the token charges come to $250 versus $753. That’s an illustrative calculation from the rate card in US dollars, excluding tools and taxes. It isn’t a measured invoice.
If those 201K tokens are two independent document batches, two 100.5K-input calls with 5K billed output each would cost $0.0251 in total under the same assumptions. That arithmetic changes if both calls need a shared prefix, produce more output, or require an extra synthesis pass. For a job that has to compare clauses across both batches, keeping the documents together may be worth the higher rate. The pricing question is whether the model needs all that context in the same call.
Why did the benchmark cost a third as much?
Artificial Analysis’s November 9 evaluation put Ember and Claude Haiku 5.5 at 36 on its Intelligence Index after rounding, both at maximum reasoning effort. Its weighted cost per benchmark task was about $0.14 for Ember and $0.41 for Haiku 5.5. Meta’s chart shows the underlying scores as 35.8 and 36.2. The rounded tie is useful context for the cost comparison. Artificial Analysis’s release evaluation · Meta’s launch chart

Both models list $0.10 input and $0.50 output per million at their base rates. Artificial Analysis attributes the gap in its suite partly to Ember’s cheaper cached inputs and roughly a third as many output tokens. An agent’s cost can move in the opposite direction if its cheaper model needs more retries or hands work back to a larger model. When comparing two routes, I’d divide the total token and tool spend, including escalations, by the number of tasks that passed validation.
The same evaluation gives a reason to be selective. Ember reached 27.2% on FrontierCode 2.0, where Haiku 5.5 scored 34.9%. Ember also trailed on AA-Briefcase, 1,521 versus 1,574 Elo. For a coding queue, those results are a reason to separate file lookups and test triage from requests that need a mergeable patch. Artificial Analysis’s task-level results
Which endpoint gives you which inputs?
Meta lists 1,048,576 tokens of context and a maximum of 524,288 output tokens. Its endpoint takes text, images, video, audio and PDFs, and returns text. It supports Responses, Chat Completions and Messages. Reasoning effort runs from minimal to max, with max as the default. Ember uses Standard mode on the direct API. Meta says content sent in that mode is excluded from model training. Meta’s model documentation · Meta’s mode and pricing terms
OpenRouter lists meta/muse-ember. Google Cloud lists meta/muse-ember-1.0 as a Preview with a global endpoint and text and image inputs. Meta also names Oracle Cloud in its launch announcement. If you’re calling through a partner, check that partner’s file support, rate card and billing before porting a workload. In South Korea, Meta explicitly restricts Wonder and Wonder Full on its own API and Muse Code, so Spark is the more relevant example of an upstream planner there. I haven’t verified Ember checkout or inference with a Korean account. OpenRouter model listing · Google Cloud model card · Meta’s Wonder region notice
My take
The first queue I’d give Ember is PDF field extraction where every result has a schema and a source page to check. I’d sample real documents with missing fields, duplicate entries and awkward layouts, then count how often the extracted value survives that check. I’d log total input, billed output, cache hits and escalations next to the pass rate. If the validated batch is cheaper, it has earned the job. If the system keeps paying for the same long history or retries the same hard cases, I’d change what gets sent to Ember before scaling the queue.