Coding & Dev 📅 2026-11-11 · Mini AI Tools Research Desk

Meta Muse Ember: Small-Model Specs, Pricing, and Sub-Agent Workflows

A complete breakdown of Meta Muse Ember (muse-ember-1.0): token pricing, prompt caching, long-context rate jumps, and Artificial Analysis benchmarks for agentic execution.

$ EXECUTIVE BENCHMARK SUMMARY (TL;DR)

What it is, and where it fits

Meta Model API list prices🔍 View full resolution
Meta Model API list prices

Muse Ember comes from Meta Superintelligence Labs and is available on the Meta Model API and in Muse Code. The main official specs are below.

Item Details
Product name Muse Ember
Release date 9 November 2026 (dated on Meta’s research blog)
Lab Meta Superintelligence Labs
API ID muse-ember-1.0 (Standard mode only; no Contributor-mode variant on the API)
Official one-liner The smallest, most efficient reasoning model, built for the work agents repeat all day: tool calls, coding subtasks, routing, extraction and long-document parsing
Input / output Official docs: text, image, video, audio and PDF in; text out. Artificial Analysis currently lists text and image only. Audio, video and PDF rest on Meta’s documentation; this article did not re-test them
Context / max output API docs: 1,048,576 context tokens and 524,288 max output tokens. Launch post: a 1M-token context window and “up to 512K” output. These wordings differ. 524,288 equals 512×1,024, which matches a binary reading of 512Ki, but the launch post does not state 524,288 or use “Ki”; a decimal reading of 512K is 512,000, which is not the API figure. Do not treat them as the same number.
Reasoning effort "minimal" through "max"; default "max". "none" is not supported
Endpoints Responses, Chat Completions and Messages, at https://api.meta.ai/v1
Weights Proprietary. Parameter count not disclosed. No local download
Place in the family Officially: Wonder for the hardest problems, Spark for coding and agent main loops, Ember for repeatable work at scale. Ember is the first model trained using Muse Wonder Full

Meta positions Muse Ember as its most cost-efficient reasoning model designed specifically for high-volume token workloads: tool calling, coding subtasks, intent routing, and document parsing. Meta's chief AI officer Alexandr Wang noted that under independent evaluation standards, Ember delivers capabilities close to Muse Spark 1.3 while cutting task costs by roughly 17 times.

What it is built to do

The developer docs name four kinds of bounded, repeated work:

  • Sub-agent tasks handed off by a main agent: reading files, running commands, looking things up, making a small fix.
  • Tool-heavy turns, where cost and latency add up call by call.
  • Classification and routing to the right handler or a larger model.
  • The same job run over thousands of images, files or tickets in parallel — captioning, field extraction, tagging.

The same page draws a line: for hard single-shot coding, knowledge-heavy questions, or visual coding, use Spark or Wonder. The official pairing is one sentence: “Muse Wonder plans, Muse Ember handles the volume.”

Multimodality is part of the pitch. The launch post says an agent can read screenshots, charts and scanned documents, or work from voice memos, meeting recordings and video, without a second model. Computer use, image understanding, tool calling, structured output and search grounding are all documented. Search grounding is billed separately, at $2.50 per 1,000 queries, on top of token charges.

Across different execution passes, total task compute costs ranged between $1.33 and $1.59 depending on token usage.

How it compares with the other Muse models

The three reasoning models take the same request body on the same endpoints. Switching is mostly a model ID change. The real differences are the default reasoning effort, the price, and whether Contributor mode exists.

Official guidance on choosing a model🔍 View full resolution
Official guidance on choosing a model
Item Muse Ember Muse Spark 1.3 Muse Wonder 1.0
Model ID muse-ember-1.0 muse-spark-1.3 (recommended; 1.2 and 1.1 still exist) muse-wonder-1.0
Official role High-volume, repeated execution Coding and agentic work at a lower cost than Wonder Hard software engineering and long-horizon runs
Default effort max high max
Standard price (input / cached / output, per 1M tokens) $0.10 / $0.004 / $0.50 up to 200K input; $0.30 / $0.012 / $1.50 above $1.25 / $0.15 / $4.25, same rate at any context length $4.00 / $0.20 / $20.00, same rate at any context length
Contributor mode Not on the API Yes: muse-spark-1.3-contributor at $0.10 / $0.002 / $0.20, with permission to train on your content Not on the API. Wonder Full is Muse Code only
AA Intelligence Index at max, as published 36 37 44 (from AA’s write-up, not Meta’s comparison table)
Cost per AA task at max About $0.14 $2.39 (Meta’s table) $6.95 (AA’s write-up)

