You Don't Pick the Autonomy Level. Your Evidence Does.
The interesting question in agentic engineering stopped being what do I prompt months ago. These days it's a quieter, more nervous one: how much rope do I hand this thing, and what do I need back before I can walk away from it?
I've been keeping a rough ladder in my head for that — low end, it just suggests and I decide; high end, it runs on its own and only surfaces the decisions that actually need me. It's a useful ladder. It's also been quietly lying to me, and it took a bad week to see how.
Here's the lie, stated plainly: I kept treating the rung I reached as the rung I'd earned. They are not the same thing, and the gap between them is where every agentic disaster I've had actually lived. I've written before that green doesn't mean done — a passing build tells you no check failed, not that the work is right. This is the same disease one level up. The autonomy you can defend is exactly the autonomy your evidence can carry. Everything above that line is a story you're telling yourself with more agents running.
You don't pick the level. Your proof does. "Add more verification" is the kind of advice that's true but useless until it has edges — so let me show you mine.
Two skills I kept scoring as one
For months I bragged about the same two things as if they were one thing. "I let this agent run for twenty minutes untouched." "I had eight agents going at once." Both feel like look how hands-off I've become — and they are completely different skills that break in opposite directions.
One is about reach: how far from my own judgment I let a single agent wander before it has to come back and show me something. The other is about coordination: whether I can carve the work into slices that don't collide, so I only step in when one of them face-plants.
You can be strong at one and a menace at the other. The trap I kept walking into was running "several agents at once" while personally holding every dependency in my head — deciding what each one touched, merging their output by hand, arbitrating conflicts on the fly. That's not orchestration. That's me being the orchestrator, manually, at higher speed. It looked like leverage. It was just faster context-switching wearing leverage's jacket. Running many agents is not the same as coordinating them, and running one agent far is not the same as running it safely. Score them separately or you'll congratulate yourself for the wrong one.
The contract is the receipt
Here's the thing that actually moved my autonomy up a rung, and it's boring: I stopped letting an agent start until I'd written down what it was for.
Not a prompt. A contract. On agentry — the governed-agent tooling I've been building — that's a single declarative file: the goal, the boundaries, the identity it runs as, what it's allowed to touch, how it's grounded, who has to approve what, how it's checked, when it stops, and what it costs. The first few times it felt like paperwork written to feel responsible. It isn't. Every field on that thing is a specific failure I'm pre-paying:
- A stopping condition is the entire difference between "chase this goal" and an agent that hits your time-to-interactive target by deleting the page. "Do whatever it takes" is only safe when whatever it takes has a floor it isn't allowed to cross — and the floor has to be measurable, or it's decoration.
- Evidence is the field that decides whether I'm delegating or just hoping. Not "it says the tests pass" — the diff, the failing-then-passing run, the repro, the logs. Something a different process can check without asking the agent that produced it.
- Escalation and budget are the two I used to skip and the two that turn a runaway into a bounded loss. An agent that can retry forever on my tokens isn't autonomous. It's a leak with initiative.
The contract isn't ceremony. It's the receipt I'll want when a run goes sideways and someone — usually future-me at an ugly hour — asks what this thing was even permitted to do. No contract, no receipt. No receipt, and "high autonomy" just means I was lucky, and luck has never once shipped a stopping condition.
Three things I build backwards from
Once I started treating autonomy as something you earn with evidence, three pieces of machinery stopped being optional — the things I now build before I let the rope out, each one answering a question I'll be asking at the worst possible moment:
A tripwire, not a transcript — for how fast will I know it went wrong? Every governed decision writes a tamper-evident trail, so catching a bad turn is a query, not an archaeology dig. If finding out I was wrong means re-reading a chat log, I don't have autonomy, I have a liability with good manners.
A cheap undo — for how cleanly can I roll it back? Fail-closed defaults and a real revert path aren't paranoia, they're the toll for the next rung. Reversibility is what lets you run hotter: the refactor behind strong tests and a clean revert can take far more rope than a task with no source of truth to revert to.
Evidence that travels — for what would prove I was right? The proof rides with the work — a diff, the tests, the logs, the findings — instead of collapsing into a confident paragraph at the end.
If my honest answers are slowly, painfully, and "I trust the summary," I'm not operating at high autonomy. I'm exposed, and calling the exposure a feature.
Which is exactly the wall I hit last week.
The week I almost trusted the summary
The most dangerous version of this failure is the tidiest one: you let the agent's own write-up stand in for the review. The summary is clean, the tone is confident, and reading it feels like doing the work. It isn't. It's surrender with good formatting.
I ran straight at it a few days ago. I had a manager agent taking a list of findings, handing slices out to a small fleet of reviewers, collecting what they found, and returning only the decisions that needed me. A small version of the shape I actually trust — one coordinator, separate checkers, me on the decisions. The efficient move was to skim the manager's summary and ship.
I didn't — and the only reason it held is that I made the reviewers argue with the code, not with each other's summaries. They earned it twice: they caught claims in the original findings that turned out to be confidently wrong, and then caught blind spots in my own fixes that my green tests had waved straight through. I wrote up the wreckage in certainty is the bug, but the autonomy lesson is sharper than the debugging one: a fleet without independent verification isn't leverage. It's faster wrongness, delivered with more confidence and a nicer diff.
The fix was never "trust it harder." It was the unglamorous stuff — separate the thing that does the work from the thing that checks it, make the evidence independent of whatever generated it, keep the scope small enough that a rollback is cheap. The summary is not the review. The number of agents is not the leverage. The evidence is the only part of any of this that actually scales.
The field map
- Reach and coordination are different skills. "How far one agent runs" and "how many I run at once" fail in opposite ways. Score them apart, or you'll mistake fast context-switching for orchestration.
- The level follows the verification, not the task's vibe. A payment refactor behind strong tests and a clean revert can run hotter than a docs task with no canonical truth. Risk and reversibility set the ceiling.
- Write the contract before the agent starts. Goal, boundaries, stopping condition, evidence, escalation, budget. Each field is a failure you're pre-paying; skipping it doesn't remove the failure, it just makes it a surprise.
- Build backwards from three questions. Know-it's-wrong-fast, undo-cleanly, prove-it's-right aren't a post-hoc quiz — they're why you build the audit trail, the fail-closed default, and the evidence that travels with the work.
- Independent verification is the only thing that scales. A summary is not a review; a fleet is not leverage. Separate who builds from who checks, or high autonomy is just faster wrongness.
Verification was always going to be the ceiling. The mature posture isn't the highest rung you can climb to — it's the highest one you can currently defend, and the honest ones move up slowly, one axis at a time, only as the evidence for the next rung actually accumulates.
So no, you don't get to pick the autonomy level. You write the contract, you build the proof, and the proof tells you which rung you've earned. Everything above it is theatre.
Pick the level your evidence can defend. Then, and only then, climb. 🪜