All posts
7 min read

How capability narrowing keeps delegated AI agents on a leash

The scariest sentence in agent design is "the agent can delegate to other agents." Delegation is where capability leaks happen: a carefully restricted lead hands a subtask to a helper, and the helper — created on the fly, prompted by a model — ends up with permissions nobody consciously granted. Here's how Choreo makes that structurally impossible, in code rather than in a system prompt.

Everything is a policy: allow, ask, or deny

Every capability an agent might use — reading files, writing them, deleting them, running code, running shell commands, sending email, making phone calls, calling external APIs — resolves to one of three answers before it executes. Allow runs. Ask raises an approval card a human answers, and the approval outlives a server restart — the request is a database row, not a promise in memory. Deny refuses, and the agent is told the capability is off rather than left to fail confusingly. Dangerous things default conservative: sending mail asks by default; deleting files is denied outright until you turn it on; an outbound phone call needs approval plus a destination allowlist plus a daily cap.

A child can only get less

When an agent delegates, the sub-agent's effective permissions are computed by taking the stricter of the parent's policy and the child's own, for every capability: deny beats ask, ask beats allow. Numeric limits — tool-call budgets, delegation depth, timeouts — are clamped with a minimum: the child gets the smaller of its own number and its parent's. Tool blocklists are unioned, so anything forbidden to either is forbidden to the child. There is no code path by which delegation widens anything. The lead can also narrow further per call — hand a research helper a read-only slice of its own toolset.

Reading the wrong thing tightens the screws

Prompt injection's classic shape is: fetch a hostile page, then obediently POST a secret somewhere. So the turn itself carries taint: once an agent reads untrusted content — a web page, an email body, a file it didn't write — capabilities that could exfiltrate escalate from allow to ask for the rest of the turn. Untrusted content is also fenced with markers the payload can't forge, so "instructions" found inside a document read as data, not as orders.

Why in code, not in the prompt

A prompt rule is a request; a model under pressure — or under injection — can ignore it. Every check above runs in the dispatcher that executes tool calls, outside the model entirely. The model can want whatever it wants; the call either passes policy or it doesn't. Because the checks live at the platform layer, the allow/ask/deny policy and delegation narrowing govern platform tools on all three runtimes — our loop, Codex, and Claude Code. Two honest exceptions, published rather than hidden: the taint escalation above is a feature of our own loop, and the native web tools bundled inside the packaged runtimes bypass our capability gate. Both are stated on the trust page — or set an agent's policies yourself and watch a sub-agent inherit the narrower version. Free plan, no card.

See it for yourself — free, $2 of credits once you confirm your email, no card.

Start free