Meta Muse Wonder Explained: Benchmarks, Pricing and Active Memory (2026)

If you are choosing a model for an agent that has to run for hours, remember your preferences, and survive a failed tool call without a human nudging it, the question on October 12, 2026 was whether Meta had finally shipped something worth putting in that loop. Meta Superintelligence Labs announced Muse Wonder and Muse Wonder Full that day, calling them its most capable models to date and aiming them at "personal and professional agentic tasks" [1]. The launch post says the work started fourteen months earlier, and TechCrunch frames it as Meta's first frontier model release since the 2025 reorganization of its AI efforts [1] [4].

This post goes through what Meta actually disclosed about Active Memory and Active Focus, what the 14-row benchmark scorecard shows once you read the model card's fine print, how the pricing compares with Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1 and GPT-6 Astra for realistic agent workloads, and how to call the model today with runnable Python and bash. If you want the backstory of the Muse family first, our explainers on Muse Spark 1.3 and its contributor tier, Muse Glimmer 30B and why Meta ended Llama cover that ground, so this article stays focused on Wonder itself.

TL;DR: Muse Wonder in 2026

• Two models: Muse Wonder is the API model. Muse Wonder Full is the larger variant and is only available to Muse Code subscribers, not through the API [1] [4].
• Inputs and context: text, image, video and audio in, text out, with a 1M token context at inference [2].
• API price: $4 per million input tokens and $20 per million output tokens, listed at the same rates on OpenRouter [7] and reported by TechCrunch [4].
• Headline features: Active Memory (carrying what matters across conversations) and Active Focus (persisting through blockers, asking for clarification, checking in before important actions) [3].
• Benchmarks: Meta's scorecard puts Wonder Full on top in 6 of 14 rows and Claude Opus 5.5 on top in 6, with the independent Artificial Analysis index placing Opus 5.5 at 58, Wonder Full at 56 and Wonder at 52, as transcribed by FelloAI [8].
• Biggest caveat: Meta states that its runs of rival models are "best-effort" and that where no third-party score exists it uses the highest of its own internal, self-reported or leaderboard numbers [2].
• Not disclosed: parameter count, architecture, training data and the actual mechanism behind Active Memory.

Why this launch matters: Meta's first frontier claim

For most of 2026 the Muse line was a story about efficient, mid-size models. Muse Spark launched in April as the first Meta Superintelligence Labs model, and later versions added a contributor pricing tier and an open 30B sibling. Wonder is the first time Meta says it is competing at the top end, and the launch materials are explicit about the comparison set: the model card names GPT-6 Astra, Claude Fable 5.1 and Claude Opus 5.5, all evaluated at max reasoning effort [2]. Meta did not put Claude Sonnet 5.5 or GPT-6 Sol in its chart, which is relevant because those are the two models most teams actually run at volume. We covered both in earlier posts on Claude Sonnet 5.5 and GPT-6 Sol and Luna.

The training context is also worth knowing. TechCrunch reports the models were trained at Meta's Prometheus data center in central Ohio, and Meta's own post refers to a gigawatt-scale cluster [1] [4]. Meta describes the release as "the next step on our scaling ladder", which signals that Wonder is a point on a roadmap rather than an endpoint [4]. Reporting from earlier in the year said the internal codename for this generation was Watermelon [11].

Meta also positions Wonder differently from the prior models in a business sense. Muse Wonder is sold through the Meta Model API and Muse Code, and it will "soon power experiences in Muse", with the consumer rollout going to paying subscribers first [3]. CNBC's headline calls the launch a test of users' willingness to pay, which matches the structure: a priced API, two paid coding tiers and paid consumer tiers [5].

Wonder vs Wonder Full: Which Model You Can Actually Use

The two variants are easy to confuse, and the distinction decides whether you can build on the stronger one at all.

Muse Wonder is the model with a per-token price, a model listing on OpenRouter under the ID meta/muse-wonder, and the model page on Meta's developer site that links to a playground using the ID muse-wonder-1.0 [6] [10]. Muse Wonder Full is reachable only inside Muse Code, on the Power Usage plan at $50 per month and the Maximum Usage plan at $200 per month, with the $200 tier described as about 80 times the usage limit of the Everyday plan [8] [9].

The practical consequence is a split between what Meta advertises and what developers can build on. The headline numbers in the launch chart lean on Wonder Full for coding results such as SWE-Marathon (57.5 at xhigh effort for Full versus 53.1 for Wonder), yet a team writing its own agent against the API gets the smaller model. If you plan to compare Wonder against another model for your own product, test Muse Wonder, because that is the one you can deploy.

How Active Memory and Active Focus Work (As Far As Meta Discloses)

Meta frames Wonder's identity around two capabilities, and it is worth separating what the sources actually say from what people assume.

Active Memory: what is stated

Meta defines Active Memory as "the ability to carry what matters to you across conversations", with the model surfacing relevant details for the task in front of it [3]. The research blog adds that it carries important context about the user across conversations and retrieves details relevant to the current task [1]. Research scientist Kavya Kopparapu told TechCrunch that "we put a tremendous amount of effort into making sure your model can remember what's important to you" [4].

