Meta's Muse Wonder Costs Exactly What Opus 5.5 Costs. It Loses 9 of Meta's Own 14 Benchmarks

• Hermes IDE: Download free · Star it on GitHub — one console for every coding agent, on macOS, Windows and Linux
• Book: AI Agents Pocket Guide · AI in TypeScript — the 5-book series
• Me: xgabriel.com | GitHub

You open Meta's Muse Wonder launch this morning and the scorecard reads like a coronation. Fourteen rows, Meta's columns on top in seven of them, Claude Opus 5.5 and GPT-6 Astra lined up beside them.

Then you notice there are two Meta columns. The one with the headline numbers is Muse Wonder Full, and Meta's API doesn't serve it. The one you can call costs exactly what Opus 5.5 costs, and on Meta's own table it loses to Opus 9 times out of 14.

Read that table row by row before you move a single workload. I haven't run Muse Wonder for this post. Every number below comes from Meta's model card, Artificial Analysis or the pricing source linked next to it.

Two models launched today, and the API serves one

Meta Superintelligence Labs released Muse Wonder and Muse Wonder Full on Monday, October 12, 2026 (Meta newsroom, TechCrunch). Meta calls them "our most capable models", with "state-of-the-art performance on personal and professional agentic tasks."

Only one of them comes with an API key:

