top of page
Abstract Shapes

INSIDE

PUBLICATIONS

Muse Wonder Full: Meta's Subscription-Only Frontier Coding Agent

6 minutes ago
68 min read
Muse Wonder Full review hero: a terminal workspace where an agent edits a repository across three diff panes while a test panel reports four passes and one failure, in charcoal and amber, with the product name on the image

Status: Active | Last tested: 2026-11-19 (Muse Wonder Full, muse-wonder-full-1.0, released 2026-10-12) | Re-check: trigger-based (max 6 months)


Active: the tool is current and recommended.


For detailed explanations of the CI-First evaluation terms used in this review, including the Humics Protection Badge and the AI Imposture Risk levels, see the Glossary at the end of this post.


Muse Wonder Full Review
Back to the TOC

In this Tool Review


Back to the TOC

Section icon: The three names, the one that has no API, and the price that belongs to a different model.

Muse Wonder Full

The three names, the one that has no API, and the price that belongs to a different model


Meta ships two models under one product name, and almost every secondary account of the launch mixes them. The mix matters because the benchmark scores belong to one of them and the published token rates belong to the other.


Name

What it is

Where it appears

Muse Wonder Full

The model this review scores. The higher-capability variant of Muse Wonder, sold only inside a Muse Code subscription, on the Power Usage and Maximum Usage plans. Vendor catalogue id muse-wonder-full-1.0

The models page, the Muse Wonder product page, the subscriptions page and the help centre

Muse Wonder

A different model, muse-wonder-1.0, available on the Meta Model API and in Muse Code on every plan. Priced at $4.00 per million input tokens, $0.20 cached input and $20.00 output, Standard mode only

The Model API, the pricing page, the rate-limit table and every plan from Everyday upward

The Muse Wonder series

The family name for both models, introduced on 2026-10-12. It is a generation label, not a model a buyer can select

The launch post, the model card and the model page


The card's working id is not an API id, and that is the first fact to settle. There is no muse-wonder-full model on the Model API. The vendor's own sentence is explicit: setting reasoning effort to "max" on muse-wonder-1.0 does not select Muse Wonder Full, which is available only in Muse Code. The catalogue prints muse-wonder-full-1.0 beside the subscription row, and the Muse Code documentation publishes no separate model id for it, so the route is the model picker inside the CLI rather than a string in a request body. This review keeps the card's slug muse-wonder-full for the CMS and the URL, and records the vendor id as muse-wonder-full-1.0.


The $4.00 and $20.00 rates belong to the other model. Meta's pricing page prices muse-wonder-1.0 and has no row for Full. A reader who sees "$4 in, $20 out" quoted next to a Wonder Full benchmark score has been handed two facts about two products. Full is bought as a monthly plan, and what the plan caps is usage, not tokens.


This is a new review, not a re-score of a sibling. U365's published library already carries Meta Muse Spark 1.3 (6.3, CI-First Strong) and Muse Spark 1.2 (5.8, CI-First Positive). Neither is edited here, no sibling CMS record is touched, and Full inherits no score from either. They appear in this document only as the models a buyer compares against. Muse Ember 1.0, Muse Spark Open and Muse Glimmer 30B are separate Meta models and are not scored here.


Two settings do most of the work, and one of them is on by default. Reasoned effort runs from "minimal" to "max", and the default on the Wonder models is "max". The default is therefore the most expensive setting as well as the most capable one, and a reader who never opens the setting is buying the top of the effort range on every request. The second setting is Contributor mode, which subscriptions turn on by default: it gives more usage in exchange for permission to train future Meta models on the content sent. It can be turned off, and turning it off lowers the allowance by an amount Meta does not publish.


What this review is not. It is not a review of muse-wonder-1.0, which has its own price and its own availability and would score differently. It is not a review of Muse Code as a product, although Muse Code is the only way to reach the model and its defaults are therefore part of the assessment. It is not a review of the Muse consumer app, which runs on Muse Spark. And it is not a verdict on Meta's model line as a whole: three models in that line carry three different commercial shapes, and this review scores one of them.

Back to the TOC


Section icon: Tool Snapshot.

Muse Wonder Full

Tool Snapshot


Muse Wonder Full, Meta's subscription-only frontier coding model: the highest measured Meta model in this edition, delivered through a terminal agent at $50 or $200 a month rather than at a token rate.


Category: Applied AI / Frontier coding and agentic model. It is the higher-capability variant of Muse Wonder, built for complex software engineering and long-horizon agent work, and it is reachable only through Muse Code, Meta's terminal coding agent.


Primary use cases:


  • Multi-file changes in a real repository. The model is sold for work that crosses files: making a change, verifying it, and recovering from the errors found on the way. That is the work where the independent index places it above its own API sibling by 6.5 points, 50.08 against 43.57 on the same measurement.

  • Long-running agent work with parallel tools. Meta describes planning, delegation to sub-agents, parallel tool calls and recovery across many steps, and the plan allowances are sold in multiples of a base prompt budget rather than in tokens.

  • Agent main loops. The documentation recommends Muse Wonder as the main loop of a coding agent, with cheaper Muse Ember handling volume subtasks. Full is the same arrangement at the top of the range.

  • Computer use. The model drives a desktop from screenshots through a native computer-use tool, and the vendor reports OSWorld V2.1 results in the same table as its coding rows.

  • From-scratch programming and long-horizon engineering. The vendor states that Full tops DeepSWE and SWE-Marathon in independent third-party runs, and its model card names the result sources for both.


What it is not. It is not an API model: there is no endpoint, no model id to call and no per-token rate. It is not a cheaper route to frontier work: the entry price for Full is $50 a month, ten times the Everyday plan, and the only plan above it is $200. It is not the best measured model in the field: on the current independent index it sits below Claude Opus 5.5 and GPT-6.2 Sol. It is not a teaching product and it has no pedagogy. It is not open weights, it is not self-hostable, and no parameter count is published. It is not a document assistant in the ordinary sense, even though it reads documents, because the only surface that carries it is a coding agent.


Pricing, as published on 2026-11-19:


Plan

Monthly price

Usage against Everyday

Muse Wonder

Muse Wonder Full

Notes

Everyday Usage

$5.00

1x, published as 10 to 50 prompts every 5 hours

Included

Not included

Muse Ember, Muse Spark, Muse Wonder and Muse Image; voice mode; web search

High Usage

$15.00

5x

Included

Not included

More multimodal inputs

Power Usage

$50.00

20x

Included

Included

Entry point for Full; early access to new features; higher file uploads

Maximum Usage

$200.00

80x

Included

Included

No larger model, only a larger allowance


The price is a fee and a cap, not a rate. Meta publishes no per-model usage cost inside a plan, so the honest unit is prompts or multipliers against a base that the vendor does not quantify in tokens. There are no paid top-ups: at the limit a subscriber upgrades to the next plan or waits for the allowance to refresh, and on Maximum there is nothing to upgrade to. Upgrades take effect immediately and are prorated; downgrades apply from the next billing cycle. A buyer comparing $50 with a token bill is comparing a ceiling with a meter, and the two do not convert without the usage data Meta has not published.


Official links:



Model-specific fields:


  • Vendor model id: muse-wonder-full-1.0, printed on the models page beside the subscription row. It is a catalogue identifier, not an API model id.

  • Availability: Muse Code subscription only, on Power Usage ($50) and Maximum Usage ($200). Not on the Meta Model API at any price.

  • Context window: 1M tokens (1,048,576 in the technical table). Maximum output is not published.

  • Reasoning effort: "minimal" to "max" on the Wonder models, with "max" as the default. The effort setting of Muse Wonder does not route to Full.

  • Modalities: text, image, video, audio and PDF input; text output. No image, audio or video generation.

  • Endpoints: none for Full. Muse Code runs as an interactive terminal agent, a headless command (muse exec), or a session protocol driven through muse serve and the TypeScript SDK.

  • Surfaces: macOS, Linux and Windows through Muse Code. Approvals and an OS sandbox are on from the first run.

  • Parameters and architecture: not disclosed.

  • Licence: proprietary. Muse Code subscriptions are governed by the Meta Subscription Terms of Service, with the Meta Model API Terms of Service and the Acceptable Use Policy applying to the underlying service.

  • Regional restriction: Muse Wonder and Muse Wonder Full are not currently available in South Korea, and a Muse Code subscription there does not include them. Muse Image is not available in India.


At a Glance Dashboard


Field

Value

Category

Applied AI / Frontier coding and agentic model (subscription-only, delivered through Muse Code)

CI-First Benefit Score

5.8 / 10 (CI-First Positive)

Sub-scores

Time 6 / Quantity 7 / Quality 7 / Skill 3

Primary AI Profile

Co-Worker and Assistant (level 2)

Humics Badge

Humics-Neutral (-1 / +3)

AI Imposture Risk

Medium overall (Time Medium, Quantity Medium, Skill High)

Entry price for this model

$50.00 a month (Power Usage); $200.00 for Maximum Usage

Independent index

50.08 at max effort, Artificial Analysis Intelligence Index v5.0.1, 35th of 156

Context window

1M tokens (1,048,576), maximum output not published

Status

Active

Primary institute

UIT (Technology, AI, Data Science)

Back to the TOC


Section icon: The Problem.

Muse Wonder Full

The Problem


A frontier coding model is now bought in two completely different ways, and the difference is not cosmetic. One way is a token meter: you pay per million tokens, you can compute a budget per task, and you can move a workload between providers without changing your tools. The other is a monthly plan: you pay a fee, you get an allowance measured in a unit the vendor defines, and the marginal cost of the next task is zero until the allowance runs out and then it is a plan upgrade.


Muse Wonder Full sits entirely in the second category. That solves one problem and creates another. The problem it solves is the budget conversation. At $50 a month, a developer can put a frontier-class model in front of hard repository work without a per-task cost decision, and can run a long agent session without watching a token counter. The problem it creates is that the buyer cannot answer the ordinary purchasing questions: what does a task cost, how many tasks fit in a month, and what happens at the limit. Meta publishes four prices and four multipliers, and it publishes no per-model usage cost, so the answers are not available before purchase.


The second problem is the one this review spends most of its evidence on. The model is sold on benchmark leadership, and the leadership is real on the vendor's own table: Full tops DeepSWE and SWE-Marathon in third-party runs, and the vendor says so in one sentence. But the same model's position on the independent index is not leadership today. At 50.08 on index version 5.0.1 it is 35th of 156 models, below Claude Opus 5.5 at 59.11 and below GPT-6.2 Sol at 57.26. Both sentences are true: a model can lead two coding benchmarks and sit mid-field on a composite that weights nine evaluations. A buyer who reads one sentence and not the other buys the wrong thing.


The third problem is verification. A coding agent that makes and verifies changes across many files produces exactly the output a reader is least able to check by reading: a diff. A diff can be reviewed, and a test suite can be run, which is the good case. But the model also writes the plan, chooses the files, decides when it is finished and reports its own progress. A reader who accepts the agent's account of what it did has accepted the agent's judgement twice, once for the change and once for the report. The framework calls that the Skill Illusion, and an agentic coding product is the purest form of it.


The fourth problem is commercial rather than technical. Meta's subscriptions default to Contributor mode, which trades permission to train on your content for more usage. It can be turned off, and the allowance falls by an amount Meta does not state. A team that adopts the plan without reading that setting has made a data decision by default. That is a purchasing fact with a technical consequence, and it belongs in the same conversation as the price.

