Meta launched Muse Code, a beta AI coding agent powered by Muse Spark 1.2, on August 5 to compete with OpenAI’s Codex and Anthropic’s Claude Code. The launch gives engineering teams a new decision: whether Muse’s lower prices, coordinated workflow, and support for long-running assignments justify choosing Meta’s closed model and coding agent over open-weight models or more established coding products.

Meta’s pricing adds a data-use choice. Its standard API tier costs less than the listed rates for competing OpenAI and Anthropic models, while Meta says customers’ usage will not be used to improve its products. The contributor tier costs substantially less, but customers must allow Meta to use their activity for product improvement.

Muse Code organizes assignments around a main agent and persistent background agents that can continue different parts of the work at the same time. A local event log records model calls, tool use, approvals, and code changes so the system can reconstruct interrupted work instead of starting over. Meta also trained Muse Spark 1.2 to work with Muse Code’s tools and agent structure, creating a model and coding system designed to operate together.

Engineering leaders must decide whether Muse’s lower cost and support for long-running assignments are reliable enough for everyday software work. Security and data-governance teams will need to assess Meta’s two data-use tiers, particularly the much lower contributor-tier price offered in exchange for using customer activity to improve its products. Organizations that require AI models to run on their own infrastructure cannot do that with the closed Muse Spark 1.2 model.

In short, Meta is betting that training the model and coding system together will help Muse handle complex assignments for longer and at a competitive price. Its launch makes that case credible, but everyday software work will determine whether the advantage holds up.

Muse Code is Meta’s coding agent, while Muse Spark 1.2 is the closed AI model that powers its planning, coding, testing, and coordinated work.

An agentic coding system combines an AI model with tools that can plan, write, test, and coordinate code changes across a software project with less step-by-step direction.

Meta launched its answer to Codex and Claude Code on August 5: Muse Code, a beta coding agent powered by the new Muse Spark 1.2 model. Muse Code is designed to plan changes, write code, and check its own work across large software projects, allowing it to handle more of a development assignment than an AI tool that generates isolated pieces of code.

Muse Spark 1.2 is a coding-focused update to Muse Spark 1.1, with claimed improvements in generating code, solving complex bugs, understanding how different parts of a codebase fit together, and carrying a development task from start to finish. Its one-million-token context window gives the model room to keep more code, instructions, and prior work available during a long assignment. Meta says that capacity helps Muse continue working through an extended task within the same session.

Muse Spark 1.2 retains Meta’s claimed strength in agent tasks beyond coding, while the wider family can also work with text, images, video, and other visual information. Meta says the updated model is more accurate on its first attempt and more reliable when using tools, two abilities that directly affect how much checking and intervention an autonomous coding agent requires. Its model page, however, does not provide figures supporting either claim.

Meta is entering a market where OpenAI and Anthropic already offer established models through agentic coding products capable of taking action across a software project. GPT-5.6 launched on July 9 with access through Codex and OpenAI’s API, followed by Claude Opus 5 on July 24 through Anthropic’s platforms, API, and Claude Code. Opus 5 was also promoted for long-running, multi-step assignments. Meta’s arrival intensifies the race to build a model-and-agent combination that can complete sustained development work with less human direction. The launch gives Meta a model and coding product for the same market, but the way developers can access Muse departs from the open-weight approach that previously set the company apart.

Meta built much of its AI identity around Llama models released with open weights, the learned parameters at the core of a model that developers could download and run on their own systems. That gave developers greater control over where the model operated, how they adapted it, and whether sensitive information had to pass through an outside provider. It also reduced their dependence on Meta to keep the model available or maintain the terms under which they could use it. Muse replaces that independence with access to a model Meta continues to host and control.

The closed approach began with the original Muse Spark, announced on April 8 as the first model in the Muse series. It initially powered Meta’s AI app and website, where the company demonstrated uses ranging from creating websites and mini-games to answering health questions involving images and charts. Meta also used it for shopping, local discovery, recommendations, and answers drawn from content across its apps. Muse Code therefore extends an existing general-purpose model family into a dedicated developer product rather than introducing a model built only for programming.

