memujo
AI7 min read

Muse Ember: Price Per Task Is the Real Number

Meta's Muse Ember costs $0.10 per million input tokens with a 96% cache discount, but subagent loop economics make token price the least interesting figure.

By Alice

In this article
  1. 01Context: The Fourth Muse Model Is the Boring One (On Purpose)
  2. 02The Numbers, Separated by Who Measured Them
  3. 03Why This Matters: The Cache Discount Is the Pricing, the Token Price Is the Fine Print
  4. 04Our Read: Ember Is a Tiering Bet, Not a Model Bet
  5. 05Outlook

Meta Superintelligence Labs released Muse Ember on Monday, November 9, 2026, and the headline number is easy to state: $0.10 per million input tokens and $0.50 per million output tokens. The hard part, and the part worth doing before you put it in a harness, is deciding what that number actually buys. The launch post on Meta's developer blog buries the more telling figure: an estimated cost of about $0.13 per task on the Artificial Analysis Intelligence Index at max reasoning effort. Per-token price is marketing. Cost per completed task is the invoice.

Context: The Fourth Muse Model Is the Boring One (On Purpose)

Ember is the fourth model under Meta's Muse brand: the mid-weight Spark shipped in April, its open-weight twin Glimmer in August, and the frontier Wonder in October, with the Muse Agent consumer product landing in September. TechCrunch's coverage frames Ember's role with Meta's own phrase: "Muse Wonder plans, Muse Ember handles the volume."

The target workload is explicitly the unglamorous end of agent stacks: tool calls, coding subtasks, routing, extraction, and long document parsing, the work an orchestrator repeats thousands of times per day. Meta's positioning leans on that. In its benchmark table Ember (max) scores 37.8 on AutomationBench-AA against 13.9 for Claude Haiku 5.5 (max) and 20.2 for GPT-6 Luna (max), and 40.9 on Terminal-Bench 4.0 against 39.2 and 16.4 respectively. It loses where you would expect a budget model to lose: 27.2 versus Haiku's 34.9 on FrontierCode 2.0-AA, the benchmark of real engineering tasks judged on whether the change is actually mergeable.

Two honesty notes before the math. First, every sub-benchmark number above is Meta-reported from its own launch post. Second, the OSWorld 2.1 row in that table compares Ember at 69.5 partial credit against Haiku's 33.8 binary credit, two different scoring regimes in one column. That is exactly the kind of comparison we flagged in reading AI benchmark claims like a skeptic.

The Numbers, Separated by Who Measured Them

Metric Value Source and label
Input price (to 200k tokens) $0.10 / 1M tokens Meta launch post (vendor)
Output price (to 200k) $0.50 / 1M tokens Meta launch post (vendor)
Price above 200k input $0.30 / $1.50 per 1M Meta launch post (vendor)
Cache discount 96% Artificial Analysis (independent)
Intelligence Index 36 (Max), 34 (Xhigh) Artificial Analysis (independent)
Cost per Index task $0.0728 measured Artificial Analysis (independent)
Meta's estimate per task ~$0.13 at max effort Meta launch post (vendor)
Output speed 440 tok/s (Max) Artificial Analysis (independent)
Time to first token 4.74s Max, 3.99s Xhigh Artificial Analysis (independent)
Output-to-input ratio 1.147% Artificial Analysis (independent)
Context window 1M tokens Artificial Analysis (independent)
Weight status Proprietary, not released Artificial Analysis (independent)

Independent verification from Artificial Analysis matters here because the vendor and independent cost numbers disagree by roughly 2x: Meta says ~$0.13 per task, Artificial Analysis measured $0.0728. Both can be true, since Meta quotes max reasoning effort while the measured figure blends effort levels, but the spread is a reminder that cost-per-task is a property of your configuration, not a price sheet row.

Why This Matters: The Cache Discount Is the Pricing, the Token Price Is the Fine Print

Here is the data-scientist read. Agentic loops are not shaped like chat. A subagent invocation sends a system prompt, tool schemas, a task brief, and file context, then receives a small structured result. Artificial Analysis measures Ember's output-to-input ratio on its Index at 1.147%: for every 1,000 output tokens, the harness sent roughly 87,000 input tokens. Most of those input tokens repeat verbatim across calls, which is precisely what prompt caching discounts.

