---
title: "The Agent Autonomy Ladder: How AI Agents Earn Trust"
description: "The agent autonomy ladder promotes an AI agent one action at a time, on evidence: how costly a mistake is, how easily it is caught, and its track record on that exact action."
author: "MDflow"
date: 2026-11-16
reading_time: "16 min"
canonical_url: https://mdflow.cz/blog/agent-autonomy-ladder
md_url: https://mdflow.cz/blog/agent-autonomy-ladder.md
---

# The Agent Autonomy Ladder: How AI Agents Earn Trust

*Published November 16, 2026 · 16 min read*


Nobody sensible argues any more about whether an AI agent should be allowed to act. The argument is about **how it gets permission to act more** — and most teams have no answer beyond a person eventually deciding they feel better about it.

A Meta engineering team that runs an AI teammate across live on-call rotations has a more disciplined answer, and the interesting part is not the agent. It is the promotion track they built around it.

> **TL;DR** — **The agent autonomy ladder is a promotion track, not a setting.** An agent starts by investigating and changing nothing, moves to drafting fixes a human approves, and only then clears low-criticality work alone. It climbs when three things hold **for one specific action**: a mistake there is cheap, something other than a person catches it, and the agent already has a track record on that exact action. That makes autonomy a property of an action, not of an agent — and it makes the written record the thing the whole scheme rests on. The playbook, the corrections and the log have to outlive the shift, which is what a shared markdown workspace like [MDflow](https://mdflow.cz) is for. [Start free](/login).

## What is the agent autonomy ladder?

**The agent autonomy ladder is a three-rung promotion track for an AI agent, modelled on how a team onboards a new on-call engineer.** It was described by Swaapnika Motapothula, Chinmay Gandhi and Vlad Tsvang of Meta in an [AI Engineer talk published on 10 November 2026](https://www.youtube.com/watch?v=_NBx2NNOuA4), covering an AI teammate that now runs real rotations around the clock.

The analogy they start from is the human one, and the first two rung names are theirs. A new on-call engineer shadows first: investigates, suggests, touches nothing. Then they pair: write the fix, have someone else approve it. Then, with a record behind them, they handle routine work alone. The agent gets exactly the same ladder.

| Rung | What the agent does | What reaches production |
| --- | --- | --- |
| 1 — Shadow | Investigates using the team's memory and runbooks, reports a root cause | Nothing |
| 2 — Pair | Drafts the fix with a root cause and a test plan, answers review comments, fixes CI | Nothing without a human approval |
| 3 — Level three | Clears low-criticality work on its own, interrupts only for what matters | Low-criticality changes, through normal review and CI |

High-criticality work stays with humans at every rung. In the team's own example, the 2 a.m. checkout page is still a human decision — the agent brings the investigation, the person owns the call.

Two details are easy to skim past and both matter. The first is that **the rungs are per action, not per agent**. The same teammate sits at level three for closing a noisy duplicate alert and at level one for a production mitigation, at the same moment. The second is that **most of what it drafts never lands**, and the team treats that as the design working rather than failing. Review is the filter.

## The promotion test: cost, catchability, track record

**An action moves up the ladder when three conditions hold together — and all three are about the action, not the model.**

1. **A mistake there is cheap.** Not zero, cheap. The question is what it costs if this specific action goes wrong once.
2. **Something other than a person catches it.** A test, CI, code review — a check that fires whether or not anyone is paying attention at 2 a.m.
3. **The agent has a track record on that exact action.** Not on the task family, not on similar work. That one.

This is a stricter test than it looks, and it explains an asymmetry that otherwise seems arbitrary: in the talk the agent closes a noisy alert on its own while a production mitigation still waits for a human. Closing a noisy alert is cheap and reversible, and it is the kind of routine action an agent accumulates a record on quickly. A production mitigation is none of those things.

It also makes the ladder measurable rather than vibes-driven. The team's stated next step is to grade every mitigation the agent proposes and feed the outcome back, so the agent **earns** its next rung instead of being handed it. The rung after level three — medium-criticality autonomy — is explicitly described as something still to be earned with evidence, not something shipped.

Worth being equally precise about what they did *not* claim. They say early signs of on-call load reduction are promising and then decline to put a number on it until they can measure it properly. That restraint is the most credible thing in the talk.

## Why design-time autonomy levels are not enough

**Academic autonomy frameworks tell you where an agent sits; a ladder tells you how it moves.** Both are necessary and they answer different questions.

The clearest of the frameworks is [Levels of Autonomy for AI Agents](https://arxiv.org/abs/2506.12469) by K. J. Kevin Feng, David W. McDonald and Amy X. Zhang at the University of Washington. It sorts agents into five levels by the role the human takes — operator, collaborator, consultant, approver, observer — and makes an argument that is still underrated: **autonomy is a design choice that can be set separately from raw model capability.** A very capable agent can be deliberately built to check in at intervals; a modest one can run alone on a narrow task. The paper goes on to propose *autonomy certificates*: issued by third parties on the basis of structured justifications it calls autonomy cases, in the spirit of safety cases, and capping the autonomy level an agent is permitted to operate at.

An older framework, [Levels of AI Agents: from Rules to Large Language Models](https://arxiv.org/abs/2405.06643), borrows the SAE driving scale and ties levels to the technology instead — rule-based, then learned, then LLM-based with memory and reflection.

Put the ladder next to these and the gap is obvious. Design-time levels are assigned **once, to the whole agent**. The ladder is assigned **repeatedly, per action, on accumulated evidence**. Most production disagreements about agent autonomy are really this mismatch: someone asks "how autonomous is our agent?" when the only answerable version of the question is "how autonomous is our agent *at this one action*, and what is the evidence?"

The two views converge on one practical point, though. An autonomy case is a **written artefact**. So is a track record. Neither survives in a chat transcript.

## What the ladder needs underneath it

The talk's most quotable line is also its least glamorous: **the agent is generic, and the expertise is owned by the team.** What makes an agent good at a rotation is the team's playbook, alert profiles, skills and past decisions. Swap those out and you have a different teammate running the same loop.

That has three consequences worth copying.

**The agent belongs to the rotation, not to a person.** Their reasoning is blunt — an on-call agent cannot belong to one engineer, because the on-call itself does not. Whoever is on duty can correct it or pick up its work mid-investigation. The example they give is the whole argument in miniature: Monday at 2 a.m., Sam tells it that when checkout times out after a config push, roll the config back first. Three days later Jordan hits the same alert, asks for a fix, and gets Sam's answer — with a note saying where it came from. Teach it once, and the correction reaches the next person on the rota instead of evaporating at the end of a shift.

**Corrections are an input, not a retrospective.** Every piece of feedback reopens the item and lands in memory. When someone says "that was wrong", the correction becomes the new memory rather than a line in a document nobody reads until the quarterly review.

**Memory has to earn its place too.** Theirs retrieves semantically, scores what actually helped, and promotes or retires entries automatically — because an unmanaged memory degrades into a pile of stale assertions that look authoritative. We wrote about that failure mode in [Agent Memory Consolidation](/blog/agent-memory-consolidation).

**For developers**, the practical consequence is that the ladder has a prerequisite most teams skip: before you can promote an agent on evidence, the evidence and the playbook have to live somewhere durable, shared and legible. A runbook in one person's head, or in a chat thread, cannot support a promotion decision.

**For AI agents**, the consequence is narrower and sharper. An agent cannot read your intentions, and it cannot infer the rule that Sam learned the hard way at 2 a.m. It can only read what is written down. Every rung above the first is, in practice, a bet on the quality of that written material.

## Which teams benefit most

1. **On-call and incident response.** The original case: alerts, runbooks, mitigations and a decision queue that currently lands on whoever is awake.
2. **Teams running several agents against shared systems.** Per-action autonomy is the only version of the question that stays answerable once there is more than one agent.
3. **Regulated and high-stakes engineering.** "What is this agent allowed to do, and on what evidence?" is an audit question, and a ladder produces an auditable answer where a feature flag does not.
4. **Platform and DevEx teams.** Adding a rotation should be a setup, not a new project — which only works if identity, config and memory are per team rather than per deployment.
5. **Anyone whose automation is already bolted on in silos.** An alert script, a triage bot, a deploy bot and a fix-it agent, each keeping its own context and forgetting it, is exactly the arrangement that turns a human into the glue between four tools that each saw one clue.

## How MDflow fits

Start with the boundary, because it is the honest part. **MDflow is not the ladder.** It does not grade an agent, promote it, gate a production action or hold a permission. It holds the written half the ladder stands on: the playbook an agent reads, the corrections that outlive a shift, and a record of what an agent actually did.

**What lines up today**

**Plain markdown the agent reads directly.** Documents are stored as markdown with no export step, and agents reach them over a [remote MCP server](/docs/mcp) or the [HTTP API](/docs/api) — so the same playbook is readable from Claude Code, Cursor, Codex, the ChatGPT app and anything else that speaks either protocol.

> **Connect Claude to MDflow:** open the [MDflow connector](https://claude.ai/directory/mdflow) in Claude's Connectors Directory, click **Connect to Claude**, and sign in — no URL or token to paste. One connection covers claude.ai, the Claude desktop and mobile apps, and Claude Code signed in with a Claude subscription. A Personal Access Token is the legacy route for Claude and the route for clients that send their own auth header, such as Cursor, Codex and the HTTP API.

**Folder descriptions as the retrieval signal.** A folder description states what a set of documents is *for*, and it is ranked above folder names and document titles when an agent asks for context on a topic. `mdflow_get_context` is the topic-first route; the API is the explicit one. For a rotation, that is the difference between an agent finding the checkout runbook and an agent finding seven documents with "checkout" in the title.

**Team ownership with scoped access.** Team workspaces give a rotation shared documents rather than one person's folder, and Team access tokens (`mdt_…`) are the closest thing here to the talk's "its own identity, with only the access the team is comfortable granting it": each token is bound to one Team account, granted specific workspaces, capped at read-only or read-and-write, and never gains access to workspaces created later. Every request re-checks live state, so effective access is the token grant intersected with the creator's current membership, role and per-workspace permission. Removing a member deletes their tokens instantly. Say the limit plainly, because it is the opposite shape: a **personal** access token (`mdf_…`) is account-wide read **and** write, with no read-only option and no workspace scoping. Only Team tokens are scoped.

**A written track record of what the agent did.** In a personal workspace, the [Document Log](/features) records created, edited, shared and deleted events with the actor on every row — `you` for browser actions, `automated · <token name>` for anything arriving over the HTTP API or MCP server — filterable by event type and workspace, with a side-panel diff on edited rows. Events are retained for 30 days; free accounts see the last 24 hours and Pro accounts the full retained history. Team accounts have their own separate audit feed, covering account, membership, workspace, folder, document, restore and export lifecycle changes with a 365-day retention policy. Scope both honestly: they record what an agent did to *your documents*, not to your production systems. For promotion decisions about document work they are the evidence; for production mitigations, your deployment system is.

**Corrections that survive the shift.** Version history captures the previous version on every save, across every write path including the API and MCP server, with line-by-line diffs and a non-destructive restore. Note which rule applies to which document, because they differ: history on a **personal** document is private to its owner, while a **Team** document retains bounded previous versions that any active member can compare and restore — which is the one you want for a rotation. Personal version history is a Pro feature; on a Team document it comes with the seat. Neither surface exposes version history through the API or MCP server, so an agent can write a correction into a document and cannot quietly rewrite the history of what that document used to say.

**Where we are headed** — direction, not a dated commitment. The folder description is the primitive we keep investing in, because scoping what a set of documents is *for* is what makes pulled-on-demand context work at all. The other thread is narrowing the round trip between where prose is version-controlled and where it is edited, which is why in-place editing for GitHub, Google Drive and OneDrive already ships.

## The bottom line

The agent autonomy ladder is worth copying because it replaces a feeling with a test. An action climbs when a mistake there is cheap, when something other than a person catches it, and when the agent has a record on that exact action — which means **"how autonomous is our agent" is the wrong question**, and "how autonomous is it at this action, on what evidence" is the right one.

What the ladder quietly demands is writing. A playbook good enough that a generic agent becomes your team's teammate. Corrections that reach the next person on the rota instead of dying with the shift. A record of what the thing actually did. None of that survives in a chat transcript, and none of it belongs to one laptop.

[Start free](/login), [connect an AI agent](/docs/mcp), or [read the API docs](/docs/api).

## Frequently asked questions

### What is the agent autonomy ladder?

It is a promotion track for an AI agent, modelled on how a team onboards a new on-call engineer. At level one the agent investigates and reports, and changes nothing. At level two it drafts a fix with a root cause and a test plan, but nothing reaches production until a human approves it. At level three it clears low-criticality work on its own and interrupts a human only for what matters. The framing comes from the Meta engineering team that runs an AI on-call teammate across real rotations, described in an AI Engineer talk published in November 2026.

### How does an AI agent earn more autonomy?

On evidence, against three conditions applied to one specific action rather than to the agent as a whole. First, a mistake on that action has to be cheap. Second, the mistake has to be caught by something that is not a person paying attention, such as a test, CI or code review. Third, the agent needs an existing track record on that exact action. All three have to hold, which is why the same agent can be trusted to close a noisy alert by itself while a production mitigation still waits for a human.

### What is the difference between autonomy levels and an autonomy ladder?

Levels describe where a system sits; a ladder describes how it moves. Academic frameworks such as the University of Washington's *Levels of Autonomy for AI Agents* sort agents into levels by the role the human takes — operator, collaborator, consultant, approver, observer — and treat autonomy as a design choice set separately from model capability. A ladder adds time and evidence to that picture, and crucially assigns the level per action rather than per agent.

### Should an AI on-call agent belong to a person or a team?

To the team, because the rotation does. If the agent belongs to one engineer, its memory of what went wrong last Tuesday leaves with that engineer at the end of the shift. A shared teammate carries the playbook, the alert profiles and past decisions from one shift to the next, so a correction one person gives it on Monday is the answer another person gets on Thursday — with a note saying where it came from.

### Where should the playbook an AI agent reads live?

Somewhere shared, readable by an agent without a scraping step, and separate from any one person's chat history. Plain markdown in a workspace an agent reaches over MCP or an HTTP API is one answer, which is what MDflow is. Keep the boundary honest: a document store holds the written half — the playbook, the corrections, the record of what an agent actually did to your documents. It does not grade an agent, promote it, or gate a production action.

## Further reading

- [Give Your On-Call Its Own AI Teammate](https://www.youtube.com/watch?v=_NBx2NNOuA4) — Swaapnika Motapothula, Chinmay Gandhi and Vlad Tsvang (Meta), AI Engineer, 10 November 2026. The source of the ladder, the promotion test and the per-rotation ownership argument.
- [Levels of Autonomy for AI Agents](https://arxiv.org/abs/2506.12469) — Feng, McDonald and Zhang (University of Washington), 2025. Five levels by the human's role, autonomy as a design choice, and the autonomy-certificate proposal.
- [Levels of AI Agents: from Rules to Large Language Models](https://arxiv.org/abs/2405.06643) — the SAE-style framework that ties levels to the technology instead of the human's role.
- [Leveraging AI for efficient incident response](https://engineering.fb.com/2024/06/24/data-infrastructure/leveraging-ai-for-efficient-incident-response/) — Meta Engineering, June 2024. Earlier AI-assisted root-cause work in the same problem space, reporting 42% accuracy at identifying root causes — meaning the root cause was among the top five suggested code changes in 42% of those investigations.
- [DrP: Meta's root cause analysis platform at scale](https://engineering.fb.com/2025/12/19/data-infrastructure/drp-metas-root-cause-analysis-platform-at-scale/) — Meta Engineering, December 2025.
- [AI Agent Approvals: Approve the Job, Not the Step](/blog/ai-agent-approvals-job-not-step) — the companion question: what a human is approving, once the clicking stops scaling.
- [Agent Memory Consolidation: Why AI Agents Dream](/blog/agent-memory-consolidation) — why memory that is never revisited degrades, and what a second pass does about it.
- [Team Knowledge Base for AI Agents](/blog/team-knowledge-base-for-ai-agents) — the shared, versioned substrate a rotation-owned agent reads from.
- [MDflow MCP docs](/docs/mcp) and the [HTTP API reference](/docs/api) — how an agent connects to a workspace.

