Muse Ember for Coding Subagents: Pricing and Setup
Use Muse Ember for bounded coding work while a stronger model plans and reviews. Compare direct API prices and mixed coding results, calculate the whole-request premium above 200K input tokens, verify a Meta API call, route Claude Code workers, and check OpenRouter, Cline, regional eligibility, and data settings.
Contents
Try Muse Ember for bounded coding subagents, while a stronger model handles planning and final review. Keep each worker’s input below 200K tokens when practical, because crossing that threshold triples Meta’s token rates for the entire request. Do not replace your main engineering model solely on its headline benchmark score.
As of 2026-11-12, Meta offers muse-ember-1.0 through Model API and Muse Code. The model launched on November 9, with a focus on repeated tool calls, coding subtasks, routing, and extraction.
What work should Muse Ember handle?
Give Ember a narrow assignment with supplied context and a checkable result. Keep ambiguous requirements, architectural decisions, and final acceptance with the planner.
Meta’s model guide recommends pairing Ember with Muse Spark or Muse Wonder. The larger model plans; Ember handles repeated execution. Useful first assignments include finding relevant functions, reading package configuration, extracting test failures, and implementing a small change with explicit acceptance tests.
Meta recommends Spark or Wonder instead for hard single-shot coding problems and knowledge-heavy questions. That distinction matters when a task requires discovering the right approach rather than following a clear brief.
The direct API specifies a 1,048,576-token context window and a maximum output of 524,288 tokens. Those limits do not establish what a coding client will accept. Ember’s default reasoning effort is max, with settings from minimal through max.
Start with read-only investigation. Add editing rights after the worker consistently returns correct file references and useful findings.
What do the coding benchmarks actually show?
The launch results support testing Ember as a worker, but they do not establish it as the best model for merge-ready changes.
Meta’s November 9 comparison reports these results at maximum reasoning effort:
| Evaluation | Muse Ember | Claude Haiku 5.5 | GPT-6 Luna |
|---|---|---|---|
| Terminal-Bench 4.0, best published harness | 40.9 | 39.2 | 16.4 |
| Artificial Analysis Coding Agent Index | 46 | 37 | 31 |
| FrontierCode 2.0-AA | 27.2 | 34.9 | 25.2 |
The launch table and its footnotes distinguish the test setups. Terminal-Bench uses mini-swe-agent for Ember, Claude Code for Haiku, and Codex for Luna. These are model-and-harness comparisons, not a controlled model swap inside one tool.
Artificial Analysis independently reports the Coding Agent Index results: Ember in Muse Code scores 46, versus Haiku in Claude Code at 37 and Luna in Codex at 31.
Artificial Analysis also reports Haiku at 32.8 on Terminal-Bench within its Intelligence Index evaluations. Do not silently substitute that figure for Meta’s 39.2 best-published-harness result. They belong to different reported evaluation series.
The relevant weakness is consistent: Ember trails Haiku on FrontierCode, which evaluates engineering changes for mergeability. Test Ember first for investigation and constrained execution. Keep Haiku or your existing stronger worker when accepted patches matter more than inexpensive intermediate work.
Our guide to Coding Agent Index cost per task explains how to compare complete agent configurations without treating their scores as model-only measurements.
How does the 200K pricing threshold change the bill?
Budget against input length, not the advertised context capacity. On Meta’s direct API, cached input and retained conversation history count toward the 200K threshold.
These direct API list rates are current as of 2026-11-12. All amounts are USD per 1M tokens. The table shows standard processing where applicable, without regional premiums, batch discounts, or hosted-tool charges.
| Model and input tier | Uncached input | Cached input | Output |
|---|---|---|---|
| Muse Ember, up to 200K input | $0.10 | $0.004 | $0.50 |
| Muse Ember, over 200K input | $0.30 | $0.012 | $1.50 |
| Claude Haiku 5.5, up to 100K input | $0.10 | $0.01 | $0.50 |
| GPT-6 Luna, up to 272K input | $0.10 | $0.01 | $0.50 |
| DeepSeek V4.1 Flash 1017, off-peak | $0.15 | $0.003 | $0.60 |
| DeepSeek V4.1 Flash 1017, peak | $0.30 | $0.006 | $1.20 |
Sources: Meta pricing, Anthropic pricing, GPT-6 Luna pricing, and DeepSeek pricing.
Haiku’s rates become five times higher above 100,000 input tokens. Luna applies twice its input and cache rates, plus 1.5 times its output rate, above 272K input tokens. Both have separate cache-write charges, so a cache-hit price is not the full cost of creating and reusing a cache.
DeepSeek’s deepseek-flash currently serves V4.1 Flash 1017. Peak periods are 01:00–04:00 and 06:00–10:00 UTC, Monday through Friday, excluding Chinese public holidays. Other periods use off-peak rates.
For Ember, define U as uncached input, C as cached input, and O as billed output. Select the price tier using U + C, then calculate:
Token cost = (U × input_rate + C × cache_rate + O × output_rate) / 1,000,000Consider two estimated direct-API requests with no cache hits or paid server-side tools:
199,000 input + 10,000 output:
(199,000 × $0.10 + 10,000 × $0.50) / 1,000,000 = $0.0249
201,000 input + 10,000 output:
(201,000 × $0.30 + 10,000 × $1.50) / 1,000,000 = $0.0753The second request does not pay the premium only on its final 1,000 input tokens. Its entire input and output use the higher rates.
Meta also counts the conversation behind previous_response_id as input. A small new message can therefore trigger long-context pricing. Give workers focused briefs instead of forwarding the planner’s entire conversation.
Artificial Analysis’s November 9 snapshot reports Ember at 36 points and about $0.14 per Intelligence Index task. Haiku reaches 36 at $0.41; DeepSeek V4.1 Flash 1017 reaches 33 at $0.60. Those are benchmark averages, not quotes for your repository or guarantees of equivalent task success.
For a DeepSeek comparison, use the current Flash model and pricing distinctions rather than an older V4 release’s rates.
Connect the Meta API and verify one response
Use Responses for a new integration. Keep Chat Completions for existing messages-array code, or Messages for an Anthropic-format client.
Meta documents three API formats:
| Format | Request endpoint |
|---|---|
| Responses | POST https://api.meta.ai/v1/responses |
| Chat Completions | POST https://api.meta.ai/v1/chat/completions |
| Messages | POST https://api.meta.ai/v1/messages |
All three use bearer authentication. They are different request formats, so changing the URL alone does not convert a request body.
Create a key through the Meta Model API dashboard, under API keys → Create API key. The quickstart documents this account setup.
Run this smoke test in Bash, with curl and jq installed:
set -o pipefail
read -rs MODEL_API_KEY && export MODEL_API_KEY
curl --fail-with-body --silent --show-error \
"https://api.meta.ai/v1/responses" \
-H "Authorization: Bearer $MODEL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "muse-ember-1.0",
"input": "Classify this ticket as bug, billing, or feature. Return only the label: The parser unit test now fails.",
"reasoning": {"effort": "minimal"},
"max_output_tokens": 1024,
"store": false
}' |
jq '{
status,
model,
text: (
[.output[]?
| select(.type == "message")
| .content[]?
| select(.type == "output_text")
| .text]
| join("\n")
),
usage
}'Check for status: "completed", the Ember model ID, a bug classification, and a populated usage object. These fields follow the documented Responses response structure.
This test deliberately uses minimal effort. The published benchmark results use max; the smoke test does not reproduce them. The output cap includes reasoning and visible output.
If the request fails, inspect the returned error before adding tools. Recheck the key, endpoint, and exact model ID. If output is incomplete, inspect the output budget and retry with an appropriate cap.
A successful classification verifies the API route. It does not verify repository access or tool execution.
Route a bounded Claude Code subtask to Ember
Use Meta’s documented Messages integration for a concrete planner-and-worker trial. This route runs Meta models inside Claude Code; it does not retain a Claude planner behind the same Meta endpoint.
With Claude Code installed, keep MODEL_API_KEY from the previous step. From a disposable JavaScript project containing package.json, run this in Bash:
(
unset ANTHROPIC_API_KEY
export ANTHROPIC_BASE_URL="https://api.meta.ai"
export ANTHROPIC_AUTH_TOKEN="$MODEL_API_KEY"
export ANTHROPIC_MODEL="muse-wonder-1.0"
export ANTHROPIC_DEFAULT_OPUS_MODEL="muse-wonder-1.0"
export ANTHROPIC_DEFAULT_SONNET_MODEL="muse-spark-1.3"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="muse-ember-1.0"
export CLAUDE_CODE_SUBAGENT_MODEL="muse-ember-1.0"
claude
)The subshell keeps these overrides out of later shell sessions. Meta’s coding-agent instructions specify the base host without /v1 and bearer authentication through ANTHROPIC_AUTH_TOKEN.
The main model is Wonder. The haiku alias and default subagent model point to Ember. However, current Claude Code model configuration allows invocation parameters and agent definitions to override the subagent default.
Use this explicit test prompt:
Use one general-purpose subagent with the haiku model to read package.json.
Return the package name and scripts.test value, or say which field is absent.
Do not edit files or execute commands. Then stop.While the worker runs, check /tasks. Claude Code v2.1.242 and later display the subagent’s model there. Confirm that the worker uses muse-ember-1.0, that a file-read tool actually ran, and that its report matches package.json.
Keep normal tool approvals enabled. A read-only instruction in a prompt is not a permission boundary.
If the wrong model runs, inspect the invocation and agent definition before blaming the provider. For an alternative that keeps Anthropic models throughout, follow the read-only Haiku subagent setup and verification guide.
Use OpenRouter or Cline without assuming a worker-only setting
Use OpenRouter when your application already connects through it, but select its model ID rather than Meta’s direct ID.
The OpenRouter model listing uses meta/muse-ember. Its Responses quickstart targets https://openrouter.ai/api/v1/responses with an OpenRouter API key, not a Meta key.
As of 2026-11-12, the listing shows $0.10 input and $0.50 output per 1M tokens. Its model catalog also lists cache-read and cache-write pricing. Confirm the selected provider’s long-context billing before sending requests above 200K input tokens. The displayed headline rates do not establish a flat price across the full context window.
For Cline, follow its OpenRouter provider setup. Open Settings, select OpenRouter under API Provider, and enter your OpenRouter API key. Choose meta/muse-ember in the model selector. Leave the optional custom base URL unset for the standard OpenRouter route.
Run the same file-read task before asking for edits. Confirm a real tool call and compare the returned values with the file.
Selecting Ember in the provider’s model picker is not evidence that only subagents use it. Cline’s native subagent documentation currently covers CLI and Desktop, not the VS Code or JetBrains extensions. For the explicit mixed-model trial described here, use the Claude Code configuration above.
Check regional eligibility and data settings before sending code
Check the access route’s terms before uploading repository content. An aggregator listing does not establish that your location or deployment is permitted.
Meta’s Geographic Use Policy, read as of 2026-11-12, lists Russia, Belarus, and Iran among restricted territories. Its restrictions cover access and knowingly permitting end users in restricted territories to access integrated products. It also prohibits technical circumvention of geographic controls.
On Model API, Ember is Standard mode only, with no Contributor-mode variant. Meta states that Standard-mode content is not used to train its models.
That is not a zero-retention promise. Zero Data Retention requires separate enablement, and support can vary by model.
Muse Code subscriptions have a separate rule: they default to Contributor mode. Before using a subscription for repository work, review that setting. To turn it off, open /settings, select the Contributor mode row, and switch it off. The setting is device-specific, so check each computer.
Decide after a bounded trial
Compare Ember with your current worker on a fixed set of representative tasks before changing team-wide routing.
For example, select 20 tasks from recent work. Keep the repository snapshot, tool permissions, acceptance checks, and cache policy consistent. Record the actual model, reasoning effort, input length, retries, elapsed time, and whether each result was accepted.
Calculate:
Cost per accepted task =
(planner cost + worker cost + retry cost + model-review cost)
÷ accepted tasksTrack human review time separately. Expand Ember’s assignment only when accepted-task cost improves without an unacceptable quality loss. Keep the previous worker for task types where Ember’s retries or rejected changes erase the saving.