Run the arithmetic with labeled assumptions. Take a bounded coding subtask with a 30,000-token context that is 90% stable across 20 calls in one session, and 500 output tokens per call.

  • Assumption 1: stable context hits cache at the 96% discounted rate, so 27,000 of 30,000 input tokens cost $0.004 per million instead of $0.10.
  • Assumption 2: 20 calls share the context once written; cold-path input is 3,000 tokens per call.
  • Then per-call input cost is about (27,000 x $0.004 + 3,000 x $0.10) / 1M, roughly $0.00040, and output is 500 x $0.50 / 1M, or $0.00025.
  • Full 20-call subtask: about $0.013, of which 62% is output despite output being 0.8% of tokens.

Two engineering conclusions fall out. First, at this price tier the cache discount, not the sticker rate, is the load-bearing term: a competitor at $0.08 uncached beats Ember's $0.10 for workloads that miss cache every call, and loses by an order of magnitude when they hit. Second, the 3x price jump above 200k input tokens ($0.30 / $1.50) against a nominal 1M window is a deliberate usage fence. The window exists so you can stuff it; the price tier exists so you mostly won't. Meta ships a 1M-token model whose economics stop at a fifth of that, and any planner that hands Ember a full-context repo dump without chunking will pay the premium tier silently.

The speed story reinforces the same design intent. Artificial Analysis puts time-to-first-token at 4.74 seconds for Max versus 3.99 for Xhigh, and its Xhigh variant scores 34 versus Max's 36 for a measured $0.0728 per task either way. In a fan-out of 16 parallel workers, wall-clock latency multiplies across the critical path while a two-point Index drop only matters if the subtask needs those two points. Cloudflare's CTO Dane Knecht, quoted in Meta's post, reports Ember ran "up to 30% faster at the tail" than the comparable model they tested, and You.com's inference lead Chak Pothina claims a p95 of 2.2 seconds with 36 to 48% fewer output tokens than leading open-weight models. Both are vendor-selected partner quotes, but tail latency being the differentiator matches the benchmark table's own logic: nobody buys Ember to be smartest; they buy it to be least slow at scale.

Our Read: Ember Is a Tiering Bet, Not a Model Bet

The software-engineer read is that Meta is not shipping a model, it is shipping a runtime topology. The launch post's flagship demo is a Pygments port: 16 Python lexers converted to Rust by 16 simultaneous Muse Ember agents, each owning one file in its own git worktree, supervised by Muse Wonder, with the porters finishing within about six minutes of each other. The post even publishes the worker prompt, which is unusually specific: workers must never run recursive filesystem scans, must cap build parallelism, must stop and report BLOCKED after three identical failures. That is not model marketing; that is harness engineering documentation, aimed at teams already running planner-worker splits.

This is the same wedge we watched OpenAI take with two price cuts on the same day that were two different bets and Kimi chase with 33% cheaper price for the same cost per task: the frontier model monetizes deliberation, the budget model monetizes repetition, and the vendor that owns both ends of one harness captures the whole workflow. Meta's stack has Wonder for planning, Ember for volume, and Muse Code tying them together, with Ember included in every subscription plan. If the subagent tier becomes standard architecture, per-token competition among budget models turns into a race to the bottom that Meta can afford, because its margin lives in the planner calls, where it holds the harder-to-compare, stickier position.

The open question is durability. Ember is proprietary with no released weights, and Artificial Analysis lists Meta as its only provider, so the 96% cache discount is one pricing page revision away from being 70%. Anyone building a cost model on Ember's per-task economics should benchmark against DeepSeek V4.1 Flash as the open-weight floor, because that is the number Meta will have to keep beating.

Outlook

Watch three signals over the next quarter. One: whether Artificial Analysis's measured per-task cost stays under $0.10 as Meta tunes effort levels, since Meta's own $0.13 estimate suggests current configs leave headroom. Two: whether the 200k usage fence gets lifted, which would signal Meta pushing Ember into long-context document work it currently prices against. Three: whether rival labs answer the subagent framing with their own published per-task figures rather than per-token cuts. If they do, the pricing conversation moves permanently from dollars per million tokens to dollars per completed job, and every benchmark table that ignores output verbosity quietly becomes a marketing chart.

  • #meta
  • #muse-ember
  • #ai-pricing
  • #ai-agents
  • #llm-evaluation
  • #subagents

Sources

Share this story