Meta Muse Wonder 1.0 & Muse Wonder Full: Complete Guide

Meta Muse Wonder is the new model family that Meta released on October 12, 2026, and it marks a clear change in how the company thinks about artificial intelligence. Instead of building another chatbot that answers questions and waits for the next prompt, Meta has built a pair of models designed to carry out work on their own, remember what happened in earlier sessions, and stay on task for hours. If you follow the race between large AI labs, this release matters, because it shows where the industry is heading: away from single replies and toward long-running, autonomous workflows.

The models were trained in Prometheus, Meta’s gigawatt-scale data center, one of the largest single compute facilities ever built for AI training. That scale is not a marketing detail. It explains why Meta could train a model with a very long memory horizon, strong agentic behavior and the stamina to keep working through complicated multi-step projects. The training run was built around one idea: a useful assistant should behave less like a search box and more like a capable colleague who knows the project, remembers past decisions and asks before doing something risky.

This release is a major step for Meta AI agent models as a category. Until now, Meta was mostly known for open research and consumer products spread across its apps. With this launch, the company is competing directly in the market for professional-grade agents that handle legal analysis, financial review, document-heavy operations and serious software engineering. The family has two members: a standard model available through an API, and a larger flagship that spends more compute on hard problems and lives inside a dedicated terminal agent.

In this guide, we walk through the entire release in ten sections. You will learn what each version does, how the memory and focus features work, what the context window really offers, how developers can connect, what the subscription tiers cost, how token pricing compares with rival models, and what the benchmark results say about real performance. By the end, you will know which version fits your workflow and which one you can safely ignore.

The short version: the standard model is the practical choice for automation and document work, while the flagship is built for developers who need deep, long-running engineering help. The details below explain why, and where each model has limits.

Overview of Meta Muse Wonder and Its Core Architecture

The base version of the family is called Muse Wonder 1.0, and its model identifier in the API is muse-wonder-1.0. This is the version most people will actually use, because it is the one exposed to developers and companies through a public interface. Meta positions it as an everyday workhorse: a model that can read long documents, reason about them carefully and produce structured results without constant supervision.

The intended use cases are professional and practical. Muse Wonder 1.0 is aimed at analytics, legal review, financial analysis, research summaries and the daily operational tasks that consume so much office time. Think of reviewing a stack of contracts for unusual clauses, reconciling figures across several reports, drafting a memo from scattered notes, or monitoring a flow of incoming requests and routing them correctly. These tasks share a pattern. They require attention to detail, patience across long inputs and the ability to follow a multi-step process without losing the thread.

Architecturally, the model is built around three priorities that Meta emphasized in its release materials. The first is agentic reliability, meaning the model should complete a long sequence of actions without drifting off course. The second is memory, meaning it should carry knowledge from one session to the next instead of starting from zero every time. The third is judgment, meaning it should recognize when a request is ambiguous or when an action is risky and pause to ask rather than guess.

One important limitation is that the model produces text only. It does not generate images, audio or video. For many professional workflows this is not a drawback, because the output people actually need is a written analysis, a structured table, a piece of code or a decision summary. But if your project depends on creating visual assets, you will need a separate tool alongside it.

Another point worth understanding early is that the standard model has a high-effort mode. Turning on maximum effort makes the model spend more time reasoning before it answers, which can improve results on harder questions. However, this does not turn it into the flagship. The two models are different systems with different compute budgets, and effort settings on the base model do not close the gap. We explain that distinction in the next section.

For teams evaluating the family, the key takeaway is simple. The base model is the accessible, API-ready option that covers most business needs, and it is the natural starting point for any pilot project.

Muse Wonder Full: The Flagship for Complex Tasks

Muse Wonder Full is the senior model in the lineup, identified as muse-wonder-full-1.0, and it is built for the hardest problems the family can handle. Where the standard version aims for balanced everyday performance, the flagship deliberately spends far more compute on each task. That extra investment pays off in situations that demand long chains of reasoning, many dependent steps and sustained concentration over hours rather than minutes.

The typical use case is large-scale software engineering. Imagine refactoring a sprawling repository, migrating a codebase from one framework to another, hunting a subtle bug that only appears after a specific sequence of events, or restructuring a service that dozens of other modules depend on. These jobs are difficult not because any single step is hard, but because hundreds of steps must remain consistent with each other. A model that loses track halfway through creates more damage than it fixes. The flagship is designed to avoid exactly that failure.

Here the relationship between the two versions becomes clear, and it is the single most misunderstood point of the release. Meta Muse Wonder offers a maximum effort setting on the base model, but switching it on does not make the base model equal to the Full version. They differ in how much compute is available and how the system is configured for long tasks. Treating the two as interchangeable would be a mistake, and it would lead to disappointment if you expected flagship-level endurance from the cheaper model.

