Progressive autonomy for agents works the same as delegating a presentation to a 20-year-old new hire. But full autonomy on day one is maybe not a great idea.
Would you send your 20-year-old hire across the world for an important presentation after three months of work?
“Do you have a passport?”
That is what my boss Raymond asked me three months into my first job as a visual designer.
I said, “No, but I can get one.” I grew up in a Dutch farmer village of about 6,000 people. I had never left the European Union, which meant an ID card had always been enough.
Now I needed a passport.
Raymond wanted me to fly to Houston and present work I had been designing with him, to people from companies like Microsoft. We made some really cool demonstrations about the future of visualization in reservoir modeling.
I paid 80 euros for a priority request and had the passport within two weeks. Then I booked the tickets. The delegate was on its way.
Just six months earlier, I had dropped out of the Conservatory. I went in chasing a dream of becoming a music producer with nothing but a high school diploma, and came out with a plan that had fallen apart. Then Raymond saw something else in me and gave me a job as a visual designer instead.
Three months later, he trusted me enough to send me across the ocean to represent the company in a room full of people I had never met.
I am still surprised how my life turned around like that. But my story is a nice example of the principle of progressive autonomy.
The Principle
Progressive autonomy means the autonomy you grant a delegate is not binary. It is not a switch you flip. You hand off work one step at a time, and when you trust the result, you hand over more.
No handing the keys to the intern on day one, and no permanent manual review either.
If it is not a switch, how do you set it? If we benefit from two weeks of conservatory experience here, I would say it is more a dial or a fader. It is a range or level you can control.
Progressive autonomy is more about response than permission.
Giving people or agents permission once is not the same as granting them autonomy over time as a response to proven trust.
This principle applies to AI agents as well.
Raymond added responsibilities as I earned his trust. Autonomy was granted increasingly.
Four things he did, in order:
- He judged me.
- He challenged me.
- He observed me.
- He sent me.
He Judged Me
Raymond gave presentations himself and they worked. He was not in trouble. But every trip cost him a week he did not have, and he needed more people to carry the vision across continents.
Two kinds of pain he started with, before he looked at me and decided my skills might match what he was missing. It was not on my resume, and he never saw me present persuasively.
Let users choose what to hand over.
Most agentic software skips that judging. It offers to take over your work before you have decided that you want your work taken over, which is a strange thing to ask of someone whose current process runs fine. Would you hand a task that already works to something you have never seen doing it?
Let users decide what needs to be automated and what agents should work on. Do not hand it off to the agents without that judgment.
He Challenged Me
Raymond handed me an opportunity, maybe even a lifeline, when he offered me a job. He did not stop there. He handed me tasks and included me in important visionary work. He collaborated with me.
Then he would bring important managers and customers over to my little desk in the corner of the office at the end of the hallway.
Show them what you made. Show them the prototype.
We made those concepts together, with the vision in his head and my hands on the keyboard to bring it to life. That is how he found out whether his judgment was any good.
Test the agent in small, visible steps.
Most agents run on submit and wait. You prompt a request, you go get coffee, and you come back to an outcome you now have to unpick. It is hard to inspect that result when you did not work alongside the agent.
That is why it is useful to let an agent ask you something halfway through, for instance with an interface that appears when a decision matters and disappears once you have answered. Start with co-working.
He Observed Me
Raymond was in the room.
He saw me grow and learn, and he knew my work and understood my current capability. That is what the three months bought him. Evidence that I was up for it, collected by hand.
Show the work, not just the result.
Let agents give users the same view. Let them expand their reasoning and show their intent before executing. Show progress along the way, because an agent working silently for an hour is hard to follow.
Show intermediate states so the user can check the work before it is finished, and give them a way to stop it. A small agent task you cannot inspect is a small gamble on tokens.
Once you trust it, then repeat. Hand over a piece, watch it, hand over another. The value is in the loop, not in a single run.
This means you have to build for the bad rounds too. Keep a log of what the agent did, make the work reversible, and let people turn the autonomy back down when a round goes wrong. Dial it down when it is too soon.
This is where products built on full autonomy get stuck. There is no fallback when the model under-delivers. Legacy software has the opposite problem, which is not a bad problem to have: the manual path already exists. You can add progressive autonomy on top of something people can still do themselves in case the agent is not ready yet.
He Sent Me
Raymond trusted me enough to send me to Houston. But not alone.
An older colleague, Aad, came with me. Not to present for me or to handle my conversations. He was there in case something went wrong and to accompany me on this adventure. Trust that traveled with me.
Chaperone the agent. Autonomy is not isolation.
The more you trust the agent, the longer the loop. Intervals increase and touchpoints decrease. But you can still watch and accompany the agent, in case you need to step in and see the work unfold.
Allow the user to step back in even though the autonomy progressed. Let the interface reflect the level of delegation people have granted, and let the user see where the agents are operating.
In agentic design tools, you see the frames highlighted that agents are actively editing. This lets the user chaperone the work and intervene when needed.
Closure
Autonomy is not a switch or a setting you flip. Let users control what they hand over to agents, like a dial they can turn in either direction. Let your software show enough that they can chaperone the work alongside.
Design your product with the principle and the patterns that judge, challenge, observe and eventually send agents off to do the work. But dial it back down when they do not prove trustworthy.
Raymond took the time to build trust and let me earn my autonomy. Give your users the time to progressively delegate too.
