Skip to content
Agentic Control Plane

Coding Agent Permissions: Policy Recommendations for Six Common Agent Setups

David Crowe David Crowe · · 5 min read
engineering agents policy
Share X HN LinkedIn

Ask what an agent should be allowed to do while nobody is watching, and the answer depends on the job more than the model.

The same few setups keep showing up in the agents we run and the ones that run through our gateway: a copilot at your elbow, a worker running unattended, a scout that mostly reads, an agent that ships to prod. Each has a sensible default policy. They differ enough that one policy for every agent is too tight for some and too loose for others.

For each setup below there are three verdicts: what runs freely, what stops and asks a human, and what never runs. Where attended and unattended differ, I say so. That split matters most. A rule that only holds while you’re watching is supervision, not a rule.

Rules in ACP are Allow, Ask first or Never, keyed by tool, like Bash.git.push or Bash.curl. The rules page has the copy-paste versions. A few things are held by the safety floor even with no rule: force-pushes, destructive SQL passed to a database client, curl | sh, and recursive deletes outside the project all wait for approval. Deleting your home directory, mkfs, disk wipes and fork bombs are always blocked.

The coding copilot

Interactive, in your terminal, you at the keyboard.

Allow the everyday work: reads, edits, builds, tests, ordinary shell. Approval fatigue is the failure to design against. A copilot that asks about everything trains you to say yes to everything, and then the questions protect nothing.

Ask first for the irreversible: deletes and outbound curl. Keep the list short so each prompt means something. Claude Code shows these holds inline. On other harnesses the call is blocked and you approve it on the console or from the email, then the agent retries.

Never is mostly the floor’s job here. Add your own Never rules for anything you’d never approve anyway.

One thing to know: ACP’s read-a-secret-and-send-it detector is off by default and has no console switch, so don’t count on it. A rule that asks before every outbound curl is what you have today.

Attended and unattended should match on subagents. When a copilot spawns subagents, they inherit the fences, not your trust.

The unattended worker

Always on, doing a job: triage, sync, drafting, monitoring.

Allow the job: reads, writes, web, connector calls.

Ask first on nothing, ideally. Nobody is there to answer. A held call in an unattended session becomes a deny plus an approval on the console, and if nobody answers it expires as denied. Design the policy so every call resolves without a human.

Never for the self-modification set: rewriting its own memory, running the shell, scheduling itself, delegating to other agents, changing its own skills, reading credentials. An unattended agent that can edit its own memory or schedule is an agent whose behavior next week you didn’t write.

Set these in the console under Policies, Agents, background. Slash commands only write rules for interactive sessions.

If ACP can’t be reached, the Claude Code plugin keeps unattended tiers blocked until it answers. The shared hook other harnesses use fails open unless you set ACP_FAIL_MODE=closed or ~/.acp/failmode on that machine. For an overnight worker on a non-Claude harness, set it.

The research scout

Gathers, summarizes, reports.

Allow reads, search and fetch, since reading the world is the job. Also writes inside its own workspace and read-style shell commands like cat, grep and ls.

Ask first for any write outside the workspace and any shell beyond reads. Put curl on this list even though it looks like reading, because it can POST data out.

Never for credential edits, remote shells and secrets in outbound requests. A scout has no reason to do any of them, so the rule costs nothing.

A scout’s policy barely changes unattended, which makes it the easiest agent to hand off first.

The ops/deploy agent

Touches infrastructure.

Allow inspection: logs, status, describes, diffs.

Ask first on every mutation: deploys, infra changes, service control, deletes. Do this attended too. This is the one setup where asking on the attended path is the point, because the approval is the deploy review. If that feels heavy, you don’t have an ops agent yet.

Never has a gap. What you want to block is anything aimed at prod, and ACP rules key on the tool, not on a connection string or hostname inside the command. It can’t tell prod-db.internal from localhost today. The defensible setup is to ask on every mutation, keep production credentials out of the agent’s environment, and make database clients a Never in unattended tiers.

The flight recorder

This is a posture, not an agent. Allow everything, record every call, and redact PII from the trail.

A workspace starts here: audit mode records every call, and only the safety floor holds anything. It’s the right day-zero setup for an agent that already works. You find out what it actually does before deciding what it may do, and a week of the record usually contains your first Never rule. It’s also a fine permanent choice for low-risk agents where the trail is all you need.

The setup that fails is the one reached by accident: a few checks, written once, that hold for nobody.

The scheduled/cron agent

An unattended worker plus a trigger. The trigger is what it must not own.

Everything from the unattended worker applies. Add one rule: it must never create or edit its own schedule, because an agent that schedules itself never stops. Add a spending budget too. Under Settings, Limits, you can set a maximum spend per period and halt tool calls when it’s reached. That’s a per-period cap, not per run, and it only counts model spend ACP can see. If the job writes anywhere that matters, start it draft-only and promote the writes after a week of reading drafts.

How to pick without guessing

Don’t reason your way to the right policy from a blog post. Try it in shadow first. A persona assigned in shadow runs against your agent’s real calls as they happen, and marks every call it would have denied or paused, with the reason. Nothing blocks. After a week, read that list against what you know the agent should be doing. If the list is all fence-probing, switch to enforce. If it’s full of the agent’s actual job, the policy is wrong, and you found out for free.

We ship five of these shapes as personas that work this way. They’re at /personas. The method works with any tool: write the rule down, watch what it would have done, and only then let it act.

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:

macOS · Linux · WSL
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
Windows · PowerShell
irm https://agenticcontrolplane.com/install.ps1 | iex

What the installer writes  ·  Getting started

Share X HN LinkedIn
Get the next data drop
What agents actually cost, new tool-surface captures, and the occasional incident post-mortem — sent when we publish something worth your inbox, not on a schedule. Unsubscribe anytime.
Share: Twitter LinkedIn
Related posts

← back to blog