Control buys your team speed inside safe boundaries, and Delegation is where you draw the line that makes the speed safe: what an agent handles without asking, what it brings to a person first, and how much work you hand it at once. You let the agent draft freely, explore an approach, and propose the change, then have it pause at the moves that are expensive to walk back: before it merges a PR, ships to production, or touches a database. When that line is deliberate, you get the throughput of an agent that rarely blocks and the calm of knowing the riskiest actions still pass a human gate, so a confident wrong call costs a review comment instead of an incident.
What Delegation owns is the judgment about who decides, not the mechanism that enforces it: the allow-list and the destructive-command gate are Capability, and breaking work into session-sized units the system around it can checkpoint is Environment. The line itself runs from soft rules a human can waive in a low-risk case to hard policy (“never delete a database, any agent, any environment”) that nothing is allowed to cross. The question it leaves you with is how much of that line lives in one person's head on a given run, and how much the tooling itself enforces, so it holds when no one is watching.
Exploratory
No line between agent and human work. Whatever the agent does, it does.
- Enables
- Full speed, and a cheap way to learn where the agent's judgment actually needs a human. The calls that go fine and the ones that scare you are what a real gate later gets drawn from.
- Deficiencies
- High-stakes actions get taken with no human at the points that matter, one bad run reaches production, and oversized tasks degrade or stall mid-way.
- Cost to maintain
- Cleanup after the agent oversteps, plus the latent risk of the run that does real damage.
Techniques
None yet. Manual and ad hoc.
Expert-led
One lead applies their own rules to their own work: never merge, always review the plan first, and break work into a session-sized chunk before handing it over.
- Enables
- A sane line for the work that lead touches, with the riskiest moves kept with a human.
- Deficiencies
- A single point of failure. The rule lives in their head, not the workflow, and others delegate differently or not at all.
- Cost to maintain
- Their attention holding the line on every run, plus re-teaching it whenever someone new picks up the agent.
Techniques
- . Reusable prompt documents that encode a workflow, its rules, and its anti-patterns, so a task starts from a runbook instead of a fresh explanation.
- . Explicit do-not lines written into skills and orientation docs, ruling out whole classes of action without asking the agent to weigh the alternatives.
- . A JSON state file that is decomposition, controller, and handoff at once, so a new session knows what is done, what is next, and what the last one learned.
Documented
“Agents draft, humans approve” is written into team norms, with the high-stakes actions named and a convention for how big a task to hand an agent at once.
- Enables
- A shared line across the team. New people inherit it, and it survives the lead being out.
- Deficiencies
- It still relies on people honoring it, nothing in the workflow stops an agent from crossing the line, and gaps open where a norm is silent.
- Cost to maintain
- Writing the policy and keeping the list of reserved actions current as stakes change.
Techniques
- . Explicit do-not lines written into skills and orientation docs, ruling out whole classes of action without asking the agent to weigh the alternatives.
- . Reusable prompt documents that encode a workflow, its rules, and its anti-patterns, so a task starts from a runbook instead of a fresh explanation.
- . A JSON state file that is decomposition, controller, and handoff at once, so a new session knows what is done, what is next, and what the last one learned.
Structural
Stop-points sit in skills, rules that take no exceptions live in contracts, and the workflow itself decomposes work into session-sized units, so the line survives whoever drew it.
- Enables
- The agent cannot take a reserved action on its own. The human gate is enforced rather than remembered, and it holds consistently across every run and project.
- Deficiencies
- A too-strict line blocks low-risk work and trains people to wave it through, and an agent that hits the line mid-task still has no good way to hand the problem back to a human.
- Cost to maintain
- Upfront engineering of stop-points and allow-lists, plus tuning the line as trust and stakes shift.
Techniques
- . Reusable prompt documents that encode a workflow, its rules, and its anti-patterns, so a task starts from a runbook instead of a fresh explanation.
- . A JSON state file that is decomposition, controller, and handoff at once, so a new session knows what is done, what is next, and what the last one learned.
- . Explicit do-not lines written into skills and orientation docs, ruling out whole classes of action without asking the agent to weigh the alternatives.
- . A settings file that enumerates exactly which commands an agent may run, started from zero and widened only as the work needs it, so its reach is a reviewed decision rather than a default.
- . Scripts that wrap standard CLI tools with guardrails (credential routing, identity checks, confirmation on destructive operations) so the safety lives in the tool rather than in the prompt.
- . A built-in path for the agent to stop and ask a human when it is stuck, instead of looping or silently giving up, so asking for help is built into the harness rather than left to the agent's judgment.
Delegation rarely stands alone. Where it overlaps a sibling discipline, an investment on one side quietly depends on the other. The Control domain page lays these out in full.
- Delegation and Capability
Capability sets what the agent can reach; Delegation sets what it is trusted to decide on its own. Connect a tool but reserve every call about it and you have a locked drawer; hand over a decision for a system the agent cannot touch and you have named a responsibility it has no way to exercise.
Buy both in step, and reach and judgment cover the same work; buy one ahead of the other and you pay for a surface no one is cleared to use.
- Delegation and Environment
Delegation draws the line on what the agent decides alone; Environment is the harness that catches the call when it goes wrong. How far you can safely move that line depends on what the system behind it catches: solid gates let you delegate more, because a bad decision meets a test failure instead of a customer.
Widen the line with no harness and every handed-over call rides on the agent being right; harden the harness but never widen the line and the safety net goes unused.
The agent has what it needs to act.
- CollectionGetting context in: gathering the artifacts an agent needs to orient.
- ManagementKeeping the context your agents read current as decisions and conventions change.
- DisclosureFeeding context in efficiently: routing the agent to the slice it needs, not a data dump.
The agent can only do what it should.
- CapabilityWhat the agent can do: the tools you connect, and the ones you deliberately withhold.
- Delegation (current page)What the agent should do: the responsibilities you hand over, and the ones you reserve.
- EnvironmentThe system the agent works within: the tests and gates its work must clear, and the points where a human takes over.
The human can see what happened.
- CaptureMaking sure every run leaves a raw record.
- AvailabilityPutting the record of agent work where your team can query and review it.
- TraceWalking back through a single run, end to end, with the reasoning alongside the decisions.
The team gets better over time.
- EvaluationMeasuring whether your processes work, by the numbers and by gut-check.
- PrioritizationChoosing what to change and where to invest next.
- ConvergenceMaking a change stick across the team.