It also helps to think about cost and access. The flagship is not offered through the public API. It runs inside a dedicated terminal environment for developers, and it requires a paid subscription tier. That makes it a more specialized product. It is meant for people who spend their working days inside code and who will use its extra capacity frequently enough to justify a monthly fee.

For organizations, this split creates a sensible division of labor. Use the standard model for broad automation, document handling and analysis at scale, where each request is relatively contained. Reserve the flagship for the few high-value engineering projects where depth matters more than speed or cost. Many teams will end up using both, assigning each model to the kind of work it handles best.

The flagship also shows how Meta intends to differentiate itself. Rather than chase a single model that does everything, it offers a tiered approach in which the strongest capability is bundled with a specialized tool. That is a deliberate product choice, and it shapes everything about how the family is sold.

How Memory and Focus Work in Practice

The biggest idea behind Meta Muse Wonder is the pair of capabilities Meta calls Active Memory and Active Focus, and together they are what separate this family from a conventional chat model. Most assistants forget everything when a conversation ends. They also tend to repeat a failing approach when something goes wrong. These two features directly target those frustrations.

Active Memory is about continuity. The model can carry context from one session to another, so a project you discussed last week does not need to be explained again today. Just as importantly, it can update outdated facts. If you told it last month that a deadline was in March and later said it moved to May, the model is designed to replace the old fact rather than hold both and get confused. Meta reports a score of 85.6 on MemoryBench, a benchmark that measures this kind of cross-session recall and fact updating. That number suggests the feature is more than a demo, although real-world results always depend on how a product stores and retrieves information.

Active Focus is about staying on target during long tasks. When an approach fails, a focused agent does not blindly retry the same thing. It recognizes the failure, changes strategy and keeps moving toward the goal. It also knows when to stop and check with the user. Before a critical or irreversible action, such as deleting data, sending a message to a customer or pushing a change to production, the model is designed to ask for confirmation and clarify missing details. FocusBench is the evaluation Meta uses to measure this behavior.

These capabilities matter because the failure modes they address are the ones that make agents risky in the real world. A model that confidently executes the wrong plan for two hours, or acts on a stale fact, can waste more time than it saves. By building memory refresh and checkpoint behavior into the core of the system, Meta is trying to make long-running agents trustworthy enough for professional use.

There is one practical caveat, and developers should note it now. The memory behavior that feels seamless inside Meta’s own apps does not automatically appear when you call the model through an API. In that setting, you are responsible for storing the long-term facts yourself and supplying them in each request. We return to this in the developer section.

Still, the direction is clear. Memory and focus are no longer optional extras. They are central to what makes an assistant worth delegating work to.

Context Window and Data Handling

Any serious agent needs room to think, and the family is built with a 1M token context window to provide it. A million tokens is roughly the length of several long novels, or an entire mid-sized codebase together with its documentation. In practical terms, it means you can load a huge amount of source material into a single session and ask questions about it without constantly trimming or summarizing.

The model accepts text and returns text. That text-only output keeps the system focused, and it fits the main use cases of code, analysis and documents. You can feed in logs, specifications, contracts, spreadsheets exported as text and research notes, and receive structured written answers in return.

The more interesting question is not how much the window can hold, but how well the model uses it. Many systems advertise large windows and then lose accuracy as the conversation grows. They forget instructions given early on, confuse similar details or get distracted by irrelevant passages. Meta says its models are built to hold up under these conditions. When handling long documents, Meta Muse Wonder is designed to keep its reasoning consistent across inputs in the range of 64K to 100K tokens and beyond, even when the material contains distractors, meaning irrelevant text deliberately mixed in to confuse the model.

This matters for everyday work. Consider a legal team reviewing a data room with hundreds of pages. The important clause might be buried in an appendix, while similar-looking language appears in unrelated sections. A model that holds the whole picture in mind and does not mistake one passage for another is far more valuable than one that skims. The same logic applies to engineering. A bug may depend on a configuration file, a helper function and a comment written months ago, all located in different places.

For best results, a few habits help. Place the most important instructions clearly at the start of the session, and restate critical constraints when the task changes. Organize large inputs with clear headings so the model can navigate them. And remember that a large window is not a substitute for good retrieval design. If your corpus is far larger than the window, you will still need a search layer that selects the right material.

The lesson is that capacity and reliability are two separate measurements. The headline number is impressive, but the long-context stability under noise is the property that determines whether the feature is truly useful.

Developer Access and Integration

Developers can reach the standard model through the Meta Model API, which exposes muse-wonder-1.0 as the entry point for building custom tools. This is the route most companies will take, whether they are creating an internal assistant, automating a document pipeline or embedding analysis features into a product they already sell.