Back to the TOC


Section icon: The Outcome.

Muse Wonder Full

The Outcome


Muse Wonder Full puts Meta's strongest measured model in this edition behind a monthly plan that starts at $50, delivers it through an agent that runs and verifies its own work, and leaves the buyer unable to compute cost per task because the vendor publishes an allowance without a rate.


The capability position is real, and Meta describes Full as its most capable model yet. On the Artificial Analysis Intelligence Index version 5.0.1, Full scores 50.08 at max effort, against 43.57 for muse-wonder-1.0 on the same index and the same day of release. That 6.5-point gap is the measured value of the upgrade, and it is the cleanest fact in the review because both models were scored by the same evaluator on the same version. The vendor's own claim goes further on coding: Full tops DeepSWE 1.1 and SWE-Marathon in third-party runs, and the model card names Datacurve and Abundant AI as the result sources for those rows.


The position against the field is where the marketing and the measurement part. At 50.08, Full sits below Claude Opus 5.5 (59.11) and GPT-6.2 Sol (57.26) on the same index version, and 35th of 156 models overall. That is a strong result for a first frontier release and it is not a leadership result. Meta's launch framing, that the series delivers state-of-the-art performance on personal and professional agentic tasks, is supportable on selected benchmarks and not supportable as a general claim on the composite. The review records both.


The delivery position is the part a buyer feels every day. Muse Code runs in the terminal, on macOS, Linux and Windows, with approvals and an OS sandbox on from the first run, an interactive mode, a headless mode for CI, and a session protocol for driving it from another program. That is a complete agent surface rather than a chat window, and it is the only way to reach Full. The cost of that arrangement is that the product and the model cannot be evaluated separately: a good result belongs to the pair, and so does a bad one.


Where the outcome is smaller than the price suggests. The one published matched test of the model in Muse Code found it three times slower than Claude Code with Opus 5.5 on four small repository jobs: 26 minutes 39 seconds against 8 minutes 53 seconds, with both systems finishing all four jobs. The same test found no quality gain for Full over regular Wonder on its small projects, which is the specific comparison a Power subscriber is paying $35 a month over High to obtain. Neither result is a general ranking, and both are the kind of evidence a buyer should have before upgrading. The full detail is in What Users Say.


For U365 Fellows, the outcome is a capable agent with a purchasing decision attached. A learner or professional can put a real repository in front of a frontier-class model for $50, run a multi-file change, and have the tests executed by the agent. That is a genuine change in what one person can attempt in a week. It is not a change in what that person can verify, and the plan structure encourages exactly the behaviour the framework warns about: a flat fee makes the next task feel free, and an agent that reports its own success makes the next check feel unnecessary.


What the release does not change. It does not put Full on the API, it does not publish a token rate, it does not publish a maximum output length, and it does not publish the per-model usage cost that would let a buyer compare a plan with a meter. It does not make the model the measured leader, and it does not remove the need for a reviewer who can read a diff. Those facts sit in the cost section, the imposture table and Section 7c, and a higher benchmark row does not move them.

Back to the TOC


Section icon: Who Should Use Muse Wonder Full.

Muse Wonder Full

Who Should Use Muse Wonder Full


Learner type

Difficulty

Typical ROI

Career path

Students (Bachelor, Master)

Intermediate to Advanced

A frontier coding agent at a price a student can consider, and the wrong first purchase for most of them. The Everyday plan at $5 already includes Muse Wonder, which is the model to learn on, and Full costs ten times as much for a capability gain that a student's projects are unlikely to measure. The case for Full is a final-year project with a real repository, a test suite and a deadline, and even then the case rests on the project rather than on the model. The Skill Illusion is the live risk: an agent that ships a working application has not taught the student to build one.

UIT (Technology, AI, Data Science) tracks through repository work, testing and agent supervision. UID (Digital Design, UX/UI) for design-to-code projects where the interface is the deliverable and the diff is the evidence. No published U365 credential assesses AI-assisted engineering as a named component, and none is asserted.

Professionals (career upskilling)

Advanced

The strongest case in the release: a developer with a large repository, a test suite and work that crosses files. The measured gap over muse-wonder-1.0 is real, the plan removes the per-task budget conversation, and the agent surface runs the commands a developer would run. It is a weaker case for short interactive work, where a flat plan buys nothing a token meter does not, and for anyone whose work is document analysis rather than code.

UIT (Technology, AI, Data Science) engineering tracks for agent supervision, evaluation design and cost engineering. UIB (Business Management, Entrepreneurship) for the commercial reading of a plan, a cap and a default data setting.

Everyone (lifelong learners)

Intermediate

A poor fit as a general assistant. The only surface is a terminal coding agent, the model is sold on repository work, and the price of entry is a coding plan. A reader who wants a general assistant should use the consumer Muse app or a model with a chat surface. The gain here is for people who already write code, and the cost for everyone else is a subscription they will not use.

LIPS and CARE Collect and Review phases for the reading a change requires, and the UP-Context-Engineering Method order for prompting. No assessment home is asserted.


For teams and organisations. The model is sold to individuals and to teams through the same plans, and a team deciding on it starts with four questions.


  • Team deployment. Each developer installs Muse Code with the one-line installer and signs in with a Meta account, or runs headless in CI with META_API_KEY. The subscription attaches to the Muse Code key created during onboarding, and any additional API key a team creates is billed separately as pay-as-you-go. A team therefore has two billing surfaces to govern: the plans its developers hold, and the API keys the same organisation creates for automation. Full is reachable only through the first.

  • Cost at team scale. The line that moves is the plan, not the token rate. Power is $50 and Maximum is $200 per subscriber per month, and the allowance is a multiplier against a base the vendor does not quantify in tokens. At 20x and 80x, the difference between a team that fits inside Power and one that needs Maximum is a factor of four in price for the same model. Meta publishes no per-model usage cost, so a team cannot forecast that boundary from published data; it has to measure its own work.

  • Data and compliance. Subscriptions default to Contributor mode, which permits Meta to use the prompts, code, files and context sent, and the responses returned, to train future models. Turning it off stops future content being used and lowers the allowance by an unpublished amount, and Contributor mode is not available to accounts with Zero Data Retention. A team with a client-confidentiality obligation has to make this setting a provisioning decision rather than a user preference, because the default is the permissive one.

  • U365 for companies. Professional learners reach University 365's academic services individually or through their organisation, and the company route runs through a customized training agreement for employee groups. Corporate education programmes are built on demand, and their tuition follows content and duration.


Skill level required: Advanced. The model is easy to start and hard to supervise: stating a finish line, bounding the files in scope, reading a diff rather than a summary, running the tests yourself, and knowing when the agent's own report is the only evidence you have. None of that is needed to get an answer, and all of it is needed to rely on one.


Prerequisites. A Meta account and a Muse Code subscription on Power Usage or Maximum Usage. Muse Code runs on macOS, Linux or Windows; Windows loses voice input and session messaging and may show a User Account Control prompt the first time the sandbox initializes. A repository with a test suite is not a technical prerequisite, and it is the practical one: without a command that proves the change, the agent's report is the only evidence.


Typical time to first result: Under fifteen minutes. Install the binary, sign in, trust the workspace, select Full from the model picker on a Power or Maximum plan, and give it one bounded task.


Typical time to competence: Twenty to thirty hours of active use. Two habits carry most of the value: naming the proving command before the run, and reading the diff before accepting the summary.


Who should wait. Anyone on Everyday or High who has not yet measured whether regular Muse Wonder fails on their work, because Full is a $35 monthly step from High and the published matched test found no gain on small projects. Anyone who needs an API, because there is no API route. Anyone whose data cannot be used to train future models and who cannot accept the allowance penalty of turning Contributor mode off without knowing its size. And anyone who needs the measured leader, because on the current independent index Full is not it.

Back to the TOC


Section icon: U365 Institutes Alignment.

Muse Wonder Full

U365 Institutes Alignment


The alignment below rates what a U365 institute could take from this model as a working instrument and as an object of study. The primary home is UIT (Technology, AI, Data Science), because the model's measured work is repository-scale engineering and long-horizon agent execution, and because the purchasing question it raises is a cost-engineering question before it is a commercial one. The other three readings are real and each is bounded.


UIT (Technology, AI, Data Science)


  • Rating. High (primary)

  • Why. Four engineering competencies, each of which survives the removal of the tool. Agent supervision: the product plans, edits and runs commands with approvals and a sandbox, and supervising it means writing a task decomposition, bounding the files in scope, and reading the diff, which is management rather than prompting. Repository-scale reasoning: a 1M-token context and a model sold for changes that cross many files, where the discipline is naming what is in scope and refusing a rewrite. Evaluation reading: the same release publishes vendor-run rows, third-party rows and an independent composite that disagree about leadership, and telling those three sources apart is the skill. Cost engineering: a plan sold as a fee and a multiplier, with no published per-model usage cost, is a live exercise in measuring cost per finished task from your own work rather than from a rate card. The published programme set already teaches Python, software development and cloud computing; this model is a working object on which those skills are exercised.

  • The limit that holds the row. The model is a service a practitioner operates, not an artefact a practitioner inspects. There are no weights, no architecture description and no parameter count, so the competencies are engineering-with rather than engineering-of. No published programme assesses agent supervision or plan cost engineering as a named component. Adjacent anchors, not assessment homes.


UIB (Business Management, Entrepreneurship)


  • Rating. Medium

  • Why. Two decisions the release forces that are commercial before they are technical. Subscription against meter: a team choosing between a $50 plan and a token bill is choosing between a ceiling and a meter, and the arithmetic cannot be completed from published data because the allowance is not expressed in tokens, so the comparison has to be built by the unit that buys it. And the data trade: Contributor mode is on by default, gives more usage in exchange for training rights over the content sent, and can be turned off at an unpublished cost in allowance. Reading a default setting as a commercial term rather than a preference is exactly the kind of judgement a business cohort should practise on a live contract.

  • The limit that holds the row. The model supplies no management method and does not measure its own return. It publishes no completion rate, no time-per-task figure and no cost-per-task figure, so a business case has to be assembled from the buyer's own records. No published programme assesses the economics of a subscription plan as a named component. Adjacent anchors, not assessment homes.


UIC (Digital Communication, Marketing)


  • Rating. Low

  • Why. One competency, and it is narrow: reading a launch claim against the document that supports it. This release is a worked example, because the headline benchmark scores belong to Muse Wonder Full while the published token rates belong to Muse Wonder, and both facts appear in the same launch coverage without the distinction being made. A communication practitioner who can see that two true sentences describe two different products is doing the job the profession claims. There is no writing, campaign or content-strategy surface in the product beyond the code and text a coding agent produces.

  • The limit that holds the row. The model teaches no register, no audience analysis and no publication standard, and the only surface is a terminal coding agent. Rated as evaluation contact with a launch-claim reading exercise. No credential is mapped.


UID (Digital Design, UX/UI)


  • Rating. Low to Medium

  • Why. The design contact is real and second-hand: Muse Wonder Full drives a desktop from screenshots through a native computer-use tool, and the vendor's demonstrations include interface and game work built through an agent. A designer can study the output as the current state of design-to-code at the top of Meta's range, and can use the agent to produce interface variants fast enough that comparison becomes the work. The computer-use capability is the part that matters, because it operates a real application rather than describing one.

  • The limit that holds the row. The model performs no design judgement and evaluates no design against a brief. It reads images and video and produces text and code, and it generates no images, so the visual surface is input plus front-end code rather than visual authorship. No layout, interaction or motion competency is assessed by it. No credential is mapped.