None of these statements describe a mechanism. Meta does not say whether Active Memory is a learned behavior inside the weights, an external store with retrieval that the product layer manages, or a mix of both. The model card lists the context length at 1M tokens at inference and does not mention a persistent memory store or a memory API [2]. That matters for developers: calling the model through the API gives you the 1M context and the model's trained habits for using context, but the model card does not promise that facts persist between separate API calls unless you resend them.

MemoryBench: the one measurement of memory

The only quantitative evidence for Active Memory is MemoryBench, which the model card describes as an internal benchmark. It tests recall of critical information across long, complex multi-turn conversations of 64K to 100K tokens that span several individual facts, with distractor conversations and injected turns that conflict with or later update the target details, scored by an LLM judge against weighted, question-specific rubric criteria [2].

That design tells you what Meta is measuring. It is long-context recall with updates and interference, which is a legitimate and hard problem, since a model that remembers the first version of your address after you corrected it is worse than one with no memory. It is not a measurement of cross-session persistence, because every test conversation fits inside a single context window of 100K tokens or less, far under the 1M limit.

The scores as transcribed by FelloAI from Meta's chart are 85.6 for Muse Wonder, 85.5 for Wonder Full, 81.5 for Opus 5.5, 81.4 for GPT-6 Astra and 79.0 for Fable 5.1 [8]. TechCrunch separately reports that Wonder scores higher than Fable, Opus and Astra on MemoryBench [4]. Two cautions apply. The benchmark is Meta's own, so no outside lab has validated the questions or the judge. The gap to Opus 5.5 is about four points, and since the card says competitor runs are best-effort, the real margin could be larger or smaller.

Active Focus: persistence as a trained behavior

Active Focus is defined as the ability "to keep working toward your goal when a task gets hard", which the research blog unpacks as trying alternative approaches, working through blockers, adapting to new information, asking for clarification when needed and checking in before important actions [1] [3].

The associated measurement is FocusBench, an internal evaluation of personal agentic tasks across domains such as housing, travel, IT and finance, which tests whether agents can persistently work through real-world blockers across multiple interactions and adapt to dynamically changing environments [2]. FocusBench is one of seven components of the Personal Superintelligence Index, along with Agents' Last Exam, AutomationBench-AA, JobBench, GDP.pdf, VBT and DRACO [2]. FelloAI's transcription lists PSI scores of 59.1 for Wonder Full, 54.3 for Wonder, 55.2 for Opus 5.5, 54.5 for GPT-6 Astra and 49.9 for Fable 5.1 [8]. Because PSI is an internal composite whose weights Meta does not publish, it can show direction but cannot settle a procurement decision.

The "checks in before important actions" language has a direct design implication. An agent that pauses for confirmation before irreversible steps is safer in a personal assistant, yet it can stall an unattended pipeline. The model card's responsible-use section recommends human-in-the-loop confirmation for irreversible actions when the model can take real-world actions [2], so the confirmation behavior is intentional rather than a side effect. If you run fully automated workflows, test how often Wonder asks for clarification on your tasks and decide whether your orchestration layer should answer those questions automatically.

A scatter plot that hints at generalization

One figure in the launch post compares Muse Spark 1.3 with Muse Wonder Full, plotting in-distribution scores on the horizontal axis against out-of-distribution averages on the vertical axis, where each point is a distinct reasoning effort. Meta says Wonder Full performs better on out-of-distribution tasks than the Spark 1.3 trend would predict [1]. The chart's values are not given in text, so the claim is directional. It is a reasonable argument that the gain is more than benchmark tuning, and it is also a claim that rests on Meta's choice of which tasks count as out-of-distribution.

How to approximate Active Memory in your own agent

Since the API gives you a model rather than a memory product, a practical pattern is to keep a small durable store of user facts, retrieve the relevant ones per task, and place them at the top of the prompt, then let the model update the store through a tool. The snippet below is our own pattern for testing memory behavior, not Meta's implementation.

python
/code
# A simple external memory pattern: explicit, auditable writes to a JSON file.
# This is our own pattern for testing memory behavior, not Meta's Active Memory implementation.
import json, os, pathlib
from openai import OpenAI

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])
MODEL = "meta/muse-wonder"
STORE = pathlib.Path("user_memory.json")

def load():
    return json.loads(STORE.read_text()) if STORE.exists() else {}

def save_fact(key, value):
    mem = load(); mem[key] = value
    STORE.write_text(json.dumps(mem, indent=2))
    return f"saved {key}"

tools = [{"type": "function", "function": {
    "name": "save_fact",
    "description": "Persist a durable fact about the user (preferences, constraints, corrections).",
    "parameters": {"type": "object", "properties": {"key": {"type": "string"}, "value": {"type": "string"}}, "required": ["key", "value"]},
}}]

def turn(user_text):
    system = "Known user facts (may be outdated, prefer the newest): " + json.dumps(load())
    msgs = [{"role": "system", "content": system}, {"role": "user", "content": user_text}]
    r = client.chat.completions.create(model=MODEL, messages=msgs, tools=tools, max_tokens=500)
    m = r.choices[0].message
    for tc in (m.tool_calls or []):
        print(save_fact(**json.loads(tc.function.arguments)))
    return m.content

