# Muse Code: Meta's terminal coding agent, explained

> Muse Code is Meta's terminal coding agent: Muse Spark models, subagent fan-out into git worktrees, a replayable event log, and native Windows since September 2026.

Updated October 10, 2026 (first published September 3, 2026) · by the AQ team · Canonical: https://aq.dev/agents/muse-code/

Muse Code is Meta's AI coding agent for the terminal: a CLI named muse that you run inside a project directory, where it plans a change, edits files, runs shell commands, and checks its own work, powered by Meta's Muse Spark models over hosted inference. It launched in beta on August 5, 2026, left beta on September 1, 2026 with an SDK developer preview and monthly subscription plans, and added a native Windows build in mid-September 2026, so it now installs on macOS, Linux, and Windows. What makes it architecturally distinctive among [coding harnesses](https://aq.dev/glossary/coding-harness/) is the combination of persistent asynchronous subagents, fan-out into isolated git worktrees for parallel work, and an append-only event log that makes sessions crash-safe and replay-exact. This page explains how it works, what changed through early October 2026, and where it still needs help, as of October 10, 2026.

## What Muse Code is (and is not)

Muse Code is a single binary called muse. You install it with one shell command on macOS or Linux, or one PowerShell command on Windows, sign in with your Meta developer account on first run (muse first asks whether to trust the workspace, then offers a browser sign-in or an API key; CI environments set META_API_KEY instead), and drive it from the terminal like Claude Code, Codex CLI, or Grok CLI. Native Windows support arrived on September 16, 2026 (before that, WSL2 was the documented route in): per Meta's announcement, the Windows build is PowerShell-fluent, sandboxed by default, runs on x64 and arm64, and installs without administrator access.

```
# macOS or Linux (as of October 2026)
curl -fsSL https://dev.meta.ai/install.sh | bash

# Windows (PowerShell, native since September 2026)
irm https://dev.meta.ai/install.ps1 | iex

# In a project
cd your-project
muse
```

Two boundaries worth being precise about. First, this is a local harness around hosted inference, not local weights: the muse binary runs on your machine, but every model call goes to Muse Spark on Meta's service, so there is no GPU requirement and no offline mode. Second, it is Meta-models-only: no bring-your-own-key, because Muse Code exists to run Muse Spark, the model Meta co-trained with the harness itself.

## The architecture: subagents, worktrees, and an event log

Three design decisions separate Muse Code from the first generation of terminal agents.

**Persistent asynchronous subagents.** Most harnesses spawn a subagent per task and throw it away. Muse Code keeps specialized background agents active throughout the session: workers carry out next steps in parallel while reviewers check the work behind them, each choosing when to report back instead of blocking the main agent. The pitch is fewer redundant context-gathering passes and less babysitting.

**Fan-out into isolated git worktrees.** When Muse Code parallelizes, the isolation is real on disk. Each child subagent gets its own worktree and branch: the runtime creates worktrees under .muse/worktrees/ in detached-HEAD state, checked out from the parent's HEAD, with no manual git worktree command from you. Each child commits on its own branch, results drain back to the parent automatically when its turn is idle (or the parent blocks on one with subagent_wait), and the parent reviews or merges them one at a time. This is the [git worktrees for AI coding agents](https://aq.dev/guides/git-worktrees-for-ai-coding-agents/) pattern, built into the harness.

**An append-only event log.** Every model call, tool run, approval, and file edit is appended to a local event log, and that log is the single source of truth for the session. That buys two things. Sessions are restart-safe: if the process crashes or gets killed, the next session reads the log and carries on from the last recorded step, no re-prompting to rebuild state. And sessions are rewindable: a double press of Esc rolls the conversation back to an earlier point, with the harness offering only safe rewind points derived from the log.

## What shipped when it left beta (September 1, 2026)

The September 1, 2026 release moved Muse Code from beta to general availability and added four things, per Meta's announcement:

- **An SDK in developer preview.** The engine behind the CLI (sessions, tools, permission control) as a TypeScript library. Your program spawns a local muse host and talks to it over the Muse Session Protocol (MSP), a local inter-process protocol, so you can build your own agents on top of the runtime.
- **Inter-session messaging.** Sessions on the same machine can deliver messages to each other: when a change in one session affects what another is building, the agent itself discovers the peer and passes a warning across, using two built-in tools. Messages travel over a Unix socket between processes you own, so nothing crosses the network.
- **Workflow orchestration.** A way to turn a large task into a coordinated team of subagents that build and review in parallel, on top of the worktree fan-out described above.
- **Subscription plans.** Monthly plans for predictable pricing, alongside pay-per-token Model API billing. The token route has two tiers: standard, at normal Model API pricing, and a discounted contributor tier that is rate-limited in a rolling 5-hour token window and whose usage Meta may use to improve its products. If your code is sensitive, read that data-use tradeoff carefully.

## What changed in September 2026

Muse Code moved fast after general availability. The changes that matter, each verified on Meta's own pages and announcements as of October 2026:

- **Muse Spark 1.3 (September 2, 2026).** Meta began rolling out Muse Spark 1.3 to Muse Code and the Model API the day after general availability: better long-horizon and agentic performance, more active collaboration (clarifying questions, flagging when it is stuck), and, by Meta's internal comparisons, roughly 20 percent fewer tool calls and 25 percent fewer tokens than the launch model for the same work. The max reasoning variant, announced to follow after additional safety testing, shipped within the week and is available in Muse Code as of October 2026.
- **Native Windows (September 16, 2026).** Meta closed its most-requested platform gap: Muse Code runs natively on Windows with no WSL required. Per Meta for Developers' announcement, the Windows build is PowerShell-fluent, sandboxed by default, ships for x64 and ARM64, and installs with zero admin rights; inter-session messaging on Windows was listed as coming soon at launch.
- **Published plan pricing.** As of October 2026, Meta's product page lists three monthly plans: Everyday Usage at $5 per month (10 to 50 prompts every 5 hours, image and video uploads included, plus voice mode and web search), High Usage at $15 per month (about 5x more usage), and Power Usage at $50 per month (about 20x more usage plus early access to new features). The same page states Muse Spark's context window supports up to 1M tokens, and its token table prices the standard tier at $1.25 per million input tokens, $0.15 cached input, and $4.25 output, against $0.10, $0.002, and $0.20 for the contributor tier, whose column plainly says usage is used to improve Meta's products.

## What changed in early October 2026

Meta's changelog entries carry no dates on the page, so take these as the newest items listed there as of October 10, 2026, each cross-checked against the docs:

- **A Python SDK.** The SDK is no longer TypeScript-only: the changelog adds a Python package on PyPI (muse-code-sdk, with a wire-types companion, muse-code-msp), and the TypeScript package now versions in lockstep with Muse Code releases instead of drifting on its own. Both talk to the local host that muse serve runs, and muse schema prints the session protocol's JSON schema.
- **Remote MCP servers with OAuth.** New muse mcp login and muse mcp logout commands handle OAuth sign-in to remote [MCP servers](https://aq.dev/guides/mcp-servers-for-coding-agents-explained/), so tools behind an identity-aware endpoint no longer need pasted tokens.
- **Voice dictation on by default.** On macOS, Option+V dictates into the session and /voice manages it; the changelog lists voice input enabled by default on Windows x64 and ARM64 as well. A muse voice transcribe command transcribes an audio file from the CLI.
- **Editors over ACP.** The changelog tracks fixes to a Zed adapter speaking the Agent Client Protocol, and community-built ACP bridges (not from Meta) connect Muse Code to VS Code and JetBrains IDEs. The terminal is still the first-party surface.
- **A worktree sandbox fix.** One security entry closes a hole where git commands inside subagent worktrees could run filter commands on the host: worth knowing if you audit what the fan-out machinery may touch.

## How it compares to the field

Muse Code competes on architecture rather than ecosystem. Claude Code and Codex CLI have a year-plus head start on integrations, editor hooks, and community knowledge; Muse Code counters with the event log (no other mainstream harness makes sessions replay-exact from a single local log as of October 2026), disk-real worktree isolation for its subagents, and a model co-trained with the harness. Our [guide to choosing a coding harness](https://aq.dev/guides/how-to-choose-a-coding-harness/) gives the criteria that actually separate these tools, and the [harness directory](https://aq.dev/guides/coding-agent-harness-directory/) keeps the full field in one place. Many teams do not choose at all: they run two harnesses on the same task in parallel worktrees and keep the better diff, a fair way to evaluate Muse Code against your incumbent this month.

## What the event log does not solve: the machine problem

Muse Code's persistence story is about surviving crashes, not continuing work. The event log means a killed session resumes cleanly, but the muse process runs wherever you started it: close the laptop and the agents stop, worktrees and all, until you come back. [Keep Muse Code running after closing your laptop](https://aq.dev/guides/keep-muse-code-running-after-closing-laptop/) walks through the options. Inter-session messaging is deliberately same-machine (a Unix socket), so it does not make sessions reachable from anywhere or visible to anyone else.

The second gap: Muse Code is single-player by construction. Subagents parallelize the work, but no teammate can watch the session, type into it, or pick it up when you are out. That solo default is the industry pattern, not a Muse Code quirk: a July 2026 [LeadDev analysis](https://leaddev.com/ai/ai-coding-agents-kill-team-collaboration) of 25,264 agent-generated pull requests across 2,361 popular GitHub repositories found that in 79 percent of agentic PRs the same developer both reviewed and modified the agent's contribution, and only about one in eight workflows involved multiple humans. The fix for both gaps is boring: run the harness on a machine that does not sleep, and put the session somewhere your team can see it. [Always-on coding agents](https://aq.dev/guides/always-on-coding-agents/) covers the vendor-neutral patterns.

## Where AQ fits

AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud. AQ workspaces are real Linux terminals in persistent tmux sessions on your team's VM, and a plain shell there runs any Linux CLI, Muse Code included: install it on the VM, sign in once, and run muse inside a workspace exactly as on your own machine. The session then survives closed laptops, resumes from any device, and streams live to the browser, where teammates open the same workspace and watch or drive the same session (typing into someone else's terminal is delegated: the owner approves a control request in one click).

The worktree philosophies stack rather than fight. AQ gives every workspace its own isolated git worktree on a branch like ai/1234-fix-auth, so parallel workspaces never collide; inside one workspace, Muse Code is free to fan its subagents into its own .muse/worktrees/ without touching a neighbor. Each engineer authenticates CLIs with their own accounts, agents commit and open PRs with per-user GitHub auth, PRs are tracked per workspace, and labeling a Linear issue ai-task creates a workspace with ownership following the assignee. Pricing is two plans: Free is a personal sandbox for one person (AQ creates a private machine in an isolated network, nothing to install, no time limit), and AQ Pro is $50 per user per month early access (standard $200, billed monthly), covering VMs you connect from your own cloud or a dedicated always-on AQ-managed VM, with your rate locked for your first 12 months.

Plainly: Muse Code's event log makes a session recoverable, and a persistent shared machine makes it continuous and visible. If you are evaluating Meta's harness solo on a laptop, you need nothing else. The moment you want it running overnight, or want a second pair of eyes on what its subagent team is doing, put it on a VM your whole team can open.

## Frequently asked questions

### What is the Muse Code CLI?

The Muse Code CLI is the product: a terminal program (the muse binary) rather than a companion to some larger app. You install it with a one-line shell command on macOS or Linux, or a PowerShell one-liner on Windows, then run muse inside a project directory. Planning, file edits, shell commands, and subagent fan-out all happen in that terminal session, with inference served by Meta's hosted Muse Spark models.

### What model does Muse Code use?

Muse Spark, Meta's coding-focused model family, over hosted inference. Muse Code launched in August 2026 on Muse Spark 1.2; Meta began rolling out Muse Spark 1.3 on September 2, 2026, with a max reasoning variant following after additional safety testing. As of October 2026, Meta's product page states the context window supports up to 1M tokens and that image and video inputs are accepted. There is no bring-your-own-key or local-weights option: the harness exists to run Meta's models.

### Does Muse Code run on Windows?

Yes, natively since September 16, 2026: no WSL required. Per Meta's announcement, the Windows build is PowerShell-fluent, sandboxed by default, ships for x64 and ARM64, and installs without administrator access (run irm https://dev.meta.ai/install.ps1 | iex in PowerShell), though Meta's docs note the sandbox may show a one-time administrator (UAC) prompt the first time it initializes. Agent-run commands use PowerShell rather than Bash. Before the native build, WSL2 was the documented route, and it still works if your tooling already lives there. As of October 2026, Meta's docs still list session messaging as unavailable on Windows.

### Does Muse Code run on Linux?

Yes. Linux (x86_64 and arm64) has been supported since the August 5, 2026 beta, with the same one-line installer as macOS: curl -fsSL https://dev.meta.ai/install.sh | bash. Linux is also where Muse Code fits long-running work best, since a Linux server or VM inside tmux keeps sessions alive when your laptop does not.

### Is there a Muse Code desktop app?

No. As of October 2026, Meta ships Muse Code as a terminal CLI only: no desktop app and no IDE of its own. The editor route that exists is the Agent Client Protocol: Muse Code's changelog tracks a Zed (ACP) adapter, and community-built ACP bridges (not from Meta) connect it to VS Code and JetBrains IDEs. Treat any download advertised as a Muse Code desktop app with care before granting it your repository and Meta sign-in. If what you want is a graphical, shareable view of a session, the pattern that works today is running the CLI on a server and streaming the terminal to a browser.

### What is the Muse Code SDK?

A library that lets your own program drive Muse Code sessions programmatically: starting and resuming sessions, sending instructions, and reacting to what the agent does. It launched in developer preview on September 1, 2026 as TypeScript only; as of October 2026 there are two packages, @muse-code/sdk on npm and muse-code-sdk on PyPI (with the wire-types companion muse-code-msp), and the changelog says the TypeScript package now versions in lockstep with Muse Code releases. Both talk to a local host (muse serve) over the Muse Session Protocol (MSP), whose JSON schema muse schema prints, so everything runs on your machine with no extra server.

### How much does Muse Code cost?

As of October 2026, Meta's product page lists three monthly plans: Everyday Usage at $5 per month (10 to 50 prompts every 5 hours, with image and video uploads, voice mode, and web search), High Usage at $15 per month (about 5x more usage), and Power Usage at $50 per month (about 20x more usage plus early access to new features). Plans renew monthly on your sign-up date, and usage through an API key on top of a plan bills pay as you go. Token billing on the Model API lists the standard tier at $1.25 per million input tokens ($0.15 cached, $4.25 output) and the contributor tier at $0.10 per million input tokens ($0.002 cached, $0.20 output); the contributor discount exists because Meta uses that tier's usage to improve its products, so check the terms before pointing it at sensitive code.

### Does Muse Code keep running after I close my laptop?

No. The event log makes a killed session resume cleanly when you return, but the muse process and its subagent worktrees run on your machine and stop when it sleeps. Our guide to [keeping Muse Code running after closing your laptop](https://aq.dev/guides/keep-muse-code-running-after-closing-laptop/) covers the options: run it on a server or VM inside tmux, or use a harness platform like AQ where the session lives on an always-on machine and streams to your browser.

---

About AQ: AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud. Start at [aq.dev](https://aq.dev/).