# Muse Code

Muse Code is Meta's terminal-first coding agent for long-horizon software engineering, built around Muse Spark and multi-agent execution. It can plan, edit, run commands, coordinate parallel workers, and operate interactively or in CI.

Canonical URL: https://aiidelist.com/ide/muse-code

Language: en

Updated: 2026-09-27

## Overview

- Category: Terminal / CLI Coding Agents
- A terminal-first Meta coding agent focused on long-horizon, multi-agent software engineering with Muse Spark.
- Editor base: CLI
- Platforms: macOS, Linux, Windows
- Open source: No
- Local model support: No
- Bring your own API key: No

## Quick verdict

Muse Code is a strong fit for developers who want Meta's Muse Spark tightly integrated with auditable multi-agent terminal workflows, especially for repo-scale and parallel engineering tasks; it is less aligned with local-only inference or workflows that prioritize broad model-provider choice.

## Best for

- Large repository refactors and migrations
- Parallel implementation across independent packages or features
- Terminal-first developers who want auditable agent execution
- CI automation and repeatable engineering workflows
- Multimodal implementation tasks using screenshots, PDFs, or video

## Strengths

- Designed for long-horizon terminal coding rather than autocomplete-style assistance.
- Parallel agents can use isolated Git worktrees to reduce write collisions.
- Strong observability with event logs, approvals, rewind, and session controls.
- Works interactively, headlessly in CI, and through an SDK.
- Native macOS, Linux, and Windows support.

## Limitations

- Developers who require local-only model inference
- Users who want a graphical IDE rather than a terminal workflow
- Teams that need broad first-party support for third-party model providers inside the agent
- Users who need all session collaboration features on Windows
- The first-party agent is centered on Meta's Muse Spark models rather than broad third-party model choice.
- No free Muse Code subscription plan is currently listed.
- Some orchestration capabilities can vary by build, platform, or rollout.
- Windows currently lacks voice input and cross-session messaging.
- The Muse Code CLI itself is not published as open source, although the SDK repository is open source.

## Why Choose Muse Code?

Muse Code is not positioned as an editor replacement or an autocomplete layer. Its main distinction is the combination of a terminal-native agent harness and Muse Spark, with the agent designed around long-running repository work rather than isolated code generation. Meta says the model and harness were developed together, which matters most when the task requires repeated tool use, repository navigation, validation, and recovery over many steps.

The other notable difference is orchestration. Muse Code treats parallelism as an engineering primitive rather than simply opening more chats. A lead session can delegate bounded work, while write-capable children can be placed in separate Git worktrees. That makes the architecture particularly relevant for migrations, multi-package changes, or feature work where several independent edits can proceed at once without sharing the same checkout.

Auditability is also central to the workflow. Instead of treating the agent run as a black box, Muse Code retains session events, exposes subagent activity, supports approvals, and can rewind or resume work. For teams evaluating autonomous coding tools, that makes the review process closer to supervising an engineering workflow than accepting a single generated patch.

## Core Workflow

The most effective pattern is to give the lead agent an outcome and let it decompose the work only where parallelism is useful. Read-only investigation can share a checkout, while concurrent writers should be separated into worktrees. This distinction is important: worktree isolation is requested for the child that needs it rather than being a universal mode for every subagent.

For larger jobs, the useful unit of delegation is a bounded responsibility with its own verification step. One agent can inspect compatibility risk, another can update tests, and another can review the resulting diff. The lead agent then synthesizes the results instead of forcing every worker to carry the full task.

Muse Code also supports reusable workflows for staged or parallel orchestration, but Meta notes that workflow availability can depend on the installed build, platform, and rollout. When a workflow surface is unavailable, direct subagents and independent sessions still provide a simpler coordination model.

## Use Cases

Muse Code is especially suited to repository-scale work where one request expands into many connected actions. Dependency upgrades, framework migrations, package-by-package refactors, test repair, and large codebase investigations all benefit from being split into independently verifiable work.

It also fits automation pipelines. The headless execution path can run a task to completion in CI and emit structured events, making it possible to use the agent for maintenance jobs, validation, release preparation, or controlled code transformation without an interactive terminal.

Multimodal input changes the shape of some development tasks as well. Because Muse Spark accepts images, PDFs, and video, a session can use visual references or product material as implementation context instead of requiring every requirement to be translated into text first.

## Comparison to Alternatives

Compared with Claude Code, Codex CLI, Gemini CLI, Aider, or OpenCode, Muse Code's clearest differentiation is its first-party pairing with Muse Spark plus explicit multi-agent coordination, worktree isolation, session messaging, and a session protocol for external clients.

That tighter integration is also a constraint. Muse Code is not documented as a general bring-your-own-model harness, so developers who routinely switch among unrelated model providers may prefer tools built around provider flexibility. Muse Code instead makes the most sense when the developer wants the Muse Spark model and the surrounding Meta agent runtime as one system.

The comparison is therefore less about whether each tool can edit files or run shell commands and more about the desired operating model. Muse Code emphasizes supervised parallel execution and traceability; other terminal agents may emphasize a simpler single-agent loop, a broader model catalog, or deeper integration with a different model vendor.

## Best Configuration

Repository instructions should be made durable rather than repeated in prompts. Muse Code can load `AGENTS.md` and compatible instruction files by directory scope, so project conventions, test commands, architectural constraints, and review rules can live beside the code. Deeper project instructions take precedence over shallower ones, which is useful in monorepos with package-specific rules.

