Having an agent handle a large codebase isn't something that swapping out the model alone can accomplish. Long implementation work requires an execution foundation that preserves intermediate decisions, receives results from parallel processes, and can resume failed processes. On August 5, Meta released a beta of "Muse Code," a terminal-based coding agent that includes this execution layer. The new Muse Spark 1.2 was co-trained with the Muse Code harness.
Muse Code is available on macOS and Linux, handling planning, implementation, and verification for large repositories from the terminal. What Meta is offering here isn't a standalone model, but a product that includes the harness enabling the model to use tools and sustain long-running processes. This differs in intent from designs that feed a large context window and expect an answer in a single pass.
Installation is done via curl -fsSL https://dev.meta.ai/install.sh | bash. That said, for this beta version of Muse Code, the announcement doesn't detail the scope covered by pricing, usage limits, or supported regions. Being able to try it from the terminal and being able to integrate it directly into an organization's development workflow are two separate matters.
Resident Agents That Connect Long-Running Tasks
In addition to the normal agent loop, Muse Code runs asynchronous background agents that persist throughout each session. This isn't a mechanism that persists across sessions, but rather a design where specialized agents continue operating during a session. They advance subsequent processing in parallel with the main work and report results back to the main agent. For work that spans multiple modules, this allows investigation and follow-up processing to run in the background rather than waiting for free time.
The other pillar is a local append-only event log. According to Meta, this appends model calls, tool executions, approvals, and edits. Based on this log, execution can be accurately reproduced, and even if a crash occurs, work can resume from the point where it stopped.
Parallelization and resumability serve different roles. The former handles what to advance proactively during work, while the latter ensures the same history can be traced even if processing is interrupted. The standard skill /plan creates a plan with approval, /grill stress-tests that plan, and /goal handles achievement of a specified goal. The more scope handed over to the agent, the more this kind of intermediate-state management determines whether implementation succeeds.
1.2 Was Trained Together with the Harness
Muse Spark 1.2 is an update to Muse Spark 1.1, targeting code generation, complex debugging, codebase understanding, and end-to-end development workflows. Meta says it co-trained the model with Muse Code, using execution trajectories on the harness selected via rejection sampling. Furthermore, they say they optimized recipes for goals, compaction, and subagents, and also integrated Muse Code's toolset.
Training for long-duration tasks included whole-repository generation, large-scale end-to-end projects, and auto-research. The planning, goal conditioning, and context compaction used here are techniques for not losing sight of the current objective during long processing. What's being trained isn't limited to how the model responds to instructions—it also includes how the harness passes goals and compacted context.
A self-improvement procedure was also built into how the training data was created. Meta says it used Muse Spark 1.1 to generate difficult coding environments and instruction-following templates, and had the same model score how well candidate solutions met requirements. This means 1.2 was trained—using the tasks and evaluations created by the previous generation as a foundation—to more accurately follow complex instructions.
For GPU kernel optimization, Meta explains it tested KDA/MLA kernels for NVIDIA Hopper, with over 1,000 tool calls and runs lasting up to 24 hours. They say this showed significant improvement over the baseline, but the announcement text doesn't include an improvement percentage. This case demonstrates that long-running code exploration is possible—it isn't a measurement of speed or productivity for general development tasks.
Even at 1M Tokens, Codebase Understanding Is a Separate Problem
Muse Spark 1.2's context window is 1 million tokens. However, the difficulty of large codebases isn't determined solely by how much can be loaded. Dependencies between modules, implicit naming conventions, and compatibility constraints must continue to be explored even during changes.
In April 2026, Meta shared another internal case study—an effort that expanded AI-oriented navigation from roughly 5% to 100% across 4 repositories, 3 languages, and over 4,100 files. In preliminary testing, this reduced tool calls and tokens per task by approximately 40%. What this case study addressed was context files and dependency indexing—it wasn't a measurement of Muse Code's capabilities.
By contrast, what Muse Code aims to compensate for isn't pre-computed code knowledge, but rather maintaining direction during long processes, parallel work, continuation after crashes, and coordination with the harness. That said, even with a 1-million-token context and a resumption mechanism, there's no guarantee it can correctly read the implicit knowledge buried in a specific repository. "Handling large repositories" is a target domain—it's not an expression that guarantees accuracy for every change.
Pricing Reflects Data Usage; Evaluation Should Be Read Through the Harness
Muse Spark 1.2 is offered through Muse Code and the Meta Model API, and Meta says it has expanded availability worldwide. The Meta Model API is in public preview. The pricing table lists a contributor tier, noted as being used for product improvement, alongside a standard tier, noted as not being used for that purpose.
| Tier | Input (per 1M tokens) | Cached Input (per 1M tokens) | Output (per 1M tokens) | Pricing Table Note |
|---|---|---|---|---|
| Contributor Tier | $0.10 | $0.002 | $0.20 | Used for product improvement |
| Standard Tier | $1.25 | $0.15 | $4.25 | Not used for product improvement |
What this table shows is the data-usage distinction as it appears in the pricing table. It doesn't reveal the extent to which code, prompts, and tool history are stored or used beyond that. Users connecting their own repositories need to verify this handling individually, alongside the price difference.
Benchmarks also can't be compared by numbers alone. According to Meta's methodology, Terminal-Bench 2.1 measures the official 89 tasks using the average pass@1 across 5 trials, and DeepSWE v1.1 measures 113 tasks across 91 repositories and 5 languages, also using the average pass@1 across 5 trials. Muse Spark 1.2 was evaluated using Muse Code, while other models were evaluated using agents each vendor selected—this isn't a comparison on the same harness.
What should be verified after the beta release isn't benchmark rankings, but how far work can actually continue on real repositories. Usage limits, supported regions, enterprise administration, and Muse Code's log retention period aren't detailed in the announcement. Whether long-running processes can be incorporated into a development workflow can only be judged once these conditions are clarified alongside independent verification through real tasks.