Which coding agent has the best native controls?
Short answer: no single harness. Muse Code and DeepSeek Harness have the safest defaults, Claude Code has the most mature rule system, and most of the rest leave at least one of the seven questions below unanswered. The table compares what each harness ships on its own, as of August 2026. The last section says what a layer above the harness adds, and where it stops.
Every harness now ships something: approval prompts, an allowlist, a sandbox, hooks. None ships everything. The defaults differ a lot, and the docs rarely say what happens in the cases that matter: the approval times out, the agent runs headless, someone passes the yolo flag. We judged each one on seven questions:
- Approvals. Is there a native ask, and what are its modes?
- Rules. Can you write allow/deny policy, and how expressive is it?
- Sandbox. Is there OS-level isolation, and is it on by default?
- Interception. Can a third party stand on the call path, and does it see every tool call?
- Audit. What record exists that the agent did not write itself?
- Escape hatch. What single flag disables the controls?
- Empty chair. What happens to an approval when nobody is there to answer it?
This survey is the per-harness data behind our harness control patterns page, which names the eight control mechanisms these columns instantiate. The coverage matrix is the companion: it documents what ACP’s own hook intercepts on each harness. The MCP server controls comparison is the same survey for the other side of the wire. Deep pages per harness are linked in each row as we publish them. Corrections welcome. Every claim links to its source, and this page changes when the harnesses do.
What stands out
- Strongest defaults: Muse Code and DeepSeek Harness. Muse Code ships an OS sandbox (Seatbelt/bubblewrap) and an append-only event log, both on by default. The documented caveat: hooks and MCP servers run outside its sandbox (the deep page has the full model). dsh defaults its native sandbox to read-only, fails unanswerable approvals closed, and keeps an append-only session log with a runtime-enforced invariant: model-visible means logged.
- Most mature rule system: Claude Code. Layered settings with managed (org) scope, pattern rules, hooks on every call, and a classifier-based auto mode that derives a trust profile from your own usage.
- Cleanest architecture: DeepSeek Harness. One pipeline, typed interception points covering everything including MCP tools and Code Mode sub-calls, the only native ask-denies-itself headless posture, and subagents whose prompts auto-reject by default. Core ships architecture, not rules; the deep page explains the trade.
- Most expressive rules, no longer available: Gemini CLI. Its TOML policy engine (per-mode rules, five priority tiers, root-owned admin policy files, and
ask_userresolving to deny in non-interactive mode) was the high-water mark for rule design. Google retired it with the tool in June 2026. Its successor Antigravity ships a simpleraction(target)permissions engine, and the only hook vocabulary with a nativeask. - Best approval hardening: OpenClaw. Approvals bind exact command and cwd, approved scripts bind to on-disk snapshots, inline-interpreter forms force approval, and prompts detect invisible-Unicode obfuscation. It also has the most permissive default posture: exec
security: "full",ask: "off", on an agent built to run unattended. Both facts are on the deep page. - No permission system at all: pi. Mario Zechner and Armin Ronacher’s minimal harness (about 80k stars as of August 2026) ships four tools and no permission system, by design and documented, with containment patterns (micro-VM extension, Docker, OpenShell) offered instead. In a minimal-core design, control is an extension, so the extension seam is where control has to arrive. Its hard fork Prime Agent (Prime Intellect, about 18k stars at the same date) carries the same zero into always-on autonomous territory: one ipython kernel, daemon-resident sessions, and an inherited
hasUIsignal that misreports headless runs (deep page). - Most dangerous defaults elsewhere: Amp and Cline. Amp defaults to no approval prompts. Cline’s yolo is a literal approve-everything, and its “safe commands” tier trusts the model’s own
requires_approvalself-classification. The classifier is the thing being governed.
The comparison
| Harness | Approvals | Rules | Sandbox | Interception | Native audit | Escape hatch | Empty chair |
|---|---|---|---|---|---|---|---|
| Claude Code (deep page) | Six modes incl. auto: classifier-screened, default for Pro/Max/Team since 08-14 |
permissions.allow/ask/deny patterns; user + project + local + managed scopes; deny at any scope wins; autoMode.* prose rules |
Available, off by default (Seatbelt / bubblewrap; credential masking) | Hooks on every tool call; deny overrides allow; fail-open on timeout by default (onFailure: "block" available since 2.1.295) |
JSONL transcripts + opt-in OTel tool_decision (decision + source) |
--dangerously-skip-permissions; deny rules, hooks, and an rm -rf circuit breaker still hold; refuses root |
Defined: dontAsk mode auto-denies; unresolvable headless asks deny and continue |
| Codex CLI (deep page) | untrusted / on-request / never (on-failure removed 0.143) + Guardian reviewer agent (--approve-for-me, fail-closed, 0.147) |
Layered TOML + permission profiles (path to read/write/deny maps, network domains) + enterprise requirements.toml; approved_with_amendment persists approvals as reviewable rules |
Native on all three OSes: Seatbelt / bubblewrap+seccomp / native Windows sandbox; workspace-write networks off by default | Full hooks system, on by default: PreToolUse / PermissionRequest / PostToolUse, Claude Code-compatible schema, /import migrates (hooks reference) |
Session rollouts (JSONL + state DB); --ephemeral and codex delete erase |
--yolo (sandbox + approvals both off) |
Defined: exec never prompts; blocked actions fail back to the model |
| Cursor / Cursor CLI (deep page) | Run Modes: Auto-review (allowlist, then sandbox, then LLM classifier; recommended default), Allowlist, Run Everything | permissions.json takes deterministic terminalAllowlist / mcpAllowlist patterns plus natural-language autoRun allow/block instructions; allowlist officially “best-effort, not a security boundary” (3 bypass CVEs); .cursor/rules are steering, not enforcement |
Seatbelt / Landlock+seccomp (WSL2 on Windows); network blocked by default; sandbox.json |
Rich hook events; ask honored only for shell/MCP events; failClosed defaults to false |
None on any tier; DIY via hooks | Run Everything mode; CLI --force (alias --yolo) |
Cloud agents skip Run Modes entirely: auto-run inside a VM |
| GitHub Copilot (CLI · VS Code agent mode · cloud coding agent) (deep page · ACP install guide) | CLI: per-tool prompt; read-only tools auto-allowed; modifying calls prompt once / session / “don’t ask again in this repo” (~/.copilot/permissions-config.json). VS Code: Manual (default) / Assisted (LLM judge, experimental) / Allow all, plus an Autopilot mode that answers its own questions |
CLI --allow-tool / --deny-tool with a shell(git:*) subcommand grammar, session-only; deny beats allow unconditionally, even under --allow-all. VS Code chat.tools.terminal.autoApprove true / false / regex rules per subcommand; a false rule prompts, it does not block (“not a security boundary”, VS Code’s words; blocking = a PreToolUse hook) |
VS Code: off by default (chat.agent.sandbox.enabled; bubblewrap on Linux, Windows experimental); terminal commands only, network open unless closed; stays on under Allow all. CLI: none |
Hooks in both, Claude Code’s format read natively (repo .claude/settings.json, PascalCase payload with Claude tool names): PreToolUse allow / ask / deny; exit 2 denies; CLI preToolUse fails closed on a crash, open on a timeout, admin policy.d hooks included; VS Code ignores matchers (Preview) |
None (no per-call record documented) | CLI --allow-all / --yolo (+ all paths, all URLs); VS Code Allow all / Autopilot; hooks still fire; enterprise can block the permissive flags |
Cloud coding agent: ask resolves to deny (documented); CLI non-interactive: undefined |
| DeepSeek Harness (dsh) (deep page) | Approval service, mounted per composition | None shipped; policy arrives as a plugin | Native, default read-only (ctx.sandbox; also workspace-write, danger-full-access); bwrap-compatible local runner, remote E2B backend exists |
Typed tools/pre-execute / post-execute on one pipeline covering everything, incl. Code Mode sub-calls; post can rewrite output |
Trajectory log | danger-full-access preset (sandbox open, approval never): a named, visible profile choice |
Ask resolves to deny, natively |
| Muse Code (Meta) (deep page · ACP install guide) | On by default + LLM approval judge (--approval-judge off routes all to human); staged review of compound shell commands; workspace trust prompt |
on-request / untrusted / never modes; saved prefix rules per workspace root; deny always beats allow; interpreter prefixes can’t be broad-allowed |
Seatbelt / bubblewrap, on by default; refuses shell if sandbox unverifiable; .git/.muse/.agents read-only even in-workspace; network default proxy-only (per-destination review) |
Hooks on the full lifecycle incl. model calls, permission requests, subagent events; fleet-managed hooks via managed_hooks_path (pre-approved); caveat: hooks + MCP run outside the sandbox |
Append-only local event log of every model call, tool run, approval, edit | --yolo (approval + sandbox off, trusts the workspace: loads the checkout’s AGENTS.md); --disable-sandbox also unconfines file tools + forces full network egress |
Not documented |
| Grok Build (xAI) (deep page) | default / auto (classifier) / plan / always-approve / dontAsk (headless, fail-closed) |
TOML [permission] rules (action/tool/pattern), deny always wins; explicit allow auto-approves |
5 profiles (off default to strict), Landlock/Seatbelt; child-network block Linux-only |
PreToolUse hooks fire in every mode incl. always-approve; loads hooks from ~/.claude/settings.json but doesn’t parse Claude’s output vocab; updatedInput rewrite; HTTP hooks; fail-open core (5s timeout) |
Session log (~/.grok/sessions, format undocumented) |
--always-approve / --yolo (deny rules + hooks still fire) |
dontAsk: silent deny without an allow rule |
| Antigravity (Google, absorbed Gemini CLI) (deep page) | TUI approval cards; accept-edits / plan modes; headless (-p) soft-denies unobtainable approvals (exit 0 + stderr notice naming the needed rule) |
permissions.allow/ask/deny action(target) rules in settings.json: files, commands (prefix/regex), URLs, browser actuation, mcp(server/tool); deny > ask > allow; workspace files auto-allowed, everything else defaults to ask |
enableTerminalSandbox (off by default; nsjail / sandbox-exec / AppContainer); per-prompt opt-in/out; unsandboxed() rule escape |
hooks.json hooks, 5 events, regex matchers; native ask/force_ask in the hook vocabulary, the only harness with a first-class hook-issued ask; fail-closed on hook failure |
Per-conversation transcript JSONL; enterprise tier: central audit logging, MCP restrictions, spend caps (Gemini Enterprise) | --dangerously-skip-permissions is total, verified: hooks are not invoked at all under the flag (unlike Claude Code / Grok Build, where denies + hooks survive bypass) |
Defined: headless soft-deny, run continues |
| Goose (Block / LF) | auto / smart_approve (LLM judge + read_only_hint) / approve / chat |
Extension allowlist via GOOSE_ALLOWLIST URL; ~35 danger patterns exist but are off by default and prompt-only |
None | None: extensibility is MCP-shaped, no tool-call hook | None | GOOSE_MODE=auto (the default) |
Undefined |
| opencode (deep page · permissions reference) | Native ask via permission config |
allow/ask/deny, last-match-wins, per-tool + bash patterns ("rm *": "deny") |
None | JS/TS plugin hooks incl. the permission system (reliability caveats reported) | Session log | --auto (denies still enforced) |
Undefined |
| Hermes Agent (deep page) | Inline prompt on ~47 dangerous patterns | Published blocklist: 12 hardline patterns that hold in every mode, quoting-hardened (our read) | None | pre_tool_call / post_tool_call on every tool, in-process; pre can block, route to the human approval gate, or rewrite args; post is observational (transform_tool_result can rewrite results) |
Session log | yolo mode (hardline tier survives it) | Prompt with no answerer: halt |
| Amp (Sourcegraph) | Default: no approval prompts | amp.permissions (allow/ask/reject, glob matches, per-thread/subagent context); amp.guardedFiles.allowlist |
None | Plugin API | None | amp.dangerouslyAllowAll |
Undefined |
| Cline (guide) | Per-category auto-approve toggles | Safe-command classification | None | Hooks via stdin (open bug: hooks execute even when permissions disabled) | None | CLI default: auto-approve ON | Auto-approve |
| Crush (Charm) | Permission service on side-effectful calls | permissions.allowed_tools; options.disabled_tools |
None | No hook system | None | --yolo (still hard-blocks ssh/scp/rsync) |
Undefined |
| OpenHands | Confirmation mode default-on; --llm-approve risk analyzer |
ConfirmRisky policy, configurable threshold | Sandboxed runtime | SDK-level pluggable SecurityAnalyzer + ConfirmationPolicy |
None | --always-approve / --yolo |
Undefined |
| Qwen Code (Alibaba) (deep page) | Five modes: plan / default / auto-edit / auto (default: an LLM classifier approves “safe” actions) / yolo |
Claude-grammar permissions.allow / ask / deny rules (Bash(git *), Read(./secrets/**), mcp__x), deny > ask > allow; system settings file overrides user and project |
Optional: Docker/Podman via tools.sandbox, macOS seatbelt profile per project |
Hooks are Claude Code’s contract: PreToolUse / PostToolUse command hooks, permissionDecision allow/ask/deny, exit 2 blocks; timeout in ms; disableAllHooks off switch |
None | --yolo (hooks still fire) |
Documented: a hook ask degrades to deny in headless runs and background subagents |
| pi (earendil-works) (deep page) | None, by design. No permission prompts of any kind | None. “Pi does not include a built-in permission system”: the docs say so and point you at containment | None built in; documented patterns: Gondolin micro-VM extension, Docker, OpenShell | TypeScript extensions can mediate tool execution (Gondolin reroutes the built-in tools; hook API undocumented) | None | The default is full access | N/A: there is nothing to resolve |
| Prime Agent (Prime Intellect) (deep page) | None, by design (pi fork; kept the zero) | None. Extension docs list the permission gate as the canonical extension to write | None built in; one ipython kernel runs everything with the launching user’s access |
pi’s typed events kept intact: tool_call (blockable, input-mutable, fails closed on handler error) + tool_result (rewritable); no MCP second path (MCP = Python skills inside ipython) |
Branchable session tree (the run’s own account) | The default is full access; /autonomous limits bound spend, not actions |
ctx.hasUI lies in print mode (reports true headless, 0.8.x; all CLI sessions run in daemon workers); the no-op UI’s unanswerable confirm is the reliable empty-chair signal |
| fx (Vercel Labs) (deep page) | ask / auto (default) / yolo; auto = rules first, then a hardcoded model review of unresolved sensitive calls (docs say openai/gpt-5.4; launch-day source hardcodes zai/glm-5.2; not configurable either way), human fallback when interactive |
Wildcard permission JSON, user-global + per-workspace, last match wins; /permissions remember stores exact confirmed rules; repo .fx.json can’t set rules or model |
os mode (macOS only: workspace-scoped writes), default none; widening access is a separate approval |
fx acp: as an Agent Client Protocol server, fx sends every approval-gated call to the client (session/request_permission, full raw arguments) and fails closed; no hooks/plugin surface otherwise |
None | yolo (permission checks + sandbox off; requires yolo_acknowledged; FX_PERMISSION_MODE=yolo env does the same) |
Undefined; the reviewer’s human fallback is documented for interactive mode only |
Sources: each harness’s official docs, linked from its deep page or row. Adoption and behavior claims for harnesses we haven’t integrated come from vendor documentation and are marked where uncertain. Kilo (Cline lineage) and Mistral Vibe track their parents’ models and are omitted until we’ve verified their divergences. Qwen Code (also Gemini CLI lineage) is in the table because we verified its hook contract and headless posture on 2026-09-03. Devin CLI ships JSON hooks in .devin/ and reads .claude/ hook directories. Aider remains git-diff-review by design, with one exception worth copying: under --yes-always, shell execution is auto-denied, not auto-approved. This table extends our July primary-source read of eleven harnesses’ guardrails, where the escape-hatch column is examined in depth.
What the table says
Interception is the dividing line. Read the Interception column and the ecosystem splits in two: harnesses where a third party can stand on the call path and see everything (Claude Code, Codex since its 2026 hooks system, dsh, Hermes, Muse Code, Grok Build, and most of Cursor), and harnesses where it can’t (Goose and Crush, principally). Every other control can be added from outside if interception is complete. Nothing can be added if it isn’t. If you’re choosing a harness with control in mind, this column outweighs the rest of the table.
Convergence on Claude Code’s hook contract. Codex’s hooks are deliberately Claude Code-compatible and codex /import migrates Claude Code configs wholesale. Cursor and Hermes honor exit-code-2 blocking and the JSON decision shapes. Grok Build loads hooks straight out of .claude/settings.json but parses only its own top-level decision vocabulary (the trap). Devin CLI auto-discovers .claude/ hooks. dsh ships a hooks-claude-code bridge. The PreToolUse contract is becoming the ecosystem’s POSIX. A control layer built against it ports cheaply, and so does a permission-model bug: the same settings-format bypass has been reproduced in two different harnesses.
Classifiers took over the approval loop; ledgers did not follow. All three majors now put a model where the human prompt was: Claude Code’s auto mode (default-on for paid personal accounts since August 14), Codex’s Guardian reviewer (0.147), Cursor’s Auto-review (3.6). Hermes made LLM smart approvals its default in July; Grok Build, Goose, and OpenHands have their own variants; Cline goes furthest and trusts the governed model’s own risk flag. The fatigue math is real. Anthropic’s figures at the auto-mode launch (August 2026) had humans catching 13.6% of dangerous commands at the prompt versus 89% for the classifier. But exactly two harnesses (dsh, Muse Code) added an independent append-only record of what ran, and none added a queryable trail of what their classifier decided or why. The ecosystem is spending fast on making attended sessions quieter and almost nothing on making decisions explainable afterwards.
The empty chair is being answered, by the newest designs. dsh resolves unanswerable asks to deny. Codex exec never prompts and fails blocked actions back to the model. Claude Code ships dontAsk. Gemini CLI’s policy engine resolved ask_user to deny non-interactively. Hermes denies flagged commands in cron and one-shot modes. That is real convergence on the right answer, and it’s recent. The counterexamples are the ones to check before unattended use: Cline’s yolo, Cursor’s cloud agents (auto-run inside a VM), and OpenClaw’s default posture on an agent designed to run unattended. The reasoning is in the empty-chair test.
Where every native model ends
Grade any row generously and the same four gaps remain. They are structural, not missing features:
- The record is self-authored. Transcripts and trajectories are written by the process they describe, on the machine that ran it. Only Muse Code hardens this locally; nothing ships it off-machine.
- Policy is per-machine. Settings files, profiles, and config live with each install. Two engineers on one codebase run whatever their machines accumulated. Managed settings (Claude Code) and fleet-managed hooks (Muse Code) are the first cracks in this, for those two harnesses, org-wide.
- One flag undoes it. Nearly every row has an escape hatch that disables the controls and the record of the controls being disabled.
- Rules don’t travel. A deny you wrote in
settings.jsondoesn’t exist inconfig.toml,crush.json, orpermission.yaml. Every harness added means re-deriving your policy in a new dialect, or carrying one policy across all of them.
Those four are the job of a layer above the harness. The native controls are good now, and getting better fast; this page exists because choosing well matters. What none of them try to be is one policy with one independent record across every harness on the machine. That is the layer we build. The coverage matrix says what each harness can and cannot express, and the per-harness deep pages say where each handoff happens.
If you already run auto mode and a sandbox
Auto mode plus a sandbox is a good setup for one harness with you at the keyboard. Here is what a hook-based layer like ACP adds on your machine, and where it stops.
What it adds. One hook, installed into each harness you run, sends every tool call to one policy before the call runs. A rule such as Bash.git.push: deny is written once and checked in every harness the hook covers, without rewriting it in three dialects. How an ask is delivered differs by harness, as the next paragraphs say. Every decision lands in one log the agent did not write. A safety floor applies with no rule at all: a force-push, destructive SQL through a database CLI, curl | sh, and a recursive delete outside the project are held for your approval, and rm -rf of home or root, mkfs, a disk wipe and a fork bomb are always blocked. Tiers let you set stricter rules for background runs and subagents than for your own interactive session. The recipes are on the rules page.
The default is audit mode. A new workspace records everything and holds nothing except the floor. Your own rules start blocking when you run /acp-enforce or turn enforcement on from the Policies page.
Does it cover my other harness? Not evenly. Only Claude Code shows a hold in the session. On every other harness the call is blocked, you approve it on the console or from the approval email, and the agent retries. Codex is covered for Bash only unless you add the MCP supplement, and it has no ask. Hermes maps an ask to a block plus a console approval. The coverage matrix lists each harness’s gaps; read your row before you rely on it.
What leaves my machine. In a connected workspace the hook posts the tool name, its arguments and up to 200 KB of its output to the gateway, so the policy can run and the log can be kept off the machine. Credentials found in arguments are redacted before they are stored. With --local, nothing leaves: rules live in ~/.acp/policy.json, the record is ~/.acp/audit.jsonl on the same disk, and there are no tiers and no console.
What if ACP is down? It depends on which hook is running. The Claude Code plugin lets an interactive session continue with an UNGOVERNED banner, and blocks the subagent, background and API tiers until the gateway answers. The shared hook that the other harnesses use fails open in every tier unless ACP_FAIL_MODE=closed or ~/.acp/failmode is set on that machine. And because it is a hook, the harness’s own off switch turns it off too: disableAllHooks in Claude Code, or Antigravity’s yolo flag. A harness that stops calling hooks is the one gap no hook can close.
Frequently asked questions
Which AI coding agent has the best built-in permission controls?
As of August 2026: Muse Code ships the strongest defaults (OS sandbox and append-only event log on by default). Claude Code has the most mature rule system plus a classifier-based auto mode. Gemini CLI’s TOML policy engine was the most expressive rule language before Google folded the tool into Antigravity, whose JSON permissions engine and hook-native ask carry that lineage. DeepSeek Harness has the cleanest interception architecture and the only native ask-denies-itself headless posture. No harness ships all four of: complete interception, expressive rules, an independent audit record, and team-level policy.
Do any coding agents have a real audit log built in?
Two stand out. DeepSeek Harness keeps an append-only SessionEvent log with a runtime-enforced invariant (model-visible means logged), and Muse Code keeps a local append-only event log of every model call, tool run, approval, and edit. Everything else offers session transcripts: records written by the same process they describe. Even the two good ones live on the machine that ran the agent. No surveyed harness ships a queryable, off-machine decision ledger.
What is the most dangerous default among coding agents?
Permissive-by-default on an unattended agent. OpenClaw, the most-starred agent of all and built to run always-on, defaults to exec security full with approvals off; its own docs call the default guardrails for operator intent, not isolation. Among coding CLIs, Amp defaults to no approval prompts, Cline’s yolo mode auto-approves every tool, and Cline’s safe-command path trusts the model’s own risk self-classification. Run the empty-chair test before handing any of them an unattended job.
Running coding agents? ACP records each tool call its hook sees and makes the dangerous shell commands (a force-push, destructive SQL, curl | sh) wait for you. One command, free up to 5 agents:
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
irm https://agenticcontrolplane.com/install.ps1 | iex