Business Insider first reported the launch’s central commercial proposition on August 5: Meta is selling Muse Spark 1.2 API access below the rates commonly associated with high-end coding models, while positioning Muse Code as an agent that can write code, run tests, and validate results across complex projects. The Tech Buzz also reported the launch, but its claim that Meta had not detailed pricing, availability, or technical specifications was already out of date when published; Meta’s published pricing and the beta’s platform limitations were available through launch coverage.
The important development is not simply that Meta has another code model. Muse Code is Meta’s first attempt to ship the entire coding-agent stack: a command-line harness, persistent worker agents, worktree isolation, long-context model access, and a pricing model that explicitly discounts development data Meta can reuse.
For developers, that makes Muse Code a real Claude Code and Codex alternative worth testing. For administrators and organizations with Windows-heavy, proprietary repositories, it also creates a more complicated risk and deployment decision than the launch messaging suggests.
Muse Code is designed to keep working after the first prompt
Meta says Muse Code can perform whole-repository engineering work rather than simply autocomplete a function or answer a coding question. Its design centers on a main agent supported by specialized background agents that remain active through a session, instead of being created and discarded for each task.
Those background agents can investigate a codebase, plan changes, run tools, and report findings back to the main process. For larger jobs, Muse Code can hand work to parallel sub-agents in isolated Git worktrees, an approach intended to prevent simultaneous agents from modifying the same files in a developer’s checked-out branch.
Meta has also built an append-only local event log into the runtime. The company says that log records model calls, tool use, edits, approvals, and other state changes, allowing a crashed or interrupted session to resume rather than rebuilding its context from scratch. That is a meaningful feature for a tool meant to run over many hours: the operational problem with long-running coding agents is often not model capability but whether a failed terminal session loses the state needed to finish safely.
The beta includes workflow commands intended to put a checkpoint before the most consequential work. Meta describes /plan as an approval-gated planning step, /grill as a way to stress-test a plan, and /goal as a mechanism for keeping an agent directed at a specified outcome. The presence of those controls is useful, but it should not be mistaken for a review system. An approval gate is only as strong as the person reading the plan and the repository permissions granted to the process.
Meta demonstrated the agent making more than 1,000 tool calls during GPU-kernel optimization tasks that ran for as long as 24 hours. That is evidence that the harness can sustain a lengthy workload under controlled conditions. It is not evidence that Muse Code will safely refactor a company’s mixed-age .NET, PowerShell, JavaScript, and infrastructure-as-code estate without human review.
The Windows story is WSL, not native Windows
For Windows users, the first deployment detail matters more than the benchmark numbers: Muse Code is presently delivered for macOS and Linux, with WSL serving as the route for Windows machines. Meta has not announced a native Windows installer, a PowerShell-first workflow, or a Windows Terminal-specific build.
That puts Muse Code behind Claude Code on platform coverage. Anthropic’s current Claude Code documentation includes native Windows installation through PowerShell and WinGet, alongside macOS, Linux, and WSL options. OpenAI’s Codex is also available in developer terminal workflows that do not require a Linux compatibility layer as the default Windows path.
WSL is a practical environment for many developers, especially those already using Ubuntu, Docker, dev containers, Git, and VS Code Remote - WSL. But it is not a transparent substitute for native Windows support in managed fleets. Repository locations, credentials, corporate proxies, endpoint protection, Git configuration, line-ending behavior, filesystem performance, and access to Windows-native build tools all need to be tested rather than assumed.
The worktree model adds another operational consideration. Isolating agents in worktrees can reduce direct file collisions, but it also means organizations should expect additional repository copies and build artifacts on developer machines. On a WSL setup that crosses between the Linux filesystem and mounted Windows drives, that can make performance and path discipline more important than it would be for a simple chat-based assistant.
For a Windows development team, the sensible initial use case is a disposable WSL-hosted clone with constrained credentials and no deployment access. Let Muse Code inspect, plan, make a branch, and run local tests. Do not begin by giving it a production-connected shell, broad cloud credentials, or access to the only working copy of a legacy application.
Meta’s low-price pitch comes with a data-use fork
Business Insider reports that standard Muse Spark 1.2 access costs $1.25 per million input tokens, $0.15 per million cached-input tokens, and $4.25 per million output tokens. Those are usage prices for the model behind Muse Code, not a clean like-for-like replacement for Claude Code or Codex subscriptions.
That distinction is being glossed over in the competitive framing. Anthropic and OpenAI bundle their coding products into plans with usage limits, while Meta is quoting metered model costs. A developer who sends a few prompts a day and a team that keeps a long-running agent indexed against a large repository will produce radically different bills. Cached-context pricing helps when the same repository material is reused, but it does not answer the budget question without real telemetry from a working project.
Meta also offers a sharply discounted “contributor” tier under which user activity may be used to improve Meta’s products. That is the launch’s most consequential commercial term. The cheapest Muse Spark option is not simply a lower-performance plan; it is a data-sharing choice.
For hobby projects, prototypes, public open-source work, or carefully sanitized test repositories, that may be an acceptable trade. It could allow small teams to experiment with long-context, agentic coding at a lower cost than competitors. For source code containing customer logic, trade secrets, unreleased product plans, credentials accidentally left in configuration files, or regulated data, it should be treated as disqualifying unless the organization has separately cleared that use.
Meta’s standard paid tier is presented as the alternative for customers that do not want their activity used for product improvement. But the launch coverage does not establish the full set of enterprise controls a security team will ask about: retention periods, contractual data-processing terms, tenant isolation, audit logging, identity integration, administrative controls, regional processing, and the exact handling of tool outputs. Those omissions do not prove the controls are absent. They do mean a public beta announcement is not enough to approve the agent for sensitive repositories.
Benchmark claims do not settle the production question
Meta says Muse Spark 1.2 was trained alongside Muse Code’s harness, including trajectories covering planning, compaction, sub-agent coordination, repository-scale generation, and longer engineering tasks. Co-training the model and the agent environment can be an advantage: the model is less likely to stumble over its own tool syntax or lose the thread of a multi-step process.
Meta has also highlighted Terminal-Bench 2.1 results for the model. Benchmarks are useful indicators of whether an agent can interact with shells and development tools under repeatable conditions, but they do not measure the things that make an enterprise rollout succeed: whether the tool honors local conventions, makes understandable commits, avoids destructive changes, works through a corporate proxy, and stops when uncertainty is high.
The biggest comparative disadvantage is maturity, not necessarily model intelligence. Claude Code and Codex have built user habits, editor integrations, configuration files, permissions models, and accumulated knowledge around failure modes. A coding agent is not adopted merely because it writes a good patch; it is adopted because a team can make its behavior predictable enough to put it inside an existing review and release process.
Meta has entered that race with an intriguing technical architecture and a price lever that rivals may have trouble matching. It has not yet shown that it can provide the surrounding administration, Windows support, and trust controls needed to move from experimental developer tooling to broad enterprise use.
Muse Code is available globally in beta, but for Windows organizations that should be read as available to evaluate through WSL, not ready to standardize across native Windows development environments.
Update: Additional details (August 6, 2026)
Neowin reports that Meta’s contributor tier is priced at $0.10 per million input tokens, $0.002 per million cached-input tokens, and $0.20 per million output tokens. Access at those rates requires permission for Meta to use prompts and completions to improve future products.
The same report describes Muse Code as a native terminal binary for macOS and Linux, reinforcing that WSL remains the available route for Windows users rather than a native Windows release.
Update: Meta reportedly adds a zero-data-retention option for Muse Code (August 6, 2026)
CHOSUNBIZ reports that Meta has introduced a zero-data-retention option for Muse Code, which Meta Superintelligence Labs head Alexander Wang described as important for corporate customers. This goes beyond the contributor tier’s training-data tradeoff: the option is reportedly intended to prevent developer data from being retained or used to improve Meta’s models.
That could materially change the evaluation path for organizations whose source code cannot be submitted under the discounted contributor terms. It does not, however, establish that Muse Code is enterprise-ready for sensitive Windows repositories. Meta has not yet publicly detailed the retention duration, contractual terms, identity controls, auditability, regional processing, or administrative policy controls that IT and security teams would need to assess.
The report also reinforces Meta’s performance positioning: Muse Spark 1.2 is presented as competitive on terminal-agent benchmarks, but not as the clear leader over Claude Code. For Windows organizations, the immediate deployment constraint remains unchanged: Muse Code still requires a Linux environment through WSL rather than offering a native Windows terminal workflow.
Update: Independent testing finds Muse Code cheaper but less thorough than Claude Code (August 11, 2026)
The New Stack reports that in three controlled tests on the Day.js JavaScript library, Muse Code completed the required bug-fixing, refactoring, and timezone-reasoning tasks at dramatically lower contributor-tier cost than Claude Code—but with less polished results.
According to the outlet’s testing, Muse fixed the planted bugs and passed required checks, but Claude Code produced a more substantial multi-file refactor, resolved additional environment-related test failures, and left cleaner changes in the open-ended reasoning task. Muse reportedly used about 8.9 million tokens across the tests for $0.06 at the contributor rate, compared with an API-equivalent $9.41 estimate for Claude Code; at Meta’s standard rates, the Muse runs would have cost roughly $2.
This is not a broad benchmark: it is one outlet’s three-task comparison using a public repository. Still, it reinforces a practical Windows-team concern: lower model spend does not eliminate review cost. Organizations evaluating Muse through WSL should treat passing tests as a checkpoint, not proof that an agent’s patch is complete, maintainable, or ready to merge.