print(turn("I moved. My shipping city is now Denver, and I am vegetarian."))
print(turn("Plan a dinner order for me this weekend."))

The important design choice is to make memory writes explicit tool calls so you can audit them. A store you can read is far easier to debug than behavior hidden inside a long context.

The Benchmarks: What the 14-Row Scorecard Shows

Meta's launch chart compares Muse Wonder and Muse Wonder Full with GPT-6 Astra, Claude Fable 5.1 and Claude Opus 5.5 across 14 rows. The model card has the methodology but, in the copy we could read, not the numeric table, and the chart in the research post is an image. The numbers below come from FelloAI's transcription of Meta's chart [8], which agrees with Meta on the row names, the competitor set, the AA Index figures for the Wonder models and the SWE-Marathon harness caveat. We could not corroborate every individual cell with a second source, so treat the table as a faithful secondary transcription and check Meta's chart image for any number you plan to quote.

Counting the rows

Counting the highest value in each row gives Wonder Full six wins (PSI, Harvey LAB-AA, Vals Finance Agent V2, AutomationBench-AA, DeepSWE 1.1 and SWE-Marathon), Claude Opus 5.5 six wins (HealthBench Pro, JobBench, OSWorld V2.1, Terminal-Bench 4.0, ProgramBench and the AA Intelligence Index), Muse Wonder one win (MemoryBench) and GPT-6 Astra one win (GDP.pdf). Claude Fable 5.1 wins none. FelloAI's own count differs slightly because its OSWorld row marks Fable in bold although Opus 5.5's 81.8 is higher than Fable's 80.7, which we read as a formatting slip.

For the model you can call over the API, the picture is less flattering than the headline. Going row by row against Opus 5.5, Muse Wonder wins five rows (Harvey LAB-AA at 10.0 against 4.2, GDP.pdf at 30.8 against 30.6, MemoryBench at 85.6 against 81.5, DeepSWE 1.1 at 78.8 against 74.2 and SWE-Marathon at 53.1 against 46.3) and loses the other nine. FelloAI reaches the same 9 to 5 split [8]. Two of those five wins are razor thin or harness-dependent, which leaves legal agents, memory and real-repo coding as the clearest areas where the API model is ahead.

Where Wonder is strongest

Legal agents. Harvey LAB-AA is Artificial Analysis's version of Harvey's Legal Agent Benchmark, where agents produce legal work products from matter documents and a judge panel checks each deliverable against task-specific criteria, with version 1.1 adding hallucination checks. The metric is the share of tasks whose deliverable meets every criterion and passes the checks [2]. Wonder Full scores 13.1 and Wonder 10.0, against 8.6 for GPT-6 Astra, 6.4 for Fable 5.1 and 4.2 for Opus 5.5 [8]. The absolute numbers are low because the bar is strict (every criterion must pass), so the useful reading is the ratio: Wonder passes more than twice as many full-credit tasks as Opus 5.5 on this test. The research blog names Harvey's Legal Agent Benchmark among its headline evaluations, which suggests Meta considers it a strong result [1].

Long-horizon software work. SWE-Marathon is an ultra-long-horizon engineering benchmark of substantial projects graded by executing project tests, with pass@1 as the metric and Abundant AI as the source for all models [2]. The transcribed scores are 57.5 for Wonder Full at xhigh effort, 53.1 for Wonder, 46.3 for Opus 5.5, 45.6 for Fable 5.1 and 42.5 for GPT-6 Astra [8]. This is the largest margin on the chart, and the card immediately qualifies it: the leaderboard results for GPT-6 Astra and Claude Fable 5.1 use Codex and Claude Code respectively, so the row "is not a controlled common-harness comparison" [2]. A gap of 7 points between Wonder and Opus 5.5 could reflect the model, the harness or both.

Real-repo coding. DeepSWE v1.1 has 113 tasks across 91 repositories and five languages, graded by handwritten functional and regression tests. The scorecard uses Datacurve's third-party results for the Muse models and Opus 5.5 and OpenAI's provider-reported result for Astra [2]. Wonder at 78.8 and Wonder Full at 79.0 lead Opus 5.5 at 74.2 and Astra at 74.1 [8]. Because the Muse and Opus numbers share a third-party source, this is one of the cleaner comparisons on the chart. For context, Mistral reported 61.7% on the same benchmark version for Mistral Large 4, an open-weight model we examined in our Mistral Large 4 breakdown, though that figure came from Mistral and not from the same scorecard.

Where Wonder trails

ProgramBench is the most striking gap. It measures whether an agent can reconstruct a complete program in a clean-room environment, with internet disabled after setup, scored by a hidden behavioral test suite, and all compared models run in mini-swe-agent [2]. Opus 5.5 scores 70.5 against 59.0 for Wonder Full and 50.0 for Wonder, with GPT-6 Astra at 52.5 and Fable 5.1 at 55.5 [8]. This is a common-harness test, and Opus wins it by more than 11 points over the best Muse model. If your work resembles building a program from a specification, this row deserves more weight than SWE-Marathon.

