Muse Spark 1.2 and Muse Code: Evaluating Co-Trained Agents for Production Long-Horizon Work

Meta released Muse Code (beta) and Muse Spark 1.2 on 5 August 2026. Muse Code is a terminal-based coding agent for macOS and Linux. Muse Spark 1.2 is the coding-focused model that powers it. The two were co-trained.

For engineering managers and technical leads evaluating AI coding agents, the co-training and the agent’s runtime design matter more than the model’s headline benchmarks. This article examines what that design actually provides, when it is useful, and the practical constraints teams should weigh before adopting it.

Executive Summary

Muse Spark 1.2 improves code generation, debugging, and long-horizon repository work relative to Muse Spark 1.1. Muse Code adds persistent background agents, an append-only local event log that supports exact replay and restart, and built-in skills (/plan, /grill, /goal). The combination is aimed at multi-file, multi-hour tasks rather than single-prompt code generation.

Teams should evaluate the pair on three concrete dimensions: (1) ability to maintain direction across long sessions, (2) auditability of agent actions, and (3) the cost and data-sharing trade-offs of the available pricing tiers. The rest of this article unpacks those dimensions with the information available from Meta’s announcement and methodology notes.

Problem Overview

Most coding agents still struggle with three recurring production problems:

• Context loss or drift over multi-hour sessions.
• Lack of a reliable record of what the agent actually did (tool calls, edits, decisions).
• Difficulty recovering cleanly after a crash or interruption.

Short coding tasks mask these issues. Long-horizon work—large refactors, multi-file feature implementation, iterative performance tuning—exposes them quickly. Meta positioned Muse Code and Muse Spark 1.2 specifically against those failure modes by co-training the model with the harness and shipping a restart-safe runtime.

Technical Analysis

Model and harness co-training
Muse Spark 1.2 was trained with Muse Code’s toolset and trajectories. Meta used rejection sampling on harness runs and optimized recipes for goals, context compaction, and sub-agents. The result is a model that is intended to perform best when paired with its own agent rather than as a generic API endpoint.

Runtime design
Muse Code keeps a set of specialized background agents active for the duration of a session instead of spawning them only for individual subtasks. The main agent can hand work to these persistent helpers and receive results without repeated context re-gathering. Every model call, tool execution, approval, and edit is appended to a local event log. Meta describes the log as replay-exact and restart-safe: after a crash the agent can resume from the recorded state.

Long-horizon capabilities
Training emphasized whole-repository generation, large end-to-end projects, and auto-research. The model relies on planning, goal conditioning, and context compaction to keep direction across long runs. A published case study showed the agent writing, compiling, profiling, and iteratively improving GPU kernels across more than 1,000 tool calls, with some runs lasting up to 24 hours.

Context and modalities
Muse Spark 1.2 supports a 1,048,576-token context window and accepts text, image, video, and PDF input. Output is text.

Reported benchmarks (Meta’s own evaluations, paired with Muse Code)

• Terminal-Bench 2.1: 82.9 % (up from 76.2 % on 1.1)
• DeepSWE v1.1: 59.3 % (up from 53.0 % on 1.1)

These numbers are harness-specific. Independent third-party comparisons will be needed for broader ranking.

Availability and pricing
Muse Spark 1.2 is available through the Meta Model API and inside Muse Code. Standard pricing is $1.25 per million input tokens and $4.25 per million output tokens (cached input $0.15). A contributor tier (muse-spark-1.2-contributor) offers substantially lower rates in exchange for permission to use the data for product improvement; that tier is rate-limited more tightly.

Muse Code itself installs via a single curl command on macOS and Linux. No Windows build was announced at launch. The agent binary is closed-source.

Implementation Guidance

1. Start with a controlled long-horizon task
   Choose a real but bounded multi-file change (e.g., a medium-sized refactor or a performance investigation) rather than a green-field project. Observe how the background agents and event log behave under interruption.

2. Treat the event log as a first-class artifact
   Store or mirror the local log if audit or compliance requirements exist. The log is the primary source of truth for what the agent did.

3. Decide the pricing tier deliberately
   Standard tier for production work where data residency or training restrictions matter. Contributor tier only after legal and security review of the data-sharing terms.

4. Integrate as a terminal tool, not a replacement for the IDE
   Muse Code is designed to run in the terminal. Teams already using Claude Code, Codex, or similar agents should compare session persistence and recovery behavior rather than treating it as a drop-in model swap.

5. Measure wall-clock progress and intervention rate
   Track how often a human must intervene and how cleanly the agent resumes after a forced restart. Those metrics are more useful than isolated pass rates for deciding production readiness.

Best Practices

• Keep the event log and any generated plans under version control or a durable store when the work touches production codebases.
• Use the /plan and /grill skills explicitly for non-trivial tasks; they force an approval-gated plan before large edits.
• Limit concurrent long-running sessions until the team has calibrated resource usage and failure modes.
• Pair the agent with existing CI and test suites so that validation steps remain under team control.

Common Mistakes

• Treating the model’s 1 M context window as a guarantee that the agent will correctly track every dependency across a large monorepo. Context size and understanding are not the same.
• Assuming the closed-source binary and contributor pricing terms are acceptable without security and legal review.
• Evaluating only short coding tasks. The design advantages appear primarily on multi-hour work.
• Ignoring the fact that Muse Code is currently limited to macOS and Linux.

Business Impact

For teams that already run coding agents, the main potential gains are reduced context-management overhead and better recoverability after interruptions. Those gains translate into fewer stalled sessions and clearer audit trails—both of which matter for regulated or high-stakes codebases.

The cost side is clearer: standard pricing is competitive with other mid-tier coding models; the contributor tier is significantly cheaper if data sharing is acceptable. The closed binary and platform limitations (no Windows at launch) constrain adoption in mixed environments.

Agencies and product teams should treat Muse Code as an additional option in the agent evaluation matrix rather than a default replacement. Its value is highest where long-running, multi-file work is common and where an auditable local log is a requirement.

Future Outlook

Meta stated that larger and more capable models are in progress and that additional harness features are planned. The current release is explicitly a beta. Teams adopting it now should plan for iteration on both the model and the agent runtime.

Key Takeaways

• Co-training of model and harness is the central design claim; evaluate the pair together.
• The local event log and persistent background agents are the practical differentiators for long-horizon reliability.
• Start evaluation with real multi-file tasks and measure intervention rate and recovery behavior.
• Pricing and data-sharing terms require explicit decision; the contributor tier is not free in practice.
• Platform support is currently limited to macOS and Linux.

Frequently Asked Questions

Is Muse Spark 1.2 available as open weights?
No. It is offered through the Meta Model API and inside Muse Code. No open-weight release was announced.

How does the event log work?
Every model call, tool run, approval, and edit is appended to a local log. Meta states that the log enables exact replay and restart-safe recovery.

Can Muse Code run on Windows?
Not at the initial release. Only macOS and Linux installers were provided.

How does pricing compare to other coding models?
Standard rates are $1.25 / $4.25 per million tokens. A lower-cost contributor tier exists in exchange for data-use permission and tighter rate limits.

Should we replace existing coding agents with Muse Code immediately?
No. Treat it as a candidate for long-horizon workloads and evaluate persistence, recovery, and auditability against your current tools.

Conclusion

Muse Spark 1.2 and Muse Code are a deliberate attempt to improve long-horizon coding reliability by co-training the model with its runtime and shipping an auditable, restart-safe agent. The engineering decisions—persistent background agents, local event log, goal-oriented skills—are more informative than the benchmark numbers alone.

For engineering managers, the practical next step is a controlled evaluation on a real multi-file task, with attention to recovery behavior, log usability, and the data-sharing implications of the pricing tiers. That evaluation will determine whether the design advantages translate into measurable gains for your team’s production workflows.