Meta released Muse Ember on November 9, 2026, and the headline number is hard to ignore: $0.10 per million input tokens and $0.50 per million output tokens for a model that matches Claude Haiku 5.5’s score on the Artificial Analysis Intelligence Index — 36 to 36 — at roughly a third of the cost per task. Ember is Meta’s smallest Muse model, built for the repetitive work inside AI agents: tool calls, coding subtasks, routing, and pulling structured data out of long documents. If you run an agency, a freelance workflow, or any app that makes thousands of small AI calls a day, this is the model Meta wants you to notice. But the sticker price is not the whole story. Ember costs the same per token as Haiku 5.5 and GPT-6 Luna — it wins by spending fewer tokens per job — and there is a price cliff at 200,000 input tokens that triples your rate if you cross it. Here’s what Ember actually is, what it costs in real work, and where it will let you down.
What Muse Ember actually is
Muse Ember is the volume tier of Meta’s Muse family. The family now has four members: the mid-weight Spark (April 2026), its open-source twin Glimmer (August 2026), the frontier Wonder model (October 2026), and now Ember, the smallest and cheapest. Meta’s own summary of the split is blunt: “Muse Wonder plans, Muse Ember handles the volume.” The larger model does the hard thinking and writes the plan; Ember does the repeatable work, thousands of times a day.
The launch post, from Meta Superintelligence Labs, lists the jobs Ember is built for: carrying a business workflow end to end, calling tools in sequence, reading files, running tests and making targeted code fixes as a coding subagent, routing requests, and pulling structured data out of long documents. It is a multimodal model — it reads text, images, video, audio, and PDFs — with a 1-million-token context window and up to 512,000 output tokens per response.
You can reach Ember in three places: the Meta Model API under the model ID muse-ember-1.0, inside Muse Code (Meta’s coding agent for Mac and Windows), and through Google Cloud and Oracle Cloud. It is also listed on OpenRouter at the same price as Meta’s own API. What you cannot do is download it. Ember is cloud-only, and Meta has released no weights — unlike Glimmer, which is open-source. If your workflow depends on running a model on your own hardware, Ember is not an option, full stop.
Meta also sells access through Muse Code subscriptions, which start at $5 a month for the Everyday plan. That plan bundles Muse Ember, Muse Spark, Muse Wonder, and Muse Image, with 10 to 50 prompts every five hours. Higher tiers at $15, $50, and $200 a month multiply that allowance by 5, 20, and 80 times. For a freelancer who wants to try Ember without setting up API billing, the $5 plan is the cheapest front door — though note that Meta’s help page says subscriptions start in Contributor mode, which gives more usage in exchange for letting Meta train its models on your content. Read that trade-off before you turn it on.
The price — and the 200,000-token cliff nobody is flagging
Here is the full price list, as published on Meta’s developer pricing page:
| Usage (per 1M tokens) | Up to 200K input tokens | Over 200K input tokens |
|---|---|---|
| Input | $0.10 | $0.30 |
| Cached input | $0.004 | $0.012 |
| Output | $0.50 | $1.50 |
Two things matter here. First, the base price is identical to Claude Haiku 5.5 and GPT-6 Luna — $0.10 in, $0.50 out. If you only look at the rate card, Ember looks like a tie, not a bargain. The savings come from somewhere else, which I’ll get to in a moment.
Second, the cliff. If a single request carries more than 200,000 input tokens, Meta reprices the entire request at triple the rate — $0.30 input, $0.012 cached, $1.50 output. Not just the tokens above 200K; the whole thing. That matters because Ember’s selling point is long-document parsing, and a long document is exactly how you end up over 200K tokens. A million tokens is roughly 750,000 words, so 200K tokens is about 150,000 words — a big contract file, a year’s worth of support tickets, a thick research report. If your job regularly feeds documents that size into one call, split them into chunks under the threshold or your “cheap” model suddenly costs three times as much. Haiku 5.5, by comparison, holds its base price up to 100K input tokens, so Ember’s 200K threshold is actually the more generous of the two — but it is still a threshold you have to design around.
There is also no batch discount on Ember’s rate card. If you were hoping to cut costs further by sending work in bulk, the way some providers discount asynchronous jobs, that option does not exist here.
Why it’s cheaper per task, not per token
This is the part of the story that gets misreported. Ember and Haiku 5.5 charge the same price per token. Ember wins because it uses fewer tokens to finish the same job.
Artificial Analysis, the independent benchmarker that runs the same evaluations on every model, scores Muse Ember at 36 on its Intelligence Index at max reasoning effort — the same rounded score as Claude Haiku 5.5 — but at $0.14 per task versus Haiku’s $0.41. The unrounded scores tell a slightly more honest story: Ember at 35.8, Haiku 5.5 at 36.2, so Haiku is a hair ahead on raw capability. But the cost gap is real: Ember averages about 84,000 output tokens per index task against Haiku’s roughly 226,000. Same price per token, about 2.7 times fewer tokens spent, about a third of the bill.
Artificial Analysis calls Ember at max effort “the cheapest model scoring 36 or higher” it has measured, and puts both its max and extra-high reasoning settings on the cost/intelligence Pareto frontier — the line where you cannot get smarter without paying more. It also notes Ember is about four times cheaper per task than DeepSeek V4.1 Flash (score 33, $0.60 per task) and GLM-5.3-Flash (score 28, $0.58). GPT-6 Luna, the other small model at the same $0.10/$0.50 list price, scores 28 on the same index — noticeably behind both Ember and Haiku.
Meta’s own benchmark table, published with the launch, puts Ember ahead of Haiku 5.5 and GPT-6 Luna on most rows at max effort. Treat that table as vendor-reported: Meta is selling this model. Two footnotes deserve your attention. First, Meta’s chart notes that Ember’s costs were estimated “at proposed pricing” — the numbers were modeled, not billed. Second, on Terminal-Bench 4.0, each model was run with its own best published harness (mini-swe-agent for Ember, Claude Code for Haiku, Codex for Luna), so the harness, not just the model, is doing some of the work. The independent Artificial Analysis numbers are the ones to trust, and they still favor Ember on cost.
Alexandr Wang, who leads Meta Superintelligence Labs, put it this way on launch day: Ember “offers nearly Muse Spark 1.3 (max) intelligence at a 17x cheaper price point (per AA).” That is a marketing line built on an independent measurement, and it is roughly accurate — but “nearly Spark intelligence” only holds at max reasoning effort, where Ember spends the most tokens. Turn the reasoning effort down and the score drops with it.
The worked math: what 10,000 agent calls actually cost
Benchmarks are abstract. Here is what the numbers mean for a real workload. Take a freelance operation that runs an agent to triage and draft replies to client emails, extract invoice data from PDFs, and tag support tickets — 10,000 small agent tasks in a month. Using Artificial Analysis’s per-task cost figures:
| Model | Cost per task | 10,000 tasks | You save vs Haiku |
|---|---|---|---|
| Muse Ember (max) | $0.14 | $1,400 | — |
| Claude Haiku 5.5 (max) | $0.41 | $4,100 | $2,700 |
That $2,700 monthly gap is the whole pitch. And it is not a theoretical number: one independent review team gave Ember five everyday office jobs — replying to a messy email thread, answering questions about a 50-page report, cleaning a contact spreadsheet, turning rough notes into a 10-slide deck, and building a small working web page — and all five together cost 1.7 cents. Every job came back usable on the first try, though the first email reply missed a detail. At that price, the cost of trying Ember on your own workflow is effectively zero; the cost of being wrong about it is a few cents and an afternoon.
Meta’s own launch demo makes a subtler point, though. In the example where Ember captioned and sorted 10,000 photos, the total bill was $1.33 — and the planner model, Muse Wonder, took about 61 percent of it. The cheap part of an AI job is now the doing. What decides the cost and the quality is the work order the planner writes. If you build an agent system around Ember, budget for the planner, not just the worker: a big model writing good instructions is most of the bill, and writing a good work order is a skill in itself. Meta’s launch post even publishes the brief format it hands each worker — the task, the relevant context, the files it may change, the checks it has to pass, and the result it should bring back. That is a job ticket, and if you run a crew of any kind, you already know how to write one.
What freelancers can actually build with it
Forget the benchmark charts for a minute. Here is where Ember fits into work that pays:
Bulk triage and tagging. A support inbox, a pile of client emails, a folder of intake forms. Ember reads, classifies, and drafts replies at roughly $0.14 a task. A freelancer managing support for three small clients can run the whole triage layer for a few dollars a month.
Extraction from long documents. Contracts, invoices, research reports, meeting transcripts. Ember’s 1M-token context and long-document parsing are its headline use case — just keep each call under 200K input tokens to dodge the price cliff, or chunk the document first.
Coding subtasks. Running tests, making targeted fixes, reading files, calling tools in sequence. This is the Muse Code use case, and the $5 Everyday plan is the low-risk way in. Ember is the model that does the small steps after a bigger model has planned the work.
Routing and classification. Deciding which model, tool, or human should handle a request. Routing is a small, fast, high-volume job — exactly the shape Ember is priced for.
Content pipelines at scale. Captioning and sorting photos, drafting product descriptions, summarizing source material before a human editor takes over. Meta’s 10,000-photo demo cost $1.33 for the Ember side of the work. The human review is still the expensive part, and it should be.
The common thread: Ember is for work you already know how to do and just need done many times. It is not for work where you need the model to figure out something new.
What NOT to use it for
Ember has real weaknesses, and the launch coverage mostly buries them.
Knowledge and trivia. Artificial Analysis flags knowledge as Ember’s weak spot: it declines 64% of trivia-style questions. If your task needs the model to know things — facts, dates, names, background context — rather than process things you hand it, Ember will dodge or get it wrong more often than Haiku. Feed it the source material; do not ask it to recall facts from training.
Hard coding. On FrontierCode 2.0-AA, Ember scores 27.2 against Haiku 5.5’s 34.9 — a real gap. For mergeable code and complex agentic coding, Haiku is the stronger small model. Ember is fine for targeted fixes and test runs; it is not the model to hand a hard bug to.
Anything where you need the weights. Ember is cloud-only with no weights released and no local option. If your client requires on-premises processing, or you want to fine-tune, or you just do not want your data leaving your machine, look at Glimmer — Meta’s open-source Muse twin — or another open-weight model entirely.
Long-context jobs without chunking. Cross 200K input tokens in one request and your price triples for the whole call. Design your pipeline to chunk documents first.
Work where the benchmark harness did the heavy lifting. Remember the Terminal-Bench footnote: each model ran with its own best harness. Independent scores still favor Ember on cost, but treat Meta’s own “ahead on most rows” table as advertising, not measurement.
The community reaction on Hacker News, where the launch thread drew 287 points, split the same way. Supporters liked the price and the efficiency numbers; skeptics said Meta’s Muse models read as frontier on benchmark cards but feel weaker in real use, pointed out there are no weights, and noted that a US-hosted open-weight DeepSeek variant is cheaper on OpenRouter. One user who had used Muse Spark for documentation work said Haiku 5.5 has since outclassed it at that size. That is the honest shape of the debate: Ember is a strong value model, not a frontier model, and the people who will get the most from it are the ones who test it on their own work rather than trusting either side’s chart.
Ember vs Haiku 5.5 vs GPT-6 Luna
| Muse Ember | Claude Haiku 5.5 | GPT-6 Luna | |
|---|---|---|---|
| Launch | Nov 9, 2026 | 2026 | 2026 |
| Input price (per 1M tokens) | $0.10 | $0.10 | $0.10 |
| Output price (per 1M tokens) | $0.50 | $0.50 | $0.50 |
| Cached input (per 1M tokens) | $0.004 | ~$0.01 | — |
| Artificial Analysis Intelligence Index | 36 (35.8) | 36 (36.2) | 28 |
| Cost per index task | $0.14 | $0.41 | — |
| Context window | 1M tokens | 200K tokens | — |
| Price cliff | Over 200K input: 3× rate | Over 100K input: higher rate | — |
| Open weights | No | No | No |
| Best for | High-volume agent subtasks | Harder coding, knowledge work | OpenAI ecosystem work |
The table makes the decision plain. If your workload is high-volume, repeatable, and well-specified, Ember is the cheapest way to get Haiku-level results. If your workload needs knowledge recall or hard coding, Haiku 5.5 is worth the extra $0.27 per task. If you are already deep in OpenAI’s tooling, Luna’s 28 still does the job for simple tasks — but on the independent numbers, it is the weakest of the three at the same price.
How to try it without a big bill
- Start with Muse Code’s $5 Everyday plan. You get Ember plus Spark, Wonder, and Muse Image, with 10 to 50 prompts every five hours. That is enough to run real coding subtasks for a week and see whether Ember’s output holds up on your work. Just remember the Contributor-mode trade-off on training data.
- Run a shadow test. Send your worker traffic to both your current cheap model and Ember, apply only the incumbent’s result, and diff the two. One reviewer of the launch suggested exactly this, and it is the right way to test a model you do not yet trust: you pay a few extra cents and you learn the truth about quality on your own data.
- Chunk before you send. Keep every request under 200,000 input tokens. If you are parsing long documents, split them first — the cliff reprices the whole request, not just the overflow.
- Give it the facts; don’t ask it to remember them. Ember’s knowledge recall is its weak spot. Put the source material in the prompt and ask it to extract, summarize, or transform — not to recall.
- Watch the planner’s share of the bill. In Meta’s own demo, the planning model took 61% of a $1.33 job. If you build a Wonder-plus-Ember pipeline, the expensive part is the plan. Write tight work orders and you keep the whole system cheap.
The bottom line
Muse Ember is not a miracle model. It is a well-priced worker. Meta built it for the unglamorous middle of agent work — the tool calls, the extractions, the routing, the small code fixes — and priced it so that the bill for doing that work thousands of times a day stops being the thing that scares you off. The independent numbers back the pitch: same benchmark score as Claude Haiku 5.5, about a third of the cost per task, and a 1M-token context window with a 200K price cliff you need to design around. Its weaknesses are specific and avoidable: weak knowledge recall, a real gap on hard coding, no weights, no batch discount. If your work is high-volume and well-specified, Ember is the cheapest credible option on the market right now — and the cost of finding out whether it fits your workflow is about two cents. Try it on your own jobs before you believe anyone’s chart, including Meta’s.
Frequently Asked Questions
What is Meta Muse Ember?
Muse Ember is Meta’s smallest and cheapest Muse model, released November 9, 2026 by Meta Superintelligence Labs. It is built for high-volume, repeatable work inside AI agents — tool calls, coding subtasks, routing, and extracting structured data from long documents. Its model ID on the Meta Model API is muse-ember-1.0, and it is also available in Muse Code and through Google Cloud and Oracle Cloud.
How much does Muse Ember cost?
$0.10 per million input tokens, $0.004 per million cached input tokens, and $0.50 per million output tokens for requests up to 200,000 input tokens. Above 200,000 input tokens, the whole request is repriced at $0.30 input, $0.012 cached, and $1.50 output. There is no batch discount.
Is Muse Ember really cheaper than Claude Haiku 5.5?
Per token, no — both list at $0.10 input and $0.50 output per million tokens. Per task, yes: Artificial Analysis scores both at 36 on its Intelligence Index, but Ember finishes the average index task for $0.14 versus Haiku’s $0.41, because it uses roughly 2.7 times fewer output tokens per task. The unrounded scores are 35.8 for Ember and 36.2 for Haiku, so Haiku is marginally ahead on capability.
Can I run Muse Ember on my own computer?
No. Ember is cloud-only and Meta has released no weights. You can only use it through the Meta Model API, Muse Code, Google Cloud, Oracle Cloud, or OpenRouter. If you need a model you can run locally, Meta’s open-source Muse Glimmer is the local option in the same family.
What is Muse Ember bad at?
Knowledge recall — Artificial Analysis notes it declines 64% of trivia-style questions — and hard coding, where it trails Haiku 5.5 on FrontierCode 2.0-AA (27.2 vs 34.9). It is also a poor choice for any single request over 200,000 input tokens, since the price triples for the whole request, and for work that requires on-premises processing.
How do I try Muse Ember cheaply?
The lowest-risk entry is Muse Code’s $5-a-month Everyday plan, which includes Ember alongside Spark, Wonder, and Muse Image. For API use, run a shadow test: send the same work to Ember and your current model, use only the incumbent’s result, and compare quality and cost on your own data before switching.