Muse Code auto-approve, yolo mode and sandbox, explained
Muse Code has no setting called auto-approve. In the default on-request mode, safe actions pass automatically and only dangerous patterns stop for review. --disable-approval skips prompts entirely and keeps the sandbox. Yolo mode is --yolo, which turns off both approval and the OS sandbox and trusts the workspace for the run. Meta’s permissions doc says to use it only where you already trust the environment and the code, such as a disposable CI container.
Muse Code shipped in beta on August 5, 2026. It is Meta Superintelligence Labs’ terminal coding agent, built on muse-spark-1.2 and installed as a native binary (no source repository is published). It starts with an OS sandbox and approvals both on, and keeps an append-only local event log. This page covers what Muse Code ships for controlling tool execution, how each mechanism behaves per Meta’s docs, and where it stops. In a few places the beta’s documentation is ahead of the shipped binary, and the page says where.
This page covers Muse Code’s own controls. Our Muse Code integration is shipped (@agenticcontrolplane/muse-code). For the cross-harness picture, see the controls comparison.
The two-layer model
Meta’s permissions doc draws one line, and the rest of this page follows from it. Approval decides whether a command runs. The sandbox limits what it can touch when it does. The layers are independent: turning one off leaves the other on. Both are on by default. To understand any escape hatch below, ask which layer the flag removes.
Approval modes and the judge
--approval-mode picks one of three postures:
| Mode | What holds for review |
|---|---|
on-request (default) |
Only dangerous or external-execution patterns: destructive removal forms (rm -rf) and ripgrep options that can launch helper processes (-z, --search-zip, --pre, --hostname-bin), including when wrapped by another command. Everything else runs automatically, contained by the sandbox. |
untrusted |
Any shell stage without a matching allow rule. Escalates shell execution only. |
never |
Nothing. No prompts; the sandbox is the only control. |
In every mode, file reads and in-workspace write_file/edit_file pass without prompting. The sandbox is what bounds them. So on-request leans on the sandbox, not on approval. A short list of dangerous patterns holds for a human and the rest of the shell runs. That is the closest thing Muse Code has to an auto-approve setting.
A built-in LLM approval judge reviews prompt-bound calls automatically, so the human only sees what the judge escalates. --approval-judge off sends every decision back to the human. The docs say the judge belongs to the approval layer itself, not to a third layer. A model is checking a model’s tool calls, inside the mechanism that exists to check the model. That is a reasonable trade for attended use. Make it on purpose, because the docs describe no record of what the judge decided or why.
Staged shell review
Muse Code parses a compound command into ordered stages and checks each one. Execution blocks at the first stage that isn’t approved. Take wc -l report.log && echo cleaning && rm -rf report.log. The two read-only stages pass, and the rm -rf holds at stage 3 of 3. The command runs as a single unit only once all stages pass. If you reject the held stage, nothing runs, including the earlier safe stages. There is no partial execution.
Some stages can’t be reduced to a complete, static command: command substitutions, non-read-only redirects, variable-assignment prefixes. The mode decides what happens. In untrusted they hold for review. In on-request only dangerous-set matches hold, and the rest passes to the sandbox.
Trust scopes and rule precedence
When a stage holds, the prompt offers three answers:
- Allow once runs it one time and saves nothing.
- Always allow in this workspace saves a prefix rule scoped to the workspace root. It doesn’t carry to other projects or cover different commands.
- Reject denies the entire command.
Two details are worth copying. A deny rule always overrides an allow rule, whatever the specificity. And interpreter prefixes (python, bash, node) can’t be saved as broad allows, because what follows them is arbitrary code. always allow python would allow everything, so Muse Code refuses to write it.
Workspace trust is the outer gate. On first open, Muse Code asks whether to trust the workspace. Only a trusted workspace loads project-local skills, rules, and hooks, and the answer is remembered per workspace root. One caveat from the configuration docs: committed project memory under .agents/memory/ is read even in an untrusted workspace. Meta’s docs tell you to treat a repo’s MEMORY.md as a prompt-injection surface.
The sandbox
The OS enforces the sandbox: Seatbelt on macOS, a bundled bubblewrap helper on Linux, and a Windows sandbox on Windows that may show a UAC prompt on first use. The rules:
- Writable: the workspace plus a temp directory. Everything else is read-only, and out-of-bounds writes fail at the OS level.
- Read-only even inside the workspace:
.git,.muse, and.agents. The agent can’t rewrite its own history, configuration, or memory. We haven’t seen another harness ship this, and it matters, because an agent that can edit its own rules file can approve itself. - Fail-closed: if the sandbox can’t be verified (a Seatbelt check at session start, a bubblewrap probe on Linux), Muse Code refuses to run shell commands instead of running them unconfined.
Network has its own setting, --sandbox-network. proxy-only (the default) holds the first connection to each new host, port, or protocol for review, like a shell command. restricted means no network. unrestricted means full egress (the older name enabled still works but is deprecated). Per-destination review by default is a strong choice. Most harnesses either leave the network open or turn it off.
Escape hatches
Three flags, and the two-layer model tells you what each one costs:
--disable-approvalturns prompts off and keeps the sandbox on.--disable-sandboxkeeps approval on and turns the sandbox off. It also removes workspace confinement from the file tools (write_file/edit_filecan write anywhere) and forces the network to full egress, overriding--sandbox-network. One flag removes three controls.--yoloturns both layers off and trusts the workspace for the run, which loads the checkout’sAGENTS.md, rules, and skills. Meta’s docs recommend it only for disposable CI containers and say never to use it on a workstation with access to real credentials or infrastructure. They also warn that on a PR or fork checkout, those files are attacker-controlled instructions. People miss that trusting the workspace is part of what the flag turns on.
The docs don’t say what happens to a held approval when muse exec runs headless and nobody is there. It could deny, time out, or hang. Until Meta documents it, don’t give Muse Code an unattended job in any mode where something can hold. We call this the empty-chair test. dsh answers it natively.
Hooks
The hooks system covers the full lifecycle: SessionStart, UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, PreLLMCall, PostLLMCall, PreCompact, PostCompact, SubagentStart, SubagentStop, Stop. A hook can block an action before it happens. PermissionRequest lets a hook sit inside the approval flow itself.
Hooks register from three sources with three trust levels:
| Source | Location | Trust |
|---|---|---|
| Project | <project-root>/.muse/hooks.json |
explicit trust required (muse hooks trust <key>) |
| User | machine-wide settings file | explicit trust required |
| Managed | file at the managed_hooks_path setting |
pre-approved, no trust step |
Managed hooks are centrally administered and apply without per-machine consent. The docs state the other side: whoever controls the managed hooks file controls what executes. Protect that path like sudoers.
Two caveats, one from the docs and one from a real install:
- Hooks run outside the sandbox. A hook’s command executes directly through your shell, outside both the sandbox and approval. The only hardening is a cleared environment with a small allowlist. MCP tools are the same: approval applies, containment does not. Both documented gaps in the sandbox are the extension points.
- The docs and the binary describe different ways in. The documented
muse hooksmanagement CLI (list,validate,trust,run --fixture) is not in the shipped 0.2.1 beta binary. The binary has a plugin system behind aMUSE_EXPERIMENTAL_PLUGINSflag, which we verified on a real install. Hooks register as capabilities of a native plugin (.muse-plugin/plugin.json), installed and trusted throughmuse plugins installandapprove, with a per-hook fixture runner (muse plugins hook test). The flag gates only that management CLI. Once a plugin’s hooks are approved, they fire in ordinary sessions without the flag. Hook payloads and decision outputs follow the same schema as Claude Code hooks, down to the field names. It is a beta, so expect this to move toward the documented CLI.
Multi-agent
A lead session spawns child agents for bounded tasks. By default, children share the lead’s workspace, so parallel writes can collide. Worktree isolation is opt-in with muse --subagent-worktree-isolation, which gives each child its own git worktree checked out from the lead’s commit. In a non-git workspace the flag is silently ignored. Children can’t spawn their own children, concurrency is capped around core count, and the runtime journals every spawn, status change, and control action. If you’ve read that subagents “each run in their own worktree,” that is the flag, not the default.
The event log
Muse Code keeps an append-only local event log of every model call, tool run, approval, and edit. Meta describes it as replay-exact and restart-safe. The limits: it lives on the machine that ran the agent, the process it describes writes it, and nothing in the docs says it records what the approval judge decided or against what. It is a crash-recovery journal, not a decision ledger.
Where the native model ends
Muse Code ships with the sandbox on, approvals on, a fail-closed check when the sandbox can’t be verified, deny-beats-allow, staged shell review, and protection for its own config. What it doesn’t have:
- The judge is unexplained. The LLM judge decides automatically, and no documented record captures what it approved or why.
- The extension points bypass the boundary. Hooks and MCP tools run outside the sandbox, which is where you would add controls.
- The empty chair is undocumented. Headless approval resolution is unspecified, so unattended use is a guess.
- Everything is per machine. Prefix rules are scoped to a workspace root on one machine, and the event log stays local. Managed hooks are the one org-level tool, and they are a pointer to a file, not a policy you can query.
- One flag undoes both layers, and nothing independent records that it was passed.
The same four gaps show up in every harness we’ve surveyed: records written by the process they describe, policy that lives on one machine, escape hatches with no evidence, and rules that don’t travel to the next harness. A layer above the harness covers them. That layer is one policy and one off-machine record across the harnesses we cover (the coverage matrix lists each harness’s limits). Our Muse Code integration ships that layer for Muse Code today.
Frequently asked questions
muse code auto approve: how do I stop the prompts?
There is no setting named auto-approve. The default on-request mode already passes recognized, non-dangerous shell stages, file reads and in-workspace edits without a prompt. --approval-mode never or --disable-approval removes prompts and keeps the sandbox; “Always allow in this workspace” saves a prefix rule for one command. --approval-judge (on by default) lets a built-in reviewer decide prompt-bound calls first.
muse sandbox: what does Muse Code's sandbox allow?
Writes to the workspace and a temp directory; the rest of the filesystem is read-only, and .git, .muse and .agents stay read-only inside the workspace. It uses Seatbelt on macOS, a bundled bubblewrap helper on Linux, and a Windows sandbox on Windows. Network defaults to proxy-only, which holds the first connection to each new destination for review. If the sandbox can’t be confirmed, shell commands don’t run.
How do permissions work in Muse Code?
Two independent layers, both on by default. The approval layer checks side-effectful tool calls against policy. In the default on-request mode only dangerous patterns (destructive removal forms, ripgrep options that can launch helper processes) hold for a human, everything else runs and the sandbox contains it. Untrusted mode holds any shell stage without a matching allow rule. Never mode drops prompts entirely and relies on the sandbox alone. The sandbox layer is enforced by the OS (Seatbelt on macOS, bundled bubblewrap on Linux, a Windows sandbox on Windows): writes are confined to the workspace plus a temp directory, and Muse Code refuses shell execution outright if the sandbox can’t be verified.
What is Muse Code's approval judge?
A built-in LLM that reviews prompt-bound tool calls automatically, so the human only sees what the judge escalates. You can turn it off with –approval-judge off, which routes every decision to the human. The judge is part of the approval layer, so a model is checking a model’s tool calls. It reduces prompt fatigue, but the docs describe no record of what the judge decided or why.
How does Muse Code handle compound shell commands?
Staged review. A compound command is parsed into ordered stages and each stage is checked individually. Execution blocks at the first stage that isn’t approved, and the command runs as a single unit only once every stage passes. Rejecting a held stage means nothing runs, including the earlier safe stages. In untrusted mode, stages the parser can’t reduce to a complete static command (command substitutions, non-read-only redirects, variable-assignment prefixes) also hold for review.
Does Muse Code sandbox everything the agent does?
No, and its docs say so. Shell commands run inside the OS sandbox. Hooks execute directly through your shell outside the sandbox and approval, with a cleared environment as the only hardening. MCP tools get approval but not containment. Inside the workspace, .git, .muse, and .agents stay read-only, so the agent can’t rewrite its own history, configuration, or memory.
What does --yolo do in Muse Code?
Disables both layers (approval and sandbox) and trusts the workspace for the run, which loads the checkout’s AGENTS.md, rules, and skills. Meta’s own docs recommend it only for disposable CI containers, say never to use it on a workstation with access to real credentials or infrastructure, and warn that on a PR or fork checkout those files are attacker-controlled instructions. The partial hatches are –disable-approval (sandbox stays on) and –disable-sandbox (approval stays on, but file tools lose workspace confinement and the network is forced to full egress).
Running Muse Code? One command adds a hook. Each tool call it sees is recorded, and a force-push, destructive SQL or curl | sh is blocked until you approve it on the console or from the email.
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
irm https://agenticcontrolplane.com/install.ps1 | iex
What the installer writes · Muse Code guide · free up to 5 agents