Meta released Muse Wonder and Muse Wonder Full on October 12, 2026, pitching the pair as direct rivals to Anthropic’s Claude Sonnet 5.5 across complex, multi-step engineering workflows. While Meta’s subscription-gated Muse Wonder Full ties Claude Sonnet 5.5 at 56 on the Artificial Analysis Intelligence Index, the publicly accessible API model scores 52 while charging twice as much: $4.00 per million uncached input tokens and $20.00 per million output tokens, compared to Sonnet 5.5’s $2.00 input and $10.00 output. In unattended developer harnesses, that price premium compounds rapidly because Meta’s Active Focus mechanism re-ingests raw terminal error streams without compaction, burning up to 3.8 times more output tokens than Sonnet 5.5 before completing a repair loop.
For engineering leads building production agent harnesses, the question is not whether a frontier model can generate clean code on a synthetic single-turn prompt. The real decision is what happens when the agent encounters broken test suites, dirty git trees, and missing dependencies after the demo ends.
The Public API Downgrade and the Gating Trap
When evaluating Meta’s new agentic models, developers must first navigate an access split that alters the economics of reproducibility. Meta Superintelligence Labs divided the release into two distinct tiers: Muse Wonder (served via the Meta Model API as muse-wonder-1.0) and Muse Wonder Full, which is restricted exclusively to higher-tier subscribers on Muse Code Power Usage ($50/month) and Maximum Usage ($200/month) plans.
The benchmark parity that dominated launch coverage applies exclusively to the subscription-gated model. Independent tracking by Artificial Analysis places Muse Wonder Full at an Intelligence Index of 56 under maximum reasoning effort—matching Claude Sonnet 5.5’s score of 56, tracking narrowly behind Claude Opus 5.5 (58), and outscoring OpenAI GPT-6 Astra (53) and Google Gemini 4 Argon (53). However, developers calling the standard pay-as-you-go API receive the base Muse Wonder model, which records an Intelligence Index of 52.
Artificial Analysis Intelligence Index (October 2026)
Provenance: Verified against independent evaluations published on Artificial Analysis (October 2026). Muse Wonder Full tested under maximum reasoning configuration.
This split creates a severe evaluation boundary. An engineering team evaluating Muse Wonder Full inside the Muse Code desktop environment cannot replicate those reasoning trajectories through standard API pipelines. As analyzed in EyesTech’s inspection of Muse Wonder Full’s access model, enabling maximum reasoning on the public API does not elevate the underlying model weights to Full. Instead, API callers pay full frontier prices—$4.00 per million uncached input tokens and $20.00 per million output tokens—for a tier that trails Sonnet 5.5 on repository-level code generation.
Anthropic maintains uniform model weights across its distribution channels. The claude-sonnet-5-5 weights accessible through the Anthropic API, Google Cloud Vertex AI, and Amazon Bedrock are identical to those driving Anthropic’s native terminal agent, Claude Code. With pricing fixed at $2.00 per million uncached input tokens, $0.20 per million cached input tokens, and $10.00 per million output tokens, Sonnet 5.5 delivers higher empirical pass rates on real-world coding benchmarks at half the nominal API token tariff.
Active Focus vs Iterative Tool Loops: Where Self-Repair Spirals
The architectural divergence between the two systems becomes stark during unattended multi-step execution. Meta designed Muse Wonder around two cognitive subsystems: Active Memory, which serializes and persists user context across multi-session interactions, and Active Focus, an error-recovery subsystem engineered to keep the model iterating through blockers rather than halting prematurely.
In simple synthetic tasks, Active Focus allows the model to detect minor syntax errors and amend its proposal. But in production environments—such as executing an automated migration across a legacy TypeScript codebase—Active Focus introduces a severe token burn spiral. When a shell command fails with a non-zero exit status, Active Focus triggers an internal reflection loop that captures the entire standard error stream, terminal environment variables, and prior failed diffs, re-injecting them verbatim into the prompt context.
Because Meta’s reasoning tokens are counted toward the billed output allocation, this reflection process rapidly consumes output capacity. A test run failing on an uninstalled dependency or a type mismatch generates thousands of hidden reasoning tokens before the model attempts its next file edit. If that second attempt fails, Active Focus stacks the second failure onto the first. Traces analyzed from developer trials indicate that an error-recovery cycle that consumes approximately 28,000 tokens under Claude Sonnet 5.5 frequently inflates past 105,000 tokens on Muse Wonder—a 3.8-fold expansion in token consumption.
Claude Sonnet 5.5 avoids this runaway inflation through harness-level tool constraints. When deployed in agent frameworks like Claude Code, Sonnet 5.5 relies on localized diffing and structured tool feedback rather than unconstrained self-reflection. If a bash command fails, the harness returns an isolated, truncated error message. Sonnet 5.5’s pre-training emphasizes precision tool calls over conversational justification, emitting an updated diff without generating massive uncompacted reasoning traces. On Terminal-Bench 4.0, which rigorously evaluates command-line problem-solving, Claude Sonnet 5.5 achieves a 49.8% completion rate compared to 38.0% for the public Muse Wonder API.
Benchmark Divergence Across Real Repositories
The difference between synthetic benchmark marketing and production repository performance is captured in comparative evaluations across SWE-bench Verified and Terminal-Bench 4.0:
| Evaluation Metric | Muse Wonder Full (Max) | Muse Wonder (API) | Claude Sonnet 5.5 | Delta (Sonnet vs API) | Epistemic Status |
|---|---|---|---|---|---|
| Artificial Analysis Index | 56 / 100 | 52 / 100 | 56 / 100 | +4 points Sonnet | Tested Result (AA) |
| SWE-bench Verified (Resolved) | 54.8% | 48.2% | 57.2% | +9.0% Sonnet | Vendor Disclosures |
| Terminal-Bench 4.0 | 46.5% | 38.0% | 49.8% | +11.8% Sonnet | Independent Registry |
| Input Price (Uncached / Mtok) | Subscription Gated | $4.00 | $2.00 | Sonnet 50% cheaper | Published Rate Sheet |
| Input Price (Cached / Mtok) | Subscription Gated | $0.20 | $0.20 | Parity at $0.20 | Published Rate Sheet |
| Output Price (/ Mtok) | Subscription Gated | $20.00 | $10.00 | Sonnet 50% cheaper | Published Rate Sheet |
| Context Window Capacity | 1,048,576 tokens | 1,048,576 tokens | 1,000,000 tokens | Parity (~1M tokens) | Vendor Specifications |
On SWE-bench Verified—which tests an agent’s ability to resolve real GitHub issues from major open-source repositories—Claude Sonnet 5.5 achieves a 57.2% resolution rate. Meta Muse Wonder Full trails at 54.8%, while the public API version drops to 48.2%. The 9.0 percentage point gap between Sonnet 5.5 and the API version of Wonder reflects the cumulative cost of context drift: when a model misdiagnoses an issue on turn three, its probability of recovering on turns four through eight decays exponentially.
The Arithmetic of Amortized Task Costs
Comparing headline token prices obscures the true operational cost of deploying an autonomous coding agent. The standard metric that determines FinOps viability is the Amortized Cost per Accepted Task, which factors in failed attempts, retry loops, and prompt caching ratios:
Where Nattempts is total launched agent runs, Naccepted is verified successful PRs, and Tout includes all billed reasoning tokens consumed during uncompacted self-repair iterations.
Consider an engineering workflow where an agent attempts ten distinct repository refactoring tasks. Each task begins with a codebase context of 120,000 input tokens. Because both providers support prompt caching, 100,000 tokens qualify as cached input ($0.20 per million), while the remaining 20,000 tokens represent uncached prompt overhead.
Under Claude Sonnet 5.5, eight of the ten tasks successfully pass linting and unit tests (Naccepted = 8), averaging 6,000 output tokens per run. Across all ten attempts, the total input charge is $0.60 (cached) plus $0.40 (uncached) = $1.00. The total output charge is 60,000 tokens at $10.00 per million = $0.60. The total token expense across ten runs is $1.60. Dividing by 8 accepted tasks yields an amortized cost of $0.20 per accepted change.
Now consider the identical workflow deployed against the public Meta Muse Wonder API. Because of lower single-pass accuracy and tool drift, only six of the ten tasks are completed successfully (Naccepted = 6). Furthermore, because Active Focus re-ingests error traces during diagnostic loops, output consumption rises to an average of 18,000 billed output tokens per attempt. Across ten attempts, input costs total $0.60 (cached) plus $0.80 (uncached) = $1.40. Output costs for 180,000 tokens at $20.00 per million total $3.60. The total run expenditure reaches $5.00. Dividing by 6 accepted tasks yields an amortized cost of $0.83 per accepted change—a 4.15-fold increase in cost per unit of verified work.
Even when accounting for Meta’s competitive cache pricing, higher output token volume combined with lower resolution rates rapidly erodes enterprise budgets. If an engineering organization deploys hundreds of agentic runs per week, unconstrained self-repair loops quickly transform a minor pricing gap into an unsustainable operational deficit.
Security Boundaries and Context Privacy in Enterprise Repositories
Beyond raw execution economics, deploying autonomous agents across proprietary codebases introduces distinct security and data governance requirements. Meta’s architectural choices for the Muse family carry critical implications that enterprise infrastructure teams must evaluate.
As documented in EyesTech’s technical post-mortem on Meta’s OS-level harness, Meta built Muse around the Hatch daemon, systemd-nspawn container isolation, and eBPF network surveillance. While these protections were designed to prevent untrusted prompt injection from escaping container boundaries, independent security research by Patrick Wardle highlighted in EyesTech’s analysis of the macOS Muse zero-day demonstrated that background telemetry and shared state synchronization can create privilege inversion risks if local preference endpoints are not strictly sandboxed.
Furthermore, Meta’s terms of service establish a split data mode that developers must inspect before granting access to internal code repositories. While Standard API traffic is excluded from model training, Muse Code accounts feature a “Contributor Mode” enabled by default, which grants Meta rights to utilize prompts, code diffs, and developer interactions to train future iterations of the Muse family. For organizations handling proprietary algorithms or regulated customer data, relying on Claude Sonnet 5.5 under strict zero-data-retention commercial agreements provides an established compliance perimeter that Meta’s desktop subscription environment does not yet match.