U365 methods, not an institute (UNOP, ULM, LIPS, CARE and the UP-Context-Engineering Method)


  • Rating. Applicable

  • Why. The methods layer matters in the way an agentic tool always does: the agent holds the plan, so the human has to hold the record. LIPS and CARE describe the discipline directly, because the record of what a run was asked to do, which files it was allowed to touch, what command proved it and what it returned belongs in the Fellow's own system rather than in a session that closes. The UP-Context-Engineering Method's eight layers, from USER-PERSONA and FULL-CONTEXT through AI-EXACT-TASK to EXPECTED-FORMAT-AND-CONSTRAINTS, are what turn a vague request into a bounded run, and the constraint layer is where the proving command and the file scope belong. ULM is relevant to the purchase rather than to the run: a monthly plan is a recurring cost in the Career and Finance domain, and the decision to hold it belongs in the six-domain plan rather than in a tool-settings page. UNOP has no direct fit: the model is not built to teach, and its gains come from execution rather than from any pedagogical mechanism.

  • The limit that holds the row. The model carries no method of its own and no coaching surface. A Fellow who does not keep the plan, the scope and the proof in their own system has no account of the work, and nothing in the product writes that account for them.

Back to the TOC


Section icon: How Muse Wonder Full Works.

Muse Wonder Full

How Muse Wonder Full Works


A frontier coding model delivered only through a terminal agent, with a 1M-token window, a reasoning effort range that defaults to the top, and a commercial shape of a monthly fee with a usage cap rather than a token rate.


Inputs: Text prompts, a repository and its files, images, video, audio and PDFs. In Muse Code, the input is also the workspace itself: the files the agent may read, the instruction files it loads when you trust the workspace, the tools it may call, and the commands it may run. The model reads five modalities and produces text.


Outputs: Text, code, structured tool calls, edits to files, and the commands the agent runs. There is no published maximum output length, and there is no API response to cap, because the product is a session rather than a request.


Underlying technology, as the vendor publishes it:


  • Model: Muse Wonder Full, catalogue id muse-wonder-full-1.0, the higher-capability variant of Muse Wonder. It is one of two models in the Muse Wonder series released on 2026-10-12.

  • Delivery: Muse Code only, on the Power Usage and Maximum Usage plans. Muse Code is Meta's terminal coding agent, installable with a one-line script that puts a native muse binary on the path, and runnable interactively or headless through muse exec.

  • Context: 1M tokens (1,048,576 in the technical table), shared across the conversation and the workspace material the agent reads.

  • Reasoning effort: "minimal" through "max" on the Wonder models, with "max" as the default. Effort is a model setting, not a plan setting; the plan controls how much usage is available, not how hard the model thinks.

  • Active Memory and Active Focus: the vendor's names for carrying context across conversations and for continuing toward a goal through blockers, alternative approaches and check-ins before important actions. These are behaviours rather than user-authored memory stores, and the product publishes no mechanism by which the agent writes the user's skills or standing instructions.

  • Agent safety defaults: approvals and an OS sandbox are on from the first run, and the first entry into a workspace asks whether to trust it, which determines whether its skills, rules and hooks are loaded.

  • Platforms: macOS, Linux and Windows from one codebase. On Windows, PowerShell replaces Bash, the sandbox may prompt for administrator approval on first use, voice input is unavailable and session messaging is unavailable.

  • Programmatic control: muse serve exposes a versioned session protocol, muse schema prints its JSON schema, and the TypeScript SDK (@muse-code/sdk) wraps it. A team can drive the agent from its own program without an API model id.

  • Consumption: a plan, not a token meter. Everyday is published as 10 to 50 prompts every 5 hours; High is 5x, Power is 20x and Maximum is 80x that base. Meta publishes no per-model usage cost inside a plan.

  • Contributor mode: on by default for subscriptions. It grants more usage in exchange for permission to use the content sent to train future Meta models. It can be switched off in settings from the next request, the allowance falls by an unpublished amount, and it is not available to accounts with Zero Data Retention.

  • Regional availability: Muse Wonder and Muse Wonder Full are not currently available in South Korea, so subscriptions there do not include them.

  • Lifecycle: the API sibling muse-wonder-1.0 is documented as in preview. Meta publishes no separate lifecycle statement for Full beyond the subscription availability table.


What is not disclosed. No parameter count. No weights. No architecture description. No maximum output length. No per-model usage cost inside a plan. No published latency or throughput figure. No training-data description specific to this model beyond the model card's general statement. And no statement that would let a buyer audit what the model does internally; the framework's clause assessments turn on what ships on the surfaces, not on anything inside the model.


How the economics actually work. A subscriber pays a fee and receives a multiplier. The multiplier is relative to a base the vendor describes in prompts on the cheapest plan and in multiples above it, so the same task can consume a different share of a plan depending on how the product counts it. Meta does not publish that counting. The practical consequences are three. First, cost per task cannot be computed before use, only measured after it. Second, the marginal price of the next task is zero until the cap, which rewards batching work into a session and penalises a month with one hard job. Third, there are no top-ups: at the cap the choice is upgrade or wait, and on Maximum there is only wait. A reader comparing $50 with a token bill is comparing a ceiling with a meter.


What it is bad at natively. Short interactive work, where a plan buys nothing a meter does not and a coding agent is more surface than the question needs. Document analysis outside a repository, because the only surface is a coding agent. Any workflow that needs an API, because Full has none. Any workflow where the buyer must forecast cost per task, because the counting is not published. And any task whose correctness the person asking cannot check, which is a limit of the arrangement rather than of the model.

Back to the TOC


Section icon: Getting Started with Muse Wonder Full.

Muse Wonder Full

Getting Started with Muse Wonder Full


Required accounts: A Meta account, and a Muse Code subscription on Power Usage ($50) or Maximum Usage ($200). The subscription attaches to the Muse Code key created during onboarding; additional API keys are billed separately as pay-as-you-go and cannot reach Full.


Installation: One line in a terminal, on macOS, Linux or Windows:


curl -fsSL https://dev.meta.ai/install.sh | bash

On Windows PowerShell, the installer is irm https://dev.meta.ai/install.ps1 | iex. Confirm the binary with muse --version.


First-time configuration:


  • Decide the plan before the model. Full exists on Power and Maximum only. If you are on Everyday or High, the model picker will not offer it, and the upgrade is prorated if you make it mid-cycle.

  • Turn Contributor mode into a decision rather than a default. Subscriptions start with it on, which grants more usage in exchange for training rights over your content. Open /settings, read the row, and decide with the data owner rather than alone. Turning it off lowers the allowance by an amount Meta does not publish, so record the change and watch the first week.

  • Trust the workspace deliberately. On first entry Muse Code asks whether to trust the workspace, which determines whether its skills, rules and hooks load. Trust the repository you intend to work in, and do not trust a directory you have not read.

  • Select Full from the picker. Use /model and choose Muse Wonder Full on a Power or Maximum plan. No CLI model id is published for Full, so use the picker rather than guessing a string.

  • Keep approvals and the sandbox on for the first month. They are on from the first run, and the temptation after a few good sessions is to remove friction. A coding agent that can run commands in a repository is exactly the tool that should keep the confirmation step until you know its failure modes.

  • Write the proving command into the request. A test command, a build, a type check, a page that renders. The agent can run it, and you can run it again. Without one, the agent's own report is the only evidence.

  • Measure your first month by finished tasks, not by sessions. Keep a simple record: the task, the proving command, whether it passed first time, and the time you spent reading the diff. That record is the only cost-per-task figure you will have, because Meta publishes none.


First 15 minutes checklist:


  • ☐ Install the binary, run muse --version, and sign in.

  • ☐ Confirm the plan in the account, and confirm that Full appears in /model.

  • ☐ Read the Contributor mode row in /settings and record the decision.

  • ☐ Run one real task with a stated finish line, a file scope and a proving command.

  • ☐ Re-run the proving command yourself, read the diff, and write down what the agent reported against what you verified.


Result: One real task completed end to end, a deliberate data setting, a plan you can name, and a first measurement of what a finished task costs you in time. That is a working setup rather than an impression.

Back to the TOC


Section icon: Real Workflows.

Muse Wonder Full

Real Workflows


Three workflows, each chosen because the model's measured strength and a check the reader already owns sit in the same place. Each sample prompt uses the UP-Context-Engineering Method's eight layers in method order, with the constraints and the data limits inside EXPECTED-FORMAT-AND-CONSTRAINTS.


Workflow 1: Repair a failing test that crosses four files


When to use it: a test run fails, the cause is not in the file that failed, and you can re-run the suite yourself. This is the workflow where the model's measured position is strongest and where the end state is unambiguous.


This sample prompt uses the UP-Context-Engineering Method and the CI-First doctrine. Read the method at https://www.university-365.com/post/the-up-method-university-365-prompting-the-new-gold-standard-for-prompt-engineering, the doctrine at https://www.university-365.com/post/discover-the-ci-first-approach, learn both in a U365 online program at https://www.university-365.com/programs, and request a U.Coach for orientation at https://www.university-365.com/ucoach.


USER-PERSONA: My UP-Context-Engineering USER-PERSONA file is the file for this layer, attached. It is my psychographic file concatenated with the six ULM life-domain files. The parts that matter here: I am the engineer who owns this merge and I defend the diff line by line, and I do not accept a fix I cannot explain. If the file is not attached, ask for it before you start.
FULL-CONTEXT: The FULL-CONTEXT set for this task, added and not merged: BUSINESS-PERSONA for [the organisation the repository serves, or none], PROJECT-DESCRIPTION for [repository], the repository at [path] on branch [branch], the failing command [command], the failing tests [names], the suspected call path [files], the last change to the area [commit], and the test file whose assertions must not change. The repository is the only code authority and the test run is the only proof. If the repository path or the failing command is missing, name it and stop.
AI-PROFILE-ROLE-EXPERTISE: Act as a Co-Researcher, Analyst & Tester, in the role of a senior engineer diagnosing a regression across module boundaries, with expertise in call-path tracing, minimal-diff repair and reading a test suite for what it actually asserts.
USER-FINAL-GOAL: The suite passes on a clean checkout, the diff is small enough to read in one sitting, and I can defend the call path without the transcript, so the fix ships this week.
AI-EXACT-TASK: Trace the failure to its cause, make the smallest change that makes the failing tests pass, and explain the call path in five sentences.
AUDIENCE: Me, the engineer who merges it, and a reviewer who reads the diff without running the session. The reviewer has not seen your reasoning and will not accept a summary as evidence.
EXPECTED-FORMAT-AND-CONSTRAINTS: Format: (1) the call path in five sentences, (2) a unified diff, (3) the exact command to re-run, (4) what you did not verify. Constraints: stay inside the file list; do not reformat, rename or refactor outside the failing path; do not add a dependency; do not weaken, skip or delete a test; do not report a fix you did not run; if the cause is outside the files in scope, stop and name the file you need instead of guessing; I run you at reasoning effort high and you do not raise it to max without telling me; your knowledge stops before the release date of the libraries in this repository, so anything newer must come from the repository or from me; there is no published maximum output length, so if the answer will not fit in one session, stop and say so before editing. Data limits: the repository is cleared for this model at the level I state in the FULL-CONTEXT set; no credential, private key, customer record or unreleased code leaves my control, and Contributor mode is [on or off] by my decision, not by default.
EXAMPLES: The last fix in this area that passed the suite is the diff example, attached, and the existing test file is the assertion-style example.