The typical integration pattern is straightforward. You send a request containing your instructions and any source material, choose how much effort the model should spend, and receive a text response. From there, you can build agents that call external tools, loop through tasks and report results. Because the model is designed for agentic workflows, it works best when you give it a clear goal, the tools it needs and a way to verify its own output.

There are several design decisions to make before you start. First, decide how your application will handle the model’s pauses. Since the model may ask for clarification before a critical action, your interface needs a way to pass that question to a human and return the answer. Second, define which actions are reversible and which are not, and build confirmation steps around the risky ones. Third, plan your error handling so that a failed tool call is reported back to the model, giving it a chance to change course.

The most important point concerns memory. Inside Meta’s own products, the model can persist knowledge between sessions. Through the API, that storage is your job. You need to keep a record of the facts that matter, such as user preferences, project decisions and corrected information, and include the relevant parts in each new request. A simple database with a retrieval step is enough to start. Treat the model as a skilled reasoner that depends on you to supply its long-term notes.

This design has advantages. You control exactly what is stored, where it lives and how long it is kept, which is essential for privacy, compliance and auditing. Companies in regulated sectors such as finance and law will appreciate that data governance stays in their hands rather than being handled invisibly by a provider.

A sensible rollout starts small. Pick one contained workflow, measure accuracy against a human baseline, add logging, and expand only when results are stable. Whatever you build, remember that the memory layer, the tool layer and the safety checks are yours to design, and that the API gives you the engine, while Meta Muse Wonder still needs your infrastructure around it to deliver reliable long-term behavior.

Muse Code and Subscription Tiers

The second way to use the family is through a pair of client products, and understanding the difference saves confusion. The Muse client app is the general-purpose interface for conversations and everyday tasks. The terminal agent, called Muse Code, is a separate tool built for software developers who want the model working directly inside their command-line environment, reading files, running commands and editing code.

Running Meta Muse Wonder in Terminal Environments

The terminal setting is where the flagship lives. Muse Wonder Full is not available through the API at all. It runs exclusively inside Muse Code, and only on the paid subscription tiers. This is the most important access rule of the entire release, and it means that developers who want the strongest model must commit to the subscription route.

Working in a terminal gives the agent real leverage. It can navigate a repository, search across files, run tests, inspect failures and make changes in sequence, all while keeping the long-horizon focus described earlier. A refactor that would take a human developer a full day of careful edits can be broken into steps and executed methodically, with the agent checking in before any destructive action.

Power Usage and Maximum Usage Plans

Two tiers unlock the flagship. Power Usage costs $50 per month, and Maximum Usage costs $200 per month. The difference lies mainly in how much capacity you get. Power Usage suits individual developers or small teams who use the agent regularly but not around the clock. Maximum Usage is for heavy daily users, such as engineers who delegate large tasks continuously and need generous limits so they do not hit a ceiling in the middle of a project.

Choosing between them comes down to honest estimation of your usage. If you plan to run the agent on occasional large tasks, start with the lower tier and upgrade if you reach the limits. If the agent will be part of your daily workflow and you expect long, compute-heavy sessions, the higher tier avoids interruptions that can cost more in lost time than the price difference.

Because the flagship cannot be reached by API, companies that want it embedded in their own automated systems cannot do so today. That is a real constraint, and it is worth factoring into your architecture. The standard model remains the only option for programmatic integration.

DeepSeek V4.1 Flash: The 552B MoE Model Making Fast, Affordable AI Practical

Token Pricing and Request Economics

Cost is where the standard model makes its strongest case for businesses, and the numbers are easy to read. The public Muse Wonder API pricing is built around three rates, covering fresh input, cached input and output. For a team running thousands of requests per day, small differences in these rates add up quickly, so it pays to understand each one.

Before looking at the table, it helps to see how Meta Muse Wonder treats caching. Many applications send the same large block of text again and again, such as a long system prompt, a policy document or a codebase summary. Cached input lets the provider reuse that repeated material at a much lower rate, which can dramatically cut the bill for any workload with a stable prefix.

Token type	Price per 1 million tokens
Input tokens	$4.00
Cached input tokens	$0.20
Output tokens	$20.00

The cached rate is only five percent of the standard input rate, which is a very large discount. If your application reuses a long instruction set across many calls, designing your prompts so the repeated part comes first and stays identical can reduce costs substantially. The output rate is five times the input rate, which is a common structure across the industry, since generating text takes more compute than reading it.

To see how this plays out, consider a document-review pipeline. Suppose each request contains a 50,000-token policy manual that never changes, plus 5,000 tokens of new material, and produces a 2,000-token answer. With caching, the manual is billed at the low rate after the first call, so the main costs are the fresh input and the output. Without caching, you would pay the full input rate for the manual every single time. The saving is large enough to change whether a project is economically viable.

