Muse Code: Meta's terminal coding agent, explained

Published September 3, 2026 · by the AQ team

Muse Code is Meta's terminal coding agent: a CLI you run inside a project directory that 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 alongside Muse Spark 1.2, a model Meta trained specifically for coding, and left beta on September 1, 2026 with an SDK developer preview, inter-session messaging, workflow orchestration, and monthly subscription plans. What makes it architecturally distinctive among coding harnesses 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 at the September release, and where it still needs help, as of September 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, sign in with your Meta developer account on first run, and drive it from the terminal like Claude Code, Codex CLI, or Grok CLI. There is no native Windows build documented as of September 2026; WSL2 is the route in.

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

# 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 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 2026)

The September 1, 2026 release moved Muse Code from beta to general availability on macOS and Linux 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 are rolling out 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.

One day later, on September 2, 2026, Meta began rolling out Muse Spark 1.3 to Muse Code and the Model API: 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 Muse Spark 1.2 for the same work. A max reasoning variant is announced to follow after additional safety testing.

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 September 2026), disk-real worktree isolation for its subagents, and a model co-trained with the harness. Our guide to choosing a coding harness gives the criteria that actually separate these tools, and the 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. 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 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 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 Team 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.