Meta Launches Muse Code, the First Terminal Programming Agent with Long-Running Capabilities and a 95% Discount Option

On August 5, 2026, Meta released its first terminal programming Agent—Muse Code—alongside the Muse Spark 1.2 model, specifically optimized for programming. Muse Code can read large codebases, formulate modification plans, write code, run tests, and verify results, while allowing multiple background Agents to remain active throughout a session without needing to re-understand the project for each new task. Meta also designed a local event log with append-only, non-overwrite capabilities, enabling precise recovery to the point of interruption even after a crash. What truly sparked developer discussion was the pricing: the standard version charges $1.25 per million input tokens and $4.25 per million output tokens; if users permit Meta to use their input and output data to improve its products, the “Contributor Version” drops to $0.10 and $0.20 respectively. The trade-off behind this low price is not a typical promotion, but rather access to code and usage data. Official evaluations show that Muse Spark 1.2 is approaching the performance of leading programming models, though it has not yet fully surpassed them, and some results have not been independently replicated. Meta’s message this time is clear: the unit of competition in AI programming is shifting from individual models to complete systems comprising models, Agent execution frameworks, long-term state, and data闭环.

Article author, source: Meta AI Research

Muse Code is Meta's first terminal-based programming agent, currently available in beta for macOS and Linux. It is not designed for code completion, but rather for full software engineering tasks: entering a large codebase, understanding its existing structure, formulating a plan, modifying multiple files, running commands and tests, and iteratively refining results based on outcomes.

This places Muse Code directly into the market being contested by products like Claude Code, Codex, and Gemini CLI. The model no longer merely answers “How should this code be written?” but gains access to terminals, file systems, and development tools to continuously execute tasks with minimal human intervention.

In its published article, Meta introduces Muse Code and Muse Spark 1.2 as a single integrated system, not as two separable products. Muse Spark 1.2 handles understanding, reasoning, and generation, while Muse Code manages context organization, sub-Agent scheduling, tool invocation, state preservation, and result validation. The two were jointly optimized during training, meaning the same model may not reproduce Meta’s demonstrated results when transferred to other Agent frameworks.

The most distinctive design of Muse Code is a set of background agents running asynchronously.

Common multi-agent systems temporarily create an assistant when a subtask needs to be executed—for example, to locate relevant files, analyze test failures, or research a dependency. Once the task is complete, the assistant’s context is often discarded; when a similar issue arises again, the system may rescan the same codebase and redundantly collect the same information.

The background agents of Muse Code remain active throughout the entire session. They can continuously build understanding of the codebase, autonomously advance to the next steps, and decide when to report their results to the main agent. The main agent coordinates objectives, while the background agents can independently investigate different modules, review tests, identify call relationships, or verify implementation approaches.

This design addresses a common inefficiency in long tasks: the agent repeatedly forgetting what it has already seen. As long as the background agent’s state is reliably preserved, it doesn’t need to reread the project structure at each step, and humans don’t need to continually remind it, “You already checked this file.”

However, multiple agents modifying code simultaneously can lead to conflicts, permission issues, and cost concerns. Meta’s public article does not fully disclose how tasks are partitioned, how code changes are merged, or how other agents avoid inheriting erroneous conclusions if one background agent fails. Therefore, continuous agents represent a promising architectural direction, but their stability in real-world team projects cannot yet be judged solely based on official demonstrations.

Long-running programming agents face a very real issue: the longer the task, the more likely it is to encounter network interruptions, tool errors, process crashes, or context limits. If the system only saves the current state within the model conversation, a single failure could result in the loss of hours of exploration work.

Muse Code maintains a local event log. Each model invocation, tool execution, user approval, and file modification is appended to the log, and historical events are not directly overwritten by subsequent states.

Meta calls this mechanism "exactly reproducible" and "restart-safe." When an Agent crashes midway, the system can restore work based on event logs rather than guessing what previously occurred. This effectively transforms programming Agents from temporary conversations into more stateful engineering workflows.

Muse Code also includes several callable skills:/plangenerates an execution plan requiring user approval;/grillcritically challenges the plan to identify omissions, risks, and flawed assumptions;/goalenables the Agent to continuously execute toward a specified goal until completion criteria are met.

The underlying idea behind these features is clear: if AI is to handle hours of software engineering work, it’s not just about whether the code generated at each step is elegant, but whether it can save progress, accept reviews, identify flaws in the plan, and continue execution after failures.

Muse Spark 1.2 is a programming-enhanced version released less than a month after version 1.1. Meta states that it increases the computational power and diversity of training environments for programming tasks, with a focus on improving code generation, complex debugging, codebase understanding, and end-to-end development workflows.

The training scope includes not only single-file repair but also full code repository generation, large end-to-end projects, and automated research tasks. The model uses plans to sequence work steps, maintains direction through goal conditions, and compresses information as the context grows, preserving only what is truly needed for subsequent tasks.

Meta also involves Muse Spark 1.1 in training the next-generation model. The older model generates more complex programming environments and instruction-following templates, then scores whether candidate solutions meet the requirements, thereby producing large volumes of data for version 1.2 to learn from.

