What Is Muse Code? Meta's Terminal-Based AI Coding Agent
Muse Code is Meta's terminal-based AI coding agent. Powered by Muse Spark 1.2, it can work across large repositories and delegate complex tasks to parallel subagents operating in isolated Git worktrees.
In this article
As AI coding tools evolve from completing the next line to reading files, running tests, and changing entire projects, developers face a new set of questions. Can an agent understand a large repository? Can it divide work and run tasks simultaneously? And can it work for hours without disrupting the developer's current working copy?
Muse Code is Meta's terminal-based AI coding agent, currently available in beta. Powered by the Muse Spark 1.2 model from Meta Superintelligence Labs, it occupies the same broad category as Claude Code, Codex CLI, and Gemini CLI: developers describe a task in natural language, and the agent examines the project, edits code, calls tools, and validates its work.
Muse Code is like an AI engineer working in your terminal. When a project is large enough, it can divide the job among several assistants working simultaneously in separate spaces.
Key Takeaway
Muse Code is designed not only to generate code, but to understand a large project, plan a task, and delegate independent parts to parallel subagents. Its goal is to handle broader and longer-running software engineering work than a conventional code completion tool.
What Problem Does It Solve?
Traditional coding assistants are effective at local tasks such as completing a function, explaining an error, or generating a unit test. A task spanning many files and modules is harder: the agent must repeatedly inspect the code, run tests, interpret failures, and revise its approach, while too much detail accumulates in one conversation.
Muse Code targets work that looks more like a real engineering project:
- Finding relevant files and dependencies in a large repository.
- Turning a requirement into executable and verifiable steps.
- Working on independent features or investigations simultaneously.
- Running tests, diagnosing failures, and iterating on changes.
- Keeping subagent work away from the developer's active working copy.
Core Features of Muse Code
1. It Works in the Terminal and Inside the Project
Muse Code is not a chat page where developers must paste isolated snippets. It runs from the local terminal, where it can gather project context, read and write files, invoke development tools, and decide what to do based on their output.
This category is known as an AI coding agent. Unlike traditional autocomplete, an agent can take a sequence of actions rather than merely suggest the next piece of code.
2. It Is Powered by Muse Spark 1.2
Muse Spark is a family of models developed by Meta Superintelligence Labs. Muse Code uses Muse Spark 1.2, which is oriented toward coding and agentic work, to interpret requests, plan steps, use tools, and evaluate results.
The model and the product are different layers. Muse Spark 1.2 is the reasoning engine; Muse Code is the working environment that connects that engine to the terminal, project files, and developer tools.
3. It Can Delegate Work to Parallel Subagents
For sufficiently large tasks, Muse Code can launch multiple subagents. One might work on a backend API, another on the interface, and a third on tests.
The benefit is not limited to speed. Giving each subagent a focused assignment can prevent every implementation detail from competing for space in a single agent's context.
4. Subagents Use Isolated Git Worktrees
Several agents editing the same files at once can overwrite one another. Muse Code places subagents in isolated Git worktrees. A worktree is another working copy connected to the same Git repository, allowing each agent to make changes in its own space before results are integrated.
This reduces direct collisions and helps protect the developer's active working copy. Isolation does not guarantee a conflict-free merge, however. If tasks change the same behavior, developers still need to review conflicts and run integration tests.
5. It Targets Long-Running Engineering Tasks
Meta demonstrated Muse Code making more than 1,000 tool calls over a run lasting up to roughly 24 hours while optimizing GPU kernels for Nvidia Hopper hardware. The example illustrates a design intended for iterative work involving execution, measurement, and repeated refinement.
It is a demonstration, not a promise that every task can or should run unattended for 24 hours. Real projects still need permissions, budgets, tests, checkpoints, and stopping conditions.
How Is It Different From Similar Tools?
| Tool Type | Main Interaction | Best Suited For |
|---|---|---|
| Traditional code completion | Predicts the next code inside an editor | Finishing small, local pieces of code |
| General terminal coding agent | Reads, edits, and tests a project from a natural-language request | Debugging, refactoring, tests, and feature implementation |
| Muse Code | A lead agent plans and delegates to subagents in isolated worktrees | Large repositories, parallelizable work, and long-running tasks |
This is a positioning summary, not a quality ranking. Claude Code, Codex CLI, Gemini CLI, and other products continue to add parallel agents, background work, and isolated execution, so the practical differences can change quickly.
What Should Non-Engineers Know?
Muse Code reflects a broader shift from “one assistant that answers coding questions” toward “an interface for an AI engineering team.” The unit of work can become an entire feature or performance goal rather than one line or function.
Larger tasks also amplify mistakes. If the lead agent misunderstands the requirement, several subagents can proceed in the wrong direction simultaneously. Clear requirements, automated tests, version control, and human review therefore become more important, not less.
Who Is It For?
Muse Code may suit:
- Developers comfortable with terminals and Git.
- Engineering teams working across large repositories.
- Projects with independent tasks that can run in parallel.
- Teams prepared to verify AI output with tests and code review.
- Developers evaluating Muse Spark's coding and agentic capabilities.
Who Might Want to Wait?
- People unfamiliar with terminals, Git, or software testing.
- Teams with sensitive source code that have not reviewed data and access policies.
- Anyone expecting changes to ship without human review.
- Production teams requiring mature enterprise support and stable interfaces; Muse Code remains in beta.
How Can You Get Started?
Meta provides Muse Code for macOS, Linux, and Windows through WSL. The published installation command is:
curl -fsSL https://dev.meta.ai/install.sh | bash
After installation, users must follow Meta's current sign-in or developer-service setup. Because the product is in beta, availability, plans, usage limits, and commands may change. Check the developer site before adopting it in a real workflow.
For a first trial, use a recoverable project with good tests and no sensitive data. Review which instruction files Muse Code loads, what project context leaves the machine, and which permissions each tool receives before increasing the scope.
What Should You Check Before Using It?
- Data and privacy: A terminal agent sends some project context to a model service. Review data-use terms, training choices, and organizational policies.
- Permissions: Avoid granting immediate access to the entire computer, production systems, or every credential.
- Parallel changes: Isolated worktrees reduce direct collisions but do not replace code review and integration testing.
- Long runs: Establish budgets, tool-call limits, checkpoints, and stopping conditions.
- Beta changes: Features, pricing, regional access, and data policies can change quickly.
Our View
The most interesting part of Muse Code is not simply that Meta has entered the terminal coding-agent market. It is the decision to place parallel delegation and workspace isolation at the center of the product.
If the approach works reliably, developers increasingly act like technical leads: define goals and boundaries, delegate implementation, then review architecture, tests, and integration. Success depends on more than model benchmarks. Task decomposition, permission controls, failure recovery, and reviewable output are equally important.
Muse Code is still a beta product and is best evaluated experimentally. The ability to run autonomously for a long time should not be confused with permission to skip supervision. Being able to stop safely, understand every change, and recover from a wrong result matters as much as completing the task.
Sources
- Meta Research: Introducing Muse Code and Muse Spark 1.2 — https://research.meta.ai/blog/introducing-muse-code-and-muse-spark-1-2
- Meta developer website: https://dev.meta.ai/
- Meta AI: Muse Spark 1.1 and Meta Model API — https://ai.meta.com/blog/introducing-muse-spark-meta-model-api/
- Accessed: 2026-08-11