Muse Wonder Explained: Benchmarks, Access, and What to Test

What Is Muse Wonder?

Muse Wonder is Meta's family of frontier models for personal and professional agentic work, from building a working app to expert tasks in law, finance and health. Meta's launch announcement says both models are available today, Muse Wonder through the Meta Model API and Muse Code, and Muse Wonder Full for Muse Code subscribers.

Mark Zuckerberg introduced the family on X:

The two variants differ mainly in where you can run them:

Meta's pitch for personal agents rests on two named behaviors, both described in the launch announcement:

• Active Memory - the ability to carry what matters to you across conversations and bring back the details relevant to the task at hand.
• Active Focus - the ability to keep working toward your goal when a task gets hard: trying other approaches, recovering from errors, asking for clarification when needed, and checking in before following through on anything important.

Memory across sessions is the weak point the why AI agents forget post covers, and Active Memory is Meta's answer to it. Muse Wonder will also soon power Muse, Meta's personal agent, which can already run shell commands and write files on hardware you build through Muse Gadgets.

How Does Muse Wonder Compare to Claude Opus 5.5 and GPT-6 Astra?

Muse Wonder Full leads Meta's comparison on six of 14 benchmarks, mostly long-horizon coding and professional-agent work, and Claude Opus 5.5 leads on six as well. Every result in the table is at max reasoning effort, except Muse Wonder Full's SWE-Marathon score at xhigh. The highest score in each row is in bold:

The model you can call through the API, Muse Wonder, tells a narrower story than the Full column. Read against the three rival models:

• Where the API model leads - Muse Wonder scores highest of the four on Harvey LAB-AA, MemoryBench, DeepSWE 1.1 and SWE-Marathon: legal work, recall, and long-horizon coding.
• Where it trails - it is 20.5 points behind Claude Opus 5.5 on ProgramBench (50.0 against 70.5) and 9.2 points behind on OSWorld V2.1 partial credit (72.6 against 81.8).
• Independent index - Artificial Analysis lists Muse Wonder (max) at 52 on its Intelligence Index, against a median of 27 for comparable models, and records that it generated 130 million tokens to complete the index against a median of 85 million.

Artificial Analysis's 52 matches the Muse Wonder figure in Meta's table. For the other side of this comparison, the Claude Opus 5.5 post covers Anthropic's launch figures for the model that leads six of these rows.

How Are Muse Wonder's Benchmarks Graded?

Muse Wonder's benchmarks are graded in four ways: checking the end state an agent leaves behind, running hidden tests against code, scoring answers against a rubric with an LLM judge, and internal composites only Meta can rerun. The Muse Wonder model card lists the grader and result source for each capability benchmark:

The model card also sets rules that apply across the table:

• Refusals score zero - on the capability benchmarks, a refused task stays in the denominator rather than being dropped.
• Rival runs are best-effort - for runs Meta generated itself, prompts, tools and runtime "may not be optimally tuned for proprietary models."
• Harnesses differ on some rows - the card calls SWE-Marathon "not a controlled common-harness comparison," because two rivals ran inside their vendors' own coding agents.

For an agent that acts, the end-state and test-suite rows are the closest match to your own pass condition, because they ask whether the work exists after the run. Rubric rows describe the quality of an answer or document, and the internal composites describe what Meta trained for. For how public benchmarks differ from the evals you run yourself, see LLM benchmarks.

AutomationBench-AA's rule, that a workflow passes only when the resulting application state is right, is the rule TestMu AI's Agent Assurance applies to agents you build. It tests how your agents actually behave across workflows, tools, and actions: it derives scenarios from the agent's code or spec, invokes the agent for real, and grades each criterion against what the run changed, such as files on disk and tool calls checked against the tools the agent declares.

A criterion it could not check is reported as Unable to Verify and kept out of the pass rate. Agent Assurance is pre-alpha, publicly installable, and runs from the terminal as rook.

Note: An agent built on Muse Wonder still needs a check on what each run changed. Grade your agents on observed evidence with TestMu AI. Try TestMu AI free!

What Does the OSWorld Score Mean for Computer-Use Agents?

It means Muse Wonder Full earns most of the available partial credit on desktop workflows but fully completes far fewer of them. On OSWorld V2.1's 108 workflows on an Ubuntu desktop, Muse Wonder Full averages 78.4 when partial progress earns credit and 39.4 when only a fully completed workflow counts. The API model scores 72.6 and 34.3.

Meta reports the partial figure as the primary metric. For a user, a workflow that fills four of five fields and never submits the form earns partial reward on OSWorld and nothing in practice, which makes the binary score the closer match to what a computer-use agent delivers.

