Meta launches Muse Code, a coding agent, with Muse Spark 1.2
Meta released Muse Code, a beta terminal coding agent for large-repository software engineering, together with Muse Spark 1.2, the model built to power it, describing the release as an early step toward the frontier with larger, more capable models still to come. Muse Code plans changes, writes code, and validates the result across large repositories, and it can coordinate multiple persistent subagents on a single task to solve problems faster, more accurately, and with less human intervention. It installs on macOS or Linux.
A core design choice is what Meta calls async background agents: specialized agents that stay active for an entire session rather than being spawned fresh for each task, which avoids repeating the same information gathering. They carry out next steps on their own and decide when to report back to the main agent, and because they persist, they cut latency and reduce how much steering a difficult, multi-step task needs.
The runtime also keeps a local event log that records every model call, tool run, approval, and edit. Because that log is a single source of truth, the runtime is replay-exact and restart-safe: after a crash, Muse Code can resume exactly where it stopped, which is what lets it take on long-running tasks without being derailed by failures. Muse Code ships several default slash-command skills as well: /plan turns a task into a plan that needs approval before it runs, /grill stress-tests that plan until it holds up, and /goal drives the agent toward completing a stated objective.
Muse Spark 1.2 itself is a coding-focused update to Muse Spark 1.1, with Meta citing improvements in code generation, complex debugging, codebase understanding, and end-to-end developer workflows. Training compute devoted to coding tasks was scaled up significantly and training-environment diversity was expanded, while the model kept its earlier strength in other areas such as general agent tasks. Meta co-trained Muse Spark 1.2 with Muse Code specifically so the two perform best paired together, using rejection-sampled harness trajectories, recipe optimizations for goals, compaction and subagents, and direct integration of the Muse Code toolset into training to maximize compatibility with the harness. The model was also extensively trained on long-horizon coding work, including whole-repository generation, large end-to-end projects, and auto-research, using planning to sequence work, goal conditioning to hold direction, and context compaction to retain what it needs to keep making progress.
Meta also used a self-improvement loop to build the training data: Muse Spark 1.1 generated challenging coding environments and instruction-following templates, then graded candidate solutions against those requirements, producing a scalable training dataset for Muse Spark 1.2. Meta says this loop helped Muse Spark 1.2 follow complex instructions more precisely than its predecessor.
As a case study, Meta tested the model's ability to iteratively optimize GPU kernels over more than 1,000 tool calls, in sessions as long as 24 hours. Working inside Muse Code's agentic coding environment, the model writes, compiles, profiles, and repeatedly improves kernel performance against a fixed baseline; the test covered KDA and MLA kernels for NVIDIA Hopper GPUs, and Meta reports that the agent continues to achieve substantial improvements over that baseline, though it gives no percentage or other figure for the size of the gain. The baseline was the FLA Triton implementation of KDA, and models were barred from importing third-party kernel libraries such as FLA directly; instead they had to apply kernel-optimization knowledge to implement the algorithm in Triton themselves rather than wrap existing code. Muse Spark 1.2's solution paired a chunk-parallel preparation kernel with a sequential inter-chunk scan, combining standard fusion and tiling with KDA-specific techniques such as re-centering the gated cumulative decay at the midpoint of each chunk.
Muse Spark 1.2 is available now both inside Muse Code and through the Meta Model API, where Meta says access has been expanded globally, without specifying which regions or a rollout date. Meta says more is coming, including new harness features and more powerful models, and points to a separate evaluations report for further detail that this announcement does not itself contain.
Key facts
- Meta released Muse Code, a beta terminal coding agent for large-repository software engineering, alongside Muse Spark 1.2, the new model built specifically to power it.
- Muse Code keeps background agents active for an entire session rather than spawning them per task, and logs every model call, tool run, approval, and edit so a crashed session can resume exactly where it stopped.
- Muse Code ships several built-in skills: /plan for an approval-gated plan, /grill to stress-test that plan, and /goal to drive the agent toward a stated objective.
- Muse Spark 1.2 was co-trained with Muse Code and extensively trained on long-horizon tasks such as whole-repository generation; a self-improvement loop used Muse Spark 1.1 to generate and grade its own training data.
- In a case study, the model optimized GPU kernels (KDA and MLA on NVIDIA Hopper) over more than 1,000 tool calls across sessions as long as 24 hours, without being allowed to import third-party kernel libraries like FLA.
Why it matters
Meta built Muse Code and Muse Spark 1.2 as one co-trained system: rather than pairing a general model with a separate coding harness, it trained Muse Spark 1.2 specifically alongside Muse Code's tooling, including its handling of goals, context compaction, and subagents, so the model and the agent are tuned to work together. The announcement frames this release as an early step, with larger and more capable models still to come. Two design choices stand out in the source: background agents that stay active for an entire session instead of being spawned per task, and a full event log that lets a session resume exactly where a crash interrupted it. Both are aimed, in Meta's account, at the latency and steering problems that surface once an agent is asked to carry out long, multi-step jobs across a whole repository rather than answer single prompts.
Who it affects
Developers and engineering teams working across large, multi-file codebases who want an agent to plan, write, and validate changes with less hands-on steering, particularly on long-horizon jobs like whole-repository generation or large end-to-end projects. The kernel-optimization case study points to a more specialized audience too: engineers optimizing low-level GPU code, since the test specifically targeted KDA and MLA kernels for NVIDIA Hopper GPUs. Anyone already using the Meta Model API can also reach Muse Spark 1.2 directly there, now with access Meta describes as expanded globally.
How to use it
Muse Code installs on macOS or Linux and runs as a terminal application. Several built-in skills structure how it works: /plan turns a task into a plan that needs approval before it runs, /grill stress-tests that plan before any code changes start, and /goal drives the agent toward completing a stated objective end to end. Muse Spark 1.2, the model behind it, is also reachable directly through the Meta Model API, which Meta says now has expanded global access, though the announcement does not specify which regions gained it or when.
How solid is it
This is entirely Meta's own account, published on its research blog, with no outside benchmark or third-party test cited. The one detailed case study, an agent optimizing GPU kernels over more than 1,000 tool calls across sessions as long as 24 hours, reports that Muse Spark 1.2 continues to see substantial improvement over a fixed baseline, but gives no percentage or other figure for how large that improvement actually is. The claimed gains over Muse Spark 1.1, better code generation, debugging, and codebase understanding, are described only qualitatively, with the promised benchmark numbers deferred to a separate evaluations report that this text does not include. No individual researcher or engineer is named anywhere; the whole announcement is written in an unattributed first-person voice throughout.
Risks and caveats
Specifics that would let a reader check the claims independently are largely missing: which regions the expanded Meta Model API access now covers, how large the kernel-optimization gains are in absolute terms, and what the FLA, KDA, and MLA acronyms in the case study actually stand for are all left unstated. Meta gives no pricing, system requirements, or download size for Muse Code either. The features pitched as cutting the need for human oversight, persistent background agents and approval-gated plans, still route every plan through a human approval step by design, so the agent is not described as working unsupervised.
“This marks our next step toward the frontier, with larger and much more capable models on the way.”
— Meta, in the Muse Code announcement