Before you use the output, run the check yourself: re-run the exact command in a clean checkout, read the diff line by line, confirm that no test was skipped, weakened or deleted, and explain the call path without the transcript. The decision is yours, per CI-First.


What the model does well here: repository-scale reasoning inside one window, with a measured edge over its own API sibling. On the independent index Full scores 50.08 against 43.57 for muse-wonder-1.0, and the vendor reports leadership on DeepSWE 1.1 and SWE-Marathon in third-party runs. The behaviour the vendor describes matches the shape of the work: making and verifying changes across many files, delegating parts to sub-agents and recovering from errors.


VERIFICATION CHECKLIST for Repair a failing test that crosses four files:


  • ☐ Multi-Model Check: run the same prompt through a second model (Claude Opus 5.5 or GPT-6.2 Sol) and compare the diagnosis, not the diff. A different cause means one of them is guessing.

  • ☐ External Source: run the test command yourself in a clean checkout and confirm the failing tests now pass and that no test was skipped, weakened or deleted.

  • ☐ Human Review: read the diff line by line. A passing suite with a changed assertion is a failure that has been hidden.

  • ☐ CI-First Test: can you explain the call path and defend the fix without the transcript? If not, the fix is not yours yet.


Workflow 2: Run a bounded migration unattended


When to use it: a mechanical change has to land across many files, the rule is expressible, and a command proves the result. This is the workflow where the plan structure pays for itself, because a long run consumes allowance rather than a token bill, and where the agent's own report is most tempting to trust.


This sample prompt uses the UP-Context-Engineering Method and the CI-First doctrine. Read the method at https://www.university-365.com/post/the-up-method-university-365-prompting-the-new-gold-standard-for-prompt-engineering, the doctrine at https://www.university-365.com/post/discover-the-ci-first-approach, learn both in a U365 online program at https://www.university-365.com/programs, and request a U.Coach for orientation at https://www.university-365.com/ucoach.


USER-PERSONA: My UP-Context-Engineering USER-PERSONA file is the file for this layer, attached. It is my psychographic file concatenated with the six ULM life-domain files. The parts that matter here: I own the migration and I answer for every file it touches, and I will not accept a change I cannot revert. If the file is not attached, ask for it before you start.
FULL-CONTEXT: The FULL-CONTEXT set for this task, added and not merged: BUSINESS-PERSONA for [the organisation, or none], PROJECT-DESCRIPTION for [migration], the repository at [path] on branch [branch], the change rule [rule], the files in scope [glob or list], the files out of scope [list], the proving command [command], the rollback step [step], and the current failing baseline [output]. If the change rule or the proving command is missing, name it and stop.
AI-PROFILE-ROLE-EXPERTISE: Act as a Co-Worker & Assistant, in the role of a migration engineer applying one mechanical rule across a bounded file set, with expertise in codemods, incremental verification and reversible changes.
USER-FINAL-GOAL: The rule is applied to every file in scope, the proving command passes, nothing outside scope changed, and I can revert the whole run with one step.
AI-EXACT-TASK: Apply the rule file by file, verify after each batch, and report the files changed, the files skipped and the reason for each skip.
AUDIENCE: Me, the reviewer, and the CI log that will show whether the branch is green. The CI log does not read your summary.
EXPECTED-FORMAT-AND-CONSTRAINTS: Format: a table of file, change, verification, then a list of skips with reasons, then the exact commands you ran. Constraints: one rule only; no opportunistic cleanup; no dependency change; no change outside the scope list; run the proving command [command] after each batch and stop on the first failure you cannot explain; do not mark a file done because the edit applied, only because the command passed; do not report a run you did not execute; I run you at reasoning effort high and you may raise it to max only for a failure you can name; your knowledge stops before the release date of the tooling in this repository, so anything newer must come from the repository or from me. Data limits: the repository is cleared at the level I state; no credential, customer record or unreleased code leaves my control, and Contributor mode is [on or off] by my decision.
EXAMPLES: One file migrated by hand is the form example, attached, and the last green CI log for this branch is the verification example.

Before you use the output, run the check yourself: confirm the branch is green, confirm the scope list matches the diff, run the rollback step once on a scratch branch, and read the skips rather than the changes. The decision is yours, per CI-First.


What the model does well here: long-horizon execution with check-ins. Active Focus is the vendor's name for continuing through blockers and asking before important actions, and the plan structure means a long run is a usage decision rather than a metered bill. The caveat belongs in the same breath: the vendor's SWE-Marathon row for Full was reported at xhigh effort rather than at max, which is a lower setting than the column heading implies, so the long-horizon number is not a max-effort number.


VERIFICATION CHECKLIST for Run a bounded migration unattended:


  • ☐ Multi-Model Check: have a second model review the change rule before the run, not the diff after it. A rule that two models read differently is a rule that will be applied inconsistently.

  • ☐ External Source: run the proving command yourself on the final state, and diff the changed-file list against the scope list.

  • ☐ Human Review: read the skips and the rollback step. A run with no skips on a large scope is a run that did not look.

  • ☐ CI-First Test: can you state what changed in every file and why, without reopening the session? If not, the migration is not yours.


Workflow 3: Build a small program against an acceptance suite


When to use it: a from-scratch program has a checkable definition of done, and the agent can iterate against it. This is the cleanest use of an autonomous coding agent, because the acceptance suite is the authority and the agent's report is not.


This sample prompt uses the UP-Context-Engineering Method and the CI-First doctrine. Read the method at https://www.university-365.com/post/the-up-method-university-365-prompting-the-new-gold-standard-for-prompt-engineering, the doctrine at https://www.university-365.com/post/discover-the-ci-first-approach, learn both in a U365 online program at https://www.university-365.com/programs, and request a U.Coach for orientation at https://www.university-365.com/ucoach.


USER-PERSONA: My UP-Context-Engineering USER-PERSONA file is the file for this layer, attached. It is my psychographic file concatenated with the six ULM life-domain files. The parts that matter here: I am the person who will maintain this program, and I will not accept code I cannot read. If the file is not attached, ask for it before you start.
FULL-CONTEXT: The FULL-CONTEXT set for this task, added and not merged: BUSINESS-PERSONA for [the user of the program, or none], PROJECT-DESCRIPTION for [program], the specification at [path], the acceptance suite at [path], the runtime and version [runtime], the files the program may create [list], and the command that runs the suite [command]. The acceptance suite is the only definition of done. If the suite or the runtime is missing, name it and stop.
AI-PROFILE-ROLE-EXPERTISE: Act as a Co-Worker & Assistant, in the role of a developer building a small program against a fixed acceptance suite, with expertise in reading a specification for testable requirements and refusing scope that the suite does not cover.
USER-FINAL-GOAL: The suite passes from a clean checkout, the program is small enough for me to read in one sitting, and I can explain every module without the session.
AI-EXACT-TASK: Build the program, run the suite, and report the pass count, the failures and the parts of the specification the suite does not test.
AUDIENCE: Me, the maintainer, and a reviewer who will read the code and run the suite. Neither will accept a claim of success without the command output.
EXPECTED-FORMAT-AND-CONSTRAINTS: Format: (1) the module list with one line each, (2) the output of the proving command [command] from a clean checkout, (3) the specification items the suite does not cover, (4) what you did not verify. Constraints: create only the files on the permitted list; do not add a dependency the specification does not name; do not write tests that assert your own implementation rather than the specification; do not change the acceptance suite; do not report a pass you did not observe; stop and ask if the specification has two readings; I run you at reasoning effort high and max is allowed only for a named failure; your knowledge stops before the release date of the runtime, so anything newer must come from the specification or from me. Data limits: the specification and the suite are cleared at the level I state; no credential, personal data or client material leaves my control, and Contributor mode is [on or off] by my decision.
EXAMPLES: One module I wrote by hand from the same specification is the style example, attached, and the acceptance suite's first ten cases are the requirement examples.

Before you use the output, run the check yourself: run the suite from a clean checkout, read every module, and list the specification items the suite does not test before you accept the program. The decision is yours, per CI-First.


What the model does well here: from-scratch construction with an executable judge. The vendor reports ProgramBench results for the series in the same table as its other coding rows, and the benchmark's own design, a clean-room build graded by a hidden suite, is the right shape for this workflow. The model's measured strength is in the work, not in the explanation of the work, which is why the acceptance suite and not the summary is the evidence.


VERIFICATION CHECKLIST for Build a small program against an acceptance suite:


  • ☐ Multi-Model Check: have a second model review the module list against the specification, not the code against itself.

  • ☐ External Source: run the acceptance suite yourself from a clean checkout and compare the pass count with the agent's report.

  • ☐ Human Review: read every module. A program you cannot read is a program you cannot maintain, whatever the suite says.

  • ☐ CI-First Test: can you explain each module and its boundary without the session? If not, the program is on loan rather than owned.

Back to the TOC


Section icon: Strengths, Limits, and AI Imposture Risk.

Muse Wonder Full

Strengths, Limits, and AI Imposture Risk


Strengths


Time


  • Strength. A real saving on hard repository work, and a purchasing shape that removes the per-task budget decision.

  • Evidence. The measured gap over the API sibling is 6.5 points on the same index, 50.08 against 43.57, and the vendor sells the model for work that runs for hours rather than for single answers. A flat plan removes the token arithmetic from every task. Held at 6 by the counter-evidence: the one published matched test of the model inside Muse Code finished four small repository jobs in 26 minutes 39 seconds against 8 minutes 53 seconds for Claude Code with Opus 5.5, and the plan cap, not the model, sets the ceiling on a heavy month.


Quantity


  • Strength. A genuine multiplier on a workflow rather than on a single call.

  • Evidence. Plans are sold at 20x and 80x the Everyday base, the agent runs sub-agents and parallel tool calls, and the 1M-token window holds a repository-scale task in one session. Held at 7 because the multiplier is against an unpublished base and there are no top-ups: volume is available up to a cap nobody can forecast.


Quality


  • Strength. The strongest measured Meta model in this edition, and a real step over the model below it.

  • Evidence. 50.08 at max effort on Artificial Analysis Intelligence Index v5.0.1, 35th of 156, against 43.57 for muse-wonder-1.0 on the same version and the same release date. The vendor states that Full tops DeepSWE 1.1 and SWE-Marathon in independent third-party runs, with Datacurve and Abundant AI named as the result sources in the model card. Held at 7 rather than 8 by the field position, by the hands-on test that found no gain over regular Wonder on small projects, and by the xhigh effort behind the SWE-Marathon row.


Skill


  • Strength. Marginal, and honestly marginal.

  • Evidence. No teaching mode, no pedagogy, no open weights, and a product that produces the change rather than the capability to make it. The clause note returns a null with a boundary rather than a mechanism that transfers skill. The one skill-adjacent behaviour, reporting progress and asking before important actions, is a good habit to observe and is not instruction. Scored conservatively.