Terminal and computer use. Terminal-Bench 4.0 (Artificial Analysis as source) shows Opus 5.5 at 59.6 and Astra at 59.1 against 57.1 for Wonder Full and 52.0 for Wonder. OSWorld V2.1, a long-horizon computer-use benchmark of 108 workflows on an Ubuntu desktop VM, shows Opus 5.5 at 81.8, Fable 5.1 at 80.7, Wonder Full at 78.4 and Wonder at 72.6 [2] [8]. The card notes that Opus's OSWorld result is Anthropic's provider-reported partial score. Meta's research blog highlights computer-use style demos such as planning a run across a browser and apps, yet the benchmark data shows Wonder trailing the leaders on the standard computer-use test.

Health and jobs. HealthBench Pro, with 525 professional-grade health questions graded against physician-written rubrics, shows Opus 5.5 at 65.6 and Astra at 65.3 versus 62.3 and 60.5 for the Muse models. JobBench puts Opus 5.5 at 75.4, essentially tied with Wonder Full at 75.3 [2] [8].

The independent index

Artificial Analysis's Intelligence Index v4.3 is the one aggregate not controlled by Meta. FelloAI lists Claude Opus 5.5 at 58, Claude Sonnet 5.5 at 56, Muse Wonder Full at 56, Fable 5.1 at 53, GPT-6 Astra at 53 and Muse Wonder at 52 [8]. Note the model that Meta left off its chart: Sonnet 5.5, priced at half of Opus, scores the same as Wonder Full and four points above the API-available Wonder. We could not load Artificial Analysis's own page for Wonder, so this is a single-source transcription. Index versions also matter: an earlier snapshot listed Muse Spark 1.3 at 61 under v4.1.1, which is not comparable to v4.3 scores [12].

Reading the Fine Print: How Benchmarks Get Engineered

Coverage of the launch, including Bloomberg's report on the 14-month push [14], has raised the caveat that benchmark results can be shaped by the party reporting them, and Meta's model card gives you the specific reasons that applies here. The Bloomberg article returned an access error when we tried to open it, so the points below rest on Meta's own methodology text [2].

Score selection. The card says that where a comparable third-party or provider-reported result exists, Meta uses it, and otherwise it uses "the highest of our internally validated run, self-reported score, or official leaderboard score". Taking the maximum across three sources is a defensible way to avoid understating a score, and it also guarantees that any noisy benchmark reads high for whichever model gets the most sources.

Best-effort competitor runs. Internally generated competitor runs "remain best-effort: prompts, tools, and runtime may not be optimally tuned for proprietary models". Meta runs its own models with prompts it developed alongside the model, so the home advantage is built in. Every lab does this, which is why independent harness-matched leaderboards matter.

Mixed harnesses. The card says external coding results retain the harness or agent product used by the vendor, while controlled internal coding comparisons use the same benchmark-specific harness. The practical lesson is to compare rows only when the card says the harness is common (ProgramBench, with mini-swe-agent) and to discount rows where each model brought its own agent (SWE-Marathon).

Reasoning effort. All Muse and competitor results are at maximum reasoning effort, and SWE-Marathon for Wonder Full was reported at xhigh. Maximum effort means maximum tokens, which feeds directly into the cost calculation later in this post.

Internal benchmarks. PSI, MemoryBench, VBT and FocusBench are Meta's own. They may be excellent designs, and nobody outside Meta can currently audit the questions. The two features Meta uses to market the model, memory and focus, are measured by exactly these internal tests.

Another example of why harness details matter comes from the Claude side. Anthropic's Sonnet 5.5 launch was reported with 70.6% on Terminal-Bench 4.0 [13], while the Artificial Analysis version of Terminal-Bench 4.0 on Meta's chart puts Opus 5.5 at 59.6. Two numbers for what looks like the same benchmark family differ by about 11 points because the harness, tool setup and scoring source differ. A reader who mixes figures across sources would conclude that a cheaper Sonnet beats the flagship, which is a conclusion neither lab made.

Safety and Risk Disclosures Worth Reading

The model card includes an unusually detailed risk section for Wonder Full under the Meta Superintelligence Scaling Framework. Meta says it cannot rule out that the unmitigated model reaches the high risk threshold in the chemical and biological domain, so it applied safety post-training and system-level classifiers. Unmitigated, it rates the model "moderate or lower" for cybersecurity and loss of control, and with mitigations all domains land at moderate or lower [2].

For developers, the cyber numbers are the interesting part because they show both capability and refusal behavior. Wonder Full scores 88.4% on CyberGym and 58.9% on ExploitBench. On ExploitGym it captured 92 flags, but a verification pass found only 21 used the intended vulnerability while 71 came through unintended ones, and the published ranking counts only the 21 [2]. That is a candid disclosure and a useful reminder that a raw capture count can overstate real exploit skill. On robustness, attack success rates are low: 0.8% single-turn and multi-turn on CyberBench, 1.1% and 2.3% on the PolyGuard cyber subset, and 9.0% and 8.0% on RedCode [2].