$2.39 versus $0.14 is the roughly 17× gap Wang mentioned. AA’s own article also notes that Ember sits 8 points behind Wonder at about 1/50th the cost per task.

Spark’s Contributor tier is cheaper than Ember on output, in exchange for letting Meta train on the prompts and responses. Ember has no such tier; on the API it runs in Standard mode only, and Meta’s pricing page says Standard-mode content is not used for training. Muse Code subscriptions default to Contributor mode and can be turned off in settings.

The broader catalog includes dedicated models such as Muse Image, Muse Voice Transcribe, and downloadable-weight releases like Muse Spark Open.

In tools such as Claude Code, Meta’s docs suggest mapping the opus alias to muse-wonder-1.0, sonnet to muse-spark-1.3, and haiku plus the sub-agent model to muse-ember-1.0.

How billing works

The API is pay-as-you-go, with no minimum. Tokens that match a cached prefix are billed at the cached-input rate; cached_tokens in the response shows how many. Reasoning tokens count as billed output and share the output cap with visible text.

Rate limits are per team and per model, not per key: Ember is 3,000 requests per minute and 4,000,000 tokens per minute. Over the limit, the API returns HTTP 429. Official guidance is exponential backoff with jitter, honouring Retry-After when it is present.

The 200K input-token price jump🔍 View full resolution
The 200K input-token price jump

The 200K cutoff is easy to underestimate. At list prices, 200,000 uncached input tokens plus 10,000 output tokens cost $0.025. One extra input token takes that same request to about $0.075. Cache hits and conversation history sent with previous_response_id count toward the 200K. The launch post quoted only the lower tier; both tiers are on the pricing page. In a Muse Code subscription, long-context requests also drain the plan faster.

Against Haiku and Luna, short-request input and output list prices are the same. The gaps are cached input (Ember at $0.004; the other two are commonly listed at $0.01) and where long-context surcharges start. TechCrunch’s launch story called Ember “significantly cheaper” than Haiku and Luna. That is not true of the sticker price; it is closer to the truth for cost per task. AA’s explanation: in its agentic evaluations most of the spend is cache reads, Ember’s cache is 60% cheaper, and Ember used about a third as many output tokens as Haiku at max. Ember still generated about 115 million output tokens across the index — AA calls that “somewhat verbose” against the class median — just far less than Haiku at max. Above 200K, Ember’s higher tier is still below Haiku’s long-prompt rates of $0.50 / $2.50, which start at 100K. A workload with very long prompts and long answers still needs its own arithmetic; the index’s cost-per-task figure is not a substitute.

Muse Code is available pay-as-you-go or on a subscription. The plan cards visible on 11 November 2026 were Everyday at $5 a month, High at $15, Power at $50 and Maximum at $200. Ember’s own docs say it is included on every plan and in pay-as-you-go. The Everyday card’s marketing copy that day still named Spark, Wonder and Muse Image, so check the model picker and the Ember page.

On the third-party side, Wang posted at 03:56 Singapore time on 10 November, “give muse ember a go on openrouter.” OpenRouter lists the model as meta/muse-ember, with input, output and cache-read prices that match Meta’s. That page also lists a cache-write rate of $0.125 per million tokens, which appears on OpenRouter, not on Meta’s pricing page. You.com’s official account said Ember was live on its Inference Router from day one, with at least a 99.9% uptime SLA and a zero-data-retention option. Meta’s launch post also says Ember, Spark and Wonder are available on Google Cloud and Oracle Cloud. Zuckerberg posted the Google Cloud news at 05:49 Singapore time on 10 November. Which input modalities each cloud preview actually supports should be checked in that provider’s docs; one report said Google Cloud’s preview documents listed text and image.

Benchmarks: keep Meta’s table and independent runs apart

