The graduation ratchet

A workflow graduates through three stages. Assisted: the human does the work, and the agent helps, fetching, drafting fragments, checking. First-pass: the agent does the work and produces a complete draft, and the human reviews and corrects it. Autonomous: the agent runs the workflow end to end, and the human handles only the exceptions.

The share of the actual execution moves from human to agent at each step, and the person moves from doing, to reviewing, to handling the cases that do not fit the pattern. The work does not disappear; the part of it that needs a human shrinks to the part that actually needs judgment.

Take one workflow through all three. A quarterly diligence memo. Assisted: the analyst writes it, and the agent pulls the filings and drafts the boilerplate sections. First-pass: the agent writes the whole memo, and the analyst reviews it, fixing the comparables and the risk framing. Autonomous: the agent produces memos the desk ships, and the analyst is pulled in only for the deal that does not look like the others. Same memo, same analyst, three very different days.

The ratchet runs on the capture-and-measure loop from earlier posts. Each rung is possible because the previous rung's work was captured and scored, so the system has evidence the agent is ready and the human has a reason to trust the step back.

Without capture and rubrics, the ratchet has no teeth, and you are back to the leap-of-faith switch: automate and hope, or do not and stall. The machinery that climbs the ratchet is the same machinery that closes the deployment gap. Capture the work, score it against the team's standard, and let the score decide when it is safe to step back.

The important property of the ratchet is that it does not slip backward. Once a workflow is autonomous and trusted, no one goes back to doing it by hand. That would mean giving up hours to redo work the system now does reliably, which nobody volunteers for.

An autonomous workflow stops being a project and becomes infrastructure, the way no one un-automates payroll. Each notch up is a notch you do not give back, which is why the ratchet, slowly, only tightens. A deployment is not a thing you install once; it is a thing that climbs.

And the human does not vanish at the top; they move up. From producing the routine version of the work to handling the exceptions and the judgment calls, which was always the part that needed a person. A workflow reaching autonomous is not a person removed. It is a person freed from the part of the job a machine can now do reliably, to spend their time on the part it cannot.

Graduation is not a leap of faith or a date on a calendar. A workflow moves up a rung when the evidence says it has earned it, which is to say when its rubric scores have stabilized at the standard the team set. That is the same rubric from an earlier post, scoring real work as it happens.

Assisted graduates to first-pass when the agent's drafts are consistently good enough to be worth reviewing instead of writing. First-pass graduates to autonomous when the review keeps finding nothing to change. The human steps back exactly as fast as the measured quality allows, and not a step before. Trust is earned at the speed of the evidence.

Concretely, at Qualcomm, workflows are already climbing the ratchet. When a customer ticket arrives, an agent automatically pulls the logs across proprietary toolchains, cross-references known failure patterns, and drafts a root-cause analysis with a suggested patch, work that used to take a senior engineer half a day. The engineer reviews, refines if needed, and delivers.

That is a first-pass workflow, caught mid-climb. As the rubric scores hold, the engineer's step keeps shrinking, from doing the analysis, to checking it, to being pulled in only when something does not fit a known pattern. The same workflow, a few rungs up, is a different economic event.

This reframes what progress means for a deployment. The question is not how smart the base model got this quarter. It is how many workflows climbed a rung, and what it took to move them.

A deployment that has pushed a dozen workflows to autonomous has changed how the company runs, permanently, regardless of which model is underneath. The base model is an input. The ratchet position is the outcome, and it is the one that compounds, because every workflow that graduates frees the people who used to run it to push the next one up. That is what a maturing deployment looks like from the inside: not a smarter model arriving, but more of the work quietly moving up a rung.

There is a stage past autonomous that the architecture points toward but most deployments have not reached: self-evolving, where agents optimize their own context against rubrics pegged to the business outcomes that matter, not only to task-level quality. We are not claiming that as shipped reality for every workflow.

The honest statement is narrower. The same machinery that moves a workflow from assisted to autonomous, capture, rubrics, and the learning loop, is what a self-improving workflow would run on, and the ratchet is how it would get there: one earned notch at a time, the same way every rung below it was earned.

Deploying AI to a workflow is not a switch you flip. It is a ratchet you climb, assisted to first-pass to autonomous, with each notch earned by measured quality and each notch a door that does not open backward. The thing to watch in a deployment is not the model. It is how many workflows have graduated, and how far. Each one that reaches the top stops being something you manage and becomes something you build on.