On chemistry and biology, refusal rates on BioTIER are 98.7% in English and multilingual and 98.2% adversarial, with Meta's internal chemistry refusal at 100.0% in English and multilingual and 99.8% adversarial. For loss of control, MASK honesty is 87.3% and Agentic Misalignment is 0% [2]. The launch post adds that a full report with additional safety evaluations will be available soon [1].

The limitations list is short and specific. Meta warns that visual and spatial reasoning, especially 3D tasks, remains a known limitation, that performance can vary with quantization, serving configuration, prompts, tools and the agent harness, and that the model is not intended for people under 18 [2]. The spatial warning is worth remembering if you plan to use the video input for physical-world reasoning.

All safety numbers are for Wonder Full, which only Muse Code subscribers can use. The card says the assessment covers every model in the family, but if you deploy Muse Wonder through the API you are relying on that statement and on additional guardrails you build yourself, which the card recommends.

Pricing Math for Real Agent Workloads

List prices are only the start, because agents re-read their context on every turn. The rate card that matters has three numbers: uncached input, cached input and output. FelloAI's pricing table, which TechCrunch's "roughly equivalent in cost to Opus 5.5" statement supports for the Wonder and Opus rows, lists the following per-million-token rates [4] [8].

Muse Wonder and Claude Opus 5.5 cost exactly the same, so the choice between them comes down to quality, tool behavior and latency on your tasks rather than price. Alexandr Wang had said pricing would be meaningfully below leading rivals, which holds against Fable 5.1 and GPT-6 Astra (both $10 and $50) and does not hold against Opus 5.5 [8]. Sonnet 5.5 at $2 and $10 is half the price of Wonder, as covered in our Sonnet 5.5 pricing breakdown, while Muse Spark 1.3 at $1.25 and $4.25 is less than a third of it.

A worked example: one long coding task

Take a hypothetical but realistic agent task: a 40-turn coding session in which the context grows to about 50,000 tokens. Summed over the session, the model reads about 2 million input tokens, of which we assume 80% are cache hits (1.6 million cached, 0.4 million fresh) and writes 30,000 output tokens including reasoning. These are our assumptions for illustration, not Meta figures.

At 1,000 such tasks per day, Muse Wonder costs about $2,520 per day, Sonnet 5.5 about $1,260 and GPT-6 Astra about $7,100. The ranking is stable under moderate changes to the assumptions, though the gaps move. With no caching at all (2 million fresh input tokens and 30,000 output), Wonder costs $8.60 per task and Sonnet 5.5 costs $4.30, so a missed cache hit rate roughly triples the bill. Cache read pricing is therefore as important as headline pricing for any agent with a stable system prompt and tool definitions.

Output tokens and reasoning effort

Meta ran the scorecard at maximum reasoning effort, and reasoning tokens bill as output at $20 per million. If a hard task makes Wonder emit 150,000 reasoning tokens instead of 30,000, output cost alone rises from $0.60 to $3.00 per task, more than the entire fresh-input bill. The OpenRouter page lists reasoning and reasoning_effort among the supported parameters [6], so a sensible rollout starts at a lower effort for routine steps and escalates only for steps that fail verification. We could not find Meta documentation on the number of tokens used per benchmark task, so measure your own.

Subscription versus API

Muse Code's $200 Maximum Usage plan includes Muse Wonder Full, which is not on the API at all [8] [9]. On the example above, $200 would buy about 79 API tasks of Wonder (the smaller model), and $50 about 20. A developer running a handful of heavy coding sessions every day will likely find the flat plan cheaper than paying per token, and a team running automated pipelines cannot use the flat plan for programmatic traffic. The consumer Muse app sits at $20 and $100 monthly tiers for advanced model access and premium agent capabilities [9].

What the price buys in index points

On Artificial Analysis's index, Wonder (52) and Opus 5.5 (58) have identical prices and a 6-point gap, while Sonnet 5.5 (56) costs half as much and scores 4 points higher than Wonder [8]. On that single aggregate, Wonder is dominated by Sonnet 5.5 on both price and score. Wonder's case therefore depends on the rows where it leads: legal agents, long-horizon repository work and memory. For a workload that looks like those, the aggregate understates it.

How to Call Muse Wonder From Code

Two access paths are documented. Meta's developer site states that you can point an existing OpenAI-SDK-compatible client at the Meta Model API [10], and its model page links to a playground using the model ID muse-wonder-1.0. The developer page does not print a base URL in the portion we could read, so the examples below use OpenRouter, where the endpoint and model ID meta/muse-wonder are both documented [6]. If you use Meta's API directly, take the base URL and key from your dashboard and set them through environment variables as the snippets do. Never paste a key into source files.

Step 1: A first request with curl

The OpenRouter model page documents the chat completions endpoint and the request shape, with model and messages required and optional stream, max_tokens, reasoning, reasoning_effort, temperature, tools, tool_choice, response_format, top_p, top_k and repetition_penalty [6].

bash
/code
# First request to Muse Wonder through OpenRouter's chat completions endpoint.
# Export the key in your terminal only. Never paste it into files or commit it.
export OPENROUTER_API_KEY="paste-your-key-here-in-your-terminal-only"

