At one of my clients, we were discussing how much autonomy to give AI coding agents. When should an agent be able to make a change on its own, and when should someone step in? The more we talked about it, the more it sounded like a question engineering teams have been answering for years: how do we delegate authority while staying accountable for the outcome?
Teams already make that decision for employees, contractors, and automated systems. AI agents bring different strengths and failure modes, but the same starting point applies. What could go wrong, how far could the effects spread, and how quickly could we detect and recover from a mistake?
Capability, authority, and accountability
- Capability: What can the contributor accomplish?
- Authority: What can they do without additional approval?
- Accountability: Who owns the outcome, and how does the team detect and correct mistakes?
A capable contributor can have narrow authority. An agent can work independently within those limits while a person or team remains accountable for the outcome.
Match autonomy to the risk
Set permissions according to what a change can affect. These examples are starting points. A test change that weakens a release gate, for instance, deserves more scrutiny than its file type suggests.
| Risk | Example | Safeguards |
|---|---|---|
| Low | Documentation, tests, isolated UI changes | Automated checks, with auto-merge where appropriate |
| Moderate | Features, API changes | Automated checks and review appropriate to the change |
| High | Authentication, payments, customer data | Explicit approval and a controlled rollout |
| Critical | Secrets, destructive operations, security boundaries | Restricted access and independent authorization |
Review those boundaries as the team learns which safeguards hold up in practice. Treat merging, deploying, and activating functionality as separate decisions. A team might allow a change to merge and deploy behind a feature flag while requiring explicit approval before customers see it.
Build safeguards into delivery
- Automated tests and security checks that run before changes merge
- CI/CD gates that reflect the risk of the change
- Feature flags and progressive rollouts that limit exposure
- Monitoring, observability, and automated rollback where practical
- Clear ownership and escalation paths when something goes wrong
AI agents introduce specific risks. They can act on instructions embedded in untrusted content, behave unpredictably, and produce changes faster than people can review them. Scope their tool permissions, treat external content as untrusted, and require independent authorization for consequential actions.
Measure delivery and recovery together
Count the cost of failures and recovery when judging how fast a team can deliver. Small teams feel the cost of blanket approvals especially keenly. Limiting the reach of a mistake, detecting it quickly, and making recovery straightforward gives teams room to delegate more. Reserve human judgment for decisions where it changes the outcome.
Further reading
- Google SRE: Release Engineering covers self-service deployments and release safeguards.
- Google SRE: Error Budgets explains how teams set a tolerance for reliability risk.
- Martin Fowler: Deployment Pipeline describes how automated verification supports delivery.
- Google SRE: Canarying Releases shows how teams limit exposure during rollouts.
- DORA: Software Delivery Performance covers measuring delivery speed and stability.