- What happened: On November 9, 2026, Meta announced Muse Ember, a lightweight AI model built for repetitive AI agent tasks, and made it available through the Meta Model API and Muse Code.
- Why it matters: By splitting work with larger models, Ember could lower the cost of running AI agents. But even among models with the same base prices, the cost of completing a task can differ significantly depending on cached-input pricing and the number of output tokens.
- What to watch next: Prices triple once input exceeds 200,000 tokens. Compare total costs, including real-world success rates, retries, and result verification.
On November 9, 2026, Meta announced Muse Ember, a new lightweight AI model designed to handle repetitive AI agent work efficiently, and made it available through the Meta Model API and Muse Code. The idea is to leave complex planning and judgment to larger models, while Ember handles relatively simple tasks such as running tools and making partial code edits. Meta positions Ember as its smallest and most efficient model, aiming to reduce the cost of operating AI agents.
However, when assessing the economics of an AI model, it's necessary to distinguish between the price per million tokens and the total cost of actually completing a task. Even models with the same base price can end up with very different real costs if they generate different numbers of tokens or use caching with different efficiency. Ember also has a pricing tier that switches when input exceeds 200,000 tokens, so for agents that handle long conversation histories, base unit prices alone aren't enough to estimate costs.
A larger model plans, and Ember carries out the repetitive work
Meta's Muse lineup previously included "Muse Wonder" and "Muse Spark." Ember, the new addition, is a lightweight model meant to be used alongside these larger models. Wonder and Spark handle complex planning and advanced judgment, while Ember takes on the small, repeated tasks that arise while carrying out those plans. These include calling tools, making partial code edits, routing tasks, and extracting information. TechCrunch's report also highlights the design's premise of dividing roles with larger models.
If this approach works well, it could reduce the cost of repetitive work compared with having a large model execute everything. That said, costs also arise from the process of routing work to the appropriate model and from verifying the results Ember produces. Simply adopting a lightweight model therefore won't necessarily lower the overall cost of an AI agent. Meta itself recommends Wonder or Spark for advanced coding and questions requiring specialized knowledge, and does not position Ember as a replacement for every kind of processing.
According to Meta's official model documentation, Ember accepts text, images, video, audio, and PDFs as input and outputs text. Its context length is 1,048,576 tokens and its maximum output length is 524,288 tokens, meaning it can handle long contexts of roughly one million tokens. On the Meta Model API it is offered only in Standard mode, with the model ID muse-ember-1.0. However, the maximum context length is distinct from the input range to which the lowest base price applies, so the pricing structure needs to be checked when working with long texts.
Meta also says Ember is the first model trained using "Muse Wonder Full." This explanation alone, though, doesn't reveal what training methods were actually used or how many parameters the model has.
Same base prices, very different costs to finish a task
What matters when considering AI agent operating costs is not just a model's base price. Even for models that process input and output at the same rates, the final cost varies with how many tokens are generated to complete a task and how much previous input can be reused. For agents that repeatedly reference long conversation histories and tool outputs in particular, cached-input pricing has a major impact.
In an analysis published on November 9 by the independent AI evaluation firm Artificial Analysis, Ember, Anthropic's "Claude Haiku 5.5," and OpenAI's "GPT-6 Luna" had the same basic input and output token prices. Yet on the Intelligence Index, a composite measure run at the maximum reasoning setting, Ember and Haiku both scored 36, while the cost per evaluation task was $0.14 for Ember and $0.41 for Haiku. In other words, Ember recorded the same composite score while holding per-task cost to about one-third of Haiku's.
The main factors behind the gap were cached-input pricing and the number of output tokens. According to Artificial Analysis, cached input accounted for most of the cost in the agent tasks evaluated, and Ember's cached-input price was 60% lower than Haiku's. In addition, Ember generated roughly one-third as many output tokens as Haiku. This shows that even when standard input and output token prices are identical, a cheaper price for reused input and finishing with less output can significantly cut the overall cost of a task.
Still, these results were obtained under the evaluation conditions set by Artificial Analysis, and they don't guarantee that Ember will cost one-third of Haiku in every kind of work. Actual costs vary with the length of the history passed to the model, the cache reuse rate, the number of output tokens, and other factors. Even with the same composite score, accuracy and execution reliability on individual tasks are not necessarily equivalent. When considering adoption for business use, it's necessary to confirm not only cost but also whether sufficient quality can be maintained on the target tasks.
Beyond 200,000 tokens, prices triple, applied to the whole request rather than just the excess
One thing to watch closely in Ember's pricing is the switch in price tiers based on the number of input tokens. On the Meta Model API, the base price applies when input is 200,000 tokens or fewer, but long-context pricing takes over once input exceeds 200,000 tokens. This long-context price applies to the entire request rather than only the portion above the threshold, so even a difference of a single token can change the price significantly.
The tier determination also includes cached input. When previous_response_id is used to continue an existing conversation, that conversation history counts toward the input token total used for the determination. In other words, even if caching keeps input costs down, the long-context price applies whenever the total input, including the reused history, exceeds 200,000 tokens.
As of November 10, 2026, when Meta's official pricing documentation was checked, Muse Ember's Standard mode had the following prices. All amounts are in US dollars per million tokens.
| Input tokens | Standard input | Cached input | Output |
|---|---|---|---|
| 200,000 or fewer | $0.10 | $0.004 | $0.50 |
| Over 200,000 | $0.30 | $0.012 | $1.50 |
Once input exceeds 200,000 tokens, the unit prices for standard input, cached input, and output all triple. Moreover, this higher rate applies to the entire request, not just the portion beyond 200,000 tokens. Meanwhile, Meta's Wonder and Spark do not carry the same long-context surcharge as Ember. So even though Ember's base prices are low, the cost gap with other models could narrow for uses that pass in large amounts of context.
To see the effect of the pricing threshold, consider a case with no caching and output fixed at 1,000 tokens. The following is a calculation example using the official unit prices, not a measurement of actual usage.
| Case | Input tokens | Output tokens | Pricing applied | Calculated cost |
|---|---|---|---|---|
| A | 200,000 | 1,000 | Base | $0.0205 |
| B | 200,001 | 1,000 | Long-context | About $0.0615 |
In Case A, base prices apply to 200,000 input tokens and 1,000 output tokens, so the calculation is as follows.
In Case B, adding just one input token switches the request to long-context pricing, and the result is as follows.
In this example, adding a single input token roughly triples the price of the entire request. Of course, this is a simple calculation that ignores caching, tool usage fees, retries, taxes, and so on, and it doesn't represent an actual bill. Even so, for agents that pass long conversation histories and large volumes of tool output with every small task, designing with these pricing boundaries in mind is important. Trimming unnecessary history may reduce costs, but cutting too much context can degrade answer quality and increase retries, so both effects need to be measured.
Behind Haiku in coding, so success rates and retries need to be part of the evaluation
Although Ember has shown strong results on cost, it does not outperform larger models or competing lightweight models on every task. On "FrontierCode 2.0-AA," which evaluates whether changes to real software repositories are worthy of being merged, Ember scored 27.2%, while Claude Haiku 5.5 recorded 34.9%. The evaluation used 132 private tasks, and on this coding evaluation at least, Haiku outperformed Ember.
Cross-referencing the evaluation report published by Meta with the Artificial Analysis analysis, it can't be said that Ember is ahead on every task. In particular, when a lightweight model is built into an AI agent, low success rates on individual tasks can require retries or corrections by a larger model, which may shrink the original cost savings. It is therefore important to compare the total cost until a task completes successfully, not just token prices or the cost of a single inference.
When reading benchmark results, differences in the agent environments used to run the models also deserve attention. For example, the Terminal-Bench evaluation reported by Meta used different implementations for different models. Score differences therefore can't be explained solely by differences in the models' own capabilities. When introducing a model into a real development environment, comparisons using the same tools, execution environment, and tasks are necessary.
On safety, Meta says that it evaluated areas such as handling of sensitive information, resistance to malicious instructions embedded in external input, and human confirmation before high-impact actions, and that Ember fell below the high-risk threshold in the categories assessed. However, this is Meta's own evaluation, and it does not guarantee that Ember will not malfunction or that it is safe in real-world operation. For AI agents that operate external tools in particular, a model's decisions can translate into actual file changes or system operations, so mechanisms such as permission management, confirmation before execution, and verification of results remain necessary.
Muse Ember's strength lies in the possibility of handling recurring work at low cost while leaving advanced judgment to larger models. To draw out that benefit, however, it's essential to decide appropriately which tasks to hand to Ember and to design systems that pass along only the necessary context. Companies and developers considering adoption should measure success rates and retry counts under conditions close to real work, and compare total costs including cache usage, long-context pricing, tool execution, and result verification. The practical value of Ember will be judged not by how low its base prices are, but by how far it can reduce the cost of completing a task while maintaining sufficient quality.