Muse Wonder Active Memory & Active Focus Guide

Last updated: October 16, 2026

Meta launched the Muse Wonder series on 12 October 2026 — the models Meta calls its most capable to date, built on the groundwork of Muse Spark. Two features got top billing: Active Memory and Active Focus. They sound like magic. They aren’t, quite — but for anyone building agents, they are the two most useful knobs Meta has shipped this year. This is the practical guide: what the features actually do, which model gives you what, and how to use them in your own builds without falling into the traps early testers have already found.

Quick answer: Muse Wonder Active Memory carries your context across conversations; Active Focus keeps agents pushing through blockers. How to use both — IDs, access, stores, safety gates.

What Active Memory and Active Focus actually do

Meta’s own product language, as read from the research post and model card, is refreshingly plain:

Active Memory — carry what matters about you across conversations, and retrieve the bits that are relevant to the current task. Not “dump the whole history into the prompt and hope.”

Active Focus — keep pushing on a hard goal: try alternative approaches, work through blockers, ask when stuck, and check in before consequential actions.

The first fixes the oldest complaint about AI assistants: having to repeat your preferences, requirements and background every session. The second fixes the oldest complaint about AI agents: dying at the first failed test instead of debugging like a person would. Meta says it measures focus with a benchmark called FocusBench and long-horizon execution with SWE-Marathon — a software-engineering marathon that tests whether a model keeps working on real projects over extended sessions.

One honest note before we go further: these are Meta’s framings, and independent verification of how well they hold up is still thin. The most detailed public account of actually calling the models comes from AI engineer YongBo Yu’s first-call notes, published on dev.to on 13 October 2026 — and this guide leans on those notes plus Meta’s launch materials. We have not run Wonder ourselves.

Which model has them — and the access split that trips people up

There are two models, and the split between them is deliberate — and it is already catching people out:

Muse WonderMuse Wonder Full
Where you get itMeta Model API + Muse CodeMuse Code subscription only (Power and Maximum Usage tiers)
API model IDmuse-wonder-1.0Not on the Model API
Context1M tokens (1,048,576)1M
Inputs / outputsText, image, video, audio in; text outSame family
Pricing$4 input / $0.20 cached input / $20 output per 1M tokensIncluded in Muse Code quotas — no public per-token meter

The trap: cranking reasoning_effort to “max” on muse-wonder-1.0 does not promote you to Wonder Full. If your eval harness hard-codes “use max reasoning to get the best Muse,” you are still on Wonder for API traffic. For Full you need Muse Code on Power or Maximum Usage — compare apples to apples when you see win-rate charts on social media.

The good news for builders: the API is OpenAI-SDK-compatible at https://api.meta.ai/v1, and Meta’s docs say Wonder and Spark take the same request shapes — any Spark example becomes a Wonder call by changing the model string. Meta’s positioning: Wonder for longer, harder agent loops; Spark stays the cheaper default.

Two more facts worth knowing: neither Wonder model ships with publicly downloadable weights — that is the closed-weights path, in contrast to this week’s open-weight Muse Spark Open. And Meta says the Wonder models will soon power experiences inside its Muse personal agent, starting with subscribers, plus artifact generation.

How to use Active Memory (it won’t remember on its own)

Here is the single most important thing to understand about Active Memory: it is not free durability. The research framing is “carry important context across conversations and retrieve what matters” — but in your own agent, a stateless Chat Completions call does not remember last month’s lease PDF just because the model is Wonder. You still need three things:

  1. A store — somewhere durable facts live (a vector database, a file, a notes table).
  2. A write policy — rules for what the agent saves after each session.
  3. A retrieve policy — rules for what it fetches back when a new task starts.

The model’s job in this setup is narrower and more useful: deciding what to write and what to fetch. A practical pattern from the first-call notes: keep memory writes separate from the chat transcript entirely, and log what the agent decided to remember, so you can audit it later. In the developer’s example call, the steering message was simply “Be concise. Ask before irreversible actions” — and the first test question asked the model to sort durable memory from turn-only context in five bullets.

Two API details from Meta’s docs that are easy to miss: prefer the developer role over system for steering (system still appears in old OpenAI snippets), and do not send stop, logit_bias, or reasoning_effort: "none" — reasoning Muse models return HTTP 400 on those.

How to use Active Focus (give it guardrails, not freedom)

Active Focus is an agentic loop, not a setting. In practice it looks like this: interpret the objective → plan and act → observe the result → detect errors or missing information → revise the approach and continue → verify before reporting done. Coding is where Meta claims the two features meet: multi-file edits, long test-and-fix cycles, sub-agents, computer use.