curl -X POST https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta/muse-wonder",
    "max_tokens": 400,
    "messages": [
      {"role": "user", "content": "List three risks of letting an agent send emails unattended."}
    ]
  }'

Step 2: The OpenAI Python client

Because the endpoint is OpenAI-compatible, the standard client works with a changed base URL. The snippet below also reads the usage block so you can see what each call costs, which is the habit that keeps the earlier pricing math honest. The shape of the reasoning field is passed through extra_body; check the OpenRouter API reference for the accepted values before relying on it.

python
/code
# pip install openai
import os
from openai import OpenAI

# Defaults to OpenRouter, where the model ID meta/muse-wonder is documented.
# For Meta's own API, set BASE_URL and MODEL from your Meta dashboard.
BASE_URL = os.environ.get("MUSE_BASE_URL", "https://openrouter.ai/api/v1")
MODEL = os.environ.get("MUSE_MODEL", "meta/muse-wonder")
client = OpenAI(base_url=BASE_URL, api_key=os.environ["OPENROUTER_API_KEY"])

resp = client.chat.completions.create(
    model=MODEL,
    max_tokens=800,
    messages=[
        {"role": "system", "content": "You are a careful legal drafting assistant."},
        {"role": "user", "content": "Summarize the termination clause risks in 5 bullets: <paste clause>"},
    ],
    # The page lists reasoning and reasoning_effort as supported parameters.
    # Confirm the accepted values in the OpenRouter API reference before relying on this.
    extra_body={"reasoning": {"effort": "medium"}},
)

print(resp.choices[0].message.content)
u = resp.usage
print("prompt tokens:", u.prompt_tokens, "completion tokens:", u.completion_tokens)
# Wonder list price: $4 per 1M input, $20 per 1M output (cached input $0.20).
cost = u.prompt_tokens * 4 / 1e6 + u.completion_tokens * 20 / 1e6
print(f"upper-bound cost this call: ${cost:.4f}")

Step 3: Tool use in an agent loop

Active Focus is about continuing through blockers, so the useful test is to give the model a tool that fails and see how it reacts. The loop below defines one tool, feeds back a deliberate error on the first call, and logs whether the model retries with a different approach. The tool-call format follows the standard OpenAI-compatible schema that the tools and tool_choice parameters imply.

python
/code
# A tiny agent loop with one deliberately flaky tool, to observe retry behavior.
import json, os
from openai import OpenAI

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])
MODEL = "meta/muse-wonder"

tools = [{
    "type": "function",
    "function": {
        "name": "lookup_price",
        "description": "Look up the price of an item by exact SKU.",
        "parameters": {
            "type": "object",
            "properties": {"sku": {"type": "string"}},
            "required": ["sku"],
        },
    },
}]

calls = {"n": 0}
def lookup_price(sku):
    calls["n"] += 1
    if calls["n"] == 1:
        return json.dumps({"error": "upstream timeout, try again or use another approach"})
    return json.dumps({"sku": sku, "price_usd": 42.5})

messages = [{"role": "user", "content": "What does SKU A-1001 cost? Use the tool."}]
for step in range(6):
    r = client.chat.completions.create(model=MODEL, messages=messages, tools=tools, tool_choice="auto", max_tokens=600)
    msg = r.choices[0].message
    messages.append(msg)
    if not msg.tool_calls:
        print("FINAL:", msg.content)
        break
    for tc in msg.tool_calls:
        args = json.loads(tc.function.arguments)
        out = lookup_price(**args)
        print(f"step {step}: tool call {tc.function.name}({args}) -> {out}")
        messages.append({"role": "tool", "tool_call_id": tc.id, "content": out})
print("tool calls made:", calls["n"], "(more than 1 means the model retried after the error)")

Step 4: Testing memory yourself with a conflicting update

MemoryBench injects turns that conflict with or later update earlier facts. You can reproduce a small version of that pattern with your own data: state a fact, add distractor chatter, update the fact, and ask. This probe is our own sketch inspired by the benchmark description in the model card [2], and it does not reproduce Meta's benchmark or its scoring.

python
/code
# A small conflicting-update probe inspired by the MemoryBench description in the model card.
# It does not reproduce Meta's benchmark or its LLM-judge scoring.
import os
from openai import OpenAI

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])
MODEL = "meta/muse-wonder"

distractor = "Unrelated chatter about a conference schedule and lunch options. " * 200

convo = [
    {"role": "user", "content": "For the record, my project deadline is March 3."},
    {"role": "assistant", "content": "Noted."},
    {"role": "user", "content": distractor},
    {"role": "assistant", "content": "Understood."},
    {"role": "user", "content": "Update: the deadline moved to March 17."},
    {"role": "assistant", "content": "Updated."},
    {"role": "user", "content": distractor},
    {"role": "assistant", "content": "Understood."},
    {"role": "user", "content": "When is my project deadline? Answer with the date only."},
]

hits = 0
RUNS = 5
for i in range(RUNS):
    r = client.chat.completions.create(model=MODEL, messages=convo, max_tokens=30, temperature=0.7)
    ans = r.choices[0].message.content.strip()
    ok = "17" in ans and "3," not in ans
    hits += ok
    print(i, ans, "OK" if ok else "STALE/WRONG")