Meta’s launch post published a comparison with all three models at max reasoning. The footnote says Artificial Analysis results come from Intelligence Index v5 as published on 9 November 2026, with cost per task at list prices; internal rows come from Meta’s own suite. Terminal-Bench 4.0 uses “each model’s best published harness”: mini-swe-agent for Ember, Anthropic’s self-reported Claude Code result for Haiku, and Codex’s public leaderboard result for Luna. Those setups are not the same. Agents’ Last Exam, the Personal Superintelligence Index, OSWorld 2.1 and PerceptionBench are Meta’s internal runs. The evaluation report itself calls the internal competitor runs “best-effort” and notes that prompts and tools may not be optimally tuned for the other models.

Launch-day comparison (sources in the text)🔍 View full resolution
Launch-day comparison (sources in the text)

On that table Ember leads or ties most rows. The clear loss is FrontierCode 2.0-AA: 27.2 against Haiku’s 34.9. That test grades real repository changes on whether a maintainer would merge them. The Coding Agent Index-AA score is 46–37–31, with AA running each model in its maker’s own coding agent: Muse Code, Claude Code and Codex. On OSWorld 2.1 the partial-credit score is 69.5%, but the strict pass rate is 33.8%. If a desktop workflow cannot fail part-way, the strict number is the one that matters.

One figure is easy to mix up. Meta’s post lists AutomationBench-AA as 37.8 / 13.9 / 20.2, attributed to AA with a strict pass@1. AA’s own write-up says Ember (max) scored 68.1%, level with Muse Wonder (max) and GPT-6 Astra. Both numbers come from AA; they measure different things. 37.8 is the share of workflows where every objective was met and no guardrail was broken. 68.1 awards credit for individual objectives. If your job only counts when the whole ticket is done, 37.8 is the relevant figure.

Intelligence Index versus cost per task🔍 View full resolution
Intelligence Index versus cost per task

For an independent view, use AA’s 9 November 2026 article and model page:

  • Intelligence Index v5.0.1: Ember (max) scores 36, the same rounded score as Haiku (max); xhigh scores 34 at about $0.12 per task. Meta’s chart of unrounded values is 35.8 versus 36.2. “Matches Haiku” is fair; “beats Haiku” on the index is not.
  • Ember (max) was the cheapest model scoring 36 or higher, at about $0.14 per task; Haiku (max) was about $0.41. Luna’s top setting is about $0.15 and 28 points.
  • Speed, measured by AA on Meta’s API: 4.80 seconds to the first answer token, about 448 output tokens per second, 3.1 minutes per index task. Medians in the same price class were 9.88 seconds and 7.5 minutes.
  • Knowledge is the weak spot. AA-Omniscience accuracy is 21.1%, below 34.7% for Haiku and 50.5% for Gemini 3.8 Flash (high). Ember declined 64% of those questions, which is why its hallucination rate is 17.4%, about half of Haiku (max). Give it source material or a search tool; do not treat it as an encyclopaedia.
  • On Terminal-Bench 4.0 inside AA’s index, Ember scores 40.9% and Haiku 32.8%. Meta’s table shows Haiku at 39.2% in a different harness.

Developer and Community Early Feedback

These are individual reports, not general findings.

Analysis by Artificial Analysis emphasizes that while Ember shares baseline sticker rates with Haiku and Luna, its cached input is 60% cheaper—a crucial factor in agent loops—and Ember generates approximately one-third as many output tokens to solve equivalent tasks, driving down overall cost per completed run.

The site AI for Mortals, on 9 November, ran five everyday jobs through OpenRouter at Ember’s default max setting: a messy email thread, questions on a ~50-page report, a messy contact list, notes turned into a 10-slide deck, and a tip calculator. They reported that all five came back in under 20 seconds and cost about 1.7 to 1.8 cents in total. The first email reply dropped the fee; a second run put it back. On the same prompts, Haiku at max cost about $0.116 and took 14 minutes, with two jobs burning a 60,000-token cap on thinking and never returning an answer. At high, Haiku cost about $0.024 and took 141 seconds, with all five jobs finished. That is one lab’s five-job sample, not a universal result.

