Meta Launches Muse Wonder: 1M Context & 79% DeepSWE

Meta Superintelligence Labs (MSL) officially launched the Muse Wonder frontier model generation, comprising Muse Wonder (muse-wonder-1.0) and its flagship counterpart, Muse Wonder Full (muse-wonder-full-1.0). Engineered specifically for ultra-long-horizon software engineering and autonomous personal and professional agency, the releases represent a historic strategic pivot for Meta: shifting away from its open-weights Llama pedigree toward closed, proprietary foundation models monetized through developer APIs and premium coding subscriptions.

Trained on Meta’s gigawatt-scale Prometheus compute cluster, the Muse Wonder architecture introduces a native 1,000,000-token context window, full multimodal ingestion (text, code diffs, video, audio, and architectural diagrams), and two proprietary agentic mechanisms: Active Memory and Active Focus.

On rigorous independent software engineering benchmarks, Muse Wonder Full captured the top position across the industry, scoring 79.0% on DeepSWE v1.1 (pass@1) and 57.5% on SWE-Marathon, surpassing frontier systems including Anthropic’s Claude Opus 5.5 and OpenAI’s GPT-6 Astra.

1. The Autonomous Engine: Active Memory and Active Focus

While preceding frontier models expanded raw parameter scales, software teams running continuous agents frequently faced two chronic failure modes: context amnesia during extended debugging sessions, and agent stalls when encountering minor execution roadblocks.

The Muse Wonder generation targets these bottlenecks at the architectural level rather than relying entirely on brittle system-prompt scaffolding.

┌─────────────────────────────────────────────────────────────────┐
│               Meta Muse Wonder Agentic Execution Loop           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   [Goal / Repository Task]                                      │
│              │                                                  │
│              ▼                                                  │
│   ┌──────────────────────┐      ┌───────────────────────────┐   │
│   │    Active Memory     │◄────►│ Persistent State Layer    │   │
│   │ Cross-turn context & │      │ Git branch state, tool    │   │
│   │ project constraints  │      │ history, user preferences │   │
│   └──────────┬───────────┘      └───────────────────────────┘   │
│              │                                                  │
│              ▼                                                  │
│   ┌──────────────────────┐                                      │
│   │     Active Focus     │───▶ [Detects Runtime Error / Fail]   │
│   │ Autonomous path-     │                   │                  │
│   │ finding & backtracks │                   ▼                  │
│   └──────────┬───────────┘     [Generates Alternate Hypothesis] │
│              │                               │                  │
│              ▼                               ▼                  │
│   [Deterministic Code Patch / Verified Test Suite Pass]         │
└─────────────────────────────────────────────────────────────────┘

Active Memory

Unlike standard ephemeral context windows that clear state once a sub-agent exits, Active Memory functions as a dynamic contextual cache. The model indexes user stylistic preferences, project architectural rules, past refactoring decisions, and multi-file dependency trees across days of continuous interaction. When an engineer switches tasks or resumes a multi-stage migration, the model retrieves relevant historical priors without requiring repetitive prompt re-hydration.

Active Focus

Agentic frameworks typically suffer from high human-interruption rates: whenever a unit test fails or a CLI tool returns an unhandled exit code, the agent either throws an exception or asks the human operator for direction. Active Focus implements autonomous backtracking and pathfinding. If an execution branch hits a dead end, the model dynamically isolates the failure point, explores alternative implementation hypotheses, runs local regression checks, and only prompts the user if it encounters an unresolvable requirement ambiguity.

2. Benchmark Performance: Leading Long-Horizon Coding

To quantify its long-horizon reasoning claims, Meta evaluated the Muse Wonder models against verified software engineering benchmarks at maximum reasoning effort against current frontier competitors:

On SWE-Marathon, an evaluation suite specifically crafted to test multi-hour developer autonomy across sprawling codebases, Muse Wonder Full scored 57.5%. This represents an 11.2 percentage-point lead over Claude Opus 5.5 (46.3%) and a 15.0 percentage-point advantage over OpenAI’s GPT-6 Astra (42.5%).

The performance highlights the impact of training on sustained, closed-loop reinforcement learning environments where models must not only generate syntax, but also debug test fixtures and resolve integration conflicts.

3. Pricing Economics: Public API vs Muse Code Gating

The commercial distribution of the Muse Wonder generation represents a fundamental split in Meta’s go-to-market strategy:

The API Strategy for Muse Wonder

Developers building standalone pipelines can access standard muse-wonder-1.0 via the Meta Model API. At $4.00 per million input tokens and $20.00 per million output tokens, the model prices slightly below Claude Sonnet 5.5 and OpenAI’s GPT-6.1 Sol while offering competitive 1M context processing. With prompt caching discounts reducing read costs down to $0.20/M, teams running high-context RAG systems can maintain reasonable unit economics.

The Proprietary Moat for Muse Wonder Full

In a radical break from the open-source ethos that established the Llama brand, Meta has chosen not to offer a public token API for Muse Wonder Full. Instead, the company is leveraging its most powerful model as a proprietary wedge to capture the developer tool market:

• Power Usage Plan ($50/month): Gives developers working inside Muse Code access to daily pools of Wonder Full compute.
• Maximum Usage Plan ($200/month): Unlocks unrestricted continuous reasoning runs, autonomous background refactoring loops, and dedicated server capacity.

By walling off Wonder Full behind Muse Code, Meta is directly challenging coding assistants like Cursor, Windsurf, and Anthropic’s Claude Code, forcing engineering organizations to adopt Meta’s client software if they want access to the industry’s highest-scoring software engineering weights.

4. Architectural Analysis: The New Frontier Multi-Agent Stack

The launch of the Muse Wonder series accelerates the crystallization of a two-tier multi-agent architecture in enterprise software organizations:

1. The Reasoning and Synthesis Tier: Models like Muse Wonder Full or Claude Opus 5.5 operate as the lead architect. They parse complex feature specs, maintain the project’s dependency DAG, and leverage Active Memory to enforce system-wide architectural consistency.
2. The High-Velocity Worker Tier: Fast, ultracheap inference engines like Claude Haiku 5.5 ($0.10/M input) or Gemini 3.7 Flash handle repetitive terminal invocations, file linting, unit test executions, and automated pull request formatting.

For developer teams evaluating infrastructure, the trade-off is clear: Muse Wonder provides unmatched endurance on complex legacy refactors, but Meta’s decision to gate the flagship tier within a proprietary client means organizations must evaluate their vendor lock-in thresholds before integrating it into primary development pipelines.

Frequently Asked Questions

What are the primary differences between Muse Wonder and Muse Wonder Full?

Muse Wonder is available via public API at $4.00/M input and $20.00/M output for general developer workloads. Muse Wonder Full is Meta’s highest-performing reasoning model, achieving 79.0% on DeepSWE v1.1, but is available exclusively through paid Muse Code subscriptions ($50 to $200 per month).

What is Active Focus in the Muse Wonder models?

Active Focus is an architectural mechanism that allows the model to autonomously backtrack and try alternative implementation paths when encountering tool execution failures or failed test suites, significantly reducing the need for human intervention during long-horizon tasks.

Are the weights for Muse Wonder or Wonder Full available for download?

No. Unlike Meta’s historical Llama family, the Muse Wonder series is proprietary and closed-weights. Standard Muse Wonder is accessible via API, while Wonder Full is exclusive to Meta’s first-party developer tools.