LaunchedEditorial Listing

Muse Code

Meta · Muse Code: Meta's Terminal Coding Agent Built for Muse Spark

Open Muse Code

Muse Code is Meta's coding agent for the terminal and CI. It plans, edits files, and runs commands in your repository using Meta's Muse Spark models, with approvals and an OS-level sandbox on by default, parallel subagents in isolated Git worktrees, and a replayable session log. It suits terminal-first developers who want a CLI agent on a low monthly plan ($5 to $50), or discounted per-token rates if they accept Meta training on that usage.

PricingPaid
Setupeasy
Runs onDesktop · API
APIYes
Open sourceNo
DocsYes
CategoryCoding
Agentic CodingCLITerminalMulti-AgentSandboxMuse SparkGit WorktreesMCP

Best for

Terminal-first developers who want a coding agent with strict default guardrails and built-in multi-agent orchestration at a low flat monthly price, or who want low Contributor per-token rates and accept Meta training on that usage

Not ideal for

Developers who want to choose among models from several vendors, need an open-source client, or work mainly inside VS Code or JetBrains

Who it's for

Individual developers and engineering teams who work in the terminal or CI and want an agent tied to Meta's Muse Spark models

Capabilities

  • Interactive terminal UI (`muse`) plus headless `muse exec` for scripts and CI, with JSONL event output, prompt files, and a `--max-model-steps` cap
  • Approvals and an OS-enforced sandbox on by default: Seatbelt on macOS, bubblewrap on Linux, and a Windows sandbox, with the workspace writable and the rest of the filesystem read-only
  • Compound shell commands reviewed stage by stage, with allow-once, per-workspace prefix rules, or reject, and outbound network connections approved per destination
  • Permission profiles (Ask me, Auto-review, Unrestricted, Read-only), with a model-based approval judge clearing eligible requests in the default Auto-review profile
  • Subagents with optional per-child Git worktree isolation; one agent tree runs eight agents at once by default (including the lead), configurable from 1 to 64
  • Workflows that coordinate parallel and staged child agents (up to 1,000 child tasks per workflow, at most 16 active at once locally), with a `/workflows` control room for pausing, skipping, and restarting children, and saved JavaScript workflows for reuse
  • Background observer agents for memory recall, skill recall, goal tracking, and verification of claimed work
  • `/goal` keeps the agent working toward a stated objective across turns, and `/loop` schedules recurring prompts on a cron cadence
  • Built-in skills such as `/plan`, `/grill`, and `/taste`; imports skills from Claude Code and Codex, and `/migrate` brings over their memory notes and MCP servers
  • Loads AGENTS.md or CLAUDE.md project rules, keeps Markdown project memory, and supports hooks on 15 lifecycle events and MCP servers (stdio or streamable HTTP, with OAuth 2.1 sign-in)
  • Append-only session log enables resume after a crash, `/rewind`, `/fork`, side conversations, and trajectory export
  • Session messaging lets separate live sessions on the same machine send each other handoffs and review requests
  • Image and video attachments, voice dictation in the composer (on by default on macOS; platform support varies), and web search
  • Muse Session Protocol (`muse serve`) and a TypeScript SDK (`@muse-code/sdk`, developer preview) for driving sessions from your own code

Limitations

  • Built and trained for Meta's Muse Spark models; using other providers' models is not documented as a supported setup
  • The CLI is not published under an open-source license. Only the TypeScript SDK repository is MIT-licensed
  • No VS Code or JetBrains extension is documented. The changelog references a Zed (ACP) adapter, but the main docs do not cover editor integration
  • Subscription plans work only through the Muse Code CLI signed in with your Meta Model API account; any other API keys are billed pay-as-you-go
  • The cheapest Contributor models allow Meta to use your prompts and completions, including code, to train its models. Standard models cost 12.5x more for input and over 20x more for output
  • Workflows depend on the build and a staged rollout, and Meta says they are unavailable in the current public Apple silicon macOS package
  • On Windows, agent commands use PowerShell and session messaging is unavailable; the sandbox may trigger a UAC prompt on first use
  • On Linux the sandbox needs a working bubblewrap and a non-musl build, or every shell command fails; this also applies to CI runners
  • Hooks and MCP servers run outside the sandbox, and committed project memory is loaded even in untrusted workspaces
  • The four background observer agents make their own model calls, adding token usage on top of the main session
  • On pay-as-you-go, Contributor models are limited to 100 requests per minute per team, versus 3,000 for Standard models, which constrains high-volume parallel or CI use
  • Subscriptions require a Meta account and subscribers aged 18 or the age of majority; benefits may vary by region, and canceled subscriptions are not refunded