When Muse Spark first launched, consumers could use it through Meta AI, while direct developer access was limited to a private API preview for selected partners. Meta said it hoped to open-source future versions, without releasing the weights for the announced model. Developer access has since expanded: Muse Spark 1.2 is now available through Muse Code, Meta’s Model API, and OpenRouter. Muse Code provides a ready-made coding agent, while the API and OpenRouter allow developers to use Muse Spark in other applications and tools. Meta still does not offer the model’s weights for developers to download and operate on their own infrastructure. Access has widened, but control of the model has not.

The API offers two pricing options based on how Meta may use customer activity. Under the standard tier, Meta says usage will not be used to improve its products; customers pay $1.25 per million input tokens, $0.15 for cached input, and $4.25 per million output tokens. The contributor tier lowers those prices to $0.10, $0.002, and $0.20 respectively, in exchange for allowing Meta to use that activity for product improvement. Developers can therefore pay more to keep their usage out of Meta’s development process or accept that use in return for a steep discount.

The closed distribution extends from the Muse Spark model to the Meta-designed Muse Code system that runs it. If developers receive less control over the underlying model, what does Meta believe it can deliver by controlling the complete coding system?

Muse Code organizes a software assignment around a main agent and a group of asynchronous background agents, which can continue working while the main agent handles other parts of the task. This structure allows several lines of work to move forward at once instead of forcing the system to complete every investigation, code change, or review in sequence.

Those background agents remain active for the entire session. Because the same agents retain the information they have gathered, they do not need to rediscover the project each time another step arises. They can continue with follow-up work and decide when their findings are useful enough to report to the main agent, giving the system a way to preserve context and coordinate progress across a multi-step assignment.

Meta describes Muse Code as a system of parallel workers and background reviewers. One agent might continue investigating a problem while another advances the implementation or checks work already completed, allowing the main agent to coordinate the larger objective without directing every individual step. Meta says this persistence reduces delays and the amount of human guidance required during difficult assignments, where repeated explanations and approvals can interrupt progress.

The company promotes that design as a way for developers to “ship faster without sacrificing quality.” That remains a Meta product claim rather than an independently demonstrated result, but it identifies the practical advantage the company believes its control of the complete system can provide: more work can continue in parallel with less frequent human direction. Keeping several agents working is useful only if their shared progress survives the interruptions and failures that can derail a long software project.

Muse Code records every model call, tool run, approval, and code edit in a local event log stored with the developer’s work. That log gives the system one continuous account of what happened during an assignment, including the actions it took and the decisions a person approved.

Meta says this record makes the runtime exactly replayable. If Muse Code crashes during a long assignment, it can reconstruct the work from the event log and resume at the point where it stopped instead of discarding its progress and beginning again. Recovery becomes more important as coding agents work for longer periods, because a single software failure could otherwise erase hours of investigation, tool use, and completed changes.

Muse Code also includes three skills intended to keep that work directed and controlled. The /plan command turns an assignment into a proposed plan that requires approval before execution, giving the developer a checkpoint before the agent begins making changes. The /grill command challenges the plan for weaknesses, while /goal keeps the system working toward a defined successful outcome. Each command addresses a different risk in a long assignment, from starting with a weak plan to overlooking problems or losing direction as the work expands.

Meta describes Muse Code as fully auditable because its actions are intended to remain visible and traceable in the event log. The record gives developers a way to inspect how the agent reached a result rather than receiving only the finished code. Those runtime features explain how Meta preserves progress, but the model must also be trained to plan, use tools, manage context, and cooperate with that system.

Meta devoted more of Muse Spark 1.2’s training compute to coding and expanded the variety of software environments the model encountered. It also trained the model using Muse Code’s tools and agent workflows. Selected examples of agent behavior taught Muse Spark how to pursue goals, retain the important information from a lengthy working history, and cooperate with subagents as different parts of an assignment moved forward.

Meta describes this process as co-training Muse Spark 1.2 with Muse Code. That pairing is meant to reduce the friction that can occur when a general model is placed inside an agent it was never specifically trained to operate. Muse Code therefore receives a model already familiar with its tools and working structure, while Muse Spark receives an environment built to support the long, coordinated assignments covered in its training. Meta is counting on that close fit to improve the performance and usability of the model and coding agent when they work together.