The model card also lists visual and spatial reasoning, especially 3D tasks, as a known limitation, and asks developers to validate performance for applications that depend on precise spatial understanding. Both points shape how you test a screen-driving agent, a loop covered step by step in computer use agents.

How Do You Access Muse Wonder?

Call Muse Wonder through the Meta Model API with the model ID muse-wonder-1.0, or run it in Muse Code. Muse Wonder Full is only in Muse Code. Meta's models documentation lists a 1,048,576-token context window, text, image, video, audio and PDF input, text output, reasoning effort from "minimal" to "max", and a preview status.

Details from the same docs that affect a migration:

• Same requests as Muse Spark - Muse Wonder and Muse Spark take the same requests on the same endpoints, so moving a workload between them is a model ID change.
• OpenAI and Anthropic SDKs - the API at https://api.meta.ai/v1 serves Chat Completions, Responses and Messages endpoints, so existing OpenAI or Anthropic clients only need a new base URL and key.
• Reasoning effort - "none" returns HTTP 400 on Muse Wonder, and "max" goes beyond "xhigh" at the same per-token price, billed through extra reasoning tokens.
• Training on your content - in Standard mode your prompts, code and responses are not used to train Meta models; Contributor mode, on by default in Muse Code subscriptions, trades that permission for more usage and is not offered for Muse Wonder on pay-as-you-go.
• Cost at max effort - pricing is per token, and reasoning tokens bill as output, so the Artificial Analysis token count above is a cost signal worth testing against your own prompts.

A first call with the OpenAI Python SDK, following the pattern in Meta's reasoning docs, needs only the base URL, a key, and the model ID:

import os

from openai import OpenAI

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

response = client.chat.completions.create(
    model="muse-wonder-1.0",
    reasoning_effort="high",
    messages=[
        {
            "role": "user",
            "content": "List the files this change touches and the tests that cover them.",
        },
    ],
)

print(response.choices[0].message.content)

How Should You Test an Agent Built on Muse Wonder?

Test it on what each run changes, in your own harness, at the reasoning effort you plan to ship. The model card says performance can vary with quantization, serving configuration, prompts, tools and the agent harness, and it recommends human-in-the-loop confirmation for irreversible actions wherever the model can take real-world actions.

• Rerun your own tasks - run a sample of real tasks from your backlog on Muse Wonder and on your current model in the same harness, since Meta's rival runs were best-effort.
• Score strict completion - count a task as passed only when it is finished, the OSWorld binary view, never because most of its steps ran.
• Check the end state - assert on the files, records, tickets or UI the task should change, the way AutomationBench-AA and Terminal-Bench 4.0 grade.
• Check the route - compare the tool calls and permissions used with what the agent was allowed, so an ExploitGym-style shortcut shows up as a failure.
• Pin the reasoning effort - Meta's table reports "max" results; test at the level you will actually pay for.
• Confirm irreversible actions - put a human confirmation in front of payments, deletions and outbound messages, as the model card recommends.
• Gate on your own tests - treat the agent's exit status and its summary as a report about the run, and the tests as the verdict.

Muse Code's headless mode makes the last point concrete. The Muse Code extending docs say muse exec returns an exit code that "reflects how the run ended, not whether the work is correct," and that an agent can exit 0 while still reporting failing tests. A CI step should look like this:

set -e

# Muse Code makes the change; exit 0 only means the turn finished
muse exec --json "Add a 'Remember me' checkbox to the login form and run the unit tests." > muse-run.jsonl

# The verdict comes from your own checks
npm test
kane-cli run "Open http://localhost:3000/login, check 'Remember me', sign in, and verify the dashboard loads" --agent --headless

An agent that reports checks it never ran is a case of deceptive completion, and a UI change is where that report is hardest to catch, because the coding agent never sees the rendered page.

Kane CLI closes that gap in the script above. It drives a real Chrome browser from a plain-English objective and returns a pass or fail backed by an evidence pack of per-step screenshots, a network log and console output. Exit code 1 means an assertion failed and 2 means an environment error, so a pipeline can tell a broken feature from a broken runner.

Muse Code also scans a repository's .claude/skills folder, which is where the Kane CLI skill's project-level install puts its SKILL.md, so a Muse Code session in that repository can pick it up once you trust the workspace. Run muse skills list to confirm it loaded.

Getting Started With Muse Wonder

Pick five tasks your current agent already handles, run them on muse-wonder-1.0 at the reasoning effort you would ship, and grade each one on its end state rather than on the agent's report. If Muse Wonder Full is the variant you want, run the same test in Muse Code on a Power Usage or Maximum Usage plan.

To automate that grading for an agent you own, the Agent Assurance quickstart takes you from install to a first suite graded on what the agent changed.