Build your marketing team and develop targeted messaging to ensure your startup's presence is established in the market.
Elevate your market position with Category Design and establish your brand as the de facto leader.
Address the buyers journey with effective marketing processes that drive revenue, grow demand, and build markets.


AI Agent Autonomy: The 5 Levels From Prompt to Loop
Previous Blogs
Every AI agent your company runs sits somewhere on a five-level autonomy scale, from a person prompting by hand at L1 up to a system that runs and improves itself unattended at L5. The jump that decides whether an agent scales cleanly or ships confident errors at volume isn’t parallelism or scheduling. It’s the move from L2 to L3, the point where an independent system, not the agent that did the work, checks the work.
That finding comes from a field guide I published this year on loop design for agentic systems, informed by Anthropic’s own engineering research into how these systems hold up in production. Handing verification to the agent that produced the output doesn’t just fail to catch errors. The same blind spots that shaped the output end up grading it too.
Two real B2B deployments show what happens on either side of that jump. Goldman Sachs’ coding agent scales cleanly behind an independent test suite that decides if code passes, not the agent itself, while Klarna’s support agent scaled to full autonomy without an equivalent check and had to reverse course in 2025. Anthropic’s own multi-agent research system rounds out the picture, showing what isolating parallel work and scheduling it to run unattended costs once verification is solid.
By the end, you’ll know which level your own AI agents are running at, and which one to build toward next.
A loop is what you get when a system performs five jobs a human normally does by hand: notice what to do next, hand off the task, check the result, remember what happened, and decide when to run again. Grade a system on how many of those five jobs it still asks a person to do, and you get five levels.

Most early-stage founders I talk to sit at L1 or L2. Here’s what actually changes at each level, and what it buys you.
A person writes the task as a prompt and runs it by hand, reading the result before deciding what happens next. There’s no repeatable system yet, just a conversation. This is the right level for exploratory work, where the acceptance criteria haven’t been figured out and probably shouldn’t be automated yet.
The prompt is wrapped in a script that the team can run on demand, so the task no longer needs to be rewritten from scratch each time. A person still presses run and still reads every output before it ships. This is where the operator’s time starts scaling directly with volume, since a human touches every single cycle.
An independent system, not the agent that did the work, checks the output against an explicit checklist and only escalates the cases it rejects. This is the jump that matters most. A separate field study of loop adoption found that teams completing this single step capture most of the value in the entire five-level path.
The loop gets a scheduler and a wider set of places to look for its own work, so it starts and finds problems without anyone pressing run. Getting here safely means adding guardrails a verified loop doesn’t yet need, chiefly a hard budget cap and a kill switch, since nothing is watching each cycle in real time.
The system adjusts its own checklist and discovery surface as it learns which cases actually need a human. A person’s role shrinks to occasional governance, reviewing flagged edge cases and refining the design rather than running it. Steps toward L4 and L5 only compound whatever the loop below them is already producing, so getting L3 wrong here means compounding errors faster.
An agent asked to grade its own output tends to approve it. The evaluation inherits the same blind spots that produced the output in the first place, so the check adds confidence without adding accuracy.
Goldman Sachs’ Devin deployment is a working example of the fix. Devin doesn’t grade its own code. Its output runs through the bank’s standard code review process and automated testing pipeline before anything ships, an independent, objective check that isn’t the agent grading itself.
Human engineers only step in on flagged failures, not on every line. CIO Marco Argenti has reported productivity gains of three to four times for the tasks Devin handles, and the bank has expanded the pilot from a handful of instances to its full 12,000-person team.
That’s the L3 pattern in a production environment: an itemized, objective, checkable standard (passing tests) that a second system, not the generator, enforces.
A rejected task should never just get discarded either. It should be requeued with the specific rejection reason attached, so the next attempt fixes the issue instead of guessing again. In one documented run of this pattern across 100 research tasks, rejections fell from 12 to 3 to 0 over three passes, a geometric decline that’s the clearest sign that a loop is converging rather than thrashing.
Knowing that the L2-to-L3 jump matters most doesn’t tell a founder what to build first or what’s safe to build next. A team that hears “add an independent verifier” can still get the order wrong, skipping straight to scheduling before the verifier is solid, or trying to parallelize a check that hasn’t earned trust yet.
That’s the gap the adoption path closes. It places the checklist, the adversarial verifier, and the reason-carrying requeue at steps 5 through 7 specifically, with a defined set of steps that have to happen before them and a defined set that only become safe after.
The five levels describe where a loop ends up. The path describes how a team gets there, one small addition at a time. Skipping a step doesn’t skip the work behind it; it just moves the risk to whichever step got skipped.