Limits


  • There is no API, at any price. Full is reachable only through a Muse Code subscription on Power or Maximum. A team that needs the model inside its own application cannot buy it.

  • There is no per-token price. The $4.00 and $20.00 rates belong to muse-wonder-1.0. A reader who carries them across to Full has priced a different product.

  • The usage meter is unpublished. Meta sells multipliers against a base it describes in prompts on the cheapest plan and does not convert to tokens or to cost per task. A buyer cannot forecast the boundary between Power and Maximum from published data.

  • Contributor mode is the default. Subscriptions start with training rights over the content sent granted in exchange for more usage. Turning it off lowers the allowance by an amount Meta does not publish.

  • The model is not available in South Korea. Muse Wonder and Muse Wonder Full are excluded there, and the rest of each plan still applies.

  • The default reasoning effort is max. The most capable setting is also the most expensive in time and usage, and a reader who never opens the setting is buying the top of the range on every request.

  • No maximum output length is published. There is no figure to plan a long answer against, and no API response ceiling to reason from.

  • The benchmark base moves under the claim. The model card cites Artificial Analysis Intelligence Index v4.3; the current published index is v5.0.1, and Full's position today is 35th of 156. The launch coverage described a model near the top of the field, and the same model is mid-field on the current version without a model change.

  • The long-horizon row is not a max-effort row. The model card states that Muse Wonder Full was reported with xhigh reasoning effort on SWE-Marathon, while the table heading says max.

  • The one published matched test is unflattering on speed. Four small repository jobs took 26 minutes 39 seconds against 8 minutes 53 seconds for Claude Code with Opus 5.5, and the same test found no quality gain over regular Wonder.

  • The safety report is not complete. Meta states that a fuller safety report will be available soon, and the model card records a chemical and biological position that is a boundary rather than a clearance.

  • Windows loses part of the product. Voice input and session messaging are unavailable on Windows, and the sandbox may prompt for administrator approval on first use.

  • No open weights, no self-hosting and no external auditability. Nothing about this model can be inspected from outside Meta's service.


AI Imposture Risk


Time Illusion


  • Rating. Medium

  • Evidence. The saving on hard repository work is real: the plan removes the per-task budget conversation, the model runs long tasks unattended, and the measured gap over muse-wonder-1.0 is 6.5 points on the same index. The overhead is real as well: max effort is the default, a long run consumes allowance rather than a metered bill and therefore hides its own cost, there are no top-ups when the cap arrives, and the one published matched test put the product three times slower than Claude Code with Opus 5.5 on four small jobs. A reader who equates a flat fee with a fixed cost has mistaken a ceiling for a measurement.


Quantity Illusion


  • Rating. Medium

  • Evidence. The product is built to produce volume: sub-agents, parallel tool calls, 1M tokens of context and a 20x or 80x allowance. The failure mode is a large diff that reads as finished and a progress report that reads as verification. The counterweight is real and specific: code is executable, a test suite either passes or does not, and the acceptance suite is the authority rather than the agent's summary. Volume is therefore checkable in this product more cheaply than in a text product, which is why the trap is Medium rather than High.


Skill Illusion


  • Rating. High

  • Evidence. The agent plans, edits, runs commands, verifies its own work and reports its own success, and it produces multi-file changes that a reader who cannot write them is poorly placed to challenge. A flat $50 fee makes the next task feel free, and the agent's own account of what it did is the most fluent document in the session. Mitigations exist and are shipped by default: approvals and an OS sandbox on the first run, a workspace trust decision, an interactive diff, and the proving command the reader can re-run. Those mitigations lower the frequency of failure; they do not move the capability to the reader, which is why the trap stays High.


Overall Imposture Risk: Medium. Two traps are Medium and one is High with identifiable mitigations. Under the framework's arithmetic, one High with clear mitigations stated is Medium rather than High, and the Medium band names this trap set exactly. The band-precedence sentence does not change the outcome, because no second rating competes with it. The rating would move to High if the mitigations were off by default, if the agent could act outside a sandbox without confirmation, or if it wrote the workspace's skills and rules on its own.


Framework v1.2 clause note


Clause 5.2.3-a, agent-authored procedural memory: NULL, recorded with its boundary. The model holds conversation context through Active Memory, which is memory of the task rather than a store of the user's procedures. Muse Code loads a workspace's skills, rules and hooks when the user trusts it, and those are authored by the user or the repository rather than written by the model. No documented mechanism ships by default by which Muse Wonder Full writes skills, memory stores or standing instructions on the user's behalf, so the clause returns a null rather than applying. The live condition is specific: a build that writes or revises the workspace's skills, rules or hooks by default, or an agent that can revise them during a run without a per-write human decision, re-opens this clause at no lower than Medium, and at High where the user has no routine practice of reading what was written. That condition is the eighth re-check trigger.


Clause 4.2-a, agent-mediated conversation: NULL for the model and for its shipped surface. Neither erosion condition is met. Muse Code's check-ins are messages inside the session to the person who started it, not agent-authored text presented as the person's own voice in a human-facing channel, and nothing in the product substitutes agent interaction for human contact. The live condition to watch on any deployment: a pipeline that lets the agent commit, send or publish under a person's identity without that person reading the result first would meet condition (a). Headless mode in CI makes that arrangement easier to build, and it remains a property of the deployment rather than of the model.


Clause 7.5 is not assessed. It was removed from the framework in v1.4, and this review derives no mode, writes no mode line and records no mode value. The two clauses above are the only pedagogical clauses that apply under v1.4.1.

Back to the TOC


Section icon: Section 7c: The plan with no rate, the default that trades data for usage, and a benchmark base that moves under the claim.

Muse Wonder Full

Section 7c: The plan with no rate, the default that trades data for usage, and a benchmark base that moves under the claim


A Section 7c finding is recorded where a supplier's governance, safety record or commercial terms have a real result for the reader. The items below were checked against primary sources, and they produce findings a buyer should carry. All findings are stated as facts of record, and the difference between a company statement, a published evaluation and a policy term is kept intact.


The plan is a ceiling without a meter, and the launch showed what that costs when it fails. Meta publishes four prices, four multipliers and no per-model usage cost. Everyday is described as 10 to 50 prompts every 5 hours, and the higher plans as 5x, 20x and 80x that base. There are no paid top-ups: at the cap a subscriber upgrades or waits, and on Maximum there is only waiting. On launch day, users reported that Muse Wonder and Muse Wonder Full were draining allowances unusually fast. Meta's Chief AI Officer confirmed that Wonder usage was being counted against limits in error, according to Muse Codes' account, and Meta said the issue had been identified and fixed and usage reset, with some users reporting lingering problems afterwards. The finding is not that a launch had a bug. It is that a subscriber had no independent way to know what a task should cost, so the only signal available was the one the vendor controlled. A buyer who needs a forecast should treat the first month as measurement, not as budget.


Contributor mode is a commercial term wearing a settings label. Muse Code subscriptions default to Contributor mode, which gives more usage in exchange for permission to use the prompts, code, files and context sent, and the responses returned, to train future Meta models. It can be turned off from the next request, and the allowance falls by an amount Meta does not publish. Contributor mode is not available to accounts with Zero Data Retention. For an individual, that is a preference with a price. For a team handling client code, it is a data-processing decision that the default has already made, and the unpublished cost of reversing it means the team cannot price the compliant option before purchase. The review records the default, the trade and the missing number, and it does not allege that the default is hidden: it is documented in the subscription terms and in the help centre. The finding is that the compliant configuration has an unknown price.


The benchmark claim is true on its own base and the base is not the one a buyer meets. Three bases move under the headline. First, the scores belong to Full while the published token rates belong to Muse Wonder, so a reader comparing a benchmark row with a price is comparing two products. Second, the model card cites Artificial Analysis Intelligence Index v4.3, and the current published index is v5.0.1: on the current version Full scores 50.08 and sits 35th of 156, below Claude Opus 5.5 at 59.11 and GPT-6.2 Sol at 57.26, while the launch coverage described a model near the top of the field. The model did not change; the instrument did. Third, the model card states that the SWE-Marathon row for Full was reported at xhigh reasoning effort, while the column heading says max. None of those is a false statement. Each is a statement whose meaning depends on a base, and the base is the part a buyer needs.


The safety position is a boundary with mitigations, not a clearance. The model card records that, without mitigations, Meta does not rule out the model reaching the high risk threshold in the Chemical and Biological domain, and that it applies domain-specific mitigations including safety post-training and system-level classifiers. It records the unmitigated model at "moderate or lower" for Cybersecurity and Loss of Control, and the mitigated model at "moderate or lower" across all domains, which supports the deployment decision. The cyber evaluations are strong on the vendor's own numbers: CyberGym 88.4 percent, ExploitBench 58.9 percent, and ExploitGym 20 intended flags after a correction to its evaluation setup on 2026-10-23 that replaced an earlier 21-intended-flag figure. Refusal coverage on the chemical and biological safety evaluations is above 98 percent in English, multilingual and adversarial conditions. A supplier that publishes "we cannot rule it out without mitigations" beside its benchmark table is stating a boundary, and that is the sentence a buyer should carry.


No sub-score changed for these findings, and the reason is explicit. The Time sub-score already carries the cost and waiting shape of a plan with no rate and no top-ups. The Quality sub-score already carries the measured field position and the effort-setting caveats. The Imposture assessment already carries the volume and autonomy risks that an agent hands to a reader who delegates. The items above are a pricing structure with an unpublished unit, a data default with an unpublished reversal cost, a benchmark base that moved with the instrument, and a safety file that is still open. None of them is a resolved failure and none is a defect in the artefact a buyer receives. Section 7c closes with what it does not do: it does not allege misconduct, it does not treat a launch-day metering bug or a changed index version as a scandal, and it does not convert a company's own published caveats into findings against it.

Back to the TOC


Section icon: U365 Co-Intelligence Rating.

Muse Wonder Full

U365 Co-Intelligence Rating


CI-First Profile


Primary profile: Co-Worker and Assistant (level 2). Secondary profiles: Co-Researcher, Analyst and Tester (level 4), Professor, Coach and Tutor (level 3).


Why this profile and not Co-Creator. Meta's positioning does the reasoning. The launch sells the series for complex software engineering and long-horizon agent work, and the product it sells is a terminal agent that plans, edits, runs commands and reports. That is a delegation framing: state the outcome, bound the scope, hand over the run, review what returns. Co-Worker and Assistant is the role the model actually plays. Analyst and Tester is recorded as secondary because the agent verifies its own changes by running commands, and because the work where the model measures best is checkable against a test suite rather than against an opinion. Professor, Coach and Tutor remains reachable at level 3 because the model explains a diff and a call path on request, and it is the weakest of the three readings: nothing in the product is built to move a capability from the model to the person.


CI-First Benefit Score


Time


  • Score (0-10). 6

  • Rationale. Moderate net savings on the work it is sold for. The plan removes per-task budget friction, the model completes long repository tasks unattended, and it measures 6.5 points above its API sibling on the same index. Held at 6 by three facts: max effort is the default, the plan cap rather than the work sets the ceiling on a heavy month, and the one published matched test finished four small jobs in 26 minutes 39 seconds against 8 minutes 53 seconds for Claude Code with Opus 5.5.