Partner quotes in Meta’s post were chosen by Meta. Cloudflare’s CTO, Dane Knecht, said Ember ran up to 30% faster at the tail than the comparable model they tested. You.com’s Chak Pothina reported a p95 of 2.2 seconds on coding tasks. Those figures have not been independently reproduced here and should be read as the partners’ own measurements.

In developer community benchmarks, engineer Fahd Mirza evaluated Ember across practical multimodal workflows, including sketch-to-app conversion, raw spreadsheet structuring, multilingual parsing, and circuit diagram reasoning, demonstrating its speed and reliability on repeatable inputs.

How to call the API

Below are standard implementation examples based on Meta Model API specifications and OpenAI SDK compatible endpoints:

The official first call uses the Responses API to classify a support ticket:

curl -X POST "https://api.meta.ai/v1/responses" \
  -H "Authorization: Bearer $MODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "muse-ember-1.0",
    "reasoning": {"effort": "low"},
    "input": "Classify this support ticket as billing, bug, or feature request, and give a one-sentence reason: \"I was charged twice for my October invoice.\""
  }'

The docs’ original snippet omits reasoning. The "low" value is added here because Meta’s reasoning guide says to use a low setting for direct-answer work such as lookups, formatting and translation; classification is in that group. If you omit the field, Ember uses max, and the thinking tokens are still billed as output.

With the OpenAI-compatible Python client, point the base URL at Meta:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.meta.ai/v1",
    api_key=os.environ["MODEL_API_KEY"],
)

response = client.responses.create(
    model="muse-ember-1.0",
    reasoning={"effort": "low"},
    input=(
        "Classify this support ticket as billing, bug, or feature request, "
        "and give a one-sentence reason: "
        "\"I was charged twice for my October invoice.\""
    ),
)

print(response.output_text)

If your code already speaks Chat Completions, set reasoning_effort at the top level, not reasoning.effort:

completion = client.chat.completions.create(
    model="muse-ember-1.0",
    reasoning_effort="low",
    messages=[
        {
            "role": "user",
            "content": "Classify this support ticket as billing, bug, or feature request.",
        }
    ],
)

For multi-turn work where reasoning continuity matters, Meta recommends the Responses API with previous_response_id or replayed reasoning.encrypted_content. Chat Completions does not expose replayable reasoning to external API keys, so each turn starts thinking from scratch.

On OpenRouter the model slug is meta/muse-ember and the base URL is https://openrouter.ai/api/v1. Do not send Meta’s muse-ember-1.0 ID to OpenRouter. Fuller recipes for parallel sub-agents are in the Meta Model Cookbook under 08_muse_ember/, and in Meta’s developer blog post.

Platform Access and Production Considerations

Before integrating Muse Ember into automated workflows or agent clusters, engineering teams should evaluate the following architecture boundaries:

  • Proprietary Hosting: Ember is offered exclusively through hosted APIs without local weight downloads; systems requiring strict on-premise execution should look to open releases such as Spark Open.
  • Developer-Centric Distribution: Ember serves programmatic infrastructure (Meta Model API, Muse Code, OpenRouter, and major cloud providers) and is not intended as a consumer chat interface.
  • Effort Calibration: While reasoning defaults to max, structured extraction and routing jobs operate effectively at low or medium effort, preserving response latency and output token budgets.
  • Context Tier Thresholds: Exceeding 200,000 input tokens reprices the entire payload at triple rates; high-volume pipelines handling large codebases should partition inputs below this ceiling.
  • Hierarchical Orchestration: Ember excels at deterministic execution rather than unguided encyclopedic knowledge or massive architectural refactors; pair it as an executor alongside higher-tier planner models.

When combined with structured prompt caching and bounded subtask definitions, Ember provides a sustainable cost model for high-frequency autonomous execution.

Featured Tools in this Guide

CU

Cursor

Coding & Dev
Freemium

The next-generation AI code editor built on VS Code with repo-wide context and Composer multi-file edits.

RA

Replit Agent

Coding & Dev
Paid

Autonomous full-stack development agent that builds, tests, and deploys entire cloud apps from an idea.

MU

Muse

Productivity & Auto
Freemium

Meta personal AI agent that runs real errands on its own cloud computer, from inbox cleanup to bookings.

More In-Depth Benchmarks & Guides

View all guides →