Where it shines is exactly where agents have always died: the third turn of a hard job. Where it burns is equally clear — Active Focus keeps trying, which is good for long software tasks and terrible for rm, payments, and outbound email. An agent that keeps retrying without learning can waste resources or repeat harmful actions.

So the practical rules:

The 4-point checklist before you build on Wonder

Distilled from the launch materials and the published first-call notes, here is the pre-flight we would run:

  1. Confirm the model ID. muse-wonder-1.0 on the Model API; Wonder Full only inside Muse Code. “Max” is not an upgrade path.
  2. Bring your own memory store. Write policy plus retrieve policy, kept outside the transcript. If you can’t point to where memories live, you don’t have Active Memory — you have a long prompt.
  3. Gate consequential actions. Human confirmation for anything irreversible. Persistence without judgment is a liability.
  4. A/B against Spark before migrating. Change only the model string, keep tools identical, and measure on your own task. Wonder is priced for longer, harder loops — make sure yours are.

What the features can’t do yet

The model card, as summarised in the first-call notes, lists visual and 3D spatial work as a known weakness — harness and quantization change results too. The models are not intended for under-18 use. And the full safety evaluation report was still pending at launch, so treat the safety story as incomplete for now.

On benchmarks: Artificial Analysis put Wonder Full at 56 and standard Wonder at 52 on its Intelligence Index versus 58 for Claude Opus 5.5; Meta’s own SWE-Marathon number was 57.5% against 46.3% for Opus — Meta’s own test, so vendor-side. A market analysis this week cited Meta-reported 83.2% on an accounting benchmark against 61.4% for the prior Muse Spark 1.1. Directional, not gospel — especially the vendor-run numbers.

The cost check

At launch pricing, Wonder is $4 per million input tokens, $0.20 for cached input, $20 per million output tokens. One published illustration (not a bill): 50,000 calls of 4,000 prompt tokens and 800 completion tokens works out around $1,600 at list — but caching 3,500 of those 4,000 prompt tokens drops a single call from about $0.032 to about $0.019. The lesson: prompt caching starts mattering the moment your agent’s system prompt and tool schemas stop changing every request.

Wonder Full plays by different economics entirely: Muse Code Power / Maximum Usage quotas, not a public per-token meter. Check your usage bar before a weekend marathon — launch-day quota bugs reportedly got a Meta reset.

Should you switch from Muse Spark?

Your situationStay on SparkMove to WonderConsider Wonder Full
Short chats, simple tasksYes — the cheaper defaultOverkillOverkill
Long multi-session agent workYou’ll feel the context lossYes — this is its jobIf you’re on Muse Code anyway
Heavy coding / computer-use loopsTry Wonder firstYesYes, for the hardest jobs
Tight per-call budgetYesDo the caching maths firstCheck quota headroom

Our take: Wonder is Meta’s clearest “personal agent” bet — the same model family behind the consumer Muse app and a developer API. For builders, the useful part is boring: an OpenAI-compatible base URL, a stable model ID, a documented Full/API split, and two named behaviors you can design around. Measure them yourself before you migrate anything that matters.

Frequently Asked Questions

Does setting reasoning effort to “max” give me Wonder Full?

No. On the Model API, muse-wonder-1.0 with max effort is still Wonder. Wonder Full is only available inside Muse Code on Power or Maximum Usage subscriptions — there is no API model ID for it.

Is Active Memory automatic when I call the API?

No. API calls are stateless. Your application has to implement the memory store, the write policy (what gets saved) and the retrieve policy (what gets fetched back). The model helps decide what to remember — it does not remember for you.

Will Active Memory and Active Focus come to the consumer Muse app?

Meta says the Wonder models will soon power experiences inside its Muse personal agent, starting with subscribers, and will also power artifact generation. No dates have been announced.

Is it safe to let Active Focus handle payments or delete files?

No. Active Focus is designed to keep trying, which is exactly wrong for irreversible actions. Meta’s own model card recommends human-in-the-loop confirmation for those — keep a person in the loop for payments, deletions and outbound messages.

How is Active Memory different from just a bigger context window?

A bigger context window stuffs more into one prompt. Active Memory is selective: the agent carries what matters across separate conversations and retrieves only the relevant bits for the current task. You still design the store, the write policy and the retrieval.

Sources and Methodology

Method: desk research conducted 16 October 2026. Meta’s launch claims are labelled as Meta’s; vendor-reported benchmarks are labelled as such; nothing here is hands-on tested by us. Pricing and access details are launch figures and may change — verify against Meta’s current pricing page before building.

Have a burning question about this topic?
Feel free to email us at contact@openaimaster.ai — we are happy to help!