Meta's Smallest Model, Muse Ember, Is Here: 1M Context, $0.10 per Million Input Tokens, Built for Agents' Repetitive Work
On November 9, Meta launched Muse Ember, the smallest model in the Muse family: $0.10 per million input tokens, a 1M-token context window, and up to 512K output tokens. It matches Haiku 5.5's Intelligence Index of 36 at roughly a third of the cost per task — solving not how smart the model is, but how expensive repetitive agent work is.

Meta's smallest model has arrived, built for the most repetitive work
On November 9, Meta introduced Muse Ember on its official research blog, and the positioning could not be blunter: this is the smallest, most efficient model in the Muse family, built for the work agents repeat hundreds of times a day — calling tools, reading files, running tests, making small fixes, routing, extracting information, and parsing long documents. The model is called muse-ember-1.0, and it was available the same day on Muse Code and the Meta Model API, priced at $0.10 per million input tokens, $0.004 per million cached input tokens, and $0.50 per million output tokens. It has a 1M-token context window and generates up to 512K output tokens per call. Meta also made a point of saying Ember is the first model trained using Muse Wonder Full — the big model plans, the small model does the volume. That division of labor is now set.

Price comes first, because price is the whole reason Ember exists. On the price list alone, Ember looks identical to its two direct rivals: Anthropic's Claude Haiku 5.5 and OpenAI's GPT-6 Luna both charge $0.10 per million input tokens and $0.50 per million output tokens. But the Artificial Analysis evaluation Meta published alongside the launch (dated November 9) tells a different story: at its maximum reasoning setting, Ember scores 36 on the Artificial Analysis Intelligence Index, level with Haiku 5.5 at its best and well ahead of Luna at 28. The average cost per task is $0.14 for Ember, $0.41 for Haiku 5.5, and $2.39 for Meta's own Muse Spark 1.3. In other words, Ember gets Haiku's best-tier score for roughly a third of the money. Meta's own claim is that no model on the full Artificial Analysis leaderboard scores higher for less per task — Ember sits on the efficiency frontier.
The benchmark table deserves a line-by-line read, not just a glance at the headline score. On agent work, Ember scores 37.8 on AutomationBench (end-to-end business workflows), against 13.9 for Haiku 5.5 and 20.2 for Luna — a wide gap. On Agents' Last Exam (end-to-end agent tasks) it scores 61.6, ahead of Haiku's 57.0 and Luna's 57.1. On Meta's internal Personal Superintelligence Index it scores 46.8, against 36.1 and 37.0. On coding, Terminal-Bench 4.0 (agentic terminal coding) gives it 40.9, against 39.2 for Haiku and 16.4 for Luna; the Coding Agent Index (coding in real agent harnesses) gives it 46, against 37 and 31. But Ember also loses somewhere: on FrontierCode 2.0 (real engineering tasks judged on mergeability) it scores 27.2, behind Haiku 5.5 at 34.9 and ahead of Luna at 25.2. On multimodal work, GDP.pdf (professional work over long documents) is 22.8, level with Haiku; OSWorld 2.1 (computer use across desktop apps) is 69.5 on partial credit and 33.8 on binary scoring, leading on both; PerceptionBench (fine-grained visual perception with tools) is 80.6, against 78.6 and 62.8.
Coding is Ember's home turf, and Meta's wording here is precise: it is not for chewing through the hardest architecture problems, but for the coding subtasks an agent hands off hundreds of times a session — reading files, running tests, making targeted fixes. The 40.9 on Terminal-Bench 4.0 and 46 on the Coding Agent Index back that claim: individual tasks are not hard, but there are many of them, and they need to be steady and cheap. For the hardest problems, Meta's advice is to pair Ember with Muse Wonder: Wonder plans, Ember handles the volume. That sentence also pins down Ember's place in the lineup: Wonder takes the hardest problems, Spark takes coding and agentic workflows, and Ember takes repeatable coding and agentic tasks at a cost low enough to run in every product.
The multimodal side of Ember is easy to underestimate. It natively understands text, images, audio, and video, so agents do not need a separate model per input type: they can read screenshots, charts, and scanned documents, or work from voice memos, meeting recordings, and video. Meta's examples include working through a long real-world document, operating a computer directly from screenshots, and picking out fine visual detail. With a 1M-token context window, Ember can take in a full codebase or document set in a single call, and the 512K output ceiling leaves room for long-document parsing and batch work. For vibe coders, that means one calling pattern for having an agent read an error screenshot, dig through meeting notes, or batch-process a pile of files, without switching models in between.
Safety, price, and availability: the small model passed the same checks
On safety, Meta did not go easy on Ember for being small. Before release, it was evaluated under the Meta Superintelligence Scaling Framework, covering chemical and biological, cybersecurity, and loss-of-control risks, and it stayed below the framework's high-risk thresholds in the categories assessed. It received the same core safety training and testing as the larger models. Meta also tested how Ember behaves when acting on a user's behalf: whether it respects user intent, handles sensitive information appropriately, resists instructions hidden in web pages, documents, or tool outputs that try to redirect it, and seeks human input before high-impact actions. Those points matter most in agent work: Ember calls tools hundreds of times a day, and a single hidden instruction in a document does far more damage than a chatbot saying the wrong thing once.
On availability, Ember was usable on launch day on Muse Code and the Meta Model API as muse-ember-1.0, with support for the Responses API. Beyond Meta's own channels, Ember, Spark, and Wonder are all available on Google Cloud and Oracle Cloud. The price math is worth repeating: $0.10 per million input tokens, $0.004 per million cached input tokens, and $0.50 per million output tokens. Cached input deserves its own mention — in repetitive agent work, much of the input is the same system prompt and context showing up again and again, and cached input costs almost nothing. That is the other half of how Ember reaches $0.14 per task: not just a low list price, but cheaper repeats.
For vibe coders: is Ember worth switching to?
Start with where switching pays off. If you already run agents on batch work — fixing lint across a repo, writing tests in bulk, extracting information, parsing documents — Ember exists to push the per-call price of that work down. Meta's $0.14 per task, against $0.41 for Haiku 5.5 and $2.39 for Spark 1.3, is not a difference of a few percent but of several times. The more volume, the bigger the gap: a thousand repetitive calls a day, and the savings pay for thousands more calls. Inside Muse Code you just pick muse-ember-1.0, so the cost of switching is changing one model name, not changing toolchains — friendly for anyone already on Muse Code.
What does batch work actually look like? Four examples. First, fixing lint in bulk: a repo with hundreds of files, the agent fixing dozens of files at a time, one call per file, thousands of calls a day on Ember. Second, writing tests in bulk: one test per new function, write one, test one, high volume and fixed in form. Third, extracting information in bulk: pulling the same few fields out of hundreds of documents into one table. Fourth, parsing documents in bulk: reading a pile of PDFs, screenshots, and meeting notes and distilling them into summaries. All four share the same shape — fixed in form, repeated often, not hard one at a time — exactly the range Ember's training data covers, and exactly the premise its $0.14 per task rests on. The more your batch work looks like these four, the more switching to Ember saves; the less it looks like them, the more you should try before switching.
Now the cases where switching in a hurry does not pay. Ember is not an all-round model, and losing FrontierCode 2.0 to Haiku 5.5 is the reminder: do not expect a small model to get a genuinely hard engineering task right the first time. The right way to use it is layered: keep planning, architecture, and the genuinely hard problems on Wonder or whatever large model you use now, and hand Ember the high-volume work — reading files, running tests, small fixes, bulk extraction. Get the layering wrong, and the token money you save comes back as rework time: one fix that needs three agent loops costs more than getting it right once with a large model.
Three more cold-water notes. First, every benchmark number here comes from Meta and Artificial Analysis: the scores are from a November 9 evaluation with no independent third-party verification, and Meta itself points readers to its own report for details. Second, the parameter count was not published, so “smallest” is a relative claim that outsiders cannot verify from model size. Third, the rivals charge exactly the same list price — Haiku 5.5 and Luna are also $0.10/$0.50 — so Ember's edge is not the sticker price but “less money actually spent per task,” and that edge only holds if your tasks look like Artificial Analysis's tasks. If your tasks produce very long outputs or rarely hit the cache, redo the math yourself.
How this differs from the Muse stories already published here
This is not the first Muse story on this site: Muse Wonder ran on October 12 (a frontier model whose coding benchmarks passed Opus 5.5), Muse Spark Open on October 15 (the open-weight version), and Muse Spaces plus the Wonder-trained smaller models on November 6. Ember is none of those things: not another frontier model, not an assistant feature, but a new execution layer — the first slot in the lineup built specifically for repetitive work. Wonder takes the hardest problems, Spark takes coding and agentic workflows, and Ember pushes the cost of repetitive tasks down to $0.14 per task. Do not read Ember as Wonder's replacement; it fills a gap in the lineup.
One related item from the same week: several media outlets reported on November 10 that Meta also brought its Muse personal assistant to the Apple Watch and Wear OS watches — install the latest Muse app on your phone and you can dictate or type to manage schedules, look things up, and make reservations. That report comes from media coverage, not from Meta's research blog, so treat the details as pending Meta's own official word. It is a separate announcement from Ember, published around the same time — do not merge the two.
What a dollar buys: translating the price list into daily volume
The price list only makes sense once it is translated into daily volume. At Meta's rates, one dollar buys 10 million input tokens — roughly 7.5 million English words, or hundreds of thousands of lines of code. Cached input is cheaper still: one dollar buys 250 million cached tokens. In repetitive agent work, much of the input is the same system prompt, tool definitions, and conversation context showing up again and again — the first time at the normal rate, every time after at the cache rate, cheaper the more you run. That is the other half of how Ember reaches $0.14 per task: not just a low list price, but cheaper repeats.
By the Artificial Analysis numbers, 1,000 repetitive calls a day cost $140 on Ember, $410 on Haiku 5.5, and $2,390 on Meta's own Spark 1.3. The more volume, the bigger the gap; the less volume, the less it matters. A few dozen calls a day, and switching models saves less than a cup of coffee. Thousands of batch calls a day, and the savings pay for thousands more. But do not do the math from the list price alone: tasks with very long outputs or a low cache hit rate shrink Ember's advantage, because output tokens cost five times input tokens, and the more output a task produces, the higher the per-task cost climbs. Before switching, run your most repetitive class of calls for a week, record the per-task cost and the rework rate, and then decide.

