Every autonomy level and what it means for your agents

Not every agent output needs human review. Some changes are safe enough to ship automatically. The challenge is knowing which ones. Modulo's autonomy model solves this by making autonomy a function of evidence, not opinion.

The levels

Manual

Every agent output is reviewed by a human before it reaches production. Gates still run and their results are presented to the reviewer, but no output proceeds without human approval. This is the default level for new agents and new change types.

Supervised

Gates run on every output and can auto-pass, but any gate failure triggers human review. The human sees the gate evidence and decides whether the output is safe. This is the level for agents that have demonstrated basic reliability but still need oversight on edge cases.

Unsupervised

Gates run on every output and auto-pass or auto-fail. Gate failures spawn correction runs instead of pausing for human review. Humans are notified but do not need to approve every output. This is the level for agents with a proven track record on a specific change type.

Autonomous

Gates run but failures are rare enough that the agent operates without human oversight. Humans review summary reports rather than individual outputs. This is the level for mature, well-understood automation that has been reliable for an extended period.

How progression works

An agent starts at Manual for every change type. As it produces outputs that consistently pass all gates, its autonomy level rises for that specific change type. If a gate fails after the level has risen, the level falls back to the previous level and the evidence from the failure is added to the agent's record.

This means autonomy is always earned and always reversible. An agent that has been reliably generating documentation for months can operate autonomously on documentation changes, while still requiring manual review for code changes it has never attempted before.

Why levels are change-type-specific

A single agent may handle multiple types of change: documentation updates, bug fixes, feature development, test generation. Each type has a different risk profile and a different evidence history. Autonomy levels are tracked per change type, so an agent can be autonomous on documentation while still supervised on code changes.

The principle behind this: deterministic gates catch failures before they reach a human reviewer, and the evidence from those gates determines what the agent is trusted to do next.