Muse Wonder Active Memory: What Meta Has Shown So Far

Meta released Muse Wonder and Muse Wonder Full on October 12, 2026, which TechCrunch calls its first frontier models. The launch post leads with Active Memory, which Meta says carries user context from one conversation to the next. If you build agents, read it closely. Whatever the model remembers is something your app no longer has to store. Three weeks after launch, Meta's pages still do not say how it works or where the memory lives. The evidence Meta offers is MemoryBench, a test it built itself.

What is Muse Wonder Active Memory, in one sentence?

Active Memory is Meta's name for the Muse Wonder models carrying important user context across conversations and recalling the details a task needs.

That sentence paraphrases Meta's research blog. The developer blog adds that it keeps "earlier decisions available as work progresses." Meta's Kavya Kopparapu told TechCrunch the goal was recall that holds over weeks and months. For Active Focus, the other headline feature, Meta says it trained the models to work through blockers and check in before important actions.

How does Active Memory differ from the context window and Muse Code memory?

Muse Wonder has three things that sound like memory. Only one is documented in detail, and for Active Memory Meta does not say where it lives.

The Muse Code docs never use the name Active Memory for the Markdown store. We list it because a developer using Muse Code will meet it first.

How does Active Memory work?

Meta has not said. Neither the launch post nor the model card explains the mechanism. The developer pages cited here, starting with the Muse Wonder model page, do not either.

The open questions are basic ones:

• Is Active Memory a trained behavior, or a service that keeps notes around the model?
• Where is the remembered context kept, and for how long?
• Can a developer or user see and delete what was remembered?
• Does it work for a plain API call, or only inside Meta's own products?

The launch material presents Active Memory as a property of the model series. The docs show no API parameter for it, and the pricing page lists no separate memory charge. Our reading is that most of the capability is the model making good use of whatever long history it is given. That is our inference, and Meta has not confirmed it.

What does the Meta Model API remember between calls?

What the API docs do describe is ordinary server-side state. The Responses API guide says responses are stored by default, through a setting called store. You continue a conversation by passing previous_response_id, and the server rebuilds the history from the chain of IDs.

That chain carries user and assistant turns only. Top-level instructions do not persist, so you resend them each time. Deleting a response soft-deletes it, after which it can no longer be referenced. The guide gives no retention period for stored responses.

None of this mentions Active Memory. A new conversation without a previous response ID starts from whatever you put in the prompt, as far as the docs show. If your agent needs to recall a customer's constraints a week later, plan to store those facts yourself until Meta documents otherwise.

What does Muse Code store on disk?

Muse Code, Meta's coding agent, has a documented memory store. The configuration docs describe Markdown files with a MEMORY.md index and one file per topic. There are three scopes:

• personal project memory, the default, kept on your machine outside the repo
• project memory in .agents/memory, committed for everyone who clones the repo
• personal memory, machine-wide notes across all projects

At session start Muse Code injects the index plus the paths of up to 48 files. The agent opens individual files on demand. A background observer can also insert a relevant note into a turn before the agent answers.

Committed project memory loads even in a workspace you have not trusted, while skills wait until you trust it. Meta's docs say to treat a repo's MEMORY.md as a prompt-injection surface, so review it on any checkout you do not control.

What does MemoryBench actually measure?

MemoryBench is an internal Meta benchmark. Per the model card, it tests how accurately a model recalls key facts across long multi-turn conversations of 64K to 100K tokens. The conversations include distractors and injected turns that conflict with or update earlier details. An LLM judge scores each answer against a weighted rubric.

Meta reports these scores, all at max reasoning effort:

The test conversations are at most 100K tokens, about a tenth of the context window. So MemoryBench measures recall inside one long conversation that fits in a single prompt. It does not test recall across separate sessions days or months apart, which is the claim in the launch messaging.

The cheaper model also edges out Wonder Full here, by 0.1 points. That is within what we would treat as noise for an LLM-judged score.

What should you read in the fine print?

Every MemoryBench number above comes from Meta. The model card calls the competitor runs Meta generated itself "best-effort." It adds that their setup "may not be optimally tuned for proprietary models." We found no independent run of MemoryBench, and the model card links no public dataset.

The rest of the access story is simpler. The model ID muse-wonder-1.0 costs $4.00 per million input tokens and $20.00 per million output tokens on the Meta Model API. Cached input is $0.20 per million. Muse Wonder Full is not served through the API. It comes only with the Muse Code Power ($50 a month) and Maximum ($200 a month) plans. Meta also says Muse Wonder will soon power experiences in its Muse app, subscribers first.

The bottom line

Treat Active Memory as a promising model behavior that has no documented storage or controls yet. For an API product, keep user facts in your own store and pass them in. Before depending on Active Memory, measure recall on your own conversations. In Muse Code, curate the Markdown memory folder, especially in repos you did not write.

How do you keep agent memory you can read across Muse Wonder and other models?

Picture a support agent built on Muse Wonder. On Monday a customer explains their deployment limits. The following week a new conversation starts with no previous response ID. Meta's docs do not say whether Active Memory brings those limits back, or where it would keep them. If you later move the agent to another vendor's model, the stored response chain stays on Meta's servers.

memU keeps that kind of fact as a Markdown note outside any one model. Every supported agent host retrieves it before answering, so the note survives a switch of model or agent. Muse Code is not on memU's list of supported hosts today, so check the support matrix before you plan around it.

If you only work in Muse Code on one machine, its built-in Markdown memory covers most of this. Active Memory also comes with the model at no listed extra cost. memU helps once a second agent or a second machine needs the same notes.

To try the hosted version, get an API key from memu.so and send your agent one message:

Read https://memu.pro/SKILL.md, follow its instructions to install and configure memU, API Key is YOUR_MEMU_API_KEY.

Self-hosting and the per-host support matrix are in the memU GitHub repository. For the wider picture, see our guide to sharing memory across coding agents and the memU home page.

FAQ

Does Muse Wonder remember past conversations?

Meta says it does, through Active Memory. Active Memory is Meta's name for the Muse Wonder models carrying important user context across conversations and retrieving the details relevant to the current task. Meta has not published how it works or where the context is stored.

Can developers see or delete what Active Memory remembers?

Meta's developer docs describe no way to see or delete what Active Memory remembers, as of November 5, 2026. The Responses API lets you delete stored responses, and Muse Code memory is Markdown you can edit, but neither page ties those to Active Memory.

Is MemoryBench an independent benchmark?

No. MemoryBench is an internal Meta test of recall inside conversations of 64K to 100K tokens, scored by an LLM judge. All published scores, including competitor scores, are Meta-reported.

How much does Muse Wonder cost?

On the Meta Model API, Muse Wonder costs $4.00 per million input tokens and $20.00 per million output tokens. Cached input is $0.20 per million. Muse Wonder Full is available only in Muse Code's $50 and $200 monthly plans.

What is the Muse Wonder context window?

Meta's model docs list a 1,048,576-token context window for Muse Wonder. The model card rounds it to 1M tokens at inference.