Most developers and small businesses are stuck at Level 0 or 1 of AI adoption — chatting with an AI for advice but never letting it touch the actual work. A five-level maturity model that went viral in July 2026, published by the creator of Claude Code, maps the climb from zero agents to a thousand-plus autonomous workers. The framework's core insight: at each level, the bottleneck shifts — from permissions to attention to review capacity to trust to cost control — and leveling up means breaking one bottleneck while setting up guardrails for the next.
TL;DR — Last verified: August 7, 2026
- A five-step model (Step 0 → Step 4) maps AI adoption from chat-only advice to orchestrating 1,000+ autonomous agents.
- ~33% of AI tool users are stuck at Step 0 (chat only, zero agents). Only ~0.1% reach Step 4 (AI-native).
- The bottleneck at each step is different: permissions → attention → review capacity → trust → finding and governing work at scale.
- Leveling up is not about buying a better model — it is about setting the right guardrails (auto-accept, worktrees, loops, automated verification) so you can safely remove yourself from the loop.
- The payoff: maintenance and cleanup that used to take weeks becomes your afternoon. The work that used to be your afternoon becomes a sentence.
What are the five levels of AI coding agent adoption?
The five-level model, published in July 2026 by Boris Cherny — creator and head of Claude Code at Anthropic — describes a progression from zero agent usage to fully autonomous agent ecosystems. Each level is defined by how many agents run, what your role is, what the bottleneck is, and what guardrails you need to operate safely. The five steps are: Step 0 (Gated, 0 agents), Step 1 (Assisted, ~1 agent), Step 2 (Parallel, ~10 agents), Step 3 (Supervised autonomy, ~100 agents), and Step 4 (AI-native, 1,000+ agents). (Cherny's original table, July 2026; Shelly Palmer's analysis, July 2026)
This is not a Claude-Code-specific model — the role shifts and bottlenecks transfer to any team working with autonomous AI agents, whether you use Claude Code, OpenAI Codex, or an open-source orchestration platform. The key point: AI models are already good enough. What separates a team 10x-ing their output from one that hasn't caught up is not the model — it is the workflow and guardrails around it.
Step 0: Gated — the world's best chef shouting through the mail slot
At Step 0, you have zero agents running. You use AI for advice — asking a chatbot for help with a task, a code snippet, an email draft — but the AI never touches your actual files, tools, or systems. It is like having the world's best pizza chef standing outside your restaurant shouting recipe tips through the mail slot. The chef has great advice, but never touches the pizza. You do all the cooking yourself.
Your role: the cook. You do the work; AI just answers questions. Agent count: zero. How many people are here: approximately 33% of AI tool users, according to the original framework's distribution estimates (explainx.ai analysis, July 2026).
What Step 0 looks like in practice
You open a browser tab, type a question into an AI chat interface, copy the answer, and apply it manually. The AI never touches your codebase, your files, or any external tool. There is no MCP (Model Context Protocol) governance connecting the AI to your software. Internal access to capable AI tools may be gated by IT or security policies. Every output exists only locally on your machine.
The bottleneck: permissions, not technology
The AI is already capable enough to do real work. What stops you is that you have not given it permission to access your tools and files. At Step 0, the bottleneck is access — not model quality. Teams often stay here because of procurement delays, security review processes, or simple inertia. As Cherny noted, "one person is 10x'ing their output with Claude, but the rest of the organization hasn't caught up" (X post, July 2026).
How to level up from Step 0
- Move from browser to CLI/IDE. Download a desktop agent (Claude Code, Codex CLI, or equivalent) that runs inside your terminal or editor. This gives the AI access to your local file system and tools.
- Grant file-system and tool access. Allow the agent to read and write files in your project directory. Start with read-only permissions if you are cautious.
- Set a budget cap. If using API-based access, configure spending limits per task so a runaway agent cannot drain your account. Subscription-based access (like Claude's Max plan) makes this simpler since usage is included.
- Write a project-level instructions file (like
CLAUDE.mdorAGENTS.md) — plain-text instructions the agent reads on startup. This is your first guardrail.
Once the AI can touch your files and you can review its changes, you are at Step 1.
Step 1: Assisted — one agent, you supervising every move
At Step 1, you run a single agent at a time. The AI is now inside your kitchen, working at one station, but you stand at its elbow watching every move. It is faster than cooking alone because the AI is more skilled — it writes code faster, drafts emails faster, generates tests faster. But you can never step away. You review almost every change before it ships.
Your role: supervisor. You watch and approve. Agent count: ~1. How many people are here: the largest group after Step 0.
What Step 1 looks like in practice
You give the agent a task ("add user authentication to this endpoint," "rewrite this landing page copy"). It writes the code or content. You inspect the diff before merging or publishing. You run one session at a time. Using Claude Code as an example, this means running it in your terminal with default permissions — it asks for approval before each file edit or command execution (Anthropic auto mode documentation, March 2026).
The bottleneck: your attention
At Step 1, the bottleneck is your personal review capacity. The agent can produce work faster than you can verify it. Every keystroke, every file edit, every command — you inspect it all. This is necessary at first, but it caps your throughput at the speed of your review, not the speed of the agent. A 2026 longitudinal study of professional software engineers found that 82% of participants reported spending less time writing code and more time directing, evaluating, and correcting AI output — a role the researchers called "supervisory engineering work" (arXiv, Vella & Blincoe, 2026).
How to level up from Step 1
- Turn on auto mode. Auto mode is a permissions setting where the agent makes its own permission decisions with safeguards monitoring actions before they run. Anthropic introduced this in March 2026 as "a safer long-running alternative to
--dangerously-skip-permissions" (Anthropic, March 2026). It eliminates the constant approval prompts that keep you supervising keystroke-by-keystroke. - Enable automated code review. Turn on the built-in review tools so the agent checks its own work — tests, builds, and security scans — before showing you results.
- Shift from reviewing keystrokes to reviewing diffs. Instead of inspecting every edit, inspect the final output. Did the tests pass? Does the build work? Does the diff accomplish the task?
- Start running 2–3 sessions in parallel using git worktrees. Git worktrees give you multiple working copies of the same repository on different branches, so two agents can work on two tasks without overwriting each other (Claude Code documentation — sub-agents and worktree isolation).
When you routinely run multiple agents and review final results instead of individual edits, you are at Step 2.
Step 2: Parallel — ten agents, you orchestrating
At Step 2, you run five to ten agents simultaneously, each on its own isolated worktree or git checkout. You have stopped doing the work entirely — you are now the head chef walking the line, tasting each pizza before it goes out the door. Your job shifted from cooking to quality control.
Your role: orchestrator. You assign tasks and review final outputs. Agent count: ~5–10. How many people are here: approximately 20% of users.
What Step 2 looks like in practice
You kick off five agents in parallel: one writes tests, one fixes a bug, one refactors a module, one updates documentation, one builds a new feature. Each works in its own isolated git worktree so changes do not collide. Each agent runs its own tests, builds, and security scans before presenting results. You review the final diffs — not keystrokes — and merge what passes.
The unlock here is substantial. A backlog that used to take a team weeks becomes your afternoon of orchestrating agents. Boris Cherny himself ships 10–30 pull requests per day this way (Lenny's Newsletter interview, 2026). Inside Anthropic, engineer productivity grew roughly 8x over a year of this approach (Gless AI analysis, July 2026).
The bottleneck: review capacity
Ten agents can produce work faster than one person can approve it. If your task boundaries are weak, agents produce duplicate work, conflicting changes, or incompatible recommendations. The review queue becomes the bottleneck — and it can consume the productivity gain if you let it.
How to level up from Step 2
- Write tasks like issues, not casual chats. Each agent assignment should have: one objective, one owner, minimum required context, a defined output, and an explicit quality test (Shelly Palmer's analysis calls this "assignments with one objective, one owner, the minimum required context, a defined output, and an explicit quality test").
- Route routine failures back to the agent automatically. If a test fails, the agent retries. If a build breaks, the agent fixes it. You only see exceptions, not every iteration.
- Limit concurrency to your review capacity. Five agents generating 50 deliverables that one person cannot review helps no one. Track cycle time, rejection rate, and review-queue age.
- Set up loops. A loop is a recurring agent task that runs on a schedule — for example, auto-reviewing code, auto-rebasing PRs, or sweeping post-merge comments. Anthropic introduced
/loopin Claude Code, which runs a skill on a recurring interval (Claude Code, June 2026). - Encode standards in a configuration file. Your
CLAUDE.mdor project-level instructions file should capture your team's conventions, architecture constraints, and review guidelines. The agent reads this on every session, so it learns from its mistakes.
When work starts happening without you kicking it off manually — agents running on schedules, maintenance happening in the background — you are at Step 3.
If you are building toward this kind of multi-agent setup, our guide to building a multi-agent AI team your company actually uses walks through the orchestration architecture in detail.
Step 3: Supervised autonomy — a hundred agents, work starts itself
At Step 3, you have roughly 100 agents running across teams. The agent tree is too deep to babysit — instead of reviewing every output, you do spot checks. When something comes out wrong, you fix the recipe card (the instructions and standards that feed the agents), not the individual output. The agents themselves start chores without you being there. Maintenance and cleanup that used to wait for someone to find the time now runs continuously in the background.
Your role: manager of orchestrators. You fix systems, not individual outputs. Agent count: ~100. How many people are here: approximately 2% of users.
What Step 3 looks like in practice
Claude writes nearly all the code. The question shifts from "did you read the code?" to "what context was the model missing, and how do we prevent that failure next time?" You think in batch operations — updating the recipe, not individual pizzas. Work starts itself: a routine checks for stale PRs and rebases them every 30 minutes. A batch job fans out a large refactor across 100 worktrees. A scheduled task runs security scans overnight and fixes what it finds.
Boris Cherny reported running a thousand agents at this level — "I've got a thousand agents running right now," as one widely circulated clip described it (Fortune profile, June 2026). Anthropic as a company operates at Step 3 and is pushing toward Step 4.
The bottleneck: trust in the loop
At Step 3, the bottleneck is no longer your review capacity — it is whether you trust the automated verification loop you have built. If you scale agent count before the loop has earned widespread trust, you get unreviewed work shipping to production, and the system collapses. The trap, as Cherny warns, is "scaling agent count before the loop has earned widespread trust" (Shelly Palmer's analysis, July 2026).
A BCG study reported by Harvard Business Review in March 2026 found that 14% of knowledge workers experience acute cognitive exhaustion from supervising AI at volume, and productivity peaks near 3 tools before declining. This is the human cost of scaling agent count without scaling the trust infrastructure. For a deeper look at this risk in the context of autonomous systems, our analysis of recursive AI self-improvement risks examines what happens when agents operate without sufficient oversight.
How to level up from Step 3
- Run batch operations.
/batchfans out a large changeset to dozens, hundreds, or thousands of worktree agents simultaneously, each making one bounded change (bcherny-claude GitHub repo, 2026). - Set up dynamic workflows. Instead of scripting every step, give the agent a goal and let it plan its own workflow. The agent decides which sub-agents to spawn, what skills to invoke, and how to decompose the work.
- Connect agents to your communication channels. Claude Code's
@Claude(Claude Tag) feature lets an agent monitor Slack or messaging channels, read team conversations, and proactively kick off tasks based on what it sees (explainx.ai analysis, July 2026). - Invest in automated security review at every stage. Turn on security scanning as a hook that runs on every agent action. Agent sandboxing prevents agents from touching production or live systems (Anthropic engineering blog — Claude Code sandboxing).
- Track token/hour costs. At 100 agents, costs compound. Use model selection — cheaper models for routine work, frontier models for complex reasoning — to keep the bill manageable.
When agents kick off work on their own, fix things in the background, and you only get involved for exceptions — you are approaching Step 4.
Step 4: AI-native — a thousand agents, you steer by intent
At Step 4, you have a thousand or more agents running across the organization. Most of them you have never directly started. The loop is fully closed: agents kick off work, delegate to sub-agents, verify their own output, fix problems, and ship. You set the direction — "we want to be the best product in this category" — and the agent ecosystem enacts it. Your phone only rings when something goes wrong.
Your role: intent-setter. You steer by direction, monitor by exception. Agent count: 1,000+. How many people are here: approximately 0.1%.
What Step 4 looks like in practice
A quarter-long migration becomes a workflow you kick off with a sentence and check on weekly. Agents open new workstreams, hire their own sub-agents, restock their own dependencies, and invent new approaches within the guardrails you set. The agent SDK is the primary interface — you programmatically build and schedule agents rather than typing instructions into a chat. Claude Tag is active in most Slack channels, autoresponding to posts and taking action based on what it reads.
Boris Cherny personally reached Step 4. Anthropic as an organization is at Step 3 and pushing toward this level. Almost no one is fully here yet — the original framework estimates about 0.1% of users.
The bottleneck: identifying and governing work at scale
At Step 4, the bottleneck flips — it is no longer about having enough review capacity or trust. It is about finding enough of the right work to feed the massive agent workforce, and enforcing the right guardrails so a thousand agents produce quality output rather than a thousand units of garbage. Cost controls become critical: with hundreds of thousands of agent-hours, you need model selection (the right model for each job) and spending caps so the bill does not explode.
Comparison: the five levels at a glance
| Level | Name | Agent count | Your role | Bottleneck | Key guardrail needed |
|---|---|---|---|---|---|
| Step 0 | Gated | 0 | Cook (do the work) | Permissions / access | Move from browser to CLI; grant file access |
| Step 1 | Assisted | ~1 | Supervisor (watch every move) | Your attention | Auto mode; automated testing/review |
| Step 2 | Parallel | ~10 | Orchestrator (assign + review) | Review capacity | Worktree isolation; task-as-issue format |
| Step 3 | Supervised autonomy | ~100 | Manager (fix the recipe, not the pizza) | Trust in the loop | Loops; batch; automated security hooks |
| Step 4 | AI-native | 1,000+ | Intent-setter (steer by direction) | Finding/governing work at scale | Agent SDK; cost controls; model selection |
Sources: Boris Cherny's Steps of AI Adoption table (Google Doc, July 2026); Shelly Palmer analysis (July 2026); Fortune profile of Cherny (June 2026).
What this means for you
If you are a small business owner, solo developer, or small team just getting started with AI:
You are probably at Step 0 or 1 — and that is fine. The vast majority of users are. But know that the gap between "I ask AI for advice" and "AI does the work while I review" is the single biggest productivity jump in this model. Moving from Step 0 to Step 1 is the highest-ROI move you can make.
The model is not the bottleneck — your workflow is. Spending more on API credits or switching to a "better" model will not move you up a level. What moves you up is granting access, turning on auto mode, enabling automated verification, and building trust in the loop. As the Gless AI analysis put it: "the gap isn't about talent, and it isn't about which model you picked."
Do not skip levels. Each level's guardrails are prerequisites for the next. If you try to run 100 agents at Step 3 without first building the review muscle at Step 2, you get untrusted work shipping to production. The Microsoft agentic AI maturity model makes the same point: "you cannot build reliably at the top without solid foundations at the bottom."
Start with the highest-ROI automation first. Let agents add tests, fix small bugs, and update documentation before you trust them with cross-module feature work. The codepick.dev 2026 AI coding agents roadmap recommends: tests and small bugs → low-risk refactors → dependency updates and docs → cross-module work.
Subscription pricing beats API at scale. At Steps 2–4, API costs compound fast. A fixed subscription (like Claude's Max plan at $200/month) covers far more agent-hours than equivalent API spend. This is a practical guardrail — it caps your downside while you scale.
FAQ
Q: How do I know which level my team is at?
A: Look at behavior, not tool licenses. If your team uses AI in a browser tab for advice but never lets it touch files or tools, you are at Step 0. If individuals pair with one agent and review every change before merging, that is Step 1. If anyone routinely directs multiple agents on bounded tasks in parallel with isolated workspaces, Step 2. If AI-driven work runs on schedules and you review exceptions rather than everything, Step 3. If hundreds of agents kick off work autonomously and you only steer by intent, Step 4.
Q: Do I need Claude Code specifically, or does this model apply to any AI coding agent?
A: The model is agent-agnostic. The role shifts and bottlenecks apply whether you use Claude Code, OpenAI's Codex CLI, GitHub Copilot, or an open-source orchestration framework like Hermes Agent. The specific features (auto mode, worktrees, loops, batch) have analogous implementations across tools — the concept of "give the agent file access and stop reviewing every keystroke" is universal. Claude Code is the most documented example because Cherny published the model, but the progression applies to any team working with autonomous AI agents.
Q: What is the most common mistake teams make when trying to level up?
A: Scaling agent count before building trust in the verification loop. Teams read about "100 agents" and try to jump from Step 1 to Step 3 overnight. The result is a flood of unreviewed, unverified work. The correct sequence is: build a trustworthy verification loop at your current level → scale agent count within that loop's capacity → then add the next layer of automation. You earn autonomy through proven reliability.
Q: How much does it cost to run 10 or 100 agents?
A: With API-based access, costs depend on token usage per agent-hour — easily $50–500+ per day at scale if not managed. With a subscription plan (like Claude Max at $200/month), your agent-hours are included up to fair-use limits, which makes it far more predictable. The key cost control at every level is model selection: use a cheaper/faster model for routine tasks (writing tests, updating docs) and reserve frontier models for complex reasoning. The codepick.dev AI coding tools comparison notes that Composer 2.5 costs roughly one-tenth what Opus or GPT-5.5 cost per task.
Q: Is there a risk in becoming too dependent on AI agents?
A: Yes. The AI coding maturity model from shinyaz explicitly warns: "deepening agent dependency can reduce opportunities for junior developers to build foundational coding skills" and creates "business continuity risk when development halts during agent outages." Organizations targeting Step 3+ should deliberately maintain the ability to work without agents as a design constraint. The BCG/HBR study on AI "brain fry" also found 14% of knowledge workers experience acute cognitive exhaustion from supervising too many AI tools — productivity peaks near 3 tools before declining.
Q: What is git worktree isolation and why does it matter?
A: Git worktrees let you have multiple working copies of the same repository on different branches, in separate directories. When you run 10 agents in parallel, each gets its own worktree — so agent A's changes to auth.py do not conflict with agent B's changes to the same file. Without worktree isolation, parallel agents overwrite each other's work. Claude Code supports this natively with the -w flag or the isolation: worktree setting for sub-agents (Claude Code documentation). For a practical guide to using worktrees with stacked PRs, see our GitHub stacked pull requests guide.
Every claim here is traced to a primary source, dated, and listed under Sources. Research and drafting are AI-assisted; editing, verification and publication are human decisions, and a person is accountable for what appears on this page. How we work →
Discussion
0 comments