Quantity


  • Score (0-10). 7

  • Rationale. A genuine multiplier: 20x or 80x the Everyday base, sub-agents, parallel tool calls and a 1M-token window. Held at 7 because the multiplier is against an unpublished base, there are no top-ups, and the last task before the cap costs the same as the first.


Quality


  • Score (0-10). 7

  • Rationale. The strongest measured Meta model in this edition: 50.08 at max effort on index version 5.0.1, against 43.57 for muse-wonder-1.0, with vendor-reported leadership on DeepSWE 1.1 and SWE-Marathon in third-party runs. Held at 7 by the field position (35th of 156, below Opus 5.5 and GPT-6.2 Sol), by the hands-on test that found no gain over regular Wonder on small projects, and by the xhigh effort behind the long-horizon row.


Skill


  • Score (0-10). 3

  • Rationale. Delegation rather than learning in the common case, with no teaching mode, no open weights and a clause note that returns a null with a boundary rather than a mechanism that transfers capability. Scored conservatively per the framework's guidance.


CI-First Benefit Score: 5.8 / 10 (CI-First Positive)


Why the score sits where it sits


5.8 with sub-scores 6 / 7 / 7 / 3 is a strong quality-and-volume position carrying a moderate time position and a marginal skill position, and both halves of that sentence are deliberate.


Why not higher. Three reasons, each measured. The model is not the measured leader: 50.08 on the current index is 35th of 156, below Claude Opus 5.5 at 59.11 and GPT-6.2 Sol at 57.26, and a buyer paying $50 a month for a frontier claim should know where the claim sits. The delivery limits the benefit: there is no API, no token rate, no top-up and no published usage cost, so the ceiling on a month is set by a meter the buyer cannot read. And the one published matched test found the product three times slower than a competing agent on four small jobs and no better than regular Wonder on quality, which is the specific comparison a Power subscriber is paying for.


Why not lower. The capability step is real and independently measured. Full scores 6.5 points above muse-wonder-1.0 on the same index version and the same day, which is the cleanest available measure of what the upgrade buys, and the vendor's coding claims are specific enough to check, with named third-party result sources. The agent surface is complete: approvals and a sandbox by default, interactive and headless modes, a session protocol for programmatic control, and three platforms. A model that Meta describes as its most capable, delivered through a working agent, at a price an individual can carry, is a positive tool in the framework's terms even when it is not the field leader.


Why 5.8 and not a higher band, stated as arithmetic. Time 6, Quantity 7, Quality 7 and Skill 3 average to 5.75, which rounds to 5.8. That is CI-First Positive, the 4.1 to 6.0 band, and it sits below Meta Muse Spark 1.3 at 6.3 and level with Muse Spark 1.2 at 5.8 on U365's own published readings. The convergence is not an accident: the framework measures benefit to the person net of overhead, and a subscription-only surface charges its overhead in a currency the person cannot convert. The model buys quality and volume; the plan charges for them in time, in an unpublished allowance and in a data default.


What the score does not carry. The four dimensions measure what the reader's work gains. They do not carry the Contributor mode default, the unpublished usage unit, the South Korea exclusion, the index-version change or the open safety report, which is why those sit in Section 7c with an explicit statement that no sub-score changed. They do not carry the clause questions either, which return nulls with boundaries. A reader who wants the score to encode the contract would need a different instrument, and the framework's instrument is the clause note and the 7c finding.


Humics Protection Badge


Creativity


  • Rating. Neutral (0)

  • Rationale. It builds what it is asked to build: applications, interfaces, migrations and tests. The vendor's demonstrations include a playable 3D game and a computer-use task in a browser, and neither originates a direction. A model that produces ten variants leaves the judgement about which one matters with the reader, and the product neither trains nor replaces the user's ideation.


Critical Thinking


  • Rating. Erodes (-1)

  • Rationale. The agent plans, edits, verifies and reports its own work, and the output is a multi-file diff whose correctness is expensive to check. The failure mode is not an obvious error; it is a plausible change that passes the tests the agent chose, a progress report that reads as verification, and a session that ends with the reader accepting the agent's account of what it did. The mitigations lower the frequency and do not reverse the direction: approvals and a sandbox are shipped by default, and a reader who reads the diff is doing the critical work.


Social Authenticity


  • Rating. Neutral (0)

  • Rationale. The model produces code and text inside a terminal session, and clause 4.2-a returns a null for it as a generator. The live condition stays in the record: a deployment that lets the agent commit or send under a person's identity without the person reading the result first moves this dimension, and headless mode makes that arrangement easier to build.


Humics Protection Score: -1 / +3 Badge: Humics-Neutral


Superhuman Usage Guidance


When to invite this tool:


  • Repository work where the end state is checkable: a failing test, a bounded refactor, a dependency migration with a proving command.

  • Long-running work that benefits from an agent holding the plan across many steps, with a reviewer who reads the diff.

  • From-scratch programs with an acceptance suite, where the suite is the authority and the agent iterates against it.

  • Work where the alternative is not a cheaper model but no attempt at all, because a $50 plan changes what an individual is willing to try.

  • Teams already standardised on Muse Code, where Full is a plan step rather than a new tool.


When to keep this tool out:


  • Any workflow that needs an API, a model id or a per-token budget. Full has none.

  • Short interactive work, where a coding agent is more surface than the question needs.

  • Any output that will be merged without a qualified reader seeing the diff. The stronger the agent, the more convincing its own report.

  • A team whose data cannot be used for training and which cannot absorb an unpublished allowance penalty for turning Contributor mode off.

  • A buyer in South Korea, where the model is not sold.

  • Anyone who needs the measured field leader, because on the current independent index Full is not it.


U365 method integration:


  • LIPS + CARE: keep the run record in the Collect phase and the decision in the Action Plan and Review phases. The agent can produce the change and the command output; it cannot own the judgement about whether the change belongs in the product.

  • ULM + EVA: a monthly plan is a recurring cost in the Finance domain, and the decision to hold it belongs in the six-domain plan rather than in a settings page. The Career domain holds the decision about which work is worth delegating. Cost per finished task is CI-First cost engineering, not a ULM method.

  • UP-Context-Engineering: the eight layers are the control surface this product needs, because a stated AI-EXACT-TASK, a bounded FULL-CONTEXT and an EXPECTED-FORMAT-AND-CONSTRAINTS carrying the proving command are what keep an autonomous agent inside the job it was given. The three workflow samples above use the eight layers.

  • UNOP: no direct fit. The model is not built to teach, and its gains come from execution rather than from any pedagogical mechanism.


Over-delegation warning: the failure mode with this product is that a working agent justifies more delegation than the reader can verify. A session that ends with green tests and a clean summary reads as permission to stop reading diffs, and that is precisely the wrong conclusion: the tests prove what the tests assert, and the agent chose which tests to run. The framework's arithmetic is the point: if your Human Intelligence input drops while the Artificial Intelligence term rises, the product falls. A reader who moves multi-file work to an agent because it finishes, and changes nothing about how much of the diff a qualified person reads, has taken the product's worst offer.

Back to the TOC


Section icon: What Users Say.

Muse Wonder Full

What Users Say


Aggregate Rating Table


Platform

Rating

Number of reviews

Link

Artificial Analysis

50.08 on Intelligence Index v5.0.1 at max effort, 35th of 156; no time or cost per task because there is no public API; 112M output tokens across the index run against a 77.5M median

Independent benchmark, not a user rating

Kingy.ai, matched hands-on test

Four repository jobs finished 4 of 4 in 26 minutes 39 seconds; Claude Code with Opus 5.5 finished 4 of 4 in 8 minutes 53 seconds; Codex in 19 minutes 5 seconds. No quality gain for Full over regular Wonder on the small project trials

A published four-job test, run once per system

Muse Codes (community publication)

Plan table, Contributor mode default, and a launch-day allowance bug confirmed by Meta's Chief AI Officer and reported fixed with usage reset

Secondary reporting, not a rating

Hacker News, launch thread

672 points and 385 comments on the launch day

Not a rating platform

G2

No listing for the model

Not applicable

Not applicable

Capterra

No listing for the model

Not applicable

Not applicable

Trustpilot

No listing for the model

Not applicable

Not applicable


Note on method, stated plainly because it affects how much this section is worth. No review platform rates an individual language model. No G2, Capterra or Trustpilot listing for this model exists, and none is reproduced here. The meaningful signals for a subscription model are the independent index, the published hands-on tests that name their tasks and their times, the terms that decide what a plan includes, and the practitioner thread on the announcement. That is what this section reports, and where a platform's content was reached at platform level rather than read thread by thread, no quotation and no count is attributed to it.


What Users Praise


Three themes dominate, and the first is the one the measurements settled fastest.


The capability step is real, and it is the largest step Meta has shown within a single release. The two models shipped together, and Full measures 6.5 points above its sibling on the same index version. The launch thread's most-upvoted comment is a reversal of expectations rather than a technical claim, and it captures the surprise: a reader wrote that they had not been familiar with Meta's game, and that second place on the independent index behind Claude Opus 5.5 was not bad at all. The measured comparison behind that reaction is in this review: 50.08 for Full against 43.57 for the model below it and 59.11 for the model above it. A first frontier release that lands between its own sibling and the field leader is a genuine step.


The coding claim is specific enough to check. Meta states that Full tops DeepSWE 1.1 and SWE-Marathon in independent third-party runs, and the model card names Datacurve and Abundant AI as the sources for those rows. Readers who work in repositories responded to that specificity rather than to the composite score, and the agent surface drew the same reaction: a terminal agent with approvals and a sandbox is the shape developers already trust.


The plan changes what an individual attempts. The most practical praise is about access rather than quality. At $50 a month, a developer can put a frontier-class model in front of a hard repository task without a per-task budget decision, and the 20x allowance is enough for a working month. That is a real gain in the number of hard tasks a single person starts, and it is the gain the price is designed to buy.


What Users Complain About


Three complaints recur, and the first is about the meter rather than the model.


The allowance was not trustworthy at launch. On launch day, users reported that Muse Wonder and Muse Wonder Full were draining plan allowances unusually fast. Meta's Chief AI Officer confirmed that Wonder usage was being counted against limits in error, according to Muse Codes' account, and Meta said the issue had been fixed and usage reset. Some users reported lingering problems afterwards. The complaint is not that a launch had a bug; it is that a subscriber had no independent way to know what a task should cost, so the only available signal was the vendor's own meter.


The identity of the products is genuinely confusing, and readers caught it. One comment on the launch thread edited itself into the clearest statement of the problem: the benchmark scores for Muse Wonder on the marketing page are actually for Muse Wonder Full, which is only on the higher-tier plans, while the published token price is for Muse Wonder. Another reader put the availability fact in one sentence: only Muse Wonder is available in the API. Both are describing the same defect in the launch material, and this review's naming section exists because of it.


The coding product has rough edges, and the effort base drew criticism. One developer who paid for a month wrote that the sandbox never worked across Mac or Linux on stock installs. Another asked, of the benchmark table, why the models were all tested at max effort, which is the same base problem the model card's xhigh SWE-Marathon note records from the vendor side. And the benchmark-maxxing question appeared early and plainly: a reader asked how much benchmark-maxxing had been done, which is the right question to ask of any launch table and the reason this review separates vendor rows, third-party rows and the composite.


Sentiment Summary


Overall sentiment: Positive on capability and on the price of access, critical of the allowance and its metering, of the identity mix-up between the two models, and of the gap between a benchmark table run at max effort and a working month.