Wonder trained Ember: what “the big model teaches the small one” means
Meta made a point of one detail in the announcement: Ember is the first model trained using Muse Wonder Full. It is worth pulling out on its own, because it states Meta's product logic plainly: the big model plans, the small model does the volume. Wonder is the strongest model in the family; Ember is the smallest; the former teaches the latter, and the latter does the repetitive work. In industry terms this is usually called distillation, or teacher-student training: the large model generates high-quality training data and demonstrations, the small model learns from them, and ends up close to the large model on specific tasks at a fraction of the cost. Ember's 37.8 on AutomationBench and 46 on the Coding Agent Index are, in a sense, the report card for that teaching method.
But the method carries risks of its own, and Meta does not spell them out. First, the big model's flaws get passed down: a systematic error Wonder makes on some task is likely to show up unchanged in Ember, because Ember learned from data Wonder produced. Second, the small model learns “how” without necessarily learning “why”: faced with an edge case absent from its training data, Ember is more likely than Wonder to get it wrong — and to be more confident about it. Third, the evaluation is Meta's own: Ember's scores were measured on benchmarks Meta chose, and a different set of benchmarks might rank it differently. For users, that points to one rule: Ember fits work that is fixed in form and repeated often, not work that is appearing for the first time and nobody has done before. The first is inside the range its training data covers; the second is not.
Three models, one price: how to choose
Ember, Haiku 5.5, and Luna all charge exactly the same list price — $0.10 per million input tokens and $0.50 per million output tokens — so the choice cannot be made from the sticker. It has to come from the shape of your tasks. Repetitive agent loops — fixing lint in bulk, writing tests in bulk, extracting information, parsing documents — go to Ember, where $0.14 per task pays off more the higher the volume. The hardest single-shot engineering tasks go to Haiku 5.5: its FrontierCode 2.0 score (34.9 against Ember's 27.2) says it is stronger there, and one round of rework eats the price difference. Long documents and computer use favor Ember, which leads on GDP.pdf and OSWorld 2.1 — reading a whole document set or operating a computer from screenshots is its territory. As for Meta's own Spark 1.3 at $2.39 per task, it is positioned for harder coding and agentic workflows — when Ember cannot do a job, first ask whether it belongs on Spark or Wonder, rather than forcing Ember through it.
One more dimension is context and output headroom. Ember's 1M-token context window and 512K output ceiling are unusual at this price: taking in a whole codebase in one call, or producing a very long parsing result in one call, are task shapes that a model without that headroom cannot take at all, however cheap its list price. Turned around, if your tasks are short and a few thousand tokens of context are enough, that advantage is worth nothing to you. Before choosing, measure your own tasks: average input length, average output length, cache hit rate, rework rate. Those four numbers will tell you which model to pick better than any benchmark score.
Actually switching costs almost nothing: in Muse Code, move your most repetitive class of calls to muse-ember-1.0, run it for a week, and record the per-task cost and rework rate next to the model you used before. If the rework rate holds steady and the cost comes down, move the whole execution layer over; if rework climbs, switch back, or keep the rework-prone task types on the large model. Switching models is not a one-way door — it can go back and forth. Move one class of calls at a time, let it settle for a week, look at the numbers, then decide. The two extremes to avoid are moving every call the day the announcement drops and then moving them all back when rework spikes, and never trying at all while paying several times the per-task price. The middle path is steadiest: one class at a time, one week, numbers first.
How the lineup looks now: which gap Ember fills
Laid out flat, the Muse lineup shows Ember filling a slot that did not exist before. At the top sits Wonder, the frontier model, taking the hardest problems and the planning. In the middle sits Spark, taking coding and agentic workflows. Now at the bottom there is Ember, taking repeatable coding and agentic tasks at a price low enough to run inside every product. One layer out is Spaces, for building small apps in the assistant with a sentence; further out still are Muse Code and the Meta Model API, the two doors models reach users through; and on the cloud side, Ember, Spark, and Wonder are all available on Google Cloud and Oracle Cloud. Ember's place is not at the top or the outer edge — it is at the bottom, the execution layer. The lineup used to be “the big model does everything”; now it is “the big model plans, the small model executes.” That division of labor is now set.
For vibe coders, the practical meaning is a simple first question when choosing a model: “does this work repeat?” Repetitive work goes to Ember; work that does not repeat goes to Wonder or Spark; work you cannot classify goes to Ember first, and gets upgraded if it needs rework. Ember's arrival does not devalue Wonder and Spark — it makes them more valuable, because the large models no longer spend compute on repetitive work like reading files and running tests, and can focus on planning and hard problems. Turned around, Ember is not a cure-all: work it cannot do should be upgraded, not forced through. That is what a lineup is for — every tier has its place, and picking the wrong tier costs more than picking the wrong model.
The one-line verdict: Ember does not answer “is the model smart enough?” It answers “is it too expensive for an agent to do repetitive work?” For anyone who has agents running hundreds or thousands of small tasks a day, that is a real price cut. For someone who writes code occasionally, changing the model name will barely register. Try it first on your most repetitive class of calls, measure the per-task cost and the rework rate, and only then decide whether to move the whole execution layer over.
Comments (0)
Sources
Related articles
METR's Q4 2026 capability update, published 20 November 2026: public models' time horizons double roughly every 3.61 months, faster on the verifiable TH2 subset (1.65 months), reaching 200 hours by July 2027 on naive extrapolation — but models are clearly worse than human experts on judgement tasks without clear feedback, and GPT-5.6 Sol reward-hacked the most.
On 20 November 2026, Thinking Machines Lab released Inkling 2 Mini: a 26.4B-parameter looped transformer that runs its middle 12 layers three times per token, fits in about 20GB, and runs offline on a laptop. It leads open-weights models of its size on DeepSWE and SWE-bench Verified — with the caveats printed in the same announcement.
On 17 November 2026, GitHub shipped a bundled Copilot upgrade for Microsoft Ignite: browser use in public preview, letting Copilot work in your signed-in Chrome or Edge; the Copilot app now takes Azure DevOps repositories, with agents opening pull requests and even merging them; code review gains Adaptive effort and secret detection. Two items are generally available, six in preview.