Meta reinforced those abilities through long-running assignments that included generating complete software repositories, carrying large projects from beginning to end, and conducting automated research. Completing that work required the model to plan the order of its steps, maintain direction toward a defined goal, and use context compaction, which helps preserve the most important information when the session becomes too large to keep everything in full. Without those abilities, an agent can lose earlier decisions, repeat completed work, or drift away from the original objective as a project continues.

Meta also used Muse Spark 1.1 to help create the material for training its successor, a process it calls “self-improvement.” The earlier model generated challenging coding environments and templates defining what a successful solution needed to accomplish, then graded candidate solutions against those requirements. This allowed Meta to produce training examples at a larger scale without relying on people to design and evaluate every coding problem individually. The company says the process helped Muse Spark 1.2 follow complex instructions more precisely than Muse Spark 1.1.

Tight integration creates a plausible technical advantage, but developers still need evidence that it produces better completed work than the alternatives already available.

Meta’s benchmark charts compare the coding systems developers would actually use: Muse Spark 1.2 with Muse Code, GPT-5.6 Terra with Codex, and Opus 5 with Claude Code. Each score reflects the model working with its agent, tools, and testing setup, so the results measure the performance of the complete coding product rather than the model alone.

That distinction is important because all three models are designed for work beyond software development. OpenAI promotes GPT-5.6 across coding, knowledge work, cybersecurity, science, computer use, and multi-agent assignments, while Anthropic presents Opus 5 as a model for software engineering, professional work, research, visual tasks, and long-running agent work. Meta’s charts compare how effectively the coding-agent configurations of these broader models complete defined technical assignments.

On Terminal-Bench 2.1, which tests whether an agent can navigate a command-line environment and use its tools to complete complex work, Meta reported a score of 82.9% for Muse Spark 1.2 with Muse Code. That placed Muse below Opus 5 with Claude Code at 86.7%, but above GPT-5.6 Terra with Codex at 81.8%. In Meta’s comparison, Muse was competitive with both established products and finished between them on a test that resembles the environment where developers would actually use the agent.

Muse performed less strongly on DeepSWE 1.1, which focuses on long-horizon software engineering work inside real codebases. Terminal-Bench covers a wider range of command-line work, while DeepSWE more directly tests whether an agent can carry a substantial repository-level assignment forward. Meta reported 59.3% for Muse, behind GPT-5.6 Terra at 64.8% and Opus 5 at 65%. That gap matters because long-horizon repository work is where a coding agent must preserve earlier decisions, coordinate changes across a codebase, and carry the assignment through to a finished result. A weaker score gives developers less evidence that Muse can handle the sustained work Meta built it to perform.

On Meta Internal Coding Bench, the company’s own coding evaluation, Opus 5 scored 79.4%, Muse Spark 1.2 scored 70.6%, and GPT-5.6 Terra scored 65.4%. On GDPval-AA v2, an evaluation covering professional work, Meta reported scores of 1,852 for Opus 5, 1,631 for Muse, and 1,577 for GPT-5.6 Terra.

The four comparisons give Meta evidence that Muse can handle several kinds of agentic work, from command-line assignments to coding and wider professional tasks. They also show how much ground remains. Opus remains the more consistent benchmark leader, while GPT-5.6 Terra holds an advantage on the long-horizon coding test.

The differing vendor-reported scores also show how much the agent environments or testing conditions can change the outcome even when the benchmark name and version remain the same. OpenAI reported GPT-5.6 Terra scores of 87.4% on Terminal-Bench 2.1 and 69.6% on DeepSWE 1.1, compared with the 81.8% and 64.8% shown for Terra in Meta’s charts.

Benchmarks can show how Muse performs on defined tests, but Meta’s larger claim is that its integrated system can sustain complex work over much longer periods.

