Meta Releases Muse Wonder and Muse Wonder Full: A Comprehensive Breakdown of Million-Token Context Agent Models

Meta has doubled down on its model lineup, launching two large models built for Agent scenarios in one go: Muse Wonder and Muse Wonder Full, both supporting an ultra-long context window of 1 million tokens. The former is available on the Meta Model API, priced at $4 per million input tokens and $20 per million output tokens; the latter is tied to the Muse Code subscription plan and leads on two benchmarks, DeepSWE and SWE-Marathon.

Why Million-Token Context Targets Agent Scenarios

A 1-million-token context window isn't just about stacking parameters—it's a hard requirement for Agent workflows. Multi-turn tool calls, codebase-level retrieval, and accumulated long-term memory can quickly fill up the context. Meta's decision to write "1M-context" directly into the product positioning shows it doesn't intend to sell Muse Wonder as a general-purpose chat model, but rather to target automation tasks that require continuous reading and writing of large numbers of files.

For developers, longer context means less frequent summarization and truncation, reducing information loss during compression. But ultra-long context also brings inference cost and latency pressure, which is exactly why Meta is using two product tiers to distinguish use cases.

What Is an Agent Workflow

An Agent workflow means the model no longer just does single-turn Q&A, but acts as an "agent" that autonomously calls external tools (such as file read/write, code execution, web search, API requests) to complete multi-step tasks. A typical flow is: the model first plans the steps, then calls tools to get results, decides the next action based on those results, and repeats until the task is complete.

Unlike regular chat, every tool result in an Agent's workflow must be written back to context to support subsequent reasoning, so context consumption is extremely fast. A task involving a dozen files and dozens of tool calls can easily accumulate hundreds of thousands of tokens. This is why a long context window is regarded as infrastructure for Agent scenarios rather than an optional performance metric. When the window is insufficient, the system can only rely on summarization to compress historical information, and compression often means lost details, which leads the model to "forget" or go astray at critical steps.

Muse Wonder: Available via API, Pay-As-You-Go

According to MarkTechPost, Muse Wonder is available through the Meta Model API, with a pricing structure of $4 per million input tokens and $20 per million output tokens. The output price is 5 times the input price, in line with current mainstream large model pricing conventions, and also suggests the model's higher computational overhead on the generation side.

This pricing isn't cheap for teams making high-frequency Agent calls. If a single task requires repeatedly reading and writing hundreds of thousands of tokens, costs will accumulate quickly. Therefore, Muse Wonder is better suited to businesses with a hard requirement for context length that can also reduce repeated input through caching or prompt reuse.

Why Output Pricing Is Much Higher Than Input

Large model inference is divided into two stages: processing input (prefill) and processing output (decode). The input stage can be highly parallelized with high compute utilization; the output stage must generate tokens serially one by one, with each step depending on the previous result, resulting in low GPU utilization and longer processing time. Therefore, the unit computational cost of output tokens is inherently higher, and mainstream vendors generally set output pricing at several times that of input.

For users, this means controlling output length saves more money than controlling input. In Agent scenarios, if the model tends to generate lengthy reasoning processes or explanatory text, costs will rise significantly. A reasonable approach is to limit unnecessary output and reuse input prefixes as much as possible (such as leveraging prompt caching) to keep the cost of repeated long-context input down.

Muse Wonder Full: Tied to Muse Code, Leading on Benchmarks

Muse Wonder Full is not offered as a standalone API, but comes with the Muse Code plan. Its focus leans more toward code and engineering tasks, with official results concentrated on two benchmarks—DeepSWE and SWE-Marathon—where it holds leading positions.

These two benchmarks are typically used to automatically evaluate a model's ability to solve real software engineering problems, including cross-file modifications, defect localization, and multi-step reasoning. Muse Wonder Full's performance on them indicates that it has been specifically optimized for long-chain Agent tasks, rather than simply expanding context.

What Are DeepSWE and SWE-Marathon

SWE-type benchmarks (SWE stands for Software Engineering) are used to evaluate a model's ability to solve real software engineering problems, with questions typically drawn from real issues and PRs in open-source repositories. The model needs to read the codebase, locate defects, modify multiple files, and make tests pass, testing cross-file understanding and multi-step reasoning rather than single-point code generation.

DeepSWE focuses on complex, deeply dependent engineering problems; SWE-Marathon emphasizes long-chain, multi-stage tasks, simulating scenarios of sustained work over long periods. Both are concerned with whether the model can maintain goal consistency within long contexts. Therefore, leading on these two benchmarks means Muse Wonder Full has been specifically optimized for long-context engineering tasks, not just given a bigger window.

How to Choose Between the Two Tiers

From a positioning standpoint, Muse Wonder targets developers who need API integration and high flexibility in calling; Muse Wonder Full leans toward teams already using the Muse Code toolchain, who gain stronger code Agent capabilities through a subscription.

If a team mainly runs general-purpose Agent tasks and wants to control budget on a pay-as-you-go basis, Muse Wonder's API model is more suitable. If tasks are concentrated on codebase-level understanding and refactoring, Muse Wonder Full's benchmark advantages may translate into real efficiency. Actual results still need to be verified in your own workflow—benchmark scores can't fully represent production environment performance.

Impact on the Agent Ecosystem

Meta simultaneously launching an API version and a subscription version reflects that large model vendors are splitting Agent capabilities into product tiers at different price points. Million-token context is shifting from a "showcase metric" to a "purchasable service specification."

For developers, there are more choices, but migration costs are also rising—differences between models in tool-calling formats, context management, and billing methods will directly affect Agent architecture design. Before integrating, it's best to run small-scale comparison tests with real tasks.

One-line Summary

Meta launches Muse Wonder and Muse Wonder Full, two Agent models both supporting 1 million token context

Paragraph Summary

Meta has released two large models for Agent scenarios at once, Muse Wonder and Muse Wonder Full, both supporting an ultra-long context of 1 million tokens. Muse Wonder is available via the Meta Model API on a pay-as-you-go basis, at $4 per million input tokens and $20 per million output tokens; Muse Wonder Full is tied to the Muse Code subscription plan and leads on two software engineering benchmarks, DeepSWE and SWE-Marathon. The article points out that million-token context isn't parameter stacking, but a hard requirement for workflows like multi-turn tool calls, codebase retrieval, and long-term memory; longer context reduces information loss from summarization and truncation, but also drives up inference costs and latency. The two tiers target API integration developers and code Agent teams respectively, forming complementary pricing and scenarios, reflecting that vendors are splitting Agent capabilities into product tiers at different price points—developers should run small-scale comparisons with real tasks before integrating.