The "self-improvement" referred to here still does not mean the model modifies its own weights independently after脱离 human control. A more accurate description is that the previous-generation model is used as a data generator and evaluator to help the team scale up the training data for the next generation. The data pipeline, training runs, and final model releases remain under Meta's control.

More importantly, Meta did not train a separate "code-writing model," but instead incorporated Muse Code’s tools, goal management, context compression, and sub-agent trajectories into the training process. The capabilities of future programming models may increasingly depend on which agent framework they become familiar with during training.

A case provided by Meta involves optimizing KDA and MLA kernels on NVIDIA Hopper GPUs within the Muse Code environment using Muse Spark 1.2. The system must autonomously write code, compile it, analyze performance, and iteratively refine it based on the results.

The entire test ran for a maximum of 24 hours, with over 1,000 tool invocations. Researchers prohibited the model from directly importing pre-existing third-party kernel libraries and required it to implement the algorithm in Triton, seeking genuine performance improvements rather than wrapping existing implementations as its own results.

In the KDA task, the model combines parallel within-block preparation kernels with sequential across-block scans, incorporating specialized optimizations for gated accumulated decay. In the MLA task, it designs a Triton pipeline composed of two kernels and attempts to reuse shared KV latent representations.

The importance of such cases lies not in a single acceleration number, but in whether the Agent can maintain its goal, understand performance analysis data, and generate the next round of experiments after hundreds of failures and intermediate results. If a system can only operate stably for十几 minutes, it is more like an advanced completion tool; only when it can drive progress for 24 hours does it begin to approach an Agent worthy of delegating engineering research.

Meta's evaluation covers Terminal-Bench 2.1, DeepSWE 1.1, GDPVal-AA v2, MCP Atlas, and internal programming tests. Terminal-Bench 2.1 includes 89 tasks requiring completion in a terminal environment; DeepSWE 1.1 includes 113 tasks drawn from 91 code repositories, covering five programming languages.

According to Meta’s published charts, Muse Spark 1.2 achieved 82.9% on Terminal-Bench 2.1 with Muse Code, below Claude Opus 5’s 86.7% but above Codex and Grok Build in its evaluations. On DeepSWE 1.1, Muse Spark 1.2 scored 59.3%, not ranking first. In Meta’s internal evaluation of 440 real engineering tasks, it achieved 70.6%, also trailing behind Opus 5.

These results indicate that Muse Code has entered the competitive range of top-tier programming agents, but they do not support the conclusion that Meta has fully outperformed Claude Code and Codex.

Officialevaluation methodology documentalso states that each model was paired with its respective Agent product: Muse Spark with Muse Code, Claude with Claude Code, GPT with Codex, Gemini with Antigravity, and Kimi with Kimi Code. This comparison more closely reflects a full product showdown, but it cannot determine whether the results stem from the model or the Agent framework.

Meta also acknowledges that its internal evaluation environment and prompts may not be optimally tuned for third-party closed-source models. Muse Spark 1.2’s performance on Terminal-Bench has not yet appeared on any independent verification leaderboard. Therefore, the most accurate statement at this stage is: Meta’s internal tests show it approaches state-of-the-art performance, but independent replication is still lacking.

The Muse Spark 1.2 Standard edition charges $1.25 per million input tokens, $0.15 for cached inputs, and $4.25 for outputs. Input and output for this version will not be used to improve Meta products.

Another model, labeledmuse-spark-1.2-contributor, costs only $0.10 per million input tokens, $0.002 for cached inputs, and $0.20 for outputs—92% cheaper for inputs and approximately 95% cheaper for outputs compared to the standard version.

The cost is that contributor versions of prompts and model outputs may be used by Meta to improve its products. For open-source projects, personal experiments, or work that does not contain sensitive information, this may be a very attractive trade-off; however, for enterprise proprietary code, unreleased products, customer data, key configurations, and projects subject to confidentiality agreements, this is first and foremost a data governance issue, not a pricing issue.

Enterprises cannot assume that simply because the token price is favorable, the entire codebase should be handed over to a contributor version. Whether data may be used for training must be determined by considering Meta’s specific terms of service, code ownership, customer contracts, and internal security policies. The standard and contributor versions may use similar capabilities, but they correspond to two entirely different data relationships.

This also reveals Meta’s true competitive strategy: it not only aims to attract developers with low prices, but also seeks to build a new closed loop of programming training data through the tasks, modifications, feedback, and outcomes generated when developers use Muse Code. Developers gain access to nearly free Agent calls, while Meta may acquire data more valuable than publicly available GitHub code—real insights into how tasks are broken down, modified, and validated.

In the past, people evaluated programming AIs primarily by comparing how many problems the models could solve. Muse Code demonstrates a different competitive logic: the model is just one part of the system; whether the backend agent maintains state, whether tool calls are reliable, whether tasks can be resumed, whether context is correctly compressed, and whether iteration can continue after failure may be more important than single-code-generation capability.

Meta also explicitly stated that larger models and more Agent framework features will be introduced in the future. This means that Muse Spark 1.2 is not the final flagship product, but rather Meta’s first complete infrastructure for entering the programming Agent market.