print(f"{hits}/{RUNS} correct (newest value wins)")

Step 5: A cost calculator for your own workload

The final snippet turns the rate card into a function you can feed with your measured token counts, so you can compare Wonder, Opus 5.5, Sonnet 5.5 and the others on your traffic rather than ours.

python
/code
# Compare per-task cost across models using measured token counts.
# Rates are USD per 1M tokens: (fresh input, cached input, output), as listed at launch.
RATES = {
    "Muse Wonder":       (4.00, 0.20, 20.00),
    "Claude Opus 5.5":   (4.00, 0.20, 20.00),
    "Claude Sonnet 5.5": (2.00, 0.10, 10.00),
    "Claude Fable 5.1":  (10.00, 0.25, 50.00),
    "GPT-6 Astra":       (10.00, 1.00, 50.00),
    "Muse Spark 1.3":    (1.25, 0.15, 4.25),
}

def task_cost(model, fresh_in, cached_in, out):
    i, c, o = RATES[model]
    return (fresh_in * i + cached_in * c + out * o) / 1e6

# Replace with your measured averages per successful task.
fresh_in, cached_in, out = 400_000, 1_600_000, 30_000
tasks_per_day = 1_000
success_rate = {"Muse Wonder": 0.70, "Claude Opus 5.5": 0.75}  # example values, measure your own

for m in RATES:
    cost = task_cost(m, fresh_in, cached_in, out)
    sr = success_rate.get(m)
    per_success = f"  per success: ${cost / sr:.2f}" if sr else ""
    print(f"{m:20s} ${cost:6.2f} per task  ${cost * tasks_per_day:9,.0f} per day{per_success}")

Which Workloads Fit Wonder, and Which Do Not

A useful way to read the scorecard is by task family, using the rows where common harnesses or third-party sources reduce Meta's room to tilt the result.

Legal and document-heavy professional work. Harvey LAB-AA and GDP.pdf both come from outside sources (Artificial Analysis and Surge) according to the model card, and Wonder leads or ties Opus 5.5 on both [2]. Because the legal metric is all-criteria-must-pass with hallucination checks, the result suggests Wonder is relatively careful on long structured deliverables. A team drafting from matter documents is the natural pilot, with a human reviewing every output as Meta itself recommends for specialized domains.

Long repository work. DeepSWE (third-party scores) and SWE-Marathon (different harnesses) both favor Wonder, and ProgramBench (common harness) favors Opus 5.5 by a wide margin. This split fits a model that is strong at sustained edits to existing code and comparatively weaker at greenfield construction from a spec. Run your own held-out tasks of both kinds before committing.

Computer use and terminal automation. The data points the other way. If your agent mostly clicks through GUIs or runs terminal workflows, Opus 5.5 and Astra score higher on Terminal-Bench 4.0 and OSWorld V2.1 [8]. Meta acknowledges 3D and spatial reasoning as a known limitation [2], which also makes screenshot-heavy tasks a place to test carefully.

Personal assistants with long histories. This is the category Meta designed Wonder for, and MemoryBench is the evidence. Because the benchmark is internal and the memory mechanism is undisclosed, build a small evaluation from your own conversations before trusting it with real user data. Privacy deserves attention here: Meta says it trained the models to avoid sharing private information without permission [3], which is a training claim rather than a guarantee, so your application should still control what data enters the context.

High-volume, cost-sensitive agents. Sonnet 5.5, GPT-6 Sol and Muse Spark 1.3 cost less per token. Unless a specific Wonder strength applies, a cheaper model with a reliability layer will often win on total cost. Our guides to GPT-6 Sol and Luna and GPT-6 Astra cover the OpenAI side of that trade.

Open weights and self-hosting

Neither the launch post nor the model card mentions releasing open weights, and FelloAI notes that the Muse Spark weights promised in September had not shipped as of launch [8]. If self-hosting or data residency matters, the open options in our coverage remain Muse Glimmer 30B and Mistral Large 4.

Common Mistakes When Evaluating Muse Wonder

1. Evaluating Wonder Full and deploying Wonder. The strongest numbers in the chart are Wonder Full's, which you cannot call through the API. Run your evaluation on the model you will ship.
2. Comparing rows with different harnesses. SWE-Marathon mixes Codex, Claude Code and Muse Code style agents. Treat it as a product comparison rather than a model comparison.
3. Ignoring the cache. The same task can cost $2.52 or $8.60 depending on cache hits. Structure prompts so the system prompt, tool schema and stable context come first.
4. Averaging benchmark ranks. Wonder's wins and losses cluster by task type. An average hides exactly the signal you need.
5. Assuming memory persists across API calls. The documentation describes the capability and the 1M context but no persistence API. Store and resend what you need.
6. Leaving reasoning effort at maximum. The benchmark settings are maximum effort. Production traffic rarely needs that, and the output bill shows it.
7. Skipping the confirmation behavior. Active Focus includes checking in before important actions. Decide up front how your pipeline answers those prompts.
8. Quoting an unverified score. The scorecard values reach most readers through secondary transcription. Check Meta's chart image before you cite a number to a stakeholder.

