Do You Still Need a Control Layer? Every Harness and MCP Server Has Permissions Now
A common objection goes like this: you don’t need a separate control layer. The harness has approval modes and permission rules. The MCP servers have read-only flags and scoped tokens. The layer you’re describing already exists, twice.
The premise is mostly true. The conclusion doesn’t follow, and the reason is about who owns what, not about feature counts.
The built-in controls are real
We keep two comparison pages up to date, so we know the details.
The coding agents ship real controls. Claude Code has a layered rule system and an auto mode where a classifier screens calls. Codex has a hooks system and a sandbox on three operating systems. Muse Code turns on an OS sandbox and an append-only event log out of the box. The pages compare the major coding agents on seven questions. The short verdict is that they are good and getting better fast.
The MCP servers ship real controls too. The GitHub MCP server has a read-only mode, 23 toolsets, per-tool selection and a lockdown mode. Supabase’s --read-only runs as a read-only Postgres role. Stripe’s restricted keys are checked on Stripe’s side, so a read-only key can’t issue a refund whatever the client says. Two years ago none of this existed.
So the old argument for a control plane, that nobody enforces anything, is dead. The current argument is narrower.
Three questions the built-in controls can’t answer
Pick any control in either table and ask who owns it, where else it applies, and what it can see.
Who owns it. Server-side controls belong to the service’s admin: a Notion workspace admin, an Atlassian org admin, a Slack workspace owner. Client-side MCP controls are launch flags in a config file that sits where the agent works, and the agent can often edit it. The filesystem reference server even lets a connected client replace the allowed-directories list at runtime. Coding-agent rules are per-machine settings files.
Now ask who answers for what the agent does. That’s the person who deployed it. They own none of those three places. The rules that matter to them have nowhere to live. This is the old split between a control plane and a data plane: enforcement should belong to the operator, separate from the things it governs.
One caveat on our side. ACP runs as a hook inside the harness, so someone with access to the machine can switch it off. disableAllHooks does it in Claude Code, and Antigravity’s yolo mode does it there. What ACP changes is where the rules and the record live: in a workspace the operator owns, not in a file on each laptop.
Where else it applies. A deny rule in Claude Code’s settings.json doesn’t exist in Codex’s config.toml. GitHub’s read-only is a flag, Supabase’s is a database role, Stripe’s is a key permission, and Notion’s hosted server has none. Each tool speaks its own dialect.
So “our agents never force-push and always ask before moving money” isn’t one policy. It’s a dozen partial translations that drift apart, and some can’t be written at all in the local vocabulary. The controls exist. Your policy doesn’t exist anywhere as one thing.
What it can see. This one decides incidents. The GitHub MCP private-repo leak was a read of untrusted issue text followed by a write that sent private code out. The Supabase lethal trifecta was untrusted data, database access and a way to send data out. Each piece was approved on its own.
In both cases every single call looked fine to whoever received it. The danger was the sequence. A per-server control can’t express a rule about a sequence, because the server only sees its own calls. ACP’s cross-surface log is what lets you look at that sequence afterward. Blocking on the sequence itself is limited today.
There is a fourth gap for anyone running agents at scale: what got written down. Approvals are almost absent from MCP servers. Of the sixteen servers we compared, one has a native approval flow, and its vendor, AWS, is deprecating it in the managed successor. Audit logs, where they exist, sit in each vendor’s own console. “Show me everything the agent did across every tool, and why each call was allowed” can’t be answered from parts, because the parts don’t share a record.
We hit this ourselves
Our own gateway has an MCP client that mounts external servers. Its first internal security review recorded the day-one state: if you attached a server with a delete_database tool, a background agent could call it immediately. Nothing in the server, the protocol or the harness had a place to say no. Discovery, transport and auth all worked. The rule had nowhere to live until we built that place where the calls pass through.
Use the built-in controls anyway
None of this argues against them. Turn them all on. Scope the token, set the read-only flag, keep the sandbox on. The sandbox limits the damage; it doesn’t decide whether to fire. Layers are cheaper and calmer when the ones below them are tight.
The claim is just that three things don’t come out of per-tool controls, however good each one gets: policy the operator owns, one rule set across tools, and a view across the sequence. They need a layer where the calls pass through, owned by the person who answers for the outcome. That’s what we build. The coding-agent and MCP server pages say where each built-in control stops, and /coverage says how deep ACP goes on each harness.
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