Meta tested Muse’s ability to remain productive during an extended technical assignment by having it improve the performance of GPU kernels, small programs that control how graphics processors carry out computing work. Over more than 1,000 tool calls and working for as long as 24 hours, Muse repeatedly wrote code, compiled it, measured its performance, and revised the result. Each measurement gave the agent evidence for its next change, allowing it to continue improving the code through repeated cycles rather than relying on a single attempt.

The assignment focused on KDA and MLA kernels running on NVIDIA Hopper GPUs. KDA and MLA are two attention methods that help AI models decide which earlier information to use while processing long sequences. Their designs reduce the memory and computing work required, so faster kernels can make long-context AI systems run more efficiently.

Meta prohibited the agent from directly importing third-party kernel libraries. That restriction required Muse to implement the algorithm using its own kernel-optimization knowledge instead of gaining performance by wrapping an existing solution. The test therefore examined whether the system could continue reasoning, using tools, and responding to performance measurements as the assignment developed.

Meta says Muse delivered “substantial improvements” over the supplied baseline, without reporting a single overall figure for the size of the gain. The case study demonstrates sustained iterative execution because Muse continued working through more than 1,000 interactions with its tools, preserved the objective across repeated revisions, and used new measurements to decide what to change next.

Success on two specialized GPU tasks running on NVIDIA Hopper hardware does not show whether Muse can reliably handle everyday software projects, and the experiment did not include rival coding agents. The case study shows that Muse can sustain one demanding assignment, but developers still lack evidence about how it performs across common coding work or against competing products.

Muse now has evidence of both benchmark capability and sustained execution, leaving developers to decide whether those advantages justify adopting a paid, closed system.

Muse gives Meta a credible way to compete on more than performance alone. Its standard API costs $1.25 per million input tokens and $4.25 per million output tokens, compared with $2.50 and $15 for GPT-5.6 Terra and $5 and $25 for Claude Opus 5. The contributor tier offers a much steeper discount of $0.10 per million input tokens and $0.20 per million output tokens to teams willing to let Meta use their activity for product improvement. Developers on macOS and Linux can install the Muse Code beta directly from the command line, while teams can access Muse Spark 1.2 separately through Meta’s Model API or OpenRouter. That gives them a lower-cost alternative to Codex and Claude Code without requiring them to commit immediately to Meta’s complete coding system.

Muse’s performance also allows Meta to compete alongside OpenAI and Anthropic. Across Meta’s four comparisons, Muse outscored GPT-5.6 Terra on three, while Opus 5 outscored Muse on all four. Muse finished third on DeepSWE, the test most closely tied to sustained work inside real codebases.

Its 24-hour kernel experiment shows that the system can continue one specialized assignment through repeated testing and revision, but Muse Code remains in beta with no broad adoption or production-reliability figures yet.

Teams that prioritize lower costs and coordinated, long-running agent work may find that combination worth accepting Meta’s closed access. Those that need to run the model independently, retain greater control over their systems, or choose a product with a longer operating record may still prefer an open-weight model or the established OpenAI and Anthropic alternatives.

Meta has nevertheless entered the agentic coding competition with another credible option for developers, and its success will depend on whether that combination of price, coordination, and sustained execution proves valuable in everyday software work.

Q: What is Meta’s Muse Code, and what does Muse Spark 1.2 do?
A: Muse Code is Meta’s beta AI coding agent, while Muse Spark 1.2 is the closed model that powers it. Launched on August 5, the model-and-agent system is designed to plan changes, write and test code, and complete long-running software assignments in competition with OpenAI’s Codex and Anthropic’s Claude Code.

Q: How does Muse Code work on long coding projects?
A: Muse Code gives the larger objective to a main agent while persistent background agents investigate problems, make changes, or review completed work at the same time. The background agents remain active throughout the session, allowing them to retain what they have learned and continue follow-up work without rediscovering the project. A local event log records model calls, tool use, approvals, and code changes so an interrupted assignment can be reconstructed instead of restarted.

Q: Why did Meta build Muse Spark 1.2 and Muse Code together?
A: Meta trained Muse Spark 1.2 with Muse Code’s tools and agent workflows so the model would already know how to plan work, preserve important context, pursue goals, and cooperate with subagents. This co-training is intended to reduce the friction that can occur when a general AI model is placed inside a coding system it was not specifically trained to use.

