Meta Muse Code: The AI Coding Agent That Wants to Challenge Claude Code and Codex

Meta has officially entered the AI coding agent race.

The company has launched Muse Code, a terminal-based AI coding agent designed to handle complete software engineering tasks across large codebases, from planning and writing code to testing and validating the final result.

Powered by Meta’s new Muse Spark 1.2 coding model, Muse Code is clearly aimed at the same market as Anthropic’s Claude Code and OpenAI’s Codex. But Meta isn’t trying to win purely on model performance. Its strategy is different: persistent sub-agents, long-running coding sessions, tight model-agent integration, and extremely aggressive pricing.

What Is Muse Code?

Muse Code is Meta’s first dedicated terminal coding agent, currently available in beta for macOS and Linux. Instead of simply generating snippets of code, it can take an entire engineering task and work through it autonomously.

You can give it a high-level goal and Muse Code can:

• Plan the required changes
• Modify multiple files
• Write and refactor code
• Run tools and commands
• Validate its implementation
• Work across large repositories
• Delegate parts of a task to background agents
• Continue working through long-running tasks

This puts Muse Code directly into the same category as Claude Code and OpenAI Codex. The important distinction is that Meta has designed Muse Code around the idea that large software tasks shouldn’t necessarily be handled by one agent working sequentially. Instead, the agent can break a task apart and have multiple agents work on different pieces simultaneously.

The Interesting Part: Persistent Background Agents

One of Muse Code’s biggest differentiators is its use of persistent background sub-agents. When a task becomes large enough, Muse Code can split it into separate pieces and delegate those pieces to agents working in parallel.

For example, Meta says it tested Muse Code building six different features for a game simultaneously, with the agents working in isolated worktrees so they wouldn’t interfere with one another.

The main agent remains responsible for coordinating the work while the background agents handle specific tasks. This is different from simply spawning an agent for every individual request. Muse Code’s background agents remain active throughout the session, gather information, perform tasks and communicate their findings back when necessary.

The result is intended to be:

less waiting, less manual steering, and better performance on complicated multi-step tasks. For large repositories where several parts of a feature can be developed independently, this could become one of Muse Code’s most useful features.

Muse Spark 1.2: The Model Behind It

Muse Code is powered by Muse Spark 1.2, Meta’s latest coding-focused AI model.But Meta didn’t simply take an existing model and put a coding interface around it. The company says Muse Spark 1.2 was co-trained with Muse Code itself. That means the model was specifically optimized for the environment in which it would operate, including planning, tool usage, sub-agents, context management and long-running engineering tasks.

Muse Spark 1.2 focuses heavily on:

• Code generation
• Complex debugging
• Large codebase understanding
• Long-horizon tasks
• End-to-end software engineering
• Agent workflows

Meta also trained the model on extremely long coding tasks, including whole-repository projects and tasks requiring thousands of tool calls. In one internal test, Meta used Muse Code to continuously optimize GPU kernels for more than 1,000 tool calls, with sessions lasting up to 24 hours. The agent repeatedly wrote, compiled, profiled and optimized the implementation against a baseline. That is a very different target from simply asking an AI to write a function.

A Runtime Built for Long-Running Work
Muse Code also has an interesting approach to reliability.

The system maintains a local event log containing model calls, tool executions, approvals and edits. This gives Muse Code a replayable history of what happened during a session. If the process crashes, the agent can use that event log to resume from where it stopped rather than starting the task again.

For short coding requests, this probably doesn’t matter much. For an agent working on a large repository for hours, however, it could be extremely valuable. A coding agent that can reliably survive long-running tasks is much more useful than one that constantly needs to be restarted or re-explained.

Plan. Implement. Validate.

Muse Code also ships with built-in skills designed around different stages of software development.

For example:

/plan turns a request into an approval-gated implementation plan.

/grill stress-tests that plan before implementation.

/goal keeps the agent focused on completing a specified objective.

This reflects a broader shift happening with coding agents.

The goal is no longer:

“Write this piece of code.”

Instead, the agent is expected to understand the objective, determine what needs to change, implement it and verify that the result actually works. That validation loop is becoming one of the most important differences between an AI coding assistant and a true coding agent.

How Good Is Muse Code?

This is where things get interesting. Meta reports strong results for Muse Spark 1.2 across several coding benchmarks. On Terminal-Bench 2.1, Muse Code reportedly scored 82.9% in Meta’s evaluation. That puts it ahead of GPT-5.6 Terra at 81.8% and Grok Build at 81.6% in the reported comparison.

However, Claude Code with Opus 5 reportedly scored 86.7%. On DeepSWE 1.1, Muse Code reportedly achieved 59.3%, compared with 65.0% for Claude Opus 5 and 64.8% for GPT-5.6 Terra. So the headline isn’t that Meta has suddenly created the best coding agent.

