Meta Muse Wonder: Can AI Finally Remember, Think, and Finish What It Starts?
Meta’s new frontier models are built for memory, long-running agents, and serious software engineering. The benchmarks are strong, but the more interesting story is what they could change about how we work with AI.A few years ago, getting an AI model to write a working Python function felt…
Annons
Annons
Meta’s new frontier models are built for memory, long-running agents, and serious software engineering. The benchmarks are strong, but the more interesting story is what they could change about how we work with AI.A few years ago, getting an AI model to write a working Python function felt impressive. Today we ask models to build whole applications, explore repositories, analyze thousands of documents, and operate software on our behalf.Yet something still feels unfinished.An AI can generate beautiful code for an app. But when a dependency breaks, a deployment fails, or the requirements change halfway through, things get messy. Sometimes the agent fixes the problem. Sometimes it repeats the same mistake. Sometimes it confidently reports success when half the app doesn’t work.The same gap shows up outside programming. You spend months explaining your preferences and projects to an assistant, then find yourself explaining them again. You ask an agent to research products, compare options, check availability, and buy one. Each step is easy on its own. Coordinating all of them reliably is not.This is the problem Meta is targeting with Muse Wonder and Muse Wonder Full, built by Meta Superintelligence Labs around two ideas it calls Active Memory and Active Focus. The goal: AI that remembers what matters, keeps working through hard tasks, recovers from failure, and acts inside real applications instead of just answering questions.I went through Meta’s announcement, the model card, the developer docs, and independent benchmark results to see how much of this holds up, and how Wonder compares with GPT-6 and Claude.What Is Muse Wonder?Meta released two models, not one:Muse Wonder is the standard frontier model for demanding reasoning, coding, tool use, and multi-step agent workflows.Muse Wonder Full is the higher-capability version, aimed at especially hard work like long-running software engineering and professional agent tasks.Both support a one-million-token context window, enough to hold a sizable codebase, a large set of technical docs, or a long history of conversations. One caveat: context length tells you how much a model can accept, not how reliably it uses that information.Both are also multimodal. Per Meta’s model card, they take text, images, video, and audio as input and produce text as output, while still being able to drive tools and applications. That means you can hand the model a screenshot and ask it to rebuild the UI, or let an agent read visual information while it navigates a browser.Meta credits improvements in pretraining, reinforcement learning, and stronger base models, trained on infrastructure at its Prometheus data center.There is also a strategic shift here. Llama made Meta a leader in open-weight AI. Muse Wonder is different: it ships through hosted products and APIs, not public weights. The standard model is available through Meta’s API and Muse Code. Wonder Full requires an eligible Muse Code subscription. Meta is now selling frontier intelligence as a managed service, competing head-on with OpenAI and Anthropic.The Real Problem Isn’t Intelligence. It’s Finishing the Job.Say you want to add authentication to an existing web app. You need a login page, user accounts, password handling, protected routes, sessions, and maybe OAuth. A good language model can explain all of it and generate most of the code.Shipping it is another matter. The agent has to understand the existing architecture, inspect dependencies, decide where auth belongs, avoid breaking what already works, and coordinate changes across frontend and backend. Then it has to test. When tests fail, it needs to know why. When a migration breaks, it needs to recover. When the app’s auth setup isn’t what it expected, it needs to change plans.That is the difference between a model and an agent. A model generates responses from the input it receives. An agent wraps a model with tools, memory, an execution environment, and a loop that lets it act over many steps:User gives a task | vUnderstand the requirements | vInspect the environment | vCreate an execution plan | vUse tools and modify files | vRun tests and validate | vDid everything work? +---+---+ | | No Yes | | v vDebug Report results | vTry a corrected approachNone of this is new. Coding agents have run versions of this loop for a while. The hard part is keeping it reliable as tasks get longer, context piles up, and surprises appear. Meta’s answer rests on two ideas.Active Memory: Remembering What Actually MattersFew things are more frustrating than repeating yourself to an AI.Picture a project you’ve worked on for six months. You chose PostgreSQL over MongoDB. You standardized on Python for backend services. You rejected a UI direction, set coding conventions, and fixed a nasty deployment issue. A useful assistant should remember those decisions.But remembering everything isn’t the goal. When you ask for a new API endpoint, the assistant doesn’t need the restaurant you mentioned three months ago. It needs the context relevant to the app.That is what Meta means by Active Memory: carrying useful context across conversations and retrieving the right details when they matter, rather than just keeping a transcript. Something like this:Project: Inventory Management PlatformArchitecture:- Backend: Python / FastAPI- Database: PostgreSQL- Frontend: React- Hosting: AzureDecisions:- All database writes require validation- Authentication uses OAuth- Production deployments require approvalPrevious issue:- Database connection pool exhaustion- Resolved by adjusting pool configurationCurrent objective:- Implement inventory forecastingWith that in hand, an agent asked to build forecasting doesn’t need to rediscover every architectural decision.The hard questions come next. What happens when a memory goes stale, say you move off PostgreSQL? What if details from one project leak into another? What if the assistant “remembers” something that was never true? A real memory system has to separate facts, preferences, temporary decisions, history, and outdated assumptions, and it needs a way to correct or retire them.On MemoryBench, Meta reports a score of about 85.5 for both Wonder and Wonder Full, competitive with the other frontier models it tested. Still, a benchmark can’t tell you how memory holds up over months of real use.Meta also hasn’t disclosed how Active Memory works. It could be external storage, retrieval, changes to the model itself, or some mix. So it’s too early to call it a new memory architecture. What matters is whether it works better for real users.Active Focus: What Happens When the Agent Gets Stuck?Memory is only half the problem. An agent also has to stay on task.Ask an agent to migrate a database. It reads the schema, writes migration scripts, and runs tests. One test fails because a column type differs from what it expected, so it adjusts. Another fails because an old API endpoint depends on the original schema. Now it has to understand how the database, the application code, and the tests fit together.A weak agent keeps changing things until the tests go green, even if it breaks the intended behavior along the way. A strong agent finds the underlying issue and preserves the original requirements.Meta calls this Active Focus: sustained effort toward a goal, including trying alternatives, working through blockers, adapting to new information, and asking for clarification when needed. Compare two approaches:Approach A:Test failed→ Change code→ Test failed→ Change more code→ Test passed→ FinishApproach B:Test failed→ Read the error→ Inspect the affected dependency→ Identify the root cause→ Compare possible fixes→ Apply the smallest appropriate change→ Run targeted tests→ Run regression tests→ Verify the original requirements→ FinishBoth can end with passing tests. Only the second gives real evidence the problem was solved. For long-running agents, this distinction matters enormously: an agent can run hundreds of commands and accomplish very little if it keeps repeating approaches that don’t work.Knowing when to stop matters just as much. If an agent lacks permission to update a production system, it shouldn’t keep trying to work around the restriction. Meta says Wonder is trained to check in before important actions and ask for clarification when needed. That is essential to trustworthy autonomy. An agent that never gives up isn’t necessarily smart. Sometimes the most useful move is recognizing that a decision belongs to a human.What Changed Under the Hood?Meta says Wonder benefits from improvements in both pretraining and reinforcement learning. Pretraining is where a model learns broad patterns from huge amounts of data. Post-training, including reinforcement learning, shapes how it reasons, follows instructions, and handles complex tasks.The most interesting part of Meta’s research, though, is about generalization.The industry is obsessed with benchmarks, but benchmarks don’t always predict how a model handles unfamiliar problems. Think of two students: one memorizes hundreds of practice questions, the other understands the concepts. Both ace familiar questions. Only the second reliably handles something new.Models face the same trap. They can get very good at tasks that resemble their training and evaluation setups, while real requests mix unfamiliar information, tools, and constraints.Meta studied how performance scales with more reasoning effort, comparing tasks emphasized in post-training against tasks outside that distribution. It reports that Wonder Full generalizes to unfamiliar tasks better than the trends from its earlier Muse Spark 1.3 model would predict, and credits the stronger base models underneath.If that holds, it matters. An agent that crushes known coding benchmarks but stumbles on an unfamiliar business app is less useful than one that is consistently good across a wide range of tasks.But this is a company-reported result, and we need independent tests on genuinely new environments. Meta also hasn’t published parameter counts, full training-data composition, or how Active Memory and Active Focus are implemented. That makes it hard to separate gains from scale, post-training, the surrounding agent system, and inference-time reasoning.The Benchmarks: Strong, but Not a Clean SweepMeta compares Wonder Full against frontier models including GPT-6 Astra and Claude Opus 5.5. Instead of one headline score, it reports results across professional tasks, coding, computer use, memory, and general intelligence. Here are selected results from the model card (higher is better):Benchmark Wonder Full GPT-6 Astra Claude Opus 5.5--------------------------------------------------------------------------Artificial Analysis Index 56 53 58Harvey LAB-AA 13.1 8.6 4.2Vals Finance Agent V2 59.1 53.5 58.6AutomationBench-AA 45.4 41.6 41.2JobBench 75.3 66.1 75.4MemoryBench 85.5 81.4 81.5DeepSWE 1.1 79.0 74.1 74.2SWE-Marathon 57.5 42.5 46.3Terminal-Bench 4.0-AA 57.1 59.1 59.6HealthBench Pro 62.3 65.3 65.6ProgramBench 59.0 52.5 70.5Source: Meta Muse Wonder Model Card. Some systems were evaluated with different agent harnesses or configurations.The pattern is clear. Wonder Full is strongest in long-horizon software engineering, memory, and some professional agent tasks. Claude Opus 5.5 leads on the overall Artificial Analysis Index, terminal tasks, health reasoning, and building programs from scratch. That makes this a more interesting comparison than “one model wins.”DeepSWE: Working Inside Real CodebasesDeepSWE tests demanding software engineering. Unlike benchmarks that ask for an isolated function, it requires working within a larger context and making changes that fit the surrounding project.Wonder Full scores 79.0, ahead of GPT-6 Astra (74.1) and Claude Opus 5.5 (74.2). That suggests real strength in understanding existing code, navigating dependencies, and making coordinated changes.But acing an engineering benchmark isn’t the same as maintaining a production app full of thin documentation, vague requirements, legacy code, external services, and environments that behave differently from test. The score is evidence of capability, not a guarantee.SWE-Marathon: The More Telling TestSWE-Marathon measures longer-running engineering work, which is exactly where Active Focus should shine. Wonder Full scores 57.5, versus 46.3 for Claude Opus 5.5 and 42.5 for GPT-6 Astra. That is a notable gap.The caveat: Meta’s model card notes that some comparisons used different agent harnesses. The harness is the software around the model that manages tools, execution, prompts, and context. When harnesses differ, the result reflects the whole agent system, not just the model. That doesn’t make the benchmark meaningless. It just means that, as a developer, you never deploy a benchmark score. You deploy a model inside a system.Terminal-Bench: Where Claude and GPT Hold the EdgeOn Terminal-Bench, which tests technical work in a terminal, Wonder Full scores 57.1, behind GPT-6 Astra (59.1) and Claude Opus 5.5 (59.6). The gaps are small, but they make a point: coding isn’t one skill. It spans planning, reading code, writing code, diagnosing failures, using tools, and validating results. A model can be great at modifying a repository and less effective at terminal debugging or system administration.What Independent Testing ShowsArtificial Analysis runs its own benchmark suite, which makes it a useful counterweight to a company announcement. On its Intelligence Index v4.3:Model Intelligence Index----------------------------------------Claude Opus 5.5 58Muse Wonder Full 56Claude Sonnet 5.5 56GPT-6 Astra 53Muse Wonder 52Muse Spark 1.3 48Source: Artificial Analysis — Muse Wonder EvaluationThe first takeaway is how far Meta has come. Wonder Full jumps from Muse Spark 1.3’s 48 to 56, and the standard Wonder reaches 52, in a short generation gap. Artificial Analysis reports that Wonder Full improved on all ten components of the index, with the biggest gains in terminal tasks, professional work, and agentic workflows. That suggests real progress beyond a few hand-picked internal benchmarks.The second takeaway: Claude Opus 5.5 still leads the index, and Claude Sonnet 5.5 ties Wonder Full despite sitting in a different price tier. So has Meta built the best model in the world? The evidence doesn’t support that. Wonder Full is competitive at the frontier with specific strengths. It isn’t universally better.Knowing Things vs. Knowing What You Don’t KnowArtificial Analysis also measured knowledge and hallucination, and the results reveal a real tradeoff.On its AA-Omniscience benchmark, Wonder Full scores 30, well below Claude Opus 5.5 (46) and GPT-6 Astra (43). That points to weaker broad factual knowledge on this measure. Yet Wonder Full’s reported hallucination rate is relatively low at 23%, down from 33% for Muse Spark 1.3.Why does that matter? Because knowing an answer and knowing when you don’t know are different skills. Ask about an obscure paper, and one model invents details while another says it lacks reliable information. The first sounds more helpful. The second is more trustworthy.A lower hallucination rate doesn’t guarantee correctness, and the number is specific to this evaluation. But for agents, it’s a big deal. A research agent that admits uncertainty can go find another source. A finance agent that notices missing data can ask for the document. A coding agent that recognizes an unfamiliar API can read the docs first. Confidence without accuracy is far more dangerous once an AI can take actions.What Can Muse Wonder Actually Build?Meta showed several workflows to illustrate what Wonder can do:A playable 3D kitchen game generated from customizable image inputs. Building a game means turning visual or conceptual requirements into a working interactive experience: a scene, controls, object behavior, and game logic.Planning a Saturday run, with the agent moving across a browser and apps to build a plan around personal preferences and circumstances.A wedding seating chart with complex placement rules. Anyone who has planned a big event knows this is really a constraint-solving problem: keep some guests together, others apart, group families, respect table sizes.Personalized merchandise, where the agent pulls photos from an Instagram profile, designs custom products, and places an order.That last demo shows exactly why permissions and human approval matter. Designing a product is one thing. Placing an order on someone’s account is another.These are demos, not independent evidence of production reliability. A polished demo doesn’t reveal the success rate on unfamiliar requests. The useful next test is giving Wonder dozens of new tasks and measuring how often it finishes without correction.How Developers Can Use Muse WonderThe two main access points are the Meta Model API and Muse Code. The model identifiers are:muse-wonder-1.0muse-wonder-full-1.0The standard model is available through the API. Wonder Full requires a qualifying Muse Code subscription.Muse Code is Meta’s terminal-based coding environment. The developer docs include an install command like this:curl -fsSL https://dev.meta.ai/install.sh | bashCheck Meta’s current platform-specific instructions rather than assuming this works on every OS.Multi-Agent DevelopmentMuse Code is designed for agentic development where multiple agents collaborate on different parts of a task. Imagine building a simple inventory management app this way: User Request | v Planning Agent | +-----------+-----------+ | | | v v v Frontend Backend Database Agent Agent Agent | | | +-----------+-----------+ | v Integration Agent | v Test and Review | v Final ApplicationThis is a conceptual architecture, not a claim about the exact roles Muse Code uses. Meta’s developer resources do describe subagent orchestration, parallel worktrees, GitHub automation, and computer use.The idea: a frontend agent builds React components, a backend agent writes FastAPI endpoints, a database agent designs the PostgreSQL schema, and a validation step checks that the API contracts match what the frontend expects. That beats one agent constantly switching between unrelated concerns.But it introduces a new problem: coordination. What if the frontend expects customer_id and the backend returns customerId? What if two agents edit the same file? What if one agent finishes against an outdated API contract?Multi-agent systems need more than smart individual agents. They need shared requirements, clear interfaces, isolated working environments where appropriate, and solid integration tests. That is why parallel Git worktrees and automated verification help.The goal isn’t more agents. It’s dividing work so it reduces interference and makes results easy to validate. And a cookbook example existing doesn’t mean every workflow is production-ready.Computer Use Might Matter More Than CodingCoding gets the headlines, but computer use could be the bigger deal. Most of the world’s software was built for people, not AI: booking systems, spreadsheets, admin portals, insurance sites, project tools, desktop apps. All buttons, forms, and menus.An agent that can operate those interfaces could finish tasks without every service shipping an API. You could ask it to compare three insurance options and summarize the key differences, and it would open the documents, navigate provider sites, and organize what it finds. Or you could ask it to find pages on a website with broken navigation or layout, and it would click through and document the problems.Meta says Wonder is designed to operate browsers, desktop apps, and mobile interfaces. The catch is reliability. Interfaces change. Buttons move. Pages load slowly. Dialogs pop up. Sessions expire. Visual interfaces also fail in subtle ways: the agent clicks the wrong button or misreads the page. Reliable computer use requires strong visual understanding, careful action selection, verification, and safeguards.Let’s Talk About PricingCapability is half the decision. Cost is the other half. Meta lists these API prices for standard Muse Wonder:Usage Price per 1M tokens------------------------------------Input $4.00Cached input $0.20Output $20.00Wonder Full has no public per-token API price. Access comes through Muse Code subscriptions: a $50/month Power Usage plan and a $200/month Maximum Usage plan. That distinction matters. Using Wonder interactively in Muse Code is bounded by your subscription. Building it into an app via the API means paying per token.A quick example: a request with 100,000 uncached input tokens and 20,000 output tokens costs roughly:Input: 100,000 / 1,000,000 × $4 = $0.40Output: 20,000 / 1,000,000 × $20 = $0.40Total = $0.80Real agent tasks are a different story. They involve many requests, repeated context, caching, and tool calls, and a long-running agent might make dozens or hundreds of model calls before it’s done.That’s where independent numbers help. Artificial Analysis estimates standard Muse Wonder costs about $4.52 per task in its Intelligence Index evaluation, versus roughly $0.72 for GPT-6.1 Sol. Those figures apply to that specific setup, but they show why cost per successful outcome matters more than cost per prompt.A pricier model can still be cheaper if it solves a hard problem in fewer attempts. A cheap model that burns context without progress gets expensive fast.For agentic apps, the right question is: how much does it cost to finish the task correctly? Not how much a million tokens costs.A Bigger Context Window Isn’t Long-Term MemoryThe one-million-token window is genuinely useful, but it isn’t the same as long-term memory.Give an agent an entire repository to debug, with hundreds of files, logs, docs, and old debugging notes. Even if it all fits, finding the relevant piece is still hard. It’s like having every book in the library but not knowing which paragraph holds the answer. A good agent has to identify what matters instead of treating every token equally.Long tasks make this harder. An agent might start with a clean context and then make 50 tool calls. Each adds information. Some stays useful, some goes stale, some is wrong. Eventually, the agent needs a strategy for what to keep, summarize, retrieve, or discard. That is why memory management is a core part of agent architecture.Active Memory could help here, but Meta’s public docs don’t explain how Wonder handles storage and retrieval end to end. The large context window is a capability. Memory management determines how useful it actually is.So, Is It Better Than GPT-6 or Claude?There’s no single answer. It depends on the job:Long-running software engineering: Wonder Full’s DeepSWE and SWE-Marathon results stand out.Terminal-based work: Claude Opus 5.5 and GPT-6 Astra stay ahead, even in Meta’s own comparison.General capability: Claude Opus 5.5 leads the Artificial Analysis Index.API economics: standard Wonder faces strong competition from cheaper models.Self-hosting: if you need open weights to run and customize, Wonder’s hosted-only distribution is a drawback.The bigger point is that frontier models are increasingly specialized. A model that excels at autonomous engineering might be overkill for a quick classification task. A fast, cheap model may be fine for document extraction. A top-tier model earns its cost when the task demands complex reasoning or reliable tool coordination.The sensible approach: test models on tasks that look like your real work. Benchmarks are a starting point, not a substitute.The Hardest Problem: Knowing the Agent Actually FinishedThis issue deserves more attention than it gets. How does an agent know it completed a task correctly?Ask for a travel itinerary, and you might get a polished plan with hotels, activities, restaurants, and transport. It looks done. But what if an attraction is closed that day? What if the driving times are unrealistic? What if a booking requirement was missed? A result can look impressive without satisfying the request.Software has the same problem. An AI can ship an app that looks right but hides security holes, broken edge cases, or flaky deploy scripts.That’s why good agent workflows separate generating a solution from checking it:Software: unit tests, integration tests, type checks, security scans, and browser-based validation.Research: source verification and explicit handling of uncertainty.Finance: reconciling calculations against source data.Purchases: confirming product, price, address, and authorization before submitting.An agent that keeps working until it produces an answer isn’t necessarily reliable. An agent that keeps working until it has evidence the task is done is far more useful. That’s why the emphasis on Active Focus is interesting. But long-term success will depend just as much on validation and permissions as on raw intelligence.The Privacy QuestionAs agents gain memory and the ability to operate software, they need access to more of your life: messages, documents, browsing, calendars, purchase history. That makes them more useful, and it widens the attack surface.Consider prompt injection. An agent reads a web page containing hidden text telling it to abandon its task and leak private data. That instruction comes from external content, not the user. If the agent treats it as a legitimate command, the results can be serious. The same risk exists in documents, emails, repository files, and tool outputs.A smarter model may be better at spotting malicious instructions, but model-level defenses aren’t enough. The application needs hard permission boundaries. Reading a document shouldn’t automatically allow sending its contents elsewhere. Viewing a shopping cart shouldn’t automatically allow buying what’s in it.Meta says Wonder improves on safety, privacy handling, and resistance to adversarial instructions, and the model card details its evaluations. But real-world safety also depends on the systems around the model. The key question isn’t only whether the AI recognizes a risky action. It’s whether the software blocks unauthorized actions even when the model gets it wrong.Real-World Adoption, and Why This Matters for MetaMeta has published demos and developer resources covering game development, multi-agent orchestration, GitHub automation, computer use, and research workflows. But the models are new, and there’s little public evidence yet from independently maintained production apps: months of software maintenance, thousands of autonomous browser tasks, or long-term personal assistant use.The next phase of evaluation has to happen outside launch demos. Developers need to measure how often agents get stuck, how often humans have to step in, how accurate memory stays over time, and what successful tasks really cost. That evidence will matter more than any single demo.Strategically, this release is a big move for Meta. Llama helped popularize open-weight models, but the frontier race is now about complete systems, not just strong base models. OpenAI, Anthropic, Google, and Meta are competing across reasoning, coding, multimodality, tools, memory, and agentic execution.Meta’s edge is its consumer reach. It already runs platforms used by billions of people. If it can make reliable personal agents that understand your preferences, organize information, create content, work across apps, and remember past decisions, they could become part of everyday digital life. That’s close to what Meta calls personal superintelligence.Getting there takes more than a powerful model. Users have to trust the system with their data and actions, developers have to build reliable integrations, and safeguards have to hold up in unpredictable situations. Muse Wonder is a step in that direction, not proof of arrival.So, Can AI Finally Finish What It Starts?After going through the research and evaluations, I think Muse Wonder is meaningful progress.The jump over Muse Spark 1.3 is substantial in independent testing. Wonder Full’s long-running software engineering results are genuinely impressive. And Meta’s focus on memory, sustained execution, and real-world agent work targets exactly the problems that still frustrate people using AI.But the evidence doesn’t support saying Meta has solved autonomous AI. Competitors still lead in several areas. Long-term memory needs more independent testing. Agent reliability depends heavily on the surrounding tools and systems. And the economics of long-running tasks still matter. Completing a task once is very different from completing it reliably across hundreds of unfamiliar situations.For me, the most interesting part of Muse Wonder isn’t the leaderboard. It’s the growing recognition that making AI useful takes more than making it intelligent. An assistant has to remember what’s relevant without getting confused by stale context.It has to keep going when things break without looping on the same mistake. It has to recognize uncertainty, verify its work, and know when a human should decide. And it has to do all of that while respecting privacy, permissions, and the original goal.The real breakthrough won’t be the day a model tops another benchmark. It will be the day we can hand an AI a hard task, come back later, and trust that it was done right.We’re not quite there yet.References and Further ReadingMeta AI Research — Muse Wonder: official announcement, Active Memory, Active Focus, and capability demos.Muse Wonder Model Card: specs, benchmark methodology, limitations, and evaluations.Meta Developer Documentation — Muse Wonder: model access, pricing, context windows, and developer resources.Artificial Analysis — Muse Wonder and Muse Wonder Full: independent intelligence benchmarks, coding-agent evaluations, token usage, and economics.This story is published under the Generative AI publication. Connect with us on LinkedIn and follow Zeniteq to stay in the loop with the latest AI stories. Let’s shape the future of AI together!Meta Muse Wonder: Can AI Finally Remember, Think, and Finish What It Starts? was originally published in Generative AI on Medium, where people are continuing the conversation by highlighting and responding to this story.