Key themes: a real frontier step for Meta, the strongest model the company has published, delivered through a complete terminal agent at a plan price; a usage meter nobody outside Meta can convert; a data default that trades training rights for allowance; and a product whose headline scores belong to the variant that has no API.


U365 Editorial Note


The model's own record argues in two directions at once, and a reader should hold both. On the positive side, 50.08 at max effort on the current independent index, 6.5 points above the API sibling on the same version, vendor-reported leadership on two coding benchmarks with named third-party sources, a 1M-token window, and an agent surface with approvals and a sandbox by default are the behaviours that make the $50 step worth considering. On the negative side, the model is 35th of 156 on the composite, below two named competitors; the one published matched test found it three times slower than a competing agent and no better than the cheaper sibling on small projects; and the plan that carries it publishes no usage rate. The Framework rates AI Imposture Risk Medium overall with Skill Illusion High, and that rating is the editorial position: Muse Wonder Full is an agent to build with, provided a qualified person reads the diff and runs the proof. A reader who wants a lower rating is asking for a different product, not a different review.

Back to the TOC


Section icon: Comparison and Alternatives.

Muse Wonder Full

Comparison and Alternatives


Model or product

Position

Independent evidence

Commercial shape

Choose it if

Muse Wonder Full

Meta's strongest model, sold only inside Muse Code

50.08 at max effort on index version 5.0.1, 35th of 156; 6.5 points above muse-wonder-1.0 on the same version; vendor-reported leadership on DeepSWE 1.1 and SWE-Marathon in third-party runs

Muse Code subscription only, $50 Power Usage or $200 Maximum Usage; no API and no token rate

Your work is repository-scale, you can read a diff, and a flat plan fits how you buy

Muse Wonder (`muse-wonder-1.0`)

The API sibling and the model on every plan

43.57 on the same index version and the same release date; 3,000 requests and 4,000,000 tokens per minute; Standard mode only at $4.00 input, $0.20 cached input and $20.00 output per million tokens

Pay-as-you-go API, and included on every Muse Code plan from $5

You need an API, a token budget you can compute, or the cheaper route to most of the same work

Claude Opus 5.5

The measured field leader among the models compared here

59.11 on the same index version; the model a competing agent used to finish the four-job test in 8 minutes 53 seconds against Full's 26 minutes 39 seconds

Sold by Anthropic on its own terms, with its own agent product

Your work is short and interactive, or measured quality and agent speed dominate the plan economics

GPT-6.2 Sol

The other model above Full on the current index

57.26 on the same index version

Sold by OpenAI on its own terms, with its own agent product

You want a measured quality edge over Full and are already inside OpenAI's tooling

Muse Spark 1.3

The cheaper Meta model, and the one U365 already reviewed at 6.3

U365's published score is 6.3, CI-First Strong; API rates of $1.25 input, $0.15 cached input and $4.25 output per million tokens

API and Muse Code, including the $5 plan

Your work is bounded and high volume, and Full's frontier premium is not what the task needs

Muse Ember 1.0

The execution model in the same line

Priced at $0.10 input, $0.004 cached input and $0.50 output per million tokens up to 200K input tokens, rising to $0.30, $0.012 and $1.50 above that

API, Standard mode only

You are running sub-agent volume, routing or bulk processing under a stronger planner


The comparison that matters most is not in the table. Meta sells a line, not a ladder, and the measurements do not form one. Full is the model Meta describes as its most capable, and it measures 6.5 points above muse-wonder-1.0 on the independent index, while Muse Spark 1.3 sits at U365's 6.3 because the framework measures benefit net of overhead rather than raw benchmark position. A buyer choosing inside the Meta line is choosing between a plan, an API and an agent, and the model score is only one of the three variables. A buyer choosing between Meta and Anthropic or OpenAI is choosing between an agent surface that is included in a plan and one that is sold separately, and the independent index places Full below both competitors named here.


On U365's own published readings, the Meta line lands in a narrow band. Muse Spark 1.3 is 6.3 (CI-First Strong), Muse Spark 1.2 is 5.8 (CI-First Positive), and Muse Wonder Full is 5.8 (CI-First Positive). The scores converge because the framework charges each product for its overhead: Spark 1.3 buys a cheaper route with a lower measured ceiling, and Full buys a higher measured ceiling with a subscription, an unpublished allowance and a default data setting. Neither is ahead by a margin the framework treats as decisive.


Choose Muse Wonder Full if your work is repository-scale, a test suite can prove the change, a qualified person reads the diff, and a $50 plan is easier to carry than a token budget. Choose `muse-wonder-1.0` if you need an API, a computable cost, or the cheaper route to work that does not need the last 6.5 points. Choose Claude Opus 5.5 or GPT-6.2 Sol if the measured composite and agent speed are the deciding facts. Choose Muse Spark 1.3 if your volume is high and bounded and U365's 6.3 is the better fit for the work. Choose Muse Ember if you are buying execution volume under a stronger planner. Stay on High rather than Power if you have not yet measured a task where regular Wonder fails, because that failure is the only published reason to pay for Full.

Back to the TOC


Section icon: Verdict and Next Steps.

Muse Wonder Full

Verdict and Next Steps


Verdict: Muse Wonder Full is Meta's most capable model by its own account and a working agent to build with, and the plan that carries it asks the buyer to accept a ceiling instead of a meter and a data default instead of a decision.


At 5.8 / 10, CI-First Positive, with sub-scores 6 / 7 / 7 / 3, it is the model Meta describes as its most capable, it measures 6.5 points above its API sibling, and it carries the same score as Muse Spark 1.2 on U365's reading. That combination is the point: the capability step is real and independently measured, and the commercial shape caps the benefit the framework can credit. A model that measures 6.5 points above its own sibling, delivered through a complete terminal agent, at $50 a month, is a positive tool. A model that cannot be bought through an API, whose usage unit is unpublished, and whose subscription defaults to training rights over your code, is a positive tool with three conditions attached.


Adopt it if your work is repository-scale, your team can read a diff, a proving command exists, and the data owner has decided about Contributor mode. Do not adopt it as a replacement for an API model in your own product, a way to forecast cost per task, a reason to stop reviewing changes, or a claim to the measured field lead.


The three things to do in the first week:


  • Measure one month before you budget one. Record the task, the proving command, whether it passed first time, and the minutes you spent reading the diff. Meta publishes no per-model usage cost, so your own record is the only cost-per-task figure you will have. Decide between Power and Maximum on that record, not on the multiplier.

  • Make the data decision before the first commit. Read the Contributor mode row in /settings with whoever owns your client confidentiality obligations, decide, and write the decision down. Turning it off lowers the allowance by an amount Meta does not publish, so the first month is also the measurement of that cost.

  • Name the reviewer before you name the task. If a multi-file change has no one qualified to read the diff, the agent's measured quality is a reason to stop rather than a reason to proceed.


UP-Context prompt packs: the three samples are in Real Workflows, one per workflow, each in the UP-Context-Engineering Method's eight layers and each followed by the check the reader runs before using the output.


What would change this verdict. Full appearing on the Model API with a published rate, a published usage cost per model inside the plans, a change to the Contributor mode default, a successor that moves Full down the line, a new index version that moves the field position materially in either direction, or a full safety report that contradicts the model card's boundary. The re-check triggers at the end of this review name each one.

Back to the TOC


Section icon: Status and Last Tested.

Muse Wonder Full

Status and Last Tested


Status: Active | Last tested: 2026-11-19 | Version tested: Muse Wonder Full (`muse-wonder-full-1.0`, released 2026-10-12)


Active: the tool is current and recommended.


The model was released on 2026-10-12 and this review was written against the vendor's models page, the Muse Wonder documentation, the Muse Code documentation, the subscription page and help centre, the pricing page, the launch post, the model card and its PDF, the terms of service and the acceptable use policy, the Artificial Analysis model page, one published matched hands-on test and the launch-day practitioner thread. The scores are set on that evidence and on the framework's application rules. The re-check is trigger-based with a six-month outer limit, and the first trigger is the plan price, because the cost case in this review is a fee and a cap rather than a rate.

Back to the TOC


Section icon: Migration Path.

Muse Wonder Full

Migration Path


Not applicable. Muse Wonder Full is Active, not Retired, Deprecated or Risky, so this review carries no migration plan.


If you are moving a workload onto it, the practical changes are these. From Muse Spark 1.3 inside Muse Code: select Full from the /model picker on a Power or Maximum plan, because no CLI model id is published for it. From the API sibling muse-wonder-1.0: there is no migration path for a script, because Full has no API; the workload has to move into Muse Code or stay on the API model. From High to Power: the upgrade is prorated and takes effect immediately, and the reverse applies from the next billing cycle. From Contributor mode on to off: the change applies from the next request and lowers the allowance by an unpublished amount, so treat the first week after the change as a measurement. That is a configuration change rather than a migration away from a tool, and this review does not treat it as one.

Back to the TOC


Section icon: U365's Recommendations to Learn More.

Muse Wonder Full

U365's Recommendations to Learn More


Start with the primary documents, in this order


Read the models page first, because it is the only page that shows both variants, both commercial shapes and the model id beside the subscription row in one view. Then read the Muse Wonder documentation page, which states the availability table and the sentence that matters most: setting effort to max on muse-wonder-1.0 does not select Full. A reader who starts with the launch post will meet the benchmark table before the commercial shape, and the launch post does not carry the prices.


Then read the model card, including the parts that are not flattering


The model card is where the limits live: the release date, the 1M context, the modalities, the chemical and biological boundary that cannot be ruled out without mitigations, the cyber results including the corrected ExploitGym figure, the loss-of-control evaluations, and Meta's statement that a fuller safety report will be available soon. It is also where the effort base of the benchmark table is recorded: the SWE-Marathon row for Full was reported at xhigh effort. Those facts are worth more than any single benchmark row because they tell you where the model will fail and what the supplier has not yet published.


Then read the two commercial documents, because the plan is the product


The subscription help page carries the four prices and the four multipliers, the South Korea exclusion, and the Contributor mode default in one place. The Muse Code documentation carries the agent's defaults: approvals and the OS sandbox on from the first run, the workspace trust decision, the headless mode and the session protocol. A buyer who reads only the model page has read the capability half of the purchase.


Resources on X


The Meta AI account image on X, where the Muse Wonder launch material was published

Dedicated X channels: the Meta AI account carries the launch material and the demonstrations, and the research account carries the benchmark framing. The practitioner threads that follow a launch are the fastest read on what the product does in public, and they are where the metering complaints appeared first.


U365 courses and programmes that build the surrounding skill


  • UIT (Technology, AI, Data Science): the engineering track where agent supervision, repository-scale reasoning and acceptance testing belong.

  • UIB (Business Management, Entrepreneurship): the commercial track where a subscription, a cap and a data default are analysed as terms rather than as settings.

  • UID (Digital Design, UX/UI): the design track where computer-use output and design-to-code are judged against a brief rather than against a screenshot.


The one habit to carry


Keep a proof you own in every run, and name it before the agent starts. A test you can re-run, a build that either passes or does not, a page that renders. Muse Wonder Full is capable enough that the proof will feel unnecessary, and the plan is priced so that the next task feels free. Those two feelings are the Time and Skill illusions arriving together, and the proof is the answer to both.