The more accurate takeaway is: Muse Code is already competitive, but it isn’t the performance leader. And there’s another important caveat. These benchmark results are based on Meta’s own evaluation setup and should be treated as an early signal rather than a definitive independent ranking. Real-world performance on messy production repositories will ultimately matter much more.

The Real Weapon: Price

Performance isn’t where Meta is making its biggest statement. Price is.

Muse Code’s standard pricing is:

	Input	Cached Input	Output
Standard	$1.25 / 1M tokens	$0.15 / 1M	$4.25 / 1M
Contributor	~$0.10 / 1M	~$0.002 / 1M	~$0.20 / 1M

The contributor tier is dramatically cheaper. But there’s a catch.On the contributor tier, developers opt in to allowing Meta to use their prompts and completions to improve its models.For a coding agent, that potentially means giving Meta access to the coding sessions and source code being processed by the agent.That makes the contributor tier an interesting trade: less money in exchange for more data access.

For hobby projects, experiments or suitable open-source work, that could be a perfectly reasonable exchange. For proprietary software, client projects or sensitive enterprise repositories, it is a completely different decision. In those cases, the standard tier’s privacy protections become much more important.

Meta Is Buying More Than Users

The contributor pricing model is perhaps the most strategically interesting part of the entire launch.

AI companies have a huge problem: high-quality training data is becoming increasingly difficult to obtain.

The internet has already been extensively scraped. Synthetic data is useful, but models can also become increasingly dependent on data generated by other models. Real-world developer activity is different.

A coding agent sees:

A developer’s problem → the attempted solution → compilation errors → failed tests → debugging → corrections → final working implementation.

That is extremely valuable training information. Code also has something many other types of AI-generated content don’t: it can be automatically verified.

The code either compiles or it doesn’t. The tests either pass or they fail. The implementation either works or it doesn’t. That makes developer interactions particularly valuable for improving coding models. Meta is therefore doing something very Meta-like: using an extremely low price to encourage users to generate valuable data. The question is whether developers are willing to make that trade.

Why Meta Is Betting So Heavily on Coding Agents

There’s a reason virtually every major AI company is now building coding agents. Software engineering is one of the easiest domains for autonomous AI systems to demonstrate measurable value.

A coding agent can:

Write code → run it → test it → observe the result → modify it → test again.

There is a feedback loop. Compare that with an AI agent handling a complicated business operation. There may be no immediate way to determine whether its decision was correct. A coding environment has compilers, tests, linters, build systems and reviewers. That makes software development an unusually good environment for agentic AI. Muse Code is therefore more than another coding assistant. It is also another major test of whether AI agents can reliably perform long-running, autonomous work.

Muse Code vs Claude Code vs Codex

The competition is becoming increasingly straightforward.

Claude Code currently has the strongest reputation for handling difficult real-world coding tasks and remains ahead on the reported benchmark results.

OpenAI Codex offers strong general-purpose coding capabilities and deep integration with OpenAI’s broader ecosystem.

Muse Code is taking a different position. Its strongest advantages are:

• Extremely aggressive pricing
• Persistent background sub-agents
• Long-running workflows
• Model-agent co-training
• Large-repository support
• Simple terminal-based workflow

That makes Muse Code less of a direct “Claude killer” and more of a price and architecture challenger. And that could be just as important. If Meta can deliver comparable results at a significantly lower cost, Anthropic and OpenAI will eventually have to respond.

What Developers Should Know

Muse Code is still in beta, so it shouldn’t immediately become the foundation of a mission-critical production workflow. A sensible approach is to test it against tasks you already understand.

Give it a real repository. Give it a complicated issue. Let it plan, implement and validate the change. Then compare the result with your current coding agent. Most importantly, pay attention to the pricing tier you choose.

For sensitive code, the contributor tier deserves serious scrutiny because the discount comes with data-sharing implications. For experimentation and suitable non-sensitive projects, however, the pricing makes Muse Code extremely easy to try.

You can install it on macOS or Linux with a single command:

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

The Bottom Line

The combination of Muse Spark 1.2, persistent background agents, long-running memory, parallel execution and automated validation gives Meta a credible entry into a category currently dominated by Anthropic and OpenAI. It isn’t the performance leader yet. But it doesn’t need to be.

Meta is attacking the market from another direction: make the agent capable enough, make it dramatically cheaper, and use the resulting developer activity to improve the next generation of models. That strategy could put serious pressure on the entire AI coding market.

The bigger question is no longer whether AI can write code. It’s becoming: How much of an entire software engineering job can an AI agent complete on its own?

Muse Code is Meta’s latest answer. And the coding agent race just got a lot more competitive.