A few practical tips apply. Keep outputs concise when you do not need long prose, since output tokens are the most expensive. Structure prompts with the stable material at the beginning. Monitor usage by workflow so you can find the costly steps. And when comparing providers, look at total cost per completed task rather than the headline per-token rate, because a model that solves a problem in one pass can be cheaper than a lower-priced model that needs several attempts.

It is also useful to compare this schedule against Claude Opus 5.5. Because rates change, check the current published prices from Anthropic before making a decision, and run your own sample workload through both models. The cheapest rate on paper does not always produce the cheapest result in practice.

Coding Benchmarks and Competitor Comparison

Benchmarks are imperfect, but they offer the clearest outside view of how a model performs, and the numbers Meta reports are striking. The first test to know is the SWE-Marathon benchmark, which measures a model’s ability to complete long, demanding software engineering tasks that unfold over many steps. It rewards stamina and consistency rather than quick answers, which makes it a good match for the kind of agent this release is trying to be.

On this test, the flagship version scores 57.5. That compares with 46.3 for Claude Opus 5.5 and 42.5 for GPT-6 Astra. A lead of more than eleven points over the nearest rival is large, and it supports Meta’s claim that the extra compute spent on long tasks translates into real results. When you place the whole Meta Muse Wonder line next to GPT-6 Astra and Claude Opus 5.5, the flagship stands out specifically on extended engineering work, which is the area it was designed for.

The second important evaluation is the DeepSWE benchmark, which looks at agentic development using realistic problems rather than simplified puzzles. It consists of 113 real tasks drawn from 91 repositories across five programming languages. That breadth matters, because a model that performs well in only one language or one codebase style can give a misleading picture. Here the family took first place with a score of 0.79 out of 1, a strong result on a test built from authentic projects.

How should you read these figures? First, remember that benchmark scores come from controlled conditions, and your own repositories will have quirks that no test captures. Second, a lead on long-horizon tasks does not mean the model wins in every scenario. For short, simple edits, differences between top models are often small, and cost and speed may matter more. Third, independent replication is valuable. As outside researchers and developers run their own tests, the picture will become more precise.

Still, the pattern is consistent. The results point toward strength in sustained, multi-step engineering, which is exactly where earlier models tended to fall apart. For teams whose work involves large refactors and complex debugging, the numbers justify a careful trial.

The best approach is a pilot on your own code. Pick three or four representative tasks, such as a tricky bug, a medium refactor and a feature addition, and compare outcomes across models, measuring correctness, time and the number of times you needed to intervene.

Final Verdict: Which Version Should You Choose?

The release of Meta Muse Wonder gives developers and businesses two clear options, and the right choice depends on the kind of work you do. Neither model is better in every situation. They are tools designed for different jobs, and the smartest teams will match each one to the task it suits.

Choose the standard model, Muse Wonder 1.0, through the API if your goal is automation and document work. It fits legal review, financial analysis, research assistance, report generation and workflow automation, and it is the only version you can integrate directly into your own software. Its pricing is transparent, its caching discount rewards well-designed prompts, and its context window handles large inputs with stability. Remember that you must build the memory layer yourself.

Choose a subscription for the flagship if your daily work is complex software development. Muse Wonder Full is the right pick for multi-hour refactoring, deep debugging and large engineering projects where consistency across hundreds of steps decides success. Its benchmark lead on long tasks is the clearest evidence of its value, and the $50 and $200 tiers let you scale to your usage. Keep in mind that it works only inside Muse Code and cannot be called programmatically.

Many organizations will benefit from using both. The base model can handle the high-volume, contained tasks that need to run automatically, while the flagship supports engineers on their hardest problems. Start with a narrow pilot, measure results against your current process and expand once you trust the output.

Overall, this launch signals a shift toward agents that remember, stay focused and ask before acting. Whether the benchmarks hold up in everyday use will be answered by developers over the coming months, but the direction is clear and the early numbers are promising.

Frequently Asked Questions

Can I use Muse Wonder Full through the API?

No. The flagship version is available only inside the Muse Code terminal agent on the Power Usage ($50 per month) and Maximum Usage ($200 per month) plans. Only the standard model, muse-wonder-1.0, can be accessed through the API.

Does maximum effort on the standard model make it the same as Full?

No. Maximum effort makes the base model reason longer, but it remains a different system with a smaller compute budget. The flagship is built to spend significantly more compute on complex, multi-step work.

How much does the standard model cost to use?

The rates are $4 per million input tokens, $0.20 per million cached input tokens and $20 per million output tokens. Reusing a stable prompt prefix through caching can lower your total bill considerably.