Meta launches Muse Ember: a multimodal model at $0.10/M tokens to power agent swarms
🔎 The agent war is won on the bill, not on the benchmarks
On November 9, 2026, Meta launched Muse Ember, the smallest and most efficient of its Muse models. Not a showcase model: an execution model, built for the repetitive work of agents — tool calls, code subtasks, routing, data extraction, parsing of long documents.
The figure that matters is not the price per token, which is identical to the competition's ($0.10/M input, $0.50/M output). It's the cost per task: about $0.14, versus $0.41 for Claude Haiku 5.5 and $0.15 for GPT-6 Luna at maximum reasoning settings, according to the Artificial Analysis leaderboard relayed by Six Six AI.
The gap seems negligible for a single request. It becomes strategic when an orchestrator delegates thousands of subtasks per day to dozens of workers. The execution layer, long the hidden cost line of agentic architectures, has just collapsed. And this is probably the most structurally significant news of late 2026.
The essentials
- Meta launched Muse Ember on November 9, 2026, its smallest Muse model, designed for repetitive agentic execution: tool calls, code subtasks, routing, extraction, long-document processing.
- Multimodal input: text, images, audio, video, and PDFs. Text-only output. It can also drive desktop applications from screenshots.
- 1M token context window (1,048,576 exactly), up to 512,000 output tokens.
- Pricing: $0.10/M non-cached input tokens, $0.004/M cached, $0.50/M output (up to 200K input tokens). Beyond that: $0.30 / $0.012 / $1.50.
- Score of 36 on Artificial Analysis's Intelligence Index for ~$0.14 per task, versus $2.39 per task for Muse Spark 1.3 (score 37).
- Deliberate positioning: an execution layer to pair with a large model (Muse Wonder) that handles complex planning.
- Availability: Meta Model API under the ID
muse-ember-1.0(Responses, Chat Completions, Messages endpoints), Muse Code, Oracle Cloud, and in preview on Google Cloud.
Recommended Tools
| Tool | Main use | Price (November 2026) | Ideal for |
|---|---|---|---|
| Muse Ember — Meta Model API | Agentic execution layer | $0.10/M input, $0.50/M output | Agent swarms, serial tool calls |
| Muse Code | Agentic coding subtasks | Included in the Meta plan | Devs automating code |
| Claude Haiku 5.5 | Alternative execution | $0.10/M input, $0.50/M output | Existing Anthropic ecosystem |
| GPT-6 Luna | Alternative execution | $0.10/M input, $0.50/M output | Existing OpenAI stacks |
| Hostinger VPS | Hosting orchestrators and workers | from ~€3/month (check hostinger.com) | Deploying and monitoring your swarms |
Prices observed in November 2026 — check the official websites before committing.
Muse Ember in brief: an executor, not a showpiece
Muse Ember isn't built to impress on reasoning benchmarks, but to chain together thousands of small agentic tasks without blowing up the bill. From the announcement, Zuckerberg summed up the promise in a single sentence: more intelligence per dollar than the competition, according to Livemint.
Specs-wise, the model boasts a context of 1,048,576 tokens — a million, that is — and up to 524,288 output tokens. Enough to swallow entire codebases or document corpora without artisanal chunking.
Multimodality is extensive: text, images, audio, video and PDFs on input, text on output. A detail that changes life for agent builders: Ember can drive desktop applications from simple screenshots, as The New Stack reports. An agent clicking around your CRM from screenshots is a native use case, not a hack.
Reasoning effort is adjustable from minimal to maximal, with max as the default. An interesting choice: Meta owns the cost of quality and leaves it to developers to turn the dial down on trivial tasks.
The stated targets are clear: enterprises and developers automating code, document processing and data extraction. In other words, exactly the workloads that agent swarms multiply tenfold.
What Ember does — and what you won't ask it to do
According to the official @AIatMeta account, Ember can carry a business workflow end to end: pulling records, calling tools in sequence, updating systems across applications. That's the textbook profile of a swarm worker.
What you won't hand it: complex planning, multi-step strategy, exploratory research. Meta says so itself — Ember is built to work alongside bigger models, not to replace them.
Pricing: the per-token price is a decoy, look at the cost per task
At the listed price, Ember is strictly identical to its competitors: $0.10/M input tokens, $0.50/M output. The entire difference comes down to the cost per completed task: $0.14, versus $0.41 for Haiku 5.5.
Here is the complete Meta Model API pricing grid:
| Usage | Price |
|---|---|
| Uncached input (up to 200K tokens) | $0.10/M tokens |
| Cached input (cache) | $0.004/M tokens |
| Output (up to 200K input tokens) | $0.50/M tokens |
| Uncached input (beyond 200K) | $0.30/M tokens |
| Cached input (beyond 200K) | $0.012/M tokens |
| Output (beyond 200K) | $1.50/M tokens |
Source: VentureBeat, November 2026.
Why such a gap in cost per task when the per-token prices are identical? Because the cost per task includes everything the token bill doesn't show: reasoning tokens, retries, tool loops, failed attempts. A model that converges faster to the result costs less, at equal unit price.
Second lever, and not the least of them: the cache. At $0.004/M versus $0.10/M, cached input is 25 times cheaper. In a swarm where all workers share the same system prompt of several thousand tokens, that's the kind of detail that divides the bill.
Finally, watch out for the 200K input token threshold: beyond that, prices triple ($0.30/M input, $1.50/M output). Nothing insurmountable with a 1M context, but enough to encourage splitting things up cleanly rather than dumping everything into the prompt.
The swarm economy: why $0.14 per task changes everything
In a swarm architecture, the total cost is proportional to the price of the worker, not the planner. The orchestrator reasons once; workers execute hundreds of times. Mechanically, it's the execution layer that dominates the bill.
Let's take a concrete example: a document processing pipeline that executes 1,000 subtasks per day (extraction, routing, tool calls).
| Worker | Cost per task | Cost per day | Cost per month (30 days) |
|---|---|---|---|
| Muse Ember | ~$0.14 | ~$140 | ~$4,200 |
| GPT-6 Luna (max reasoning) | ~$0.15 | ~$150 | ~$4,500 |
| Claude Haiku 5.5 | ~$0.41 | ~$410 | ~$12,300 |
| Muse Spark 1.3 | $2.39 | $2,390 | ~$71,700 |
The math is unforgiving: switching from Haiku 5.5 to Ember saves about $8,100 per month on this single pipeline, or 66%. Compared to Muse Spark 1.3, Ember is 17 times cheaper for a gap of just one point on the Intelligence Index (36 vs. 37).
This is not an isolated case. Anthropic has already cut the cost of Claude Code sub-agents by 99%, as we detailed in our article on agent swarms. The direction is the same across all the major players: driving down the price of execution to make multi-agent architectures viable at scale.
My conviction: when execution becomes nearly free, the bottleneck shifts. It will no longer be the cost of tokens, but the quality of orchestration and verification. The winners of 2027 won't be those with the smartest model, but those who know how to industrialize reliable swarms.
Against the flash models: Haiku 5.5 and GPT-6 Luna in the rearview mirror
Ember matches Claude Haiku 5.5's best score at roughly a third of the cost per task, and beats every GPT-6 Luna configuration on efficiency. That's the heart of the announcement, and it's verifiable: the Artificial Analysis leaderboard places Ember at 36 on the Intelligence Index for ~$0.14 per task, on the efficiency frontier.
| Model | Intelligence Index (max) | Estimated cost per task | Input/output pricing (≤200K) |
|---|---|---|---|
| Muse Ember (Meta) | 36 | ~$0.14 | $0.10 / $0.50 |
| GPT-6 Luna (OpenAI) | n/a | ~$0.15 (max reasoning) | $0.10 / $0.50 |
| Claude Haiku 5.5 (Anthropic) | n/a | ~$0.41 | $0.10 / $0.50 |
| Muse Spark 1.3 (Meta) | 37 | $2.39 | n/a |
Sources: Artificial Analysis, as reported by VentureBeat and The New Stack, November 2026.
Three ways to read this table.
One: at identical sticker prices, the cost-per-task gap with Haiku 5.5 approaches 3x. That's the signature of a model optimized for convergence — fewer tokens wasted on trial and error.
Two: GPT-6 Luna at $0.15 per task is still in the race. The gap with Ember is slim; the choice will come down to ecosystem, latency, and API stability as much as price.
Three: the flash model segment has become brutally competitive, and that's excellent news for buyers. To make sense of it all, our comparison of the best LLMs of November 2026 will be updated, and our guide to LLMs for AI agents details the criteria that really matter for a worker: tool call reliability, output format compliance, cost per task.
The two-tier architecture: Wonder plans, Ember executes
The optimal setup is a large model as the orchestrator and Ember as the worker. Complex planning is expensive, but it only runs once; repetitive execution is cheap, but it runs hundreds of times.
The pattern is simple. The orchestrator — a Muse Wonder, a Claude Opus 4.7, or a GPT-5.5 — breaks down the objective, distributes subtasks, and verifies the results. Ember executes: it parses the document, calls the tool, routes the record, updates the system.
This division of labor isn't a developer trick — it's Meta's official positioning. Ember is designed to complement large models, not compete with them: the big ones handle complex planning, while Ember absorbs the repetitive execution.
The hidden advantage of this approach: Ember is accessible through the Responses, Chat Completions, and Messages endpoints. So you can mix ecosystems — an Anthropic or OpenAI orchestrator on top of Ember workers — without rewriting your calling layer.
This announcement is part of a broader Meta offensive on agents. Following the launch of Muse Spark 1.1, its first paid model focused on agentic coding, here comes the low-cost execution layer. On the other side, OpenAI is pushing its always-on personal agents, Dots. The battle is no longer over a single model, but over complete stacks.
Getting started with muse-ember-1.0: API, cloud, and cache
The model is available under the ID muse-ember-1.0 in the Meta Model API, with support for the Responses, Chat Completions, and Messages endpoints — migrating from an existing stack is nearly instant.
On the distribution side, Meta isn't taking any detours: the model is available on Oracle Cloud from launch, and in preview on Google Cloud (text and image only for now). It's also integrated into Muse Code for development workflows, according to Meta Research's official announcement.
Three settings to tackle from day one.
The first: reasoning effort. It's set to maximum by default. For routing or simple extraction, drop it to minimal — you'll cut latency and cost with no measurable loss in quality.
The second: caching. Structure your prompts so that the static part (instructions, tool schemas, examples) stays stable and sits at the top. At $0.004/M, a 10K-token system prompt shared across a thousand daily calls costs about $0.04 per day with caching, versus $1 without.
The third: hosting your orchestration layer. Agent frameworks remain demanding when it comes to supervision, queues, and logs. A Hostinger VPS is more than enough to get started, before considering something more robust. To pick the framework that will drive your workers, our guide to the best autonomous AI agents compares the current options.
Where Ember reaches its limits
Ember is a proprietary, cloud-only model, and it isn't built for frontier reasoning. It's an excellent executor, not a strategist.
First limitation: no open weights, so no local execution. If your constraint is data sovereignty or the edge, Ember isn't the answer. For the edge, check out Needle, this 14 MB model designed to run on watches and robots; for classic local setups, our guide on open source AI agents with Ollama remains the reference.
Second limitation: output is text only. No image, audio, or video generation. For a swarm worker, that's inconsequential; for a creative pipeline, it isn't.
Third limitation: ecosystem maturity. Meta is entering an API market that Anthropic and OpenAI have been shaping for years — observability tools, SDKs, best practices. Nothing insurmountable, but worth factoring into a stack decision.
Finally, let's keep a cool head about the score: 36 on the Intelligence Index is very good for the price, but far from frontier models. For complex planning, Ember isn't your tool.
❌ Common Mistakes
Mistake 1: Judging Ember by its token price
The sticker price is identical to the competition's — that's precisely the trap. What matters is the cost per task on your actual workload, reasoning tokens and retries included. Instrument your swarm from day one: count tokens per task, not per request.
Mistake 2: Entrusting planning to Ember
Maximum reasoning effort by default doesn't make Ember a planner. The model is optimized for execution, and Meta explicitly positions it as such. The solution: a two-tier architecture, with a large model as orchestrator and Ember as worker.
Mistake 3: Ignoring the cache
At $0.004/M versus $0.10/M, cached input is 25 times cheaper. A system prompt that varies from one call to the next ruins this advantage. Solution: static prefixes, fixed instructions at the top, variable parts relegated to the end of the prompt.
Mistake 4: Dumping everything beyond 200K tokens
Beyond 200K input tokens, prices triple. The 1M context is a capability, not an invitation. Solution: intelligent chunking, targeted retrieval, and moving to long context only when the task demands it.
❓ Frequently Asked Questions
Does Muse Ember replace Claude Haiku 5.5?
On paper, it matches its best score at about one-third of the cost per task. But Haiku 5.5 remains deeply integrated into the Anthropic ecosystem — Claude Code, MCP, observability tools. If your swarm already runs on Anthropic, the migration cost can eat into the savings. For a brand-new stack or a very high-volume pipeline, Ember is objectively more competitive.
What budget for a swarm of 10,000 tasks per day?
At $0.14 per task, budget roughly $1,400 per day, i.e., ~$42,000 per month with Ember. The same volume with Haiku 5.5 would cost ~$123,000 per month. Add the cost of the orchestrator — negligible by comparison — and the cache, which brings the bill down even further. Always estimate based on your actual workload.
Can Ember run locally or on mobile?
No. It's a proprietary model, accessible only via the Meta Model API and partner clouds (Oracle, Google in preview). For edge use cases, look at Needle and its 14 MB. For local agent execution, Ollama remains the entry point, with open-source models that are significantly less capable.
What's the difference with Muse Spark 1.3?
One Intelligence Index point apart (36 vs. 37), but a cost per task 17 times lower ($0.14 vs. $2.39). Spark 1.3 remains relevant for difficult reasoning at low volume; Ember dominates as soon as it comes to executing at scale. The two are complementary in a Meta stack.
Should you leave reasoning effort at maximum?
That's the default setting, but not necessarily the right one for every task. For routing, structured extraction, or simple parsing, the minimal level is often enough and reduces both latency and cost. Benchmark each use case: the extra cost of maximum reasoning is only justified on genuinely difficult tasks.
✅ Conclusion
With Muse Ember, Meta is not looking for the smartest model—it is looking for the lowest cost per task, and at $0.14 per task completed, the deal is done. If you are building agent swarms, now is the perfect time to review your execution layer: start with our guide to the best LLMs for AI agents, then test muse-ember-1.0 on a secondary pipeline before switching.