Meta has entered the agentic coding race with Muse Code, a terminal-native AI coding agent powered by Muse Spark 1.2. It brings persistent agents, parallel worktrees, session recovery and aggressive pricing, positioning Meta against Claude Code and OpenAI Codex.
On August 5, 2026, Meta Platforms introduced Muse Code, a beta terminal-based AI coding agent powered by its latest model, Muse Spark 1.2. The release marks Meta’s most direct entry yet into the competitive field of agentic coding tools, positioning the product against established offerings such as OpenAI’s Codex and Anthropic’s Claude Code.
Designed for complex, repository-scale software-engineering tasks, Muse Code emphasizes planning, implementation, validation and multi-agent coordination. Meta and its Superintelligence Labs team have framed it as a practical system for developers who need agents capable of handling long-horizon work with reduced manual intervention. The launch arrives amid the rapid maturation of AI coding assistants. Developers increasingly rely on agents that move beyond single-file suggestions to manage multi-file changes, debugging sessions and end-to-end workflows. Muse Code aims to address those demands through a combination of persistent background agents, parallel execution and competitive pricing.
What Is Muse Code?
Muse Code is Meta’s first dedicated coding agent. It is a terminal-native application available for macOS and Linux and can be installed with a single command:
curl -fsSL https://dev.meta.ai/install.sh | bash
Developers operate Muse Code from the command line, while model inference is delivered through Meta’s hosted Model API. Once installed and authenticated, developers can interact with the agent through natural-language prompts or structured slash commands. Muse Code is designed to take on complete software-engineering tasks across large repositories. It can plan necessary changes, write and edit code, run tests and validate results.
Unlike many earlier AI coding assistants that focused primarily on code completion or isolated functions, Muse Code is structured as an agentic system. It maintains context across extended sessions and coordinates specialized sub-agents to address different aspects of a problem. Meta trained Muse Spark 1.2 and Muse Code together so that the model and the agent harness could operate as an optimized pair. This co-training approach is intended to improve instruction following, codebase understanding and reliability during long-running projects.
The tool supports both interactive use and headless execution, making it suitable for individual developers as well as integration into scripts or continuous-integration pipelines. A local event log records model calls, tool use, file edits and user approvals. This allows the system to reconstruct session state and resume work following a crash or interruption-a practical feature for multi-hour or multi-day coding sessions.
Key Features of Muse Code
Several design choices distinguish Muse Code from earlier generations of coding assistants. Persistent asynchronous background agents form a core part of the architecture. Rather than spawning temporary helpers for every subtask, Muse Code can keep specialized background agents active throughout a session.
These agents accumulate knowledge about the repository and the current state of work, reducing the need to repeatedly re-explore the codebase. They can perform preparatory work and decide when to report findings to the main agent. Meta argues that this design can reduce the “re-exploration tax” associated with long-running agentic tasks and may reduce the amount of continuous human direction required.
Parallel sub-agents and isolated worktrees allow the system to scale its effort on larger jobs. When a task is sufficiently complex, Muse Code can distribute work across multiple sub-agents operating simultaneously. Each sub-agent works in its own isolated Git worktree, leaving the developer’s primary working copy untouched. In a demonstration described by Meta, the system built six features for a game in parallel without creating code collisions.
This approach is intended to accelerate substantial software changes while limiting the risk of destructive interference between agents. Bundled skills provide structured ways to guide the agent. Commands such as /plan convert a high-level request into an approval-gated plan, /grill stress-tests that plan for weaknesses and /goal directs the agent towards completion of a defined objective.
These skills give developers clear control points while still allowing the agent substantial autonomy. Together, these capabilities target long-horizon software-engineering work-the kind of multi-file refactoring, feature implementation and debugging campaigns that previously demanded continuous human direction.
The Power Behind It: Muse Spark 1.2
Muse Code is powered by Muse Spark 1.2, a coding-focused update to the Muse Spark 1.1 model released roughly a month earlier. Meta reports that it significantly increased the training compute dedicated to coding tasks and expanded the diversity of training environments. According to the company, the result is improved performance in code generation, complex debugging, codebase understanding and end-to-end developer workflows.
The model retains strengths in general agentic behaviour while specializing more heavily in software engineering. It supports a context window of approximately one million tokens and is available both within Muse Code and through the Meta Model API. Because the model and agent were co-trained, Muse Spark 1.2 is optimized for the specific patterns of tool use, planning and multi-step execution employed by Muse Code.
In company-reported launch evaluations, Meta says Muse Spark 1.2 with Muse Code scored 82.9% on Terminal-Bench 2.1. It trailed Claude Opus 5 with Claude Code, which Meta reported at 86.7%, while remaining ahead of or close to several other systems included in the company’s comparison, including OpenAI’s GPT-5.6 Terra on Codex.
On DeepSWE 1.1, which evaluates repository-modification ability, Meta reported a score of 59.3%. This placed Muse Code third among the systems included in Meta’s published comparison, behind Claude Opus 5 and GPT-5.6 Terra. Meta also published results from an internal coding benchmark derived from real pull requests. The system performed competitively in that evaluation but continued to trail the leading Claude configuration.
These figures indicate that the coding agent enters a field where performance differences are increasingly measured in single-digit percentages rather than order-of-magnitude gaps. However, the figures should be interpreted as company-reported launch results. Independent evaluation across varied repositories, languages and operating conditions will be necessary to establish how consistently the system performs outside Meta’s testing environment.
How Muse Code Competes in the Agentic Coding Race
The agentic coding market has become one of the most contested segments of applied artificial intelligence.
Anthropic’s Claude Code has developed a reputation for strong multi-step reasoning and long-context handling. OpenAI’s Codex offers integration with the broader ChatGPT ecosystem and support for parallel cloud agents. Open-source and model-agnostic coding systems are also continuing to evolve rapidly.
Meta’s strategy with Muse Code centres on three pillars: architectural differentiation through persistent background agents and parallel isolated worktrees, co-training of the model and agent harness, and aggressive pricing. Meta has highlighted the system’s ability to handle complete software-engineering tasks across large repositories with less intervention. By keeping background agents active for the duration of a session and enabling isolated parallel execution, the company aims to reduce the repeated repository exploration that can slow existing coding agents.
The company is also leveraging its infrastructure and model-development capabilities. Its contributor pricing tier, discussed below, creates an economic incentive for developers who are comfortable allowing their usage to contribute to the improvement of Meta’s products.
For technology enthusiasts and professional developers, the practical question is whether Muse Code’s combination of persistence, parallelism and cost can produce a smoother daily experience than the current leaders. The system may be particularly interesting for teams that value terminal-native workflows, long-running autonomous sessions and transparent local activity logging.
Its strongest differentiation may ultimately lie not in outright benchmark leadership, but in the combination of persistent agent architecture, session recovery, isolated parallel execution and unusually aggressive pricing.
Pricing and Availability
Muse Code is available in beta for macOS and Linux users. Access is provided through a pay-as-you-go model via the Meta Model API. The standard tier is priced at $1.25 per million input tokens and $4.25 per million output tokens, with lower rates for cached input.
A contributor tier offers substantially lower pricing-approximately $0.10 per million input tokens and $0.20 per million output tokens. Under this tier, usage may be used by Meta to improve its products.
Rate limits differ between the tiers, with the standard option supporting higher throughput. This pricing structure lowers the barrier to experimentation while creating an economic incentive for developers who are comfortable contributing usage data. It also creates an important trade-off. The contributor tier offers extremely low prices, but developers and organizations must evaluate whether its data-usage conditions are appropriate for their source code, repositories and contractual obligations.
The company states that activity under the standard model tier is not used to improve its products. However, organizations handling proprietary or regulated source code should still review the applicable processing, retention, security and contractual terms before adopting the platform.
The pricing is competitive relative to comparable usage on several leading rival models, particularly for high-volume agentic workloads. Installation is straightforward, and Meta’s documentation covers quick starts, multi-agent orchestration examples and integration patterns. Expanded global access to the underlying model was also announced at launch.
Potential Impact on Developers and the Industry
The arrival of Muse Code intensifies competition in a market that is moving quickly from novelty towards production use.
For individual developers and small teams, a capable terminal agent with restart-safe sessions and parallel execution could reduce the friction associated with large refactors, exploratory development and multi-step debugging. For larger organizations, the combination of competitive pricing, local activity logs and isolated execution environments may influence product-evaluation decisions. Enterprise adoption, however, will depend not only on model performance but also on security controls, data-processing terms, administrative governance and reliability across real production codebases.
More broadly, Meta’s entry reinforces several industry trends: the shift towards specialized agent harnesses rather than general chat interfaces, the importance of co-designing models and runtime environments, and the growing role of pricing and data feedback loops in frontier-model development.
As coding agents become more autonomous, capabilities such as persistent context, isolated parallel execution, approval gates and reliable recovery after failures may gradually become expected components of agentic development systems rather than standalone differentiators. It nevertheless remains early. The coding agent is still in beta, and real-world performance across diverse codebases, programming languages and organizational constraints will determine its long-term standing.
Benchmarks provide useful signals, but the ultimate measure for most developers will be whether the tool consistently reduces the time and cognitive effort required to ship reliable software without introducing unacceptable risks.
Meta’s release of Muse Code and Muse Spark 1.2 represents a deliberate step into the agentic coding arena. By focusing on terminal-native operation, persistent background agents, multi-agent coordination, repository-scale capability and accessible pricing, the company has created a product that directly challenges the current leaders. For technology enthusiasts following the evolution of AI software-engineering tools, the coming months will reveal how effectively Muse Code translates its architectural and economic advantages into everyday developer productivity.
Developers interested in evaluating the system can install the beta and begin experimenting with its planning, parallel-execution and validation features.
As with any new agentic coding tool, generated changes should be carefully reviewed. Approval gates should be used appropriately, and developers should examine the data-sharing implications of the contributor tier before using it with confidential or proprietary repositories. The competitive landscape continues to evolve rapidly, and Muse Code is now a notable participant in that ongoing race.