The Autonomy Ladder

November 17th, 2026 | by Lane Nelson


Part 10 of 10 – earning the right to remove the human

You don’t switch on autonomy. You earn it, one rung at a time.

It is a Tuesday, eight months in, and the drafts are good.

Marie's order-status replies (Part 7) come out of the assist layer clean enough that she sends most of them with a glance and a click. The exception worklist Rosa works (Part 5) has quietly become the first thing she opens. Colleen's three-way match (Part 6) surfaces the bad invoice before she would have found it. The system has earned a kind of trust, and so the question finally arrives, in a meeting, from someone reasonable: if it's right this often, why are we still clicking approve on every single one?

That is the right question. It is the question this whole series has been walking toward, and every post so far has said the same thing when it came up early: not yet – that's the last post. This is the last post. Here is the honest answer, and it is not "yes" and it is not "no." It is: that depends on the rung, and you have to earn the climb.

Autonomy is a ladder, not a switch

The instinct is to treat autonomy as a toggle – the AI is either supervised or it is loose. That framing is how good pilot projects turn into expensive failures. A toggle has two positions and no evidence between them; the pressure of a working demo flips it, and the first anyone hears of the downside is when something has already gone wrong at scale.

Replace the toggle with a ladder. Each rung grants a little more independence, and each rung has to be earned with evidence before you stand on it. You climb it one slice at a time – within collections, the small-dollar invoices are one slice, the disputed six-figure ones another. And you can climb back down one slice at a time. Roughly:

  • Rung 1 – Assist. The AI drafts; a human reviews and commits every item. This is where every workflow in this series starts, and where most of them should stay for a long time.

  • Rung 2 – Review at a glance. Still a human on every item, but the draft is trusted enough to approve fast – and, crucially, you are now measuring how often the human changes anything. That measurement is the toll for the next rung.

  • Rung 3 – Sample and release. A narrow, well-characterized slice – the cleanest, lowest-stakes cases – commits without an individual sign-off, while a human audits a sample and works every exception. The human moves from approving each to checking the process.

  • Rung 4 – Exception only. The machine runs the routine cases; the human sees only what it flags as uncertain, plus the monitoring dashboard. Most of the volume no longer touches a person.

  • Rung 5 – Autonomous. The machine runs that slice end to end, with a full audit trail, live monitoring, and a rollback. A human is accountable for the outcome and reviews it in aggregate – but is no longer in the loop on each item.

The most important thing about the ladder is that the rung is set per slice, not per workflow. Within one workflow you will be at rung 4 on the boring, reversible cases and stuck at rung 1 on the dangerous ones – forever, deliberately. "How autonomous is your collections assistant?" is the wrong question. "Which slice of collections has earned which rung?" is the right one.

What you are actually trading

There are two ways to get the pace wrong, and both cost you.

Climb too fast, and you get silent errors at scale. This is the failure this series has warned about in every post: the model is wrong quietly and plausibly, and once no human is looking, a 2%-wrong process ships 2% wrong all day. Premature autonomy takes a manageable error rate and removes the thing that was catching it.

Never climb at all, and the human becomes a rubber stamp. This one is subtler and nearly as expensive. Ask a person to approve five hundred good drafts a day and their attention decays – they are not reviewing by item three hundred, they are clicking. A rubber stamp is worse than no check, because it looks like oversight in the org chart and provides none in reality. You are paying for a control you no longer have.

So the goal is not maximum autonomy, and it is not maximum caution. It is the right rung for each slice, revisited as the evidence changes – and the discipline to know which one you are on.

What lets a slice climb

Four things have to be true before a slice earns the next rung. The first two set how high it can ever go; the third sets how fast; the fourth is the floor under all of it.

  1. Reversibility. How cheaply can you undo one wrong action? A draft not yet sent is free to fix. A dunning letter in a customer's inbox, a payment out the door, a credit hold released so a truck could leave – those do not come back. Reversibility is the single biggest input to how far a slice can climb.

  2. Blast radius. How bad is one wrong one, and is the damage contained? A mis-ranked exception message costs a second look. A wrong number emailed to your third-largest account in the company's name costs the account. Ask what the worst plausible single failure does, and to whom.

  3. Measured accuracy on that exact slice. Not "the drafts feel good" – a number, from a seeded or held-out test set and from live sampling, that says how often this slice is wrong and in which direction. You cannot earn a rung on a vibe. If you cannot measure the error rate on the slice you want to automate, you are not ready to automate it; you are ready to start measuring it.

  4. Audit, rollback, and monitoring. Every autonomous action is logged, attributable, and reversible; there is a kill switch that a human can hit; and the accuracy that earned the rung is watched for drift, with an alarm when it slips. This is not optional infrastructure you add later – it is the precondition for climbing at all, and it lives in the system of record, where the receipts already live.

And one thing that never moves, at any rung: a named human is accountable for the outcome. Autonomy changes whether a person touches each item. It never changes who answers for the result. Rung 5 is "the human isn't in the loop," never "no human is responsible."

What earns the climb – evidence, not nerve