Use cases

  • Fanning a batch of bug fixes and small features out to parallel subagents, each in its own Git worktree, then reviewing each branch
  • Running `muse exec` in CI to run the test suite and summarize failures, with the sandbox kept on and approvals disabled
  • Auditing a service with a workflow that has separate agents check API design, security boundaries, and test coverage, then merge one report
  • Using `/plan` to get a plan grounded in the actual code and approving it before any edits are made
  • Moving from Claude Code or Codex by importing existing skills, memory notes, and MCP servers
  • Building an internal tool or editor integration on top of the Muse Session Protocol and TypeScript SDK

Our take

Muse Code is a full-featured first-party agent rather than a thin wrapper around Meta's API. The defaults are conservative in useful ways: a real OS sandbox, network destinations approved one at a time, shell commands reviewed stage by stage, and a local event log of everything the agent did. Multi-agent work is central, not an add-on. The appeal is mostly price: $5 a month to start, or Contributor token rates that are a fraction of Standard, as long as you accept Meta training on that usage and a much lower rate limit. The cost is lock-in to Muse Spark, a closed-source CLI, no documented mainstream IDE extension, and features that still vary by platform and rollout. It is a reasonable second agent to try alongside Claude Code or Codex, especially because it reads their instruction files and skills.

Who should use it

Terminal-first developers who want strong default guardrails and built-in subagents at a low monthly price, teams running cost-sensitive agent jobs in CI where Contributor pricing and its lower rate limit are acceptable, and Claude Code or Codex users who want to try Muse Spark without rebuilding their skills and project rules.

Who should skip it

Teams that need to pick models from several vendors, organizations that require an open-source agent client, developers who rely on VS Code or JetBrains integrations, and anyone who cannot accept Meta training on their code but also needs the lowest per-token price.

Strengths

  • Approvals and an OS-level sandbox with per-destination network approval are on by default on macOS, Linux, and Windows
  • Subagents in isolated Git worktrees, workflows, and background verification come built in
  • Low entry price ($5/month) and low Contributor per-token rates
  • Reads CLAUDE.md and imports Claude Code and Codex skills, which eases switching
  • Every action is recorded in a replayable local event log

Weaknesses

  • Built for Meta's own models only
  • CLI is not open source
  • No documented VS Code or JetBrains extension
  • Cheapest pricing requires letting Meta train on your code and prompts, and has a much lower rate limit
  • Some features vary by platform, build, and rollout

Muse Code pricing

Everyday Usage

$5/month

Billed monthly

  • Latest Muse models
  • 10 to 50 prompts every 5 hours, including image and video uploads
  • Voice mode and web search

High Usage

$15/month

Billed monthly

  • 5x the Everyday Usage allowance
  • More multimodal inputs

Power Usage

$50/month

Billed monthly

  • 20x the Everyday Usage allowance
  • Early access to new features
  • Higher file uploads

Pay-as-you-go (Meta Model API)

Per token

  • Standard: $1.25 input, $0.15 cached input, $4.25 output per 1M tokens; not used for training
  • Contributor: $0.10 input, $0.002 cached input, $0.20 output per 1M tokens; may be used to train Meta models

Note: Subscriptions apply only to the Muse Code API key connected during CLI onboarding; other Meta Model API keys are billed pay-as-you-go. Usage is tracked in 5-hour and weekly windows. When you hit a limit you can upgrade or wait for it to refresh (Power Usage subscribers must wait). Upgrades take effect immediately with prorated charges; downgrades apply next cycle. Plans renew monthly, canceled plans are not refunded, subscribers must be 18 or the age of majority, and benefits may vary by region. Muse Code is its own subscription in Accounts Center; the docs do not say it covers the consumer Muse agent. On pay-as-you-go, Muse Spark's reasoning tokens are billed as output, and Contributor models are rate-limited to 100 requests per minute per team (Standard: 3,000).