For write-heavy parallel tasks, isolate writers and keep read-only researchers in the shared checkout. This avoids paying the coordination cost of extra worktrees when no files will be changed, while still protecting concurrent edits when multiple agents write.

Approval settings should also match the environment. Interactive development can keep human review in the loop, while CI requires a policy that can finish without waiting for an unavailable prompt. Teams can further constrain behavior through workspace-scoped permissions, managed configuration, MCP policy, and hooks.

The pricing choice has a privacy implication as well as a cost implication. Meta labels Contributor model traffic as usable to improve its products, while the standard Muse Spark tier is labeled as not used for that purpose. Sensitive codebases should be matched to the appropriate data policy rather than choosing a tier on token price alone.

## Migration Notes

Muse Code can fit into repositories that already contain agent instructions instead of requiring a clean-slate setup. Its instruction loader recognizes common files such as `AGENTS.md` and `CLAUDE.md`, with explicit precedence rules across directory levels.

The current changelog also documents a bundled `migrate` skill that can import Claude Code or Codex memory notes and MCP server configuration. That reduces setup friction for developers moving from another terminal agent, but imported configuration should still be reviewed because permission models, tool behavior, and supported capabilities are not identical across agents.

For teams building their own interface around Muse Code, the separate SDK is more relevant than shell automation alone. The developer-preview SDK drives sessions over the Muse Session Protocol, allowing a custom client to control sessions, tools, and approvals while keeping Muse Code as the underlying agent runtime.

## Features

### Agent Orchestration

- Parallel subagents for bounded tasks
- Per-agent Git worktree isolation for concurrent writers
- Cross-session messaging on macOS and Linux
- Reusable staged and parallel workflows where supported

### Execution & Safety

- Interactive terminal UI and headless \`muse exec\` mode
- OS sandbox and configurable approval policies
- Workspace-scoped command permissions
- Retained event logs, resume, rewind, and session export

### Context & Inputs

- Muse Spark 1.3 with a 1,048,576-token context window
- Image, PDF, and video understanding through Muse Spark
- Project instructions via AGENTS.md and compatible instruction files
- Local personal, project, and shared repository memory scopes

### Automation & Extensions

- MCP servers over stdio or streamable HTTP
- OAuth 2.1 login for remote MCP servers
- Skills, hooks, and lifecycle automation
- Developer-preview SDK over the Muse Session Protocol

## Installation

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

## Pricing

paid

- Everyday Usage: $5 — month — 10-50 prompts every 5 hours, including image and video uploads, plus voice mode and web search.
- High Usage: $15 — month — Includes Everyday benefits with 5x the Everyday usage allowance.
- Power Usage: $50 — month — Includes High benefits with 20x Everyday usage, early feature access, and higher file uploads.
- Model API Standard: $1.25 input / $4.25 output — per 1M tokens — Muse Spark 1.3 standard API pricing; cached input is $0.15 per 1M tokens and traffic is not used to improve Meta products.
- Model API Contributor: $0.10 input / $0.20 output — per 1M tokens — Lower-cost Muse Spark 1.3 contributor pricing; cached input is $0.002 per 1M tokens and traffic may be used to improve Meta products.

Pricing checked: 2026-09-27

## Supported models

- Muse Spark 1.3
- Muse Spark 1.2
- Muse Spark 1.1

## Privacy and data handling

Muse Code executes tools on the developer machine but uses Meta Model API for model inference. Meta's current product page states that Contributor model traffic is used to improve its products, while standard Muse Spark model traffic is not. Session logs and personal project memory can be retained locally; `--no-session-log` disables retained session state. Review current Meta terms and enterprise data controls before using sensitive repositories.

## Enterprise features

- Managed configuration defaults and policy planes for administrators
- Workspace-scoped approval policies and OS sandbox controls
- Headless CI execution with structured JSONL events

## Alternatives

- Claude Code
- Codex CLI
- Gemini CLI
- Aider
- Qwen Code
- OpenCode

## Sources

- [Official website](https://dev.meta.ai/products/muse-code)
- [Documentation](https://dev.meta.ai/docs/muse-code)
- [Installation](https://dev.meta.ai/docs/muse-code)
- [Pricing](https://dev.meta.ai/lp/muse-code)
- [Changelog](https://dev.meta.ai/docs/muse-code/changelog)
- [Official Muse Code product page](https://dev.meta.ai/products/muse-code)
- [Muse Code documentation](https://dev.meta.ai/docs/muse-code)
- [Muse Code subscriptions](https://dev.meta.ai/docs/muse-code/subscriptions)
- [Muse Code configuration](https://dev.meta.ai/docs/muse-code/configuration)
- [Muse Code extending and automation](https://dev.meta.ai/docs/muse-code/extending)
- [Muse Code changelog](https://dev.meta.ai/docs/muse-code/changelog)
- [Muse Spark 1.3 announcement](https://research.meta.ai/blog/introducing-muse-spark-1-3)
- [Muse Code SDK repository](https://github.com/meta-models/muse-code-sdk)

Last checked: 2026-09-27

## Update history

- 2026-08-05: Meta released Muse Code in beta alongside Muse Spark 1.2, emphasizing long-horizon coding, subagents, worktree isolation, and auditability.
- 2026-08-31: Muse Code left beta with inter-session messaging, workflows, rewind, a developer-preview SDK, and subscription plans.
- 2026-09-02: Muse Spark 1.3 became available in Muse Code and Meta Model API with improved agentic and coding performance.