Muse Wonder Just Landed: First muse-wonder-1.0 Call, Active Memory vs Active Focus, and Why max Isn't Wonder Full

Attributed compile + one small offline smoke test

Primary sources (Meta, 2026-10-12): Muse Wonder: A Frontier Model For Personal & Professional AI Agents (AI at Meta research blog), Put your ideas to work with Muse Wonder and Muse Wonder Full by Josh Walters (Meta), Muse Wonder Model Card, and the Meta Model API docs (overview, models, chat completions quickstart)

Secondary: Indian Express explainers (2026-10-13)

Benchmark and safety numbers are Meta's (or third-party numbers they cite). No MODEL_API_KEY on this box — I did not call Muse Wonder. The run below is an offline request/response linter on hand-built mocks only.

---

Meta shipped Muse Wonder and Muse Wonder Full on 2026-10-12, into a feed already full of coding-agent head-to-heads. The pitch is not "another chat model." It is a frontier stack for personal and professional agents: keep context across weeks (Active Memory), keep working through blockers (Active Focus), and survive long coding / computer-use jobs past turn three.

Access is split on purpose. Muse Wonder is on the Meta Model API and Muse Code at $4 / $20 per million tokens. Muse Wonder Full is Muse Code subscription only (Power and new Maximum Usage). That split is the catch when people paste "reasoning_effort": "max" and expect Full.

What Meta actually shipped

From the research post and model card:

	Muse Wonder	Muse Wonder Full
Where	Model API + Muse Code	Muse Code subscription only
Model API id	muse-wonder-1.0	(not on Model API)
Context	1,048,576 tokens	1M (same family)
Modalities in	text, image, video, audio	same family
Modalities out	text	text
List price (API)	$4 in / $0.20 cached in / $20 out per 1M	included in Power / Maximum Usage

Docs say Wonder and Spark take the same request shapes. Any Spark example becomes a Wonder call by changing the model string to muse-wonder-1.0. Wonder is for longer, harder agent loops; Spark stays the cheaper default (and Contributor mode on Model API).

Meta's product language for the two agent knobs:

• 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 alternatives, work through blockers, ask when stuck, check in before consequential actions.

Coding is where they claim those two meet: multi-file edits, long test/fix cycles, sub-agents, computer use. Treat DeepSWE / SWE-Marathon / PSI / Harvey LAB-AA rows as vendor or cited third-party scores. I did not reproduce them.

First call (Chat Completions)

Base URL is https://api.meta.ai/v1. Auth is a Bearer MODEL_API_KEY. OpenAI SDK drop-in:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.meta.ai/v1",
    api_key=os.environ["MODEL_API_KEY"],
)

resp = client.chat.completions.create(
    model="muse-wonder-1.0",
    messages=[
        {"role": "developer", "content": "Be concise. Ask before irreversible actions."},
        {
            "role": "user",
            "content": (
                "I am wiring a personal agent that must remember lease clauses "
                "across chats. In five bullets, what should go in durable memory "
                "vs what should stay in the current turn only?"
            ),
        },
    ],
)
print(resp.choices[0].message.content)
print(resp.usage)

Or curl:

curl -X POST "https://api.meta.ai/v1/chat/completions" \
  -H "Authorization: Bearer $MODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "muse-wonder-1.0",
    "messages": [
      {"role": "user", "content": "Reply with the single word: ready"}
    ]
  }'

Three things the docs make easy to miss:

1. Prefer developer over system for steering. system still shows up in old OpenAI snippets; Meta's quickstart steers with developer.
2. Do not send stop, logit_bias, or reasoning_effort: "none". Reasoning Muse models return HTTP 400 on those.
3. max on Wonder ≠ Wonder Full. Model card and models page say Full is subscription-only in Muse Code; cranking reasoning effort on muse-wonder-1.0 does not promote you.

For serious agent loops (tools, search grounding, file IDs, server-managed state), Meta points you at the Responses API rather than raw Chat Completions. Chat Completions is still the right first ping and the path for simple multi-turn arrays you already have.

Cost arithmetic (list price, not a bill)

Josh Walters' post lists Wonder at $4 input / $20 output per million tokens, with $0.20 cached input on the pricing card.

Illustrative only: 50,000 calls × 4,000 prompt tokens × 800 completion tokens ≈ $800 input + $800 output = $1,600 at list (ignores retries, tools, browsing, Muse Code plan floors). Same call with 3,500 of those 4,000 prompt tokens cached drops one-call list cost from about $0.032 to about $0.019. That is why prompt caching matters once your agent system prompt and tool schemas stop changing every request.

Wonder Full's economics are different: Muse Code Power / Maximum Usage quotas, not a public per-token meter. Launch-day quota bugs got a Meta reset — check your usage bar before a weekend marathon.

What I actually ran (offline)

No Meta key on the box, so I wrote a small preflight that only checks shapes:

• Clean muse-wonder-1.0 Chat Completions body → OK; Spark model id → OK (swap-compatible).
• Fake muse-wonder-full-1.0 + reasoning_effort: "max" → flagged as not on Model API.
• Legacy prompt (no messages) → rejected; system + stop + reasoning_effort: "none" → doc warnings / 400s.
• Hand-built mock choices[0].message.content parses; completions-v1-shaped mock raises ValueError.
• The $1,600 / $0.032 / $0.019 figures above are the same list-price arithmetic the linter prints.

Smoke test of your client, not of Muse Wonder. Scripts: runs/17-muse-wonder/ (preflight.py, run_output.txt).

The Full / API catch (and the memory catch)

Two product traps:

1. Full is not an API model id. 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 paste Twitter win rates.

2. Active Memory is not free durability. The research framing is "carry important context across conversations and retrieve what matters." In your agent, that still needs a store, a write policy, and a retrieve policy. Wonder does not magically make a stateless Chat Completions call remember last month's lease PDF. Put durable facts in a store you control; use the model to decide what to write and what to fetch. Meta's own card recommends human-in-the-loop confirmation for irreversible agent actions — that is the right default even with Active Focus.

Also noted on the card: visual / 3D spatial work is a known weakness; harness and quantization change results; not intended for under-18 use. Read Meta's safety section before giving an agent real credentials.

How I'd try it this week

1. Ping Model API with the curl above — confirm key, model id, and usage before rebuilding a harness.
2. Port one Spark agent loop by changing only the model string; keep tools identical for a fair A/B.
3. Separate memory writes from the chat transcript. Log what the agent decided to remember.
4. Gate irreversible tools. Active Focus keeps trying — good for long SWE tasks, bad for rm, payments, and outbound email.

Why this matters

This month's frontier noise is loud. Muse Wonder is Meta's clearest "personal agent" bet: same family behind a consumer Muse app and a developer API. For builders the useful part is boring — OpenAI-compatible base URL, stable model id, documented Full/API split, and two named behaviors (memory + focus) you can design around after you measure them yourself.

I have not run Wonder live. Start with the ping, then one real repo task with approvals on.

---

YongBo Yu is an AI engineer in Toronto building LLM workflows and agent systems. More at yongbo-yu.vercel.app and GitHub.