Technical specs

Context window

1,048,576 tokens (Muse Spark 1.2 and 1.3)

Modalities

Text, Images, Video, Voice input

API pricing

Meta Model API pay-as-you-go per token: Standard models $1.25 input, $0.15 cached input, $4.25 output per 1M tokens; Contributor models $0.10 input, $0.002 cached input, $0.20 output per 1M tokens

Available models

Muse Spark 1.3Muse Spark 1.3 ContributorMuse Spark 1.2Muse Spark 1.2 Contributor

Where Muse Code excels

Parallel feature work on one repository

One prompt can spawn several write-capable subagents, each in its own Git worktree and branch, so parallel changes never collide in your working copy.

Unattended CI jobs

`muse exec` runs a single prompt to completion with JSONL output and exit codes, and `--disable-approval` keeps the sandbox in place while skipping approval prompts.

Trying a second agent without redoing setup

Muse Code reads CLAUDE.md, discovers Claude Code and Codex skills, and `/migrate` imports memory notes and MCP servers, so existing project conventions carry over.

Muse Code vs. competitors

Muse Code vs. Claude Code

Claude Code runs Anthropic's Claude models across a CLI, IDE extensions, a desktop app, and the web, starting with Claude Pro at $20 a month. Muse Code is terminal-first (plus a session protocol and SDK), runs Meta's Muse Spark, starts at $5 a month, documents an OS sandbox and automated approval review as defaults, and can import Claude Code skills and read CLAUDE.md.

Muse Code vs. OpenAI Codex

Codex spans an open-source CLI, IDE extensions, and cloud tasks tied to ChatGPT plans or the OpenAI API. Muse Code has a closed-source CLI with its own $5 to $50 subscriptions or Meta Model API billing, and focuses on local multi-agent work in Git worktrees rather than cloud task environments.

Muse Code vs. Kimi Code

Kimi Code runs Moonshot's Kimi models through an MIT-licensed CLI, a desktop app, a VS Code extension, and ACP editors, with usage shared with Kimi chat under one membership. Muse Code is Meta's closed-source CLI for Muse Spark with no documented VS Code extension; beyond subagents, it adds staged workflows and background observer agents.

Muse Code vs. Qwen Code

Qwen Code is an Apache 2.0 agent with a desktop app and IDE integrations that works with Qwen models or other OpenAI-, Anthropic-, or Gemini-compatible providers; the client is free, but you bring your own model access. Muse Code is closed source, built for Meta's own Muse Spark models, and billed by subscription or per token.

Frequently asked questions

What is Muse Code?

Muse Code is Meta's coding agent for the terminal and CI. You run `muse` in a project, and it plans, edits files, and runs commands using Meta's Muse Spark models, asking for approval on risky actions and running shell commands inside an OS sandbox.

How much does Muse Code cost?

There are three monthly subscriptions: Everyday Usage at $5 (10 to 50 prompts every 5 hours), High Usage at $15 (5x Everyday), and Power Usage at $50 (20x Everyday). Alternatively you can pay per token through Meta Model API: Muse Spark Standard models cost $1.25 input and $4.25 output per million tokens, and Contributor models, which Meta may train on, cost $0.10 input and $0.20 output. Subscriptions apply only to the Muse Code CLI key; other API keys are billed pay-as-you-go.

Does Meta train on my code in Muse Code?

It depends on the model. Meta says Standard models (such as muse-spark-1.3) are not used to train its models, while the discounted Contributor models (such as muse-spark-1.3-contributor) allow Meta to use your prompts and completions for training. Meta also accepts zero data retention requests through its sales team.

Which platforms does Muse Code support?

The docs list macOS, Linux, and Windows. macOS and Linux install with a one-line shell script and Windows with a PowerShell script. On Windows, agent commands run in PowerShell and session messaging is not available.

Is Muse Code open source?

No open-source license is published for the Muse Code CLI. Meta's TypeScript SDK for driving Muse Code sessions is on GitHub under the MIT license, as a developer preview.