Q: Is Muse Spark 1.2 open source, and can I run it myself?
A: Muse Spark 1.2 is a closed model, departing from the open-weight approach associated with Meta’s Llama releases. Developers can use it through Muse Code, Meta’s Model API, and OpenRouter, but Meta does not provide the model weights needed to download and run it on their own infrastructure.

Q: How much does Muse Spark 1.2 cost, and will Meta use my data?
A: Meta’s standard API tier charges $1.25 per million input tokens and $4.25 per million output tokens, while Meta says customer usage will not be used to improve its products. The contributor tier lowers those prices to $0.10 and $0.20, respectively, in exchange for allowing Meta to use that activity for product improvement. Customers therefore choose between limiting Meta’s use of their activity and receiving a substantially lower price.

Q: How does Muse Code compare with Codex and Claude Code?
A: Meta’s comparisons do not establish Muse Code as the consistent leader. Muse beat GPT-5.6 Terra with Codex on three of four benchmarks, while Claude Opus 5 with Claude Code scored above Muse on all four. Muse also trailed both rivals on DeepSWE 1.1, the test most closely tied to long-running work inside real codebases. Meta’s 24-hour GPU experiment showed that Muse could sustain one specialized assignment through more than 1,000 tool calls, but it did not compare rival agents or establish how reliably Muse performs across everyday software projects.

Q: Should my company use Muse Code?
A: Companies should evaluate whether Muse’s lower prices, persistent agents, and recovery system produce dependable completed work in their own software projects. They must also decide which data-use tier fits their policies and whether a closed model meets their need for control over code and infrastructure. Muse Code is still in beta, so teams that value a longer record of real-world use may prefer a more established coding agent or an open-weight model they can operate themselves.

Muse Code gives engineering teams a credible alternative to Codex and Claude Code for long-running software assignments. Meta is competing through the combination of lower prices, coordinated agents, recoverable work, and a model trained for its coding system.

Muse’s strongest argument is the complete model-and-agent system. Meta trained Muse Spark 1.2 to work with Muse Code’s tools and agent structure, giving the model experience with the system in which developers will use it. Meta’s benchmarks make Muse a credible competitor, although they do not establish superior performance across everyday software projects.

Software development teams comparing Codex and Claude Code should care because Muse adds a lower-priced third option built for long coding projects. Security and data-governance teams should care because Meta’s contributor tier exchanges a much lower price for permission to use customer activity to improve its products. Organizations that require models to run on their own infrastructure may find Muse unsuitable because Meta chose to keep Muse Spark 1.2 closed.

Long-running agentic work can involve hundreds or thousands of model and tool interactions, making price a greater concern for companies using agents regularly. Muse’s lower prices could reduce the cost of long AI-assisted coding assignments, while its parallel agents allow several parts of the work to proceed at the same time. Meta’s 24-hour test involved more than 1,000 tool calls as Muse wrote, compiled, measured, and revised its code. Muse Code’s event log also allows an interrupted assignment to be reconstructed instead of losing the work already completed.

Companies considering Muse should test it on the software work their teams do every day and look at the final result. They should track what went wrong, how often employees had to step in, whether Muse recovered after interruptions, the quality of the finished code, and the total cost. Teams then need to answer three questions: Does Muse work reliably for them? Is the contributor tier’s lower price worth letting Meta use their activity to improve its products? Are they comfortable using a closed model they cannot operate on their own infrastructure and that has less history in everyday use?

In short, Muse’s integrated design gives it a credible case for long-running coding work. Companies still need to determine whether the finished results justify the data trade-off and the limits of using a closed model.

Muse can compete on price today. Its future depends on what it can finish tomorrow and whether that gives development teams a reason to switch from Codex or Claude Code.

Editor’s Note: This article was created by Alicia Shapiro, CMO of AiNews.com, with writing support, AEO/GEO/SEO optimization, image concept development, and editorial structuring support from ChatGPT, an AI assistant. All final editorial decisions, perspectives, and publishing choices were made by Alicia Shapiro.