![Meta Muse Ember: $0.10 Input, 1M Context [2026]](https://shattered.io/wp-content/uploads/2026/11/meta-muse-ember-agent-execution-model-0-10-per-million-tokens-2026-gen.webp)
Meta released Muse Ember on Nov. 9, 2026, and TechCrunch reported it as a new lightweight model built for agent execution. The model ID is muse-ember-1.0. It carries a 1 million token context window and a 512,000 token output ceiling. Meta prices it at $0.10 per million input tokens and $0.50 per million output tokens, and developers can call it through Muse Code and the Meta Model API.
The launch matters less for raw capability than for cost structure. Meta does not pitch Muse Ember as the model that writes the plan. It pitches it as the model that runs the plan, thousands of times, without wrecking a budget. We tracked the early signals of this model family in our look at Gemini 4 versus Meta Muse, and this release fills in the small, cheap end of that lineup.
The Verge built its coverage around Meta’s description of Muse Ember as its “smallest and most efficient model.” Meta says the model is designed for “complex reasoning execution.” This analysis sticks to what Meta’s announcement and documentation confirm, flags what outlets claim beyond that, and stays away from benchmark numbers the available Meta sources do not establish.
Don't miss new tech stories on Google
Add Shattered once in the Google app and our stories show up in your news suggestions.
What Meta Launched on Nov. 9 #
The release is a single model with a narrow job description. Muse Ember targets repeated agent work, which Meta lists as tool calls, coding subtasks, routing, extraction, and long-document parsing. Those are the unglamorous steps that sit between a user’s request and a finished result. They also happen to be the steps that burn the most tokens in a production agent.
Meta’s documentation, which it publishes through a Muse Ember cookbook on the developer site, describes the model as an efficient execution model for high-volume, repeated work. The same documentation names sub-agent tasks and the processing of collections of images, files, and records as target uses. That wording tells developers where Meta expects Muse Ember to sit in a stack: below the planner, close to the data.
Availability is limited to two surfaces for now. Muse Code is Meta’s coding environment, and the Meta Model API is the programmatic route for teams that want to wire the model into their own systems. Meta’s announcement does not, based on the sources we reviewed, list a third-party cloud marketplace for the model on day one.
Muse Ember Specs: What Meta Has Confirmed #
The confirmed spec sheet is short, and that is useful. Every figure below comes from Meta’s announcement or its documentation. Nothing here is an estimate or a leak. Where Meta has not stated something, such as benchmark scores, we leave it out instead of guessing.
| Item | Confirmed detail | Source |
|---|---|---|
| Company | Meta | Meta announcement |
| Product name | Muse Ember | Meta announcement |
| Model ID | muse-ember-1.0 |
Meta announcement and docs |
| Context window | 1 million tokens | Meta announcement |
| Maximum output | 512,000 tokens | Meta announcement |
| Input price | $0.10 per million tokens | Meta announcement |
| Cached-input price | $0.004 per million tokens | Meta announcement |
| Output price | $0.50 per million tokens | Meta announcement |
| Availability | Muse Code and Meta Model API | Meta announcement |
Read the table as a design brief. A 1 million token window lets one call swallow a long contract, a codebase slice, or a stack of records. A 512,000 token output ceiling means the model can emit very long structured results in a single response. And the price ladder, with cached input at a fraction of fresh input, rewards the pattern agents actually use: the same large prefix, over and over.
Why Meta Built a Small Execution Model #
Agent workloads multiply calls. A single user request can fan out into a planning step, a dozen tool calls, several retrieval passes, a few code edits, and a final check. If every one of those steps hits a frontier model, the bill grows faster than the value. Engineers learned this the hard way over the past year, and our coverage of AI bill shock and the limits Forrester wants on agents shows how quickly metered usage turns into a finance problem.
Meta’s answer is a tiered family. Keep the expensive reasoning for the moments that need it, and hand the repetitive volume to a cheaper model. That is not a new idea in software architecture. Teams have long put a fast cache or a lightweight worker in front of a heavy service. What is new is a first-party model from a major lab that is explicitly labeled for that role from day one.
There is also a distribution angle. By shipping Muse Ember inside Muse Code and the Meta Model API together, Meta gets usage data on how developers split work between a planner and an executor. Whether Meta uses that data is not something the announcement addresses, so treat it as an incentive rather than a stated plan.
How the Muse Wonder and Muse Ember Split Works #
Meta summarized the intended division of labor in one line: “Muse Wonder plans, Muse Ember handles the volume.” That sentence is attributed to Meta, and it is the clearest statement of product strategy in the launch material. It describes a two-model pattern in which a larger model decides what to do and a smaller one carries it out.
The planner role
In this pattern the larger model reads the task, breaks it into steps, and decides which steps can run in parallel. It is called rarely. Each call is expensive, but the count is low. The planner’s output is a set of instructions that a cheaper model can follow without needing to rediscover the whole problem.
The executor role
The executor runs the steps. It calls tools, reformats records, classifies requests, and drafts small code changes. Call volume is high and each call is small. This is where Muse Ember’s pricing does its work. When 90 percent of your tokens flow through the executor, a $0.10 input rate and a $0.004 cached rate shape the entire unit economics of the product.
The pattern has a known weakness. If the planner writes a poor plan, the executor will carry it out faithfully and cheaply. Cheap mistakes at scale are still mistakes. Teams adopting the split need evaluation harnesses that check the final result, not only the per-step success rate.
Pricing Breakdown: $0.10 In, $0.50 Out #
Three prices define Muse Ember. Fresh input costs $0.10 per million tokens. Cached input costs $0.004 per million tokens. Output costs $0.50 per million tokens. Output runs five times the fresh input rate, which is a common shape for model pricing because generating tokens costs more compute than reading them.
The cached rate stands out. At $0.004, a cached input token costs 4 percent of a fresh one, or one twenty-fifth of the price. For an agent that resends the same system prompt, tool definitions, and reference material on every call, that gap can matter more than the headline $0.10. Meta’s announcement lists the cached price but, in the sources we reviewed, does not spell out cache write fees or expiry rules, so teams should confirm those details in the documentation before modeling costs.
Pricing pressure at the low end of the market is already a theme. Our comparison of DeepSeek API pricing against Mistral showed how much room buyers have to shop on price, and Meta now adds a first-party option that undercuts the per-token cost most teams were used to paying for a mid-tier model. We are not claiming Muse Ember is the cheapest model on the market. Meta’s own sources do not establish that.
What a Real Workload Costs #
Price per million tokens is abstract. The table below turns Meta’s published rates into concrete scenarios. These are our own illustrative calculations, not Meta figures, and they assume cached input is billed at the published $0.004 rate with no extra cache write charge. Real invoices will differ if Meta bills cache writes separately.
| Scenario | Input tokens | Output tokens | Estimated cost |
|---|---|---|---|
| One full 1M-token document parse, 2,000-token summary | 1,000,000 | 2,000 | About $0.101 |
| One response at the 512,000-token output ceiling | 0 | 512,000 | $0.256 |
| 10,000 routing calls (2,000 in, 100 out each) | 20,000,000 | 1,000,000 | $2.50 |
| 100,000 extraction calls (5,000 in, 300 out each), no caching | 500,000,000 | 30,000,000 | $65.00 |
| Same 100,000 calls with 4,000 input tokens cached per call | 100M fresh + 400M cached | 30,000,000 | $26.60 |
| 1 billion input tokens, fresh versus cached | 1,000,000,000 | 0 | $100 fresh, $4 cached |
Two takeaways stand out. First, long-context reads are cheap enough to be routine. Reading a full 1 million token window once costs about ten cents. Second, caching changes the extraction scenario from $65.00 to $26.60, a 59 percent cut, purely by reusing a shared prefix. The arithmetic is simple, but it shows why Meta published the cached price next to the headline rates.
Cached Input at $0.004 Changes the Math #
Most agent frameworks resend a large static block on every turn. That block holds instructions, tool schemas, style rules, and often a reference document. In a long-running agent, the static block can dwarf the new content in each call. When the static part is billed at $0.004 per million tokens, the marginal cost of the next call shrinks toward the cost of its fresh tokens alone.
That shifts design priorities. Developers have spent months trimming prompts to save tokens. With a cached rate this low, it can make more sense to keep a rich, stable prefix and spend effort on keeping it byte-identical across calls. Anything that mutates the prefix, such as a timestamp near the top, risks breaking the cache hit. Teams should audit prompt assembly before they assume the savings will show up.
The output side still dominates for generation-heavy jobs. At $0.50 per million, a pipeline that writes long reports or large code diffs will spend most of its money on output tokens even with perfect caching. Muse Ember’s cost advantage is strongest on read-heavy, write-light work such as classification, routing, and extraction.
Where Muse Ember Fits in an Agent Stack #
Meta’s list of target tasks maps cleanly onto common agent components. Each one has different tolerance for error, and that tolerance should drive where a small model belongs.
Routing and extraction
Routing decides which tool, queue, or downstream model should handle a request. Extraction pulls structured fields out of messy text, images, or files. Both tasks have narrow outputs and clear right answers, which makes them easy to test. They are the safest first targets for a small model, because a wrong answer shows up quickly in a labeled evaluation set.
Coding subtasks and long documents
Coding subtasks include writing a test, renaming a symbol across files, or patching one function. Long-document parsing means walking through a large file and pulling out clauses, tables, or references. These jobs are riskier than routing because errors can hide inside plausible output. Meta says Muse Ember is built for them, but the sources we reviewed offer no published accuracy figures, so teams should run their own checks before moving production traffic.
The practical rule: start with tasks where you can score the output automatically, measure the failure rate against your current model, and only then expand. A model that is ten times cheaper but wrong twice as often can still lose once you count retries and human review.
Competitive Context: What Is and Is Not Established #
Outlets framed the launch competitively right away. The New Stack headlined its coverage as Meta taking on Claude Haiku and GPT-6 Luna. That is the outlet’s framing. The Meta material we reviewed does not publish a head-to-head benchmark against those models, so we cannot say how Muse Ember performs against them.
A second framing came from Artificial Analysis, whose article title calls Muse Ember the cheapest model scoring 36 on its Intelligence Index. That is a third-party claim. Our fact sheet for this story treats benchmark scores and “cheapest” status as unconfirmed, because Meta’s own sources do not establish them. Readers who care about the number should read that analysis directly and check its methodology.
For buyers, the honest comparison today rests on published prices and your own tests. Our earlier head-to-head of Claude against Gemini showed how close top models can sit on a single index, and how little a one-point gap says about a specific workload. The same caution applies to small models, where task fit counts for more than a leaderboard position.
Claims Worth Checking Before You Migrate #
Launch day produces a mix of confirmed facts, outlet framing, and third-party numbers. The table sorts what we have seen so far by who said it and how firmly it is established.
| Claim | Who said it | Status |
|---|---|---|
| Meta’s smallest and most efficient model | Meta, relayed by The Verge | Confirmed as Meta’s own description |
| 1M context window, 512,000 max output | Meta | Confirmed |
| $0.10 input, $0.004 cached, $0.50 output per million tokens | Meta | Confirmed |
| Available on Muse Code and Meta Model API | Meta | Confirmed |
| Challenges Claude Haiku and GPT-6 Luna | The New Stack headline | Outlet framing, no Meta benchmark confirmed |
| Cheapest model with a 36 Intelligence Index score | Artificial Analysis title | Third-party claim, unconfirmed by Meta sources |
| Partner quotation in the announcement | Speaker not clearly identified | Not repeated here |
That last row deserves a sentence of its own. The announcement reproduces a quotation from a partner, but the excerpt available to us does not clearly say who spoke. Without a named speaker we cannot attribute it, so we leave it out instead of guessing.
Market Impact: Agent Adoption Data #
Cheap execution models only matter if companies actually run agents. The best available survey data comes from McKinsey, and it shows an adoption curve still in its early stage. In its State of AI global survey for 2025, McKinsey wrote: “Twenty-three percent of organizations reported scaling an agentic AI system somewhere in their enterprises in 2025.” (McKinsey, The State of AI: Global Survey 2025)
The same source adds a wider band of experimenters. McKinsey wrote: “An additional 39 percent of organizations reported experimenting with AI agents in 2025.” (McKinsey, The State of AI: Global Survey 2025) Add the two figures and roughly 62 percent of surveyed organizations were either scaling or testing agents. Every one of those experiments is a token bill waiting to grow, which is the market Muse Ember targets.
Developer-facing work leads the usage. In a separate McKinsey chart series on agentic AI, the firm wrote: “In the technology industry, 24 percent of respondents reported using AI agents in software engineering.” (McKinsey, Agentic AI advances) It also wrote: “In the technology industry, 22 percent of respondents reported using AI agents in IT.” Those two functions match Muse Ember’s stated sweet spot of coding subtasks and tool calls.
The data is from 2025, so it predates this launch and says nothing about Muse Ember directly. It does explain the incentive. If a quarter of tech-industry respondents already use agents in software engineering, the vendor that cuts the per-call cost of those agents wins a large pool of repeated usage. We covered a related corner of that market in LG’s free K-EXAONE 2.5 API, where price is again the lever.
Historical Context: From Frontier Chasing to Cost Tiers #
For most of the past two years, model launches competed on the top of the leaderboard. Labs shipped a flagship, claimed a benchmark win, and priced it accordingly. The agent boom changed the buying question. Teams stopped asking only which model is smartest and started asking which model is affordable at ten thousand calls per user per day. Tiered model lineups, with a large model for hard problems and a smaller one for volume, have become a common way to sell AI. Open-weight and low-cost players pushed the same direction from below. Our report on an open model scoring 72.8 percent on the Vals hacking test shows how far cheap and open options have climbed on specialized tasks, which is the pressure Meta’s pricing responds to.
Meta’s version is notable for its framing as an execution model. Small models have often been sold as a cheaper chat option. Meta’s wording ties Muse Ember to agent infrastructure, with sub-agent tasks and tool calls at the center. That reflects a shift from selling answers to selling throughput.
Risks and Open Questions #
Several questions remain open, and the launch material does not answer them. Meta has not published, in the sources we reviewed, benchmark scores for Muse Ember. Developers do not yet know how it handles tool-calling accuracy compared with the larger model it is meant to serve. Rate limits, regional availability, and service-level terms for the Meta Model API also need checking in the docs before a team commits.
Lock-in is a second concern. A planner and executor pair from the same vendor is convenient. It also ties a team’s cost structure and evaluation suite to one provider’s pricing decisions. Teams that want flexibility should keep their orchestration layer model-agnostic and test a second executor alongside Muse Ember.
Third, a 1 million token window does not guarantee a model uses all of it well. Long-context recall varies by model and by task. The only reliable method is to test on your own documents, at the lengths you actually use, and compare against a smaller chunked approach.
Five Predictions for the Next Quarter #
These are our own forecasts, not statements from Meta or any outlet. Treat them as informed judgment that could prove wrong.
- Rivals will answer on price or caching. A cached rate of $0.004 sets a visible marker. Expect competing labs to adjust small-model pricing or cache terms within a few months.
- Cost per completed task will replace cost per token. Buyers will push independent testers to publish end-to-end agent costs, including retries, since per-token tables hide failure rates.
- Planner and executor pairings will become standard docs. Meta’s one-line split between Muse Wonder and Muse Ember will show up in other vendors’ guides as a recommended default.
- Independent benchmarks will arrive fast. The third-party scoring claim already circulating suggests testers are moving quickly, and more results will land before any Meta-published numbers.
- Adoption data will climb past 2025 levels. If McKinsey repeats its survey, the share of organizations scaling agents should rise from the 23 percent it reported for 2025, though the pace is uncertain.
What Developers Should Do This Week #
Start by picking one high-volume, easy-to-score task in your own stack. Routing and field extraction work well. Build a labeled set of a few hundred examples, run Muse Ember against your current model, and compare accuracy, latency, and cost per thousand calls. Keep the test honest by including your hardest edge cases.
Next, audit your prompts for cache friendliness. Move static instructions and tool definitions to the front, keep them identical between calls, and push anything that changes to the end. Then check Meta’s documentation for cache duration and any write fees, so your cost model matches the invoice. For broader context on where this fits among model news, see our AI and machine learning coverage.
FAQ #
What is Muse Ember? Muse Ember is a new Meta model, with the ID muse-ember-1.0, that Meta calls its smallest and most efficient. It targets repeated agent work such as tool calls, coding subtasks, routing, extraction, and long-document parsing.
When did Muse Ember launch? Coverage from TechCrunch is dated Nov. 9, 2026, the date of this article. It is available through Muse Code and the Meta Model API.
How much does Muse Ember cost? Meta lists $0.10 per million input tokens, $0.004 per million cached input tokens, and $0.50 per million output tokens.
How big is the context window? The context window is 1 million tokens, and the maximum output is 512,000 tokens, according to Meta’s announcement.
Is Muse Ember the cheapest model available? Not established. A third-party article from Artificial Analysis makes that claim in its title, but Meta’s own sources do not confirm it, so we do not state it as fact.
How does Muse Ember relate to Muse Wonder? Meta’s own line is “Muse Wonder plans, Muse Ember handles the volume.” In that framing, Muse Wonder handles planning and Muse Ember handles high-volume execution.
Has Meta published benchmark scores? The Meta sources we reviewed do not clearly establish benchmark scores or head-to-head comparisons with named rival models, so test it on your own tasks before relying on any figure.