You do not promote a slice because the vendor says it is ready or because it has been fine for a while. You promote it on evidence, gathered the same way every Monday-morning section in this series has said to gather it.

Run the slice in shadow mode first: the machine decides, a human still commits, and you log every case where the human overrode it. That override log is your accuracy measurement, on live data, at zero risk – because nothing the machine decided actually shipped without the human. When the override rate on a slice drops below the bar you set in advance and stays there, that slice has earned rung 3. Turn it on for the narrowest version of the slice, keep sampling, and widen only while the numbers hold. If they slip, the monitoring catches it and you climb back down. You are not betting on autonomy; you are letting it prove itself on a slice small enough that being wrong is cheap.

The ceilings – what never climbs

Some slices have a low ceiling by their nature, and pretending otherwise is how the disasters this series keeps warning about happen. Reversibility and blast radius set the ceiling, and no amount of measured accuracy raises it:

  • The customer-facing send in the company's name (Parts 7 and 8) – irreversible and relationship-scaled. A human hits send. Possibly forever.

  • Moving money, posting to the ledger, releasing a credit hold, writing off a balance (Parts 6 and 8) – irreversible and high blast radius. The record executes; a human commits.

  • Anything an auditor or a regulator expects a named person to have decided. Automating the decision does not remove the expectation; it just removes your ability to meet it.

The high-ceiling slices are the mirror image: internal, reversible, low blast radius, where the worst case is that a human ignores a suggestion. Ranking the exception list (Part 5). Drafting a reply (never sending it). Retrieving and citing an answer (Part 3, read-only). Those can climb freely, because being wrong costs a glance. The art is telling the two apart honestly, slice by slice, and not letting a good accuracy number tempt you into automating something that was never about accuracy – it was about reversibility.

What it must never do – even at the top

  • Never remove the audit trail to move faster. Autonomy without attribution is not autonomy; it is abdication with a dashboard.

  • Never stop watching the metric that earned the rung. The supplier that was reliable, the customer base that shifted, the model that was updated – drift is not hypothetical, and an unwatched autonomous process degrades in the dark.

  • Never climb a slice you cannot climb back down. If the rollback and the human fallback are not wired and tested, you do not have autonomy, you have a one-way door.

  • Never let "the drafts are good" stand in for a measured error rate on the specific slice you are automating. Good in general is not the same as safe here.

How you would know it worked

Two signals, and you want both.

First, the autonomy is holding: the audited error rate on each automated slice stays inside the bound you set, month over month, and the people it freed moved to work that actually needs a person – Rosa planning instead of triaging, Marie on the four hard quotes instead of the forty easy lookups. Reclaimed attention that went nowhere means you automated the wrong thing.

Second – and this is the one nobody tests until it is too late – you can descend fast. Run the fire drill: take a slice off autonomy and back to human review, on purpose, and time it. If pulling back is slow, confusing, or scary, you were never really in control of the climb; you were hoping. Autonomy you can reverse on a Tuesday afternoon is a setting. Autonomy you cannot is a cliff you already walked off.

Monday morning

Do not automate anything on Monday. Do this instead.

Take one workflow already running happily at rung 1 – the order-status drafts are the easiest place to start. Break it into slices, and for each slice write down two things: its ceiling (from reversibility and blast radius) and whether you are measuring its accuracy yet. You will find, quickly, that most of the workflow has a low ceiling and belongs at rung 1 for good – and that one or two slices are reversible, contained, and boring enough to be worth climbing. For those, turn on shadow logging and set, in advance, the override rate that would earn rung 3.

Then wait for the log to tell you. You climb when you have earned it, not when the quarter is ending.

Where this leaves the series

We started with two machines and a line between them. A system of record that computes and keeps the receipts; a system of inference that reads, drafts, ranks, and explains; and a carefully engineered boundary so that each does only what it is good at. Every post since has been one workflow drawn on that same picture, with the human standing on the boundary, approving what crosses.

The autonomy ladder is that discipline extended over time. You do not decide up front how much to trust the machine and then hope you were right. You measure what it actually does, on a slice small enough that being wrong is cheap, and you let it earn the next rung – or fail to, and stay where it is. The human steps back one careful rung at a time, only where the evidence and the reversibility both allow it, and never stops being the one who answers for the result.

We opened this series at the Louisiana Maneuvers of 1941, where the thing that impressed General Aurand was a row of IBM sorters bolted to trucks, counting ammunition faster and truer than any clerk could by hand. But his verdict on the maneuvers themselves was harder: they lacked realism. A rehearsal staged too easily proves nothing about whether you are ready for the real thing.

That is the autonomy ladder, eighty-five years early. You do not earn trust from a demo that went well under gentle conditions – you earn it from evidence gathered under real ones. Aurand built a career on the primacy of logistics: you plan from what you actually have and can actually prove, not from what you wish were true. Start with what you have, put each task on the machine built for it, keep the boundary honest – and let autonomy be a thing you earn, not a thing you switch on.

Means before ends.

Spiese Fluid Power is fictional – a composite built from published industry benchmarks and anonymized operating ratios. Its full operating profile, with sources, is published separately.