Using an Agent Model Inside a Creator Workflow

For creators, models like Wonder matter mostly as the planning layer that sits behind content tools. A long-context agent can read a channel's last 100 video transcripts, remember your preferred hook style, and draft the next week of scripts. Those scripts can then go into Miraflow's Text2Shorts to become vertical videos, or into the AI Clipping tool to pull viral moments from a long upload. Thumbnails for the same videos come from the YouTube Thumbnail Maker, supporting visuals from the AI image generator, and soundtracks from the AI music generator.

The Meta ecosystem also has its own creative models. Our comparison of Muse Image against Nano Banana Pro shows where Meta's image side stands. If you want to see these pieces working together in one place, start from the Miraflow home page and try the cinematic video generator for the shots your agent storyboards. The planning model and the production tools are separate decisions, and the cheapest planning model that writes a good brief is usually the right one.

Frequently Asked Questions

What is Muse Wonder?

Muse Wonder is Meta Superintelligence Labs' first frontier model family, announced October 12, 2026, built for personal and professional agentic tasks. It comes in two variants, Muse Wonder and Muse Wonder Full [1].

How much does the Muse Wonder API cost?

Muse Wonder costs $4 per million input tokens and $20 per million output tokens, with cached input at $0.20 per million according to FelloAI's table [7] [8]. That equals Claude Opus 5.5's list price.

Can I use Muse Wonder Full through the API?

No. Wonder Full is available only to Muse Code subscribers, with plans listed at $50 and $200 per month [1] [8].

What is the context window?

The model card states 1M tokens at inference, and OpenRouter lists 1.0M [2] [7].

What inputs does it accept?

Text, image, video and audio inputs with text output, per the model card [2]. The OpenRouter page documents only text messages in its request description, so confirm multimodal support on your chosen provider [6].

What are Active Memory and Active Focus?

Active Memory carries important context about you across conversations and retrieves relevant details for the current task. Active Focus keeps the agent working toward a goal through blockers, with clarification questions and check-ins before important actions [1] [3]. Meta has not disclosed the mechanism.

Does Muse Wonder beat Claude Opus 5.5?

On Meta's chart, Wonder Full and Opus 5.5 each lead six rows, and Muse Wonder wins 5 of 14 head-to-head rows against Opus 5.5. On Artificial Analysis's index Opus 5.5 scores 58 against 56 for Wonder Full and 52 for Wonder [8].

Is Muse Wonder open weight?

No open weights were announced with this launch [8]. For open options see Muse Glimmer 30B and Mistral Large 4.

Is the model safe for cyber and bio topics?

Meta reports its strongest safeguards to date, including low attack success rates on cyber jailbreak tests and high refusal rates on biology and chemistry prompts, all measured on Wonder Full. A full safety report is promised [1] [2].

What is the model ID?

Use meta/muse-wonder on OpenRouter [6]. Meta's developer playground link uses muse-wonder-1.0 [10].

Conclusion

Muse Wonder is a credible first frontier entry from Meta, with real strengths in legal agent work, memory over long conversations and long-horizon repository tasks, and with clear gaps against Claude Opus 5.5 on program construction, terminal use and computer use. The most useful details are in the model card rather than the press coverage: score selection takes the highest available number, competitor runs are best-effort, and the SWE-Marathon row is not a controlled comparison. Pricing equals Opus 5.5 and sits above Sonnet 5.5, so the model has to win on your specific workload to justify itself.

The practical next step is to build a small evaluation from your own tasks, run Muse Wonder, Opus 5.5 and Sonnet 5.5 with the same harness and measured token counts, and let the cost per successful task decide. The snippets above give you the client, the tool loop, a memory probe and a cost calculator to start. When Meta publishes its full safety report and when Active Memory gains documentation, revisit the decision, since the missing mechanism is the biggest open question about the model's headline feature.

References

1. [1] Meta AI Research, Introducing Muse Wonder, October 12, 2026.
2. [2] Meta, Muse Wonder Model Card.
3. [3] Meta Newsroom, Introducing Muse Wonder and Muse Wonder Full: Frontier Models for Agents.
4. [4] TechCrunch, Meta releases its first frontier model, Muse Wonder.
5. [5] CNBC, Meta debuts Muse Wonder AI model in latest test of users' willingness to pay.
6. [6] OpenRouter, Meta: Muse Wonder.
7. [7] OpenRouter, Muse Wonder pricing.
8. [8] FelloAI, Meta Muse Wonder: Benchmarks, Price and the Catch.
9. [9] Shattered, Meta Muse Wonder Pricing: $4-$200/Mo Explained.
10. [10] Meta, Meta Model API developer site.
11. [11] GIGAZINE, Meta Watermelon.
12. [12] Artificial Analysis, Muse Spark 1.3.
13. [13] MarkTechPost, Anthropic Releases Claude Sonnet 5.5: 70.6% on Terminal-Bench 4.0 at the Same $2/$10 Price.
14. [14] Bloomberg, Meta says new Muse model reaches AI frontier after 14-month push.