How I Let AI Workers Earn Their Autonomy

No agent in my AI setup goes live on day one. Each one earns its freedom through clean dry runs, full visibility into what it did, and a watchdog that is already watching before it acts. The model is rarely the weak link; the missing gate usually is.

For most of my career I was an operator. I ran operations inside businesses doing a few hundred crore to over a thousand crore in revenue. My move from operator to builder started when I stopped running other people's systems and began building my own, including an AI operating system that now runs the back office of my businesses.

That change moved a lot of things around, and one of them nobody warned me about. The moment a founder builds agents that act on their own, the founder inherits a management problem they thought they'd left behind. An agent that can act alone behaves like a very fast, very literal junior employee who never sleeps and never asks for clarification. With a junior employee, the first question every operator learns to ask is how much to trust them and when, and whether they can do the task comes second.

The Old Frame

When I first started wiring agents together, I treated autonomy as a feature. I gave the agent a task, gave it access and switched it on. That's how most tutorials teach it, and it's how most founders I talk to are doing it right now.

It works until the day it doesn't. An agent writes to the wrong file, or a scheduled task runs on stale data and quietly damages a record. Nothing raises an alert, so the failure stays silent until someone notices a wrong number three days later and has to trace back where it came from.

The old frame assumes the risk lives in the model, so the fix is to pick a smarter model. After a year of running my own system in public, I don't believe that anymore. A smarter model that nobody governs just makes more confident mistakes, and makes them faster.

What Changed

Fourteen years in operations left me with one instinct that wouldn't switch off. Nobody hands a new hire the payment approvals in their first week. The manager gives the new person a small decision that can be reversed, watches how they handle it, and widens the scope only when their judgment holds under some pressure.

At some point I noticed I was holding my agents to a lower standard than any person on my team. I was letting software act on live data with less proof than I'd ask of a bright intern, so I stopped.

I started treating every agent the way I'd treat a promising manager who hasn't proved anything yet: capable, worth trusting eventually, and not trusted today. For my agents, autonomy became a status they had to reach, instead of a switch I flipped because it was convenient.

The Gates

Every agent in my system clears the same three gates before it's allowed to run on its own.

  1. First, dry runs. The agent does the full job with the writing step turned off. I want the same behaviour across many runs, rather than one clean pass I got lucky with. If it drifts once in ten runs, it isn't ready.
  2. Second, visibility. Before an agent gets real authority, I can already see what it did, what it decided and why. If I can't see its reasoning, it doesn't get to act. This is the boring half of running several agents together that nobody posts about: I set up the tracking first and the automation second, never the other way around.
  3. Third, a watchdog. A separate task is already watching the agent before the agent touches anything live. My daily content engine is a good example: when it runs, a second checker that can only read runs a few hours later and alerts me if the day's output never appeared. The watching exists before the trust does, instead of being added after the first failure.

Only after all three hold does an agent run unattended, and even then its freedom is narrow. An agent that earned the right to draft a file hasn't earned the right to send it, post it or delete anything. Each new power needs its own gate.

Why Governance Is the Real Bottleneck

The wider industry is starting to admit this out loud. A common view now is that a large share of agent projects will be abandoned over the next couple of years, and the reason given is that governance, trust and clear ownership were never designed in, while the models themselves were strong enough. That matches what I see inside my own system.

The model is rarely the weak link; the missing gate usually is. That's also why I think the important role in an AI-run business belongs to a human operator the founder can rely on to design the gates, watch the watchers and decide what each agent is allowed to own, more than to a prompt engineer. The machine does the work. A person still decides how much freedom the machine gets, and when to take some of it back.

A Concrete Week

In a normal week my system runs a set of scheduled jobs without me touching them. One drafts content, one checks a tracker against what actually went out, and one watches the others and tells me when something didn't happen. Each of those earned its place the same way, and none of them earned it on day one.

The content job is the clearest case. For its first stretch it ran with writing turned off while I read every output by hand. When the outputs stopped surprising me, run after run, I let it write to disk. Only after that did I add a second job, a checker that can only read, which watches whether the first job actually produced its file and pings me when it hasn't. Freedom came last, after the proof and after the supervision.

That order has mattered more than any model I've chosen. A stronger model wouldn't have saved me from an unwatched write on stale data, but a watchdog did. I could buy the intelligence; the governance was the part I had to build myself.

The Principle

The lesson travels well beyond AI. A founder can treat autonomy as a switch or as a standard someone has to meet, and I've come to treat it as a standard. Whether I'm trusting a new manager, a vendor or an agent, I ask the same question: what has this person or system proved, while being watched, that justifies giving it more authority?

Most founders get burned because they give autonomy by default and take it back in a crisis. Someone gets full access on day one, something breaks, and the founder pulls control back and starts approving everything again. I run it the other way, giving autonomy slowly and widening it on evidence. It feels slower in the first week, and it's far faster over a year, because I'm not spending my weekends cleaning up messes a gate would have caught.

The Close

My agents go live because they've earned it one gate at a time, the same way a good operator earns the right to stop being watched, and never simply because I set them up that way. If you're building your own AI setup, or handing real authority to any new person, what does that person or system have to prove before you stop checking the work?

Pick a time that suits you.

Book a call