• Muse Wonder is on the Meta Model API as muse-wonder-1.0 (Meta's coding-agent docs) and on OpenRouter as meta/muse-wonder. It costs $4 per million input tokens and $20 per million output (TechCrunch). Cached input is reported at $0.20 per million (Handy AI). The model card lists a 1M-token context, with text, image, video and audio in and text out.
• Muse Wonder Full is for Muse Code subscribers only. It isn't served through the API. On the Muse Code product page, the $50-a-month Power Usage plan includes it, and a $200 Maximum Usage tier sits above that.

Opus 5.5 lists at the same $4 in and $20 out, with $0.20 cache reads (Artificial Analysis). GPT-6 Astra and Claude Fable 5.1 both list at $10 in and $50 out (OpenAI, Anthropic).

So the fair fight is Wonder against Opus 5.5. Input, output and reported cache prices all match. That is the matchup the last column of the table tracks.

Meta's scorecard, row by row

These are Meta's numbers from the model card, all at max reasoning effort. The price row comes from the sources above. The last column is my count: Muse Wonder, the API model, against Opus 5.5.

Count the last column: 5 wins, 9 losses.

Two other counts fill in the picture. Wonder Full against Opus 5.5 goes 8 wins, 6 losses, and that is the column Meta's headline numbers come from. The API model against GPT-6 Astra goes 6 wins, 8 losses, at less than half Astra's list price.

Some of the losses are close: the Personal Superintelligence Index by 0.9, Vals Finance by 2.0, AutomationBench by 2.1. Others are not. ProgramBench is the widest gap on the card: 50.0 against 70.5, Opus by 20.5 points. OSWorld V2.1 goes to Opus by 9.2, Terminal-Bench 4.0 by 7.6, HealthBench Pro by 5.1, JobBench by 4.9.

Meta's numbers, one row per benchmark. Opus 5.5 leads on 9 rows; Wonder's 5 wins are legal, GDP.pdf, memory and the two long-horizon coding rows.

Where Wonder wins

Five wins. One of them is GDP.pdf, 30.8 against 30.6. A 0.2-point gap on a vendor table is a tie, so set it aside. The other four are worth your attention.

Start with long-horizon coding. On DeepSWE 1.1, Wonder scores 78.8 against Opus's 74.2. The model card's footnote says the DeepSWE results for Wonder, Wonder Full and Opus 5.5 all come from Datacurve, a third party. That makes it the cleanest win on the card: one outside source measured both models.

SWE-Marathon is Wonder's biggest margin over Opus, 53.1 against 46.3. The source is Abundant AI. The footnote adds a caveat that the Astra and Fable runs used Codex and Claude Code, "so this row is not a controlled common-harness comparison." Read it as a strong signal with an asterisk.

Legal agent work comes next. On Harvey LAB-AA, Wonder scores 10.0 against Opus's 4.2, more than double. Look at the absolute numbers, though. The best score on the whole row is Wonder Full's 13.1, so every model scores low here, Wonder included. If you build legal tooling, that is a reason to test it.

Then memory. On MemoryBench, Wonder scores 85.6 against 81.5. This is a Meta-internal benchmark, and it uses an LLM judge. Meta built it, Meta ran it, and a model graded it. It lines up with Meta's Active Memory feature, which carries context across conversations, but weigh it as a vendor number.

Notice where the coding wins sit. They are the long-horizon rows. Terminal-Bench and ProgramBench go to Opus by 7.6 and 20.5 points, and so does OSWorld, the computer-use row, by 9.2.

What the footnotes say

Four lines in the model card change how you read the table.

1. How scores were picked. "Where a comparable third-party or provider-reported result exists, we use it; otherwise we use the highest of our internally validated run, self-reported score, or official leaderboard score." When there's no outside number, the table takes the best of up to three.

2. Competitor runs are best-effort. "Internally generated competitor runs use common settings where practical but remain best-effort: prompts, tools, and runtime may not be optimally tuned for proprietary models." Where Meta ran Opus or Astra itself, Meta says they may not have been tuned for those models.

3. Harnesses are mixed. DeepSWE blends Datacurve's runs, OpenAI's provider-reported number for Astra, and Anthropic's system card for Fable. SWE-Marathon compares models running in different agent harnesses, as the card itself says.

4. Different settings for the headline model. The table is labeled max reasoning effort, but Wonder Full's 57.5 on SWE-Marathon "was reported with xhigh reasoning effort."

Add two more: the Personal Superintelligence Index and MemoryBench are both Meta-internal. And the limitations section says it plainly: "Performance can vary with quantization, serving configuration, prompts, tools, and the agent harness."

None of this is unusual. Most vendor launch tables come with footnotes, and Meta published its own. It does mean you want a second opinion from someone who runs every model the same way.

The independent check

Artificial Analysis gives Muse Wonder an Intelligence Index of 52, rank #9 of 219 models. It gives Opus 5.5 a 58, which it calls "the highest score we have measured by several points" (AA on Opus 5.5). Astra scores 53 (AA on Astra). Wonder Full scores 56 (AA on X).

Six points behind Opus, at the same price.

To be fair to Meta, AA's post on X notes that Muse Spark 1.3 scored 48, "a release gap of only 6 weeks" before Wonder. Four index points in six weeks is a steep climb.

Same price, six index points apart. Wonder Full is plotted without a price because the API doesn't serve it.

The operational numbers on the AA page matter more if you plan to put it in an agent loop:

A coding agent makes many calls per task. AA measured 19.27 seconds to the first token, about 3.5 times the 5.52-second median, and in an agent loop that wait repeats. And 130M output tokens against an 85M median means more of your bill lands on the $20 side of the price.

Early reception splits the same way. In the Hacker News thread, one commenter found it "much worse than Opus 5.5" on an image-to-HTML test, and another called it "still an entire generation behind in real-world performance". Others were enthusiastic. Treat all of them as anecdotes. Handy AI reports that Meta's Alexandr Wang said API pricing would be "meaningfully below" rivals. Against Astra and Fable 5.1 at $10/$50, it is. Against Opus 5.5, it's identical.

The verdict

Wonder is a real frontier-class model, ranked #9 of 219 on an independent index. At $4/$20, though, Opus 5.5 is the better buy on most of Meta's own rows, and the Wonder variant that beats Opus needs a $50-a-month Muse Code plan. Wonder still earns a test in four places:

• Teams running long-horizon coding agents. DeepSWE and SWE-Marathon are its best rows, and the DeepSWE number comes from a third party.
• Legal agent builders. Harvey LAB-AA is a 10.0 against 4.2 gap.
• Finance agent builders on Astra today. Wonder beats Astra on Vals Finance Agent V2, 56.6 against 53.5, at less than half the price. Opus 5.5 scores 58.6 at Wonder's price, so test both.
• Anyone who needs a 1M-token context at $4/$20 and wants a second provider at that price point.

A benchmark lead is a reason to run your own tests. In legal or financial work, the outputs still need professional review whichever model writes them.

The only benchmark that settles it is your repo

Meta's table can't tell you how Wonder does on your codebase. Neither can AA's index or a Hacker News thread. Meta's own limitations section names the agent harness as a variable. The cheapest real answer is one ticket, both models, the same afternoon.

I build Hermes IDE, a free desktop console for coding agents, and it runs this kind of bake-off side by side. Start one session with Claude Code on Opus 5.5, signed in the usual way. The second session is Claude Code pointed at Meta's API, with the variables from Meta's docs and the Wonder model ID. The docs also say to set the Opus, Sonnet, Haiku and subagent model variables to the same ID, "so no path falls back to a Claude model". Skip those and part of the Muse run quietly happens on Claude.

Seven variables make a long command, so put them in a wrapper. First export your Meta Model API key as MODEL_API_KEY in your shell profile. Hermes types the command into a real shell, so the variable has to be visible there. Then save this as claude-muse somewhere on your PATH and chmod +x it:

#!/usr/bin/env bash
# claude-muse: Claude Code against Meta's Model API
export ANTHROPIC_BASE_URL="https://api.meta.ai"
export ANTHROPIC_AUTH_TOKEN="$MODEL_API_KEY"
m="muse-wonder-1.0"
export ANTHROPIC_MODEL="$m"
export ANTHROPIC_DEFAULT_OPUS_MODEL="$m"
export ANTHROPIC_DEFAULT_SONNET_MODEL="$m"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="$m"
export CLAUDE_CODE_SUBAGENT_MODEL="$m"
exec claude "$@"

Start the second session as a Custom agent. In the ⌘N launcher or the New Session wizard you give it a name and a command, and Hermes "starts this command in the session's terminal, as if you typed it." Set the command to claude-muse. Or put muse, Meta's own CLI, in the command field instead.

Each task gets its own git worktree on a hermes/<task> branch, so the two agents never touch each other's files. When both turns end, the Review Desk (⌘G, or Ctrl+Shift+G) shows each diff turn by turn.

You can do this by hand with git worktree add and two terminals. What Hermes adds is the review: the Review Desk flags risky edits like lockfiles and CI workflows, lets you revert a single turn, and lands the winner with undo.

Real Hermes window, test build with stand-in agents: the same task in two agents, each on its own worktree branch. A Muse bake-off uses the same layout with a Custom agent in the second slot.

One limit. Hermes doesn't know a Custom agent's approval model and has no status signals for it. The attention inbox can tell you when Claude Code is waiting on you; for the Muse session, you watch its terminal yourself.

The full walkthrough, with a compare script for tests passed, diff size and files touched, is in the bake-off how-to.

Which rows on Meta's card look like your actual work?

Run the bake-off yourself

Download Hermes IDE and open a repo you know well. Press ⌘N (Ctrl+Shift+N on Windows and Linux) and start one real ticket in Claude Code on Opus 5.5. Then start the same ticket as a Custom agent running claude-muse. When both turns end, press ⌘G and read the two diffs side by side.

I build Hermes IDE. It is free and source-available, version 2.2.10 shipped on October 12, and a star on GitHub helps other developers find it. If something breaks, or an agent you use is missing, open an issue. Hermes IDE isn't affiliated with Meta, Anthropic, OpenAI or Nous Research.

If you're designing the agents themselves, my AI Agents Pocket Guide covers the patterns behind them.