Related viewing: Theo on t3.gg tests Muse Wonder Full against Claude Opus 5.5 and GPT-6.2 Sol on real repository work, 38 minutes.


Back to the TOC


Section icon: CI-First Evaluation Summary Card.

Muse Wonder Full

CI-First Evaluation Summary Card


Field

Value

Tool

Muse Wonder Full (muse-wonder-full-1.0), Meta Platforms, Inc.

Category

Applied AI / Frontier coding and agentic model, subscription-only through Muse Code

CI-First Benefit Score

5.8 / 10, CI-First Positive

Sub-scores

Time 6 / Quantity 7 / Quality 7 / Skill 3

CI-First Profile

Primary: Co-Worker and Assistant (level 2). Secondary: Co-Researcher, Analyst and Tester (level 4), Professor, Coach and Tutor (level 3)

Humics Protection

Humics-Neutral (-1 / +3). Creativity 0, Critical Thinking -1, Social Authenticity 0

AI Imposture Risk

Medium overall. Time Medium, Quantity Medium, Skill Illusion High

Framework v1.2 clauses

5.2.3-a null with boundary, 4.2-a null with live condition

Status

Active

Last tested

2026-11-19

Version tested

Muse Wonder Full, released 2026-10-12

Pricing

Muse Code subscription only: Power Usage $50.00 a month (20x the Everyday allowance) or Maximum Usage $200.00 (80x). No API, no per-token rate, no top-ups

Independent position

50.08 at max effort, Artificial Analysis Intelligence Index v5.0.1, 35th of 156

Primary institute

UIT (Technology, AI, Data Science)

Review status

Active: the tool is current and recommended

Back to the TOC


Section icon: Glossary.

Muse Wonder Full

Glossary


CI-First Benefit Score


The arithmetic mean of the four benefit dimensions, each scored 0 to 10, rounded to one decimal place. 0 to 2.0 is CI-First Negative, 2.1 to 4.0 is CI-First Neutral, 4.1 to 6.0 is CI-First Positive, 6.1 to 8.0 is CI-First Strong, and 8.1 to 10 is CI-First Transformative. Muse Wonder Full scores 5.8, which is Positive.


Time Benefit


Whether the tool returns more time than it costs, after the overhead of using it is subtracted. Muse Wonder Full is 6: a plan that removes the per-task budget decision, long repository tasks completed unattended, and a 6.5-point measured gap over its API sibling, against max effort as the default, a plan cap that sets the ceiling, and a published matched test in which the product took 26 minutes 39 seconds on four jobs where a competing agent took 8 minutes 53 seconds.


Quantity Benefit


Whether the tool increases the volume of usable work a person can produce in a given time. Muse Wonder Full is 7: 20x or 80x the Everyday allowance, sub-agents, parallel tool calls and a 1M-token window, against a multiplier measured from an unpublished base and no paid top-ups at the cap.


Quality Benefit


Whether the tool helps the user produce better work than they could alone, judged after verification rather than on surface polish. Muse Wonder Full is 7: 50.08 at max effort on index version 5.0.1 against 43.57 for the model below it, and vendor-reported leadership on DeepSWE 1.1 and SWE-Marathon in third-party runs, against a 35th-of-156 field position, a hands-on test that found no gain over the cheaper sibling on small projects, and an xhigh effort behind the long-horizon row.


Knowledge and Skill Benefit


Whether the tool helps the user learn what they did not know and do what they did not know how to do. Muse Wonder Full is 3, scored conservatively: it plans and executes rather than teaches, it has no teaching mode, there are no open weights, and the clause note records a null with a boundary rather than a mechanism that transfers capability.


Humics Protection Badge


The sum of three ratings, each +1, 0 or -1, across Creativity, Critical Thinking and Social Authenticity. +2 to +3 is Humics-Friendly, -1 to +1 is Humics-Neutral and -2 to -3 is Humics-Risky. Muse Wonder Full scores -1, which is Humics-Neutral: it neither strengthens nor systematically destroys the three capabilities, and it requires the reader to keep the critical habit that a fluent agent discourages.


AI Imposture Risk


The likelihood that the tool traps its user in one of three illusions: the Time Illusion, where the overhead exceeds the saving; the Quantity Illusion, where volume passes for quality; and the Skill Illusion, where the user believes they can do what the tool did. Each trap is rated Low, Medium or High. Muse Wonder Full is Medium overall, with Skill Illusion High and the other two Medium.


User Sentiment


The direction of independent and practitioner reaction to the tool, read from what testers and users actually reported rather than from a rating average, because no review platform rates an individual model. Muse Wonder Full is positive on the capability step and on the price of access, and critical of the allowance and its metering, of the mix-up between the two model names in the launch material, and of the gap between a benchmark table run at max effort and a working month.


CI-First Profile


The role the AI plays in the working relationship: Co-Creator and Thought Partner (1), Co-Worker and Assistant (2), Professor, Coach and Tutor (3), Co-Researcher, Analyst and Tester (4), or Challenger, Critic and Devil's Advocate (5). Muse Wonder Full is primarily Co-Worker and Assistant, with Analyst and Tester and Professor, Coach and Tutor as secondary roles.


Review Status


The badge on this review states how much confidence to place in it. The vocabulary: Active means the tool is current and recommended. Active (updated) means it is current and recommended and was recently re-checked and refreshed. Changed means a re-check trigger fired and an update is pending, so read it with that in mind. Risky means the tool has significant unresolved issues or has been clearly surpassed by newer alternatives, so use it with caution and read the Limits section. Stale means the review has not been re-checked in over six months, so treat pricing and features as unverified. Retired means the tool still works but is no longer recommended, and Deprecated means it has been shut down or fundamentally changed. This review is Active.


Last tested and Re-check


The date on which the review's evidence was last read against the vendor's own surfaces, and the condition under which it will be read again. This review was last tested on 2026-11-19 and is re-checked on a trigger list with a six-month outer limit, because a plan price, a usage rule and an index version move faster than a calendar interval can track.

Back to the TOC


Section icon: Sources.

Muse Wonder Full

Sources


Vendor primary sources:



Independent measurement and published tests:



Secondary reporting and community:



U365 internal reference:


U365 CI-First Evaluation Framework v1.4.1 (URC methodology)

Back to the TOC


Section icon: Faculty Note on Evidence Quality.

Muse Wonder Full

Faculty Note on Evidence Quality


What this review rests on, in order of weight. First, the vendor's own primary documents: the models page, the Muse Wonder and Muse Code documentation, the subscription page and help centre, the pricing page, the launch post, the model card and its PDF, and the two governing terms. Second, one independent evaluator that publishes its method and its version: Artificial Analysis, whose index page carries the score, the version, the effort setting and the field position. Third, one published matched hands-on test whose tasks and times are named. Fourth, practitioner discussion on the launch day, which is used for sentiment and for three specific reports and never for a capability claim. No number in this review is attributed to a page whose content could not be read.


Where the vendor's numbers and the independent numbers meet, and where they part. They meet on the direction of the release: Full is the strongest model Meta has published, it is a real step above muse-wonder-1.0, and it is a capable coding agent. They part on the size and the base of the claim. Meta's coding claim is benchmark-specific and sourced, and it is supportable on the two rows it names. The composite position is not leadership: 50.08 is 35th of 156 on the current index, below Claude Opus 5.5 and GPT-6.2 Sol. A reader who takes "state of the art" from the launch post and "35th" from the index has taken two true sentences about two different things. The review states both and lets the reader hold them together.


The index version is the recurring problem in this launch's coverage. The model card cites Artificial Analysis Intelligence Index v4.3; the current published index is v5.0.1. Launch coverage reported Full near the top of the field, and the same model sits mid-field on the current version. Neither reading is wrong at its date. A composite index changes its component evaluations and its field, and a rank is a statement about a version as well as about a model. The framework's discipline is to state the version and the effort setting beside the score, which is why the 50.08 figure in this review always appears with v5.0.1 and max effort.


What is measured and what is inferred. The index score, the field position, the verbosity figures, the plan prices, the multipliers, the context window, the modalities and the safety results are measured or published by named parties and reported with their settings. The claim that Full is the right model for repository-scale work with a reviewer who reads the diff is an interpretation of those measurements against the work the model is sold for, and it is the interpretation this review defends. The claim that a reader will over-delegate is an inference from the framework's model of human behaviour, supported by the agent's autonomy and the fluency of its reports rather than by a controlled study, and it is labelled as an inference wherever it appears.


Two findings cut in the vendor's favour and should be said as plainly as the rest. Meta publishes its safety boundary in the same document as its benchmarks, naming the chemical and biological position it cannot rule out without mitigations rather than leaving it to a footnote. And it names the third-party result sources for the coding rows where it claims leadership, which lets a reader check the claim instead of taking it. A supplier that states its boundaries and its sources has done the reader a service, and this review records it.


What this review does not do. It does not score muse-wonder-1.0, which has its own price and its own review path. It does not score Muse Code as a separate product, because the model cannot be reached without it and separating the two would produce a score for a surface nobody buys alone. It does not treat a launch-day metering bug as a permanent defect, or a changed index version as a decline in the model. And it does not convert a benchmark row into a promise: a model that tops a long-horizon coding benchmark will still produce a change that a qualified reader has to correct, and the reader who plans for that is the reader the framework is written for.



Section icon: Status and Re-check.

Muse Wonder Full

Status and Re-check


Re-check triggers:


  • Any change to the Power Usage or Maximum Usage price, or to the 20x and 80x usage multipliers. The whole cost case for this model is a monthly fee plus an allowance, and both halves of that sentence can move without a model change.

  • Muse Wonder Full appearing on the Meta Model API, or any per-token rate being published for it. Today there is no API route and no token price, which is the fact that decides who can buy the model at all.

  • A change to the default Contributor mode, or a published figure for the allowance lost by turning it off. The default trades content for usage, and the size of that trade is not published.

  • A new Artificial Analysis Intelligence Index version, or a re-run at a lower reasoning effort. The 50.08 figure in this review is index version 5.0.1 at max effort; the model card cites version 4.3, and the two are not comparable.

  • A successor model, a retired model id, or a change to where Full sits in the Muse line. The line already carries Muse Spark 1.3, Muse Wonder and Muse Wonder Full, and the position of Full inside it is the part most likely to move next.

  • Publication of the full safety report. Meta states that a fuller report will be available soon, and the model card records a chemical and biological position that is a boundary rather than a clearance.

  • Any change to the South Korea exclusion, or to any other regional restriction on Muse Wonder and Muse Wonder Full. A subscription benefit that is not sold in a country is a purchasing fact rather than a detail.

  • A Muse Code build that writes skills, rules or procedural memory into the workspace by default. The clause note records a null with a boundary, and that boundary is the condition which would end it.


Comments

Rated 0 out of 5 stars.
No ratings yet

Add a rating
Image by Erik  Lucatero

Become Superhuman

Master AI to stay irreplaceable in every field.

 

 

 

​

​

Apply for Admission Today.
Select Your Initial Access Level.


Become a DISCOVERY, INSIDER, or SUPERHUMAN Fellow.

Image by Milad Fakurian

Master Your Life with a Digital Second Brain

Turn overwhelm into clarity with LIPS + CARE
U365’s unique framework to organize your goals, projects, and knowledge into a superhuman system for success

bottom of page