The first four steps don’t touch autonomy at all. They just get a task into a repeatable, run-on-demand state. Write the task as a prompt, run it by hand, and keep adjusting until one result is genuinely acceptable.
Pull an explicit checklist out of that acceptable result, since that checklist becomes the standard everything after it gets measured against. Wrap the prompt in a script that runs on demand, and the team has reached L2.
Step 5 is the one to protect above all others, adding a second agent whose only job is checking the first agent’s output against the checklist from step 3. Step 6 sharpens that check by making the verifier adversarial, instructed to assume the work is wrong and hunt for the specific reason to reject it.
Step 7 closes the loop by requeuing rejected work with the specific reason attached, so the next attempt fixes something concrete rather than guessing again. A team that completes step 5 has captured most of the value in the entire fourteen-step path.
Step 8 writes results to durable storage after every cycle, so the loop builds on its own prior output instead of starting from zero each time. Step 9 gives each parallel task its own isolated working context, a separate worktree or sandbox, so agents running at the same time don’t overwrite each other’s work.
Step 10 broadens the discovery surface, letting the loop find more of its own work rather than waiting to be told what to do.
Step 11 adds a scheduler, so the loop runs on a timer or trigger without anyone pressing run. Step 12 has to happen before that, not after: a kill switch and a budget cap so a misfiring loop can’t burn spend unsupervised.
Step 13 logs every cycle so the loop’s behavior stays auditable. Step 14 is the payoff of the thirteen steps before it, reviewing only the cases the verifier flagged and letting everything else run on its own.
None of steps 8 through 14 are worth attempting before the verifier from steps 5 through 7 is solid. They scale whatever the loop is already producing, errors included.
This framework doesn’t stop at engineering. A founder’s own marketing operation runs through the same five levels, and most run it at L1 or L2 without realizing it.
Prompting an AI tool for blog drafts, ad copy, or LinkedIn posts and reading every result before it goes out is L2 by definition. Staying there isn’t a temporary phase, it’s what happens when nobody builds the checklist, the verifier, and the automation that would move the work forward.
The same L2-to-L3 jump that changes an engineering team changes a marketing team. Content needs an independent check against brand voice and factual accuracy before it publishes, creative needs a check against brand and platform specs before it ships, and campaign data needs a check against the criteria that decide whether a result is worth acting on, not just a skim from whoever is free that day.
That’s a different problem than picking a better AI tool. It means designing the system marketing runs on, the checklist and the verifier together, so the work compounds instead of resetting to zero with every new campaign or every new hire.
The goal was never a bigger review queue. It’s a marketing operation that clears L2 the same way a coding team does, and keeps climbing.
I can’t wait to make you my next success story.
Please complete all fields so that we can explore together how best to help your company dominate the market and achieve its full potential.
By clicking the “Submit” button, you are agreeing to our Terms of Use and Privacy Policy.
To access your free downloads, please provide the following details and hit the Submit button.
Once you have submitted the form, check your email for the download links.
By clicking the “Submit” button, you are agreeing to our Terms of Use and Privacy Policy.
By clicking the “Submit” button, you are agreeing to our Terms of Use and Privacy Policy.