Interactive vs. autonomous agents: the empty-chair test
A sentence that keeps coming up when people talk about letting an agent run without them: the whole point of handing off is that I stop watching.
That is the real boundary in agent control. Not the model, not the framework, not how many tools the agent has. The question is whether a human is there when the decision gets made. Most teams know this and still write one policy and run it on both sides.
The trouble is that the controls don’t mean the same thing on both sides. Here’s a test we use. Take each control you rely on and ask what it does when the chair is empty.
The ask
With someone at the keyboard, an approval prompt is a real question. A human reads it, brings context the policy doesn’t have, and answers. The known failure is approval fatigue: a copilot that asks about everything trains you to say yes to everything. So you want to ask rarely, so each ask counts.
With nobody there, the same prompt isn’t a question. It becomes whatever your setup does with an unanswered one. There are three outcomes, and two are bad:
- Auto-approve. The ask quietly becomes a yes. Your human in the loop is now a log line.
- Hang. The agent stops mid-job and waits for a person who isn’t coming. For an always-on worker that’s an outage.
- Deny. The call is refused, the agent adapts or the job fails cleanly, and the request lands where a person can review it later.
Deny is the only safe one, because an unattended agent can’t approve itself. Some harnesses do this already. In a headless setup with no approval service, DeepSeek Harness turns an ask into a deny by itself. Where a harness can’t ask at all, ACP does the same mapping. Codex has no ask prompt, so our Codex integration turns an ask into a deny that carries an approval link. You approve on the dashboard, the identical command is re-run, and it goes through. For unattended tiers in general, an ask is blocked and waits on the console. An unanswered request expires and counts as denied.
Test it: when an approval times out in your stack, what happens? If you don’t know, it’s probably one of the bad two.
The failure setting
With someone watching, failing open can be a fair choice. If the policy check can’t run because of a network blip or a slow gateway, blocking every call bricks the session of a person who can see the warning. Fail open, say so loudly, record the lapse, and the human notices in seconds.
With nobody there, “loudly” has no audience. An always-on agent that fails open during an outage runs with no controls until the outage ends, and nobody sees the banner. The setting that made sense at the keyboard has no limit in the empty chair.
So the right answer flips by tier. The ACP Claude Code plugin fails open with a loud UNGOVERNED banner in interactive sessions and fails closed for subagent, background and api tiers. Our DeepSeek Harness and Grok Build plugins follow the same split. One caveat: the shared hook that Cursor, Codex and other hook-file harnesses use fails open in every tier unless you set ACP_FAIL_MODE=closed (or put closed in ~/.acp/failmode) on that machine. If you run unattended agents there, set it. Explicit denies hold either way.
Teams tend to pick one failure setting and call it consistent. The consistent choice is wrong on one side of the line.
The audit trail
When you’re watching, the audit log is a convenience, a searchable record of things you mostly saw happen.
When you’re not, the log is the only witness. The session transcript is the agent’s own account, written by the same model whose behavior is in question. If the record isn’t written by a layer the agent’s calls pass through, with each decision logged before and after the call, then for unattended work you have a diary, not an audit trail.
Test it: could you reconstruct what the agent did last night from evidence the agent didn’t write?
The stopping point
At a keyboard, the stopping point is you. You get bored, suspicious or done, and you hit Ctrl-C.
Without you, a loop keeps looping. Rate limits and budgets stop being billing hygiene and become the brake on a retry storm, a runaway fan-out of subagents, or a scheduled job that schedules itself. If your unattended agents have no per-agent limits, the stopping point is your credit card.
The self-modification set
This barely exists on the attended side, so it gets missed. A copilot that edits its own config does it in front of you.
An unattended agent that can rewrite its own memory, edit its own skills, change its own schedule or create its own delegations is an agent whose behavior next week you didn’t write. Each write looks ordinary alone, which is why the set is risky. The archetype recommendations cover the concrete policy: for the unattended worker, that set is a flat deny.
When an agent spawns others, attended or not, the subagents should inherit the limits, not the trust.
One policy set, two outcomes
Don’t conclude that you need two policies. Two policies drift, and the unattended one rots because nobody works under it day to day.
Use one set of rules where each rule resolves per tier. Each governed call in ACP carries a tier (interactive, subagent, background or api) set by the integration, not by the agent. The same rule lands differently on each side. Pause on file deletes is an approval for an interactive session. For the background tier the call is blocked and waits on the console, because that’s what a pause is when nobody can answer. The tier rules live in the console under Policies → Agents. Local-only mode has no tiers; a rule there applies to every session.
You don’t write special rules for autonomous agents. You write rules whose unattended outcome you chose, instead of inheriting whatever the timeout does.
The test
Before you hand an agent a job you won’t watch:
- Every ask resolves. No rule ends in “wait for a human.” An ask becomes a deny that is sent to someone.
- The failure setting flips. Open and loud at the keyboard, closed in the empty chair.
- The record is separate. Written by the layer the calls pass through, not by the agent.
- There’s a stopping point. Rate and budget limits per agent, because Ctrl-C isn’t there.
- The agent can’t edit its future self. Memory, skills, schedule and delegation are denied unless a human is in the loop.
If the safety only holds while you’re watching, you haven’t handed off yet.
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