Is the Muse Code subscription the same as a Muse subscription?

Muse Code is its own subscription in Meta Accounts Center, with plans at $5, $15, and $50 a month that apply to the Muse Code API key set up during CLI onboarding. Meta's Muse Code docs do not say it covers the consumer Muse agent or that a Muse plan includes Muse Code, so treat them as separate purchases.

Muse Code vs Claude Code: what is the difference?

Claude Code runs Anthropic's Claude models across a CLI, IDE extensions, a desktop app, and the web, and starts with Claude Pro at $20 a month. Muse Code is a terminal-first agent for Meta's Muse Spark models, starting at $5 a month, with an OS sandbox and an automated approval reviewer on by default. It reads CLAUDE.md and can import Claude Code skills. If you prefer Claude Code's interface, Meta documents pointing Claude Code at Muse Spark through Meta Model API's Anthropic-compatible Messages endpoint.

Integrations & fit

Meta Model APIGitMCP serversAGENTS.mdCLAUDE.mdClaude Code skillsCodex skillsZed (ACP adapter)TypeScript SDK
Good fit forSolo / individual, Startup / small team, Enterprise
Pricing modelPaid· Paid subscription required
See pricing on Muse Code →

Alternatives to consider

About Muse Code

Muse Code is the first-party agent for Meta Model API: you install a native `muse` binary with a one-line install script (a shell script on macOS and Linux, PowerShell on Windows), run `muse` in a project, and sign in with a browser or a Meta API key. The same binary runs an interactive terminal UI or headless with `muse exec` for scripts and CI. Meta built it around Muse Spark and says the model and the agent were trained together. Two things set it apart. First, guardrails are on from the first run. Every shell command runs inside an OS-enforced sandbox (Seatbelt on macOS, bubblewrap on Linux, a Windows sandbox on Windows) that keeps the filesystem outside the workspace read-only and approves network destinations one by one. Compound commands are reviewed stage by stage, and in the default Auto-review profile a model-based approval judge clears requests it considers safe and sends the rest to you. Second, it leans on multi-agent work. A lead agent can spawn subagents, each optionally in its own Git worktree (eight agents per tree at once by default, including the lead), workflows can run up to 1,000 child tasks over a run (at most 16 active at once locally), and four background observer agents handle memory recall, skill recall, goal tracking, and verification. Every model call, tool call, and approval is written to an append-only event log, which powers crash recovery, rewind, forks, and exported trajectories. It reads AGENTS.md and CLAUDE.md, discovers Claude Code and Codex skills, and supports hooks and MCP servers. Pricing is either a Muse Code subscription ($5, $15, or $50 a month, usable only in the CLI) or Meta Model API pay-as-you-go, where Standard models cost $1.25 input and $4.25 output per million tokens and the Contributor models cost $0.10 and $0.20 in exchange for letting Meta train on your prompts and completions (with a much lower rate limit). Meta launched it in beta on August 5, 2026 and took it out of beta on August 31. The tradeoffs: it is built for Meta's own models, the CLI is not open source, no VS Code or JetBrains extension is documented, and some features, such as workflows on the current Apple silicon build and session messaging on Windows, are not available everywhere.

Updates from Muse Code

New FeatureMuse Code on Windows, Meta Model API generally available

Meta's Connect 2026 developer recap listed Muse Code as out of beta and available on Windows, and announced that Meta Model API is generally available globally. On Windows, Muse Code installs with a PowerShell script and runs agent commands in PowerShell.

New FeatureMuse Spark 1.3 with max reasoning

Meta released Muse Spark 1.3, tuned for agentic and coding work, and made it available with the new max reasoning level in Muse Code and Meta Model API.

LaunchMuse Code leaves beta with subscription plans

Meta took Muse Code out of beta, adding inter-session messaging, workflows, and rewind to the CLI and a developer preview of the TypeScript SDK, and began rolling out monthly subscription plans.

LaunchMuse Code launches in beta

Meta released an early beta of Muse Code alongside Muse Spark 1.2, with a one-command install and browser sign-in through dev.meta.ai.

Are you the founder? Claim this listing →