Meta's Muse Code Tackles 24-Hour Coding Jobs Where Other AI Agents Quit

Meta's Superintelligence Labs has released Muse Code (beta), a terminal coding agent built for the kind of software engineering work that breaks most AI tools: large repos, multi-file changes, and tasks that run for hours. It ships alongside Muse Spark 1.2, a coding-focused model co-trained specifically to run inside Muse Code's agent harness.

Terminal-first, by design

The terminal coding agent space is already crowded, but Muse Code takes a different approach from ChatGPT Codex and Claude Code: there is no dedicated app interface. It lives entirely in your terminal, installs with a single command, and takes on complete software engineering tasks including planning, writing code, and validating results.

curl -fsSL https://dev.meta.ai/install.sh | bash

The release follows Meta's Muse Spark 1.1, which upgraded the model's agentic and multimodal capabilities and introduced Meta's paid API service. With Muse Code, Meta is now competing directly with Claude Code and OpenAI Codex on autonomous, long-horizon coding tasks.

How the architecture handles long tasks

Most coding agents fail on extended work because they are stateless. Every hard problem requires re-gathering context, re-planning, and re-steering. Muse Code addresses this with two architectural decisions.

The first is persistent background agents. Rather than spinning up and tearing down processes for each subtask, Muse Code runs specialized agents that stay active throughout a session. They carry out next steps autonomously and decide when to report back to the main agent, cutting redundant context-gathering and reducing the need for human steering.

The second is a crash-proof event log. Every model call, tool run, approval, and edit is appended to a local log. This makes the runtime replay-exact and restart-safe: after a crash, the agent resumes precisely where it stopped. On a task that runs for hours, that capability is the difference between finishing and starting over.

Built-in skills

Muse Code ships with several default slash commands:

• /plan turns a task into an approval-gated plan
• /grill stress-tests that plan as an automated adversarial reviewer, poking holes before any code gets written
• /goal works toward successful completion of a specified objective

The multimodal angle is also real. You can pipe an MP4 fly-through of a property into the terminal, and Muse Code will interpret the video and generate a visually rich vacation rental marketing page. Video-to-code is a genuinely new interaction pattern for a terminal agent.

Muse Spark 1.2: co-trained for the harness

The model powering Muse Code is a coding-focused update to Muse Spark 1.1, with improvements in code generation, complex debugging, codebase understanding, and end-to-end developer workflows. Meta significantly scaled training compute on coding tasks and expanded training environment diversity.

The co-training approach is the most technically interesting part. Meta trained Muse Spark 1.2 on thousands of real Muse Code sessions, teaching the model which tool calls to make, when to compact context, and how to hand off work to sub-agents. Training included rejection-sampled harness trajectories and recipe optimizations for goals, compaction, and sub-agents, alongside integration of the full Muse Code toolset.

The model was also extensively trained on long-horizon coding tasks: whole-repository generation, large end-to-end projects, and auto-research. Context compaction means the model actively summarizes and prunes its own working memory mid-task, preventing context window exhaustion on a 10-hour job.

There is a self-improvement loop in the training pipeline too. Meta used Muse Spark 1.1 to generate challenging coding environments and instruction-following templates. The newer model then graded candidate solutions against those requirements, producing a scalable training dataset without human labelers for every example.

The 24-hour GPU kernel stress test

Meta's most striking benchmark is a case study rather than a leaderboard number. The agent was evaluated on KDA and MLA kernels for NVIDIA Hopper GPUs, running for up to 24 hours and making over 1,000 tool calls: writing Triton kernels, compiling them, profiling output, and iterating.

The rules were strict. Models could not import third-party kernel libraries like FLA; they had to implement algorithms in Triton from scratch using specialized kernel-optimization knowledge. For KDA, Muse Spark 1.2 paired a chunk-parallel preparation kernel with a sequential inter-chunk scan, combining standard fusion and tiling with KDA-specific optimizations such as re-centering the gated cumulative decay at the chunk midpoint.

For MLA, the model designed a two-kernel Triton pipeline combining kernel fusion and tiling with MLA-specific optimizations, including reusing the shared KV latent as both K and V. These are architecture decisions a GPU engineer would reach after days of profiling, produced autonomously by the agent.

Benchmark numbers

Muse Spark 1.2 scored 82.9% on Terminal-Bench 2.1, just behind Claude Opus 5 at 86.7%. On DeepSWE 1.1 it scores 59%, outperforming Grok Build 4.5 and Gemini 3.6 Flash. Meta also publishes results on its own internal coding bench and GDPval, though those appear as images on the release page without a full methodology write-up. Independent reproduction will matter before drawing firm conclusions.

Pricing

Access runs through the Meta Model API, now in public preview with expanded global access. Two pricing tiers:

• Standard tier: $1.25 per million input tokens, $0.15 per million cached input tokens, $4.25 per million output tokens. Prompts are not used to improve Meta's products.
• Contributor tier: $0.10 per million input tokens, $0.002 per million cached input tokens, $0.20 per million output tokens, in exchange for letting Meta use the data to improve its models.

The model is also available through OpenRouter for developers who want to slot it into existing tooling. If you want Muse Spark 1.2 inside your own agent harness rather than through Muse Code, the API is the path.

Where it fits, and where to be careful

Muse Code is built for tasks where you hand off a problem and come back later. Strong use cases include:

• Large-scale refactors across many files in a big repo
• Whole-repository generation or greenfield projects
• Iterative optimization loops where the agent needs to compile, profile, and retry hundreds of times
• Multimodal-to-code workflows, such as converting a video or design mockup into a working UI

The terminal-only constraint is a real limitation. There is no visual diff review, no IDE integration, and no GUI for inspecting what the agent is doing mid-task. If you want to watch every change land in a familiar editor, Muse Code is not that tool, at least not yet.

The broader bet

What distinguishes this release is the design philosophy: train the model and the agent harness together so the model knows the exact tools it will be called with, the exact compaction strategies it should use, and the exact sub-agent handoff patterns that work. That tight coupling between model and runtime is something Claude Code has with Anthropic's infrastructure and OpenAI has with Codex. Meta now has it too, with a model available via open API. Larger models are explicitly on the roadmap, and the contributor-tier pricing makes experimentation cheap. The 24-hour kernel optimization run previews what autonomous coding agents can do when the model, the harness, and the evaluation loop are all designed as a single system.