Meta has entered the increasingly crowded market for AI coding agents with Muse Code, a new terminal-based tool designed to tackle software development jobs that can stretch across large codebases and many individual steps.
The beta product is powered by Muse Spark 1.2, Meta’s latest coding-focused AI model. Rather than simply suggesting the next few lines of code, Muse Code can plan changes, edit files, run commands, test its work and use multiple background AI agents to help complete a larger task.
It puts Meta into more direct competition with tools such as Anthropic’s Claude Code, OpenAI’s Codex and other AI agents designed to do more of the software development process themselves.
Meta isn’t claiming Muse Code wins every benchmark. Its own results put the new system close to the leading coding agents rather than clearly ahead of them.
The more interesting part may be how Meta has built the agent to keep working on long tasks, and how aggressively it is pricing the model underneath it.
What Is Muse Code?
Muse Code is an AI coding agent that runs from a computer’s terminal.
A terminal is the text-based interface developers use to run commands and work directly with software projects. Instead of opening a traditional chatbot and copying code backwards and forwards, a developer can run Muse Code inside a project and give it a task.
That task could involve:
- Finding and fixing a bug
- Adding a new feature
- Understanding a large existing codebase
- Refactoring old code
- Running tests
- Checking whether a change actually works
- Working across several files at once
- Planning a larger software project
Muse Code can then inspect the project, decide what needs to change, make those changes and validate the result.
This is the important difference between a coding assistant and a coding agent.
A basic assistant might suggest some code. An agent is designed to take a broader goal and work through the steps required to achieve it.
Meta Is Using Background AI Agents
One of Muse Code’s more distinctive features is its use of persistent background agents.
The main Muse Code agent handles the overall task, while specialised AI agents can continue working in the background.
Instead of creating a fresh helper every time another piece of information is needed, those background agents remain active throughout the session.
Meta says this reduces repeated research and makes it easier for the system to handle complicated jobs without constantly asking the developer what to do next.
It also means several parts of a problem can potentially be investigated at the same time.
For example, one background agent might inspect how a particular feature currently works while another looks for related tests or searches the codebase for other files that will need to change.
The main agent can then bring those findings together.
It Can Resume After Something Goes Wrong
Long-running AI agents create a practical problem: what happens if the software crashes halfway through a job?
Muse Code records its activity in a local event log.
Every model call, tool action, approval and edit is added to that log, giving the agent a record of what has already happened.
Meta says this makes Muse Code restart-safe. If the process stops unexpectedly, it can resume from the point where it left off rather than trying to reconstruct the entire job from scratch.
That may sound like a small technical detail, but it becomes important if AI agents are expected to work for hours instead of responding to a single short prompt.
Muse Code Includes Built-In Skills
Meta has also given Muse Code several ready-made commands for common development workflows.
They include:
- /plan to turn a task into a structured plan that can be reviewed before work begins
- /grill to challenge that plan and look for weaknesses
- /goal to keep working towards a specified objective
The idea is to give developers more control over how much autonomy they hand to the agent.
For a small change, a user might simply ask Muse Code to fix the problem.
For something more important, they could first request a plan, inspect it and approve the approach before allowing the agent to modify the project.
Muse Spark 1.2 Is Built for Coding
Muse Code is the agent, while Muse Spark 1.2 is the AI model doing much of the reasoning underneath it.
Meta describes Spark 1.2 as a coding-focused update to Muse Spark 1.1.
The company says it increased the amount of training compute devoted to coding and expanded the range of software environments used during training.
The model has been trained for tasks including:
- Code generation
- Complex debugging
- Understanding existing codebases
- End-to-end software development
- Large repository projects
- Long-running coding tasks
- General AI agent work
Meta also trained the model and Muse Code together rather than developing each in isolation.
That matters because coding performance depends on more than the underlying AI model. The tools an agent can use, the instructions it receives and how it manages context can all change the final result.
Meta Used Its Previous Model to Help Train the New One
Muse Spark 1.2 also includes an unusual self-improvement step.
Meta says Muse Spark 1.1 was used to create difficult coding environments and instruction-following exercises.
Candidate solutions were then graded against those requirements, producing additional training data for Spark 1.2.
In simple terms, the previous version helped create some of the problems used to train its successor.
That doesn’t mean the model independently redesigned itself. Meta still controlled the training process.
But it shows how AI companies are increasingly using existing models to generate, test and filter the enormous quantities of training material needed for newer ones.
How Does Muse Spark 1.2 Perform?
Meta has published results from several coding benchmarks, and they suggest Muse Spark 1.2 is competitive with the leading models without consistently beating them.
On Terminal-Bench 2.1, which tests AI agents performing tasks in a terminal environment, Meta reported:
- Claude Opus 5 with Claude Code: 86.7%
- Muse Spark 1.2 with Muse Code: 82.9%
- GPT-5.6 Terra with Codex: 81.8%
- Grok 4.5 with Grok Build: 81.6%
- Gemini 3.6 Flash: 78.9%
That placed Muse Code second in Meta’s comparison.
On DeepSWE 1.1, which tests real software engineering tasks across multiple programming languages, Muse Spark 1.2 scored 59.3%.
That was behind Claude Opus 5 at 65% and GPT-5.6 Terra at 64.8%, but ahead of Grok 4.5 at 56.6% in Meta’s testing.
Meta’s own internal coding benchmark produced a similar result. Muse Spark 1.2 scored 70.6%, behind Claude Opus 5 at 79.4% but above the other models Meta included in that particular comparison.
Benchmark Results Need Some Caution
AI benchmark charts can make model comparisons look more straightforward than they really are.
Meta acknowledges that its tests don’t put every model inside an identical coding agent.
Muse Spark 1.2 was tested with Muse Code, Claude with Claude Code, GPT with Codex and Grok with Grok Build.
That arguably reflects how developers may actually use the models, but it also means the results measure a combination of the model and the software wrapped around it.
Meta also notes that its evaluation environment may not be specifically optimised for rival proprietary models.
For DeepSWE, the official leaderboard normally uses the same agent framework across every model. Meta instead used each model’s selected coding product.
The results are therefore useful evidence that Muse Code is competitive, but they shouldn’t be read as definitive proof that it is universally better than another coding agent.
Meta Tested an AI Coding Job That Ran for 24 Hours
Meta is particularly interested in tasks that take much longer than a normal chatbot conversation.
In one experiment, Muse Spark 1.2 and Muse Code were asked to optimise specialised software used to run calculations on NVIDIA Hopper GPUs.
The AI repeatedly wrote code, compiled it, measured the performance and tried to improve it.
Meta says the experiment involved more than 1,000 tool calls and could run for up to 24 hours.
That is a very different vision of AI-assisted programming from asking a chatbot to write a function.
The longer-term goal is an agent that can continue experimenting, checking and improving its own solution while a human developer concentrates on something else.
Of course, a 24-hour research test doesn’t mean developers should immediately leave an AI agent alone with an important production system.
Autonomous coding makes checking, permissions and testing more important, not less.
The Pricing Is Particularly Aggressive
Muse Spark 1.2 is available through Meta’s Model API using pay-as-you-go token pricing.
Meta currently lists the standard version at:
- US$1.25 per million input tokens
- US$0.15 per million cached input tokens
- US$4.25 per million output tokens
Meta also offers a much cheaper version called Muse Spark 1.2 Contributor.
That tier costs:
- US$0.10 per million input tokens
- US$0.002 per million cached input tokens
- US$0.20 per million output tokens
There is a significant catch.
Meta says activity from the Contributor model can be used to improve its products, including training future models. The standard Muse Spark 1.2 tier is labelled as not being used for that purpose.
That gives developers a very clear trade-off: substantially cheaper AI coding in exchange for allowing Meta to learn from their prompts and completions.
Cheap AI Coding Comes With a Data Question
For an independent developer working on an open-source project, the Contributor pricing could be extremely attractive.
The calculation changes when the agent is being used on:
- Proprietary source code
- Unreleased products
- Customer systems
- Confidential client projects
- Security vulnerabilities
- Internal business tools
- Personal information
Australian businesses in particular shouldn’t treat the cheaper option as a purely financial decision.
If prompts or AI interactions contain personal information, confidential material or intellectual property, organisations need to understand what information is being sent to the service and how the provider may use it.
The cheapest token price isn’t necessarily the cheapest option once privacy, contracts and commercial confidentiality are taken into account.
Muse Code Isn’t a Tool for Complete Beginners
Despite the rapid growth of so-called vibe coding, Muse Code is primarily aimed at developers comfortable working from a terminal.
It currently runs on macOS and Linux and remains in beta.
Someone who has never written code before may get more value from a visual AI website builder or conversational coding environment.
Muse Code becomes more interesting when a developer already has an existing repository and wants an AI agent capable of understanding the project rather than generating isolated snippets.
That makes Meta’s target much closer to professional software development than casual experimentation.
Meta Is Joining One of AI’s Biggest Battlegrounds
AI coding has become one of the clearest real-world uses for powerful generative models.
OpenAI has Codex. Anthropic has Claude Code. Google has its own developer and agent tools. xAI has Grok Build.
Meta now has Muse Code.
The competition is moving beyond which chatbot writes the nicest piece of code. The new contest is over which AI can understand a large project, use tools, plan changes, test its work and remain useful across jobs that may take hours rather than seconds.
Muse Code’s background agents and restart-safe design show Meta is thinking about that longer-running future.
Its aggressive pricing suggests the company also wants developers actually using the system at scale.
What Are the Limitations?
Muse Code is still a beta product, and AI-generated code carries familiar risks.
Developers still need to watch for:
- Incorrect code
- Security vulnerabilities
- Changes that break another part of the project
- Misunderstood requirements
- Poorly written tests
- Unnecessary modifications
- Hallucinated functions or libraries
- Sensitive information being sent to an AI provider
A coding agent being able to run tests doesn’t guarantee the tests are complete.
It also doesn’t guarantee that the AI has understood what the business actually wanted.
The safest use is likely to involve clear permissions, human review and automated testing rather than giving an agent unlimited access to important systems.
Why This Matters for Australia
Australian software companies and startups often operate with smaller development teams than the global technology giants they compete against.
An agent capable of investigating bugs, making changes and testing its own work could give those teams another way to increase development capacity without simply adding more autocomplete to an editor.
Muse Spark’s pricing may be particularly appealing to Australian startups watching cloud and AI costs closely. The Contributor tier is dramatically cheaper than Meta’s standard option, but businesses should look carefully at what they are agreeing to before routing proprietary code or sensitive information through it.
Australian organisations also need to consider existing privacy obligations. The Office of the Australian Information Commissioner has warned organisations to assess privacy risks when using commercially available generative AI products, particularly where personal or sensitive information may be entered into them.
For most Australian developers, Muse Code is worth watching less because it has suddenly become the undisputed best coding agent and more because Meta has become a serious competitor in a market already moving quickly.
More competition could mean stronger tools, lower prices and faster improvements. The practical takeaway is to test those tools carefully and make data settings part of the buying decision, not an afterthought.
Sources: Meta AI Research
