Almost every company now uses AI. Very few have changed how the work gets done. In McKinsey's 2025 survey, only 21% of respondents whose organizations use generative AI said they had fundamentally redesigned even some workflows (McKinsey). Work still starts when a person starts it, moves when a person pushes it, and gets checked by a person at the end. AI has sped up each step and left the steps as they were.
We think that is the wrong place to stop. Speeding up a process nobody designed gets you a bad process that runs faster. In an AI-native enterprise, the work is redesigned around agents from the start. Agents do the production work by default. People do what only people can: decide what is worth doing, judge whether it was done well, and own the relationship with whoever it is for.
Companies get there one kind of work at a time, and a mandate or a platform purchase can't shortcut that. We track the progress on a scale with five levels. This is the scale we use with clients, and the one we hold our own delivery to.
.png)
Why now
Vendors are moving from selling tools to selling finished work. Sequoia put it in one line: "A copilot sells the tool. An autopilot sells the work" (Sequoia). Investors and the frontier labs are now funding firms that sell finished work instead of software. That reaches every enterprise in two places.
The firms you buy from will change. Outsourced IT, accounting, legal work, and support are the first targets. Expect vendors to offer finished work at a fixed price instead of hours. Take the offer, and ask each of them to show what their agents did and who allowed it.
Your own functions will change. Finance, IT, data, and operations run on queues and handoffs, and much of their time goes to routine steps: reconciling, triaging, and chasing approvals. Agents can now take on those steps, which gives people time back for the judgment calls, the relationships, and the work that moves the business. Software engineering shows what it looks like: at Stripe, more than a thousand changes merged each week contain no human-written code. Engineers start them from Slack and review the result (Stripe). Most of what made this work at Stripe was process design: a standard way to hand off a task, a required review, and a log of every change. Stripe designed the work first and automated it second. A month-end close or a service desk can run the same way.
Most companies are not getting there. Gartner expects more than 40% of agentic AI projects to be canceled by 2027 (Gartner). RAND's interviews with 65 AI practitioners point the same way: projects fail on unclear problems, inadequate data, and thin infrastructure (RAND).
None of those failures are about the model. Every company can buy the same models. What sets the leaders apart is everything around the model: the data underneath it, the context that connects it to how the business runs, and a process someone designed before anyone automated it. Two companies on the same model can sit two levels apart. That gap is what the scale measures.
The five levels
Researchers grade AI agents by how much they act on their own. The Knight First Amendment Institute's levels of autonomy define each level by the person's role: operator, collaborator, consultant, approver, and observer. We apply the same idea to the enterprise. The question at every level is the same: who starts the work, who decides, and what is on record?
Three things about the scale matter more than the levels themselves.
- Each kind of work has its own level. Status reports can sit at level 3 while pricing decisions stay at level 1. So the honest answer to "where are we?" is a map with a level for each kind of work.
- Each level up changes people's jobs. From level 2 on, people spend less time producing and more time directing and checking. The time this frees goes to the work that needs people: strategy, customers, and judgment. That is the hard part, and it is why buying a better tool rarely moves anyone up a level.
- Higher is not always better. Some work should stay low on purpose: anything where a wrong answer is costly and rare, or where the judgment is the product. The goal is to put each kind of work at the highest level it has earned, and no higher.
Find your level
List the five to ten kinds of work that take most of your team's time: building pipelines, answering data requests, weekly reporting, closing the month, and onboarding a new customer. Take each one down the ladder below and stop at the first "no". That is its level.
Watch for two false readings:
- Agents acting without a record are still at level 1. The risk they add is unmanaged. If you can't say which agent changed what, and who allowed it, you have no basis for moving up.
- Rubber-stamp approvals are worse than no approval. If someone approves forty agent changes a day without reading them, you are running at level 3 without the controls that make level 3 safe. Review capacity is the real limit on how fast you can climb.
How to climb
Each step up needs three things: the work redesigned, something built, and a change in how people work. Most failed AI programs build and skip the other two.
Two rules make the climb safer. Move one kind of work at a time. Start with work that is frequent and well understood, low-risk if it misses, and valuable when it lands, such as status reporting, documentation, tests, and routine pipeline fixes. Let the data promote it. When people stop correcting the routine cases, let those run.
Eight principles
The scale tells you where you are. These principles are how we build the climb, for clients and for ourselves.
- 1) Design the work before you automate it. Put an agent on a process nobody designed and you get a bad process that runs faster. Before an agent touches a kind of work, map how it runs today, cut the steps that exist only because a person used to carry the work from one system to the next, and decide where judgment sits. Then build.
- 2) Context is infrastructure. Agents work from what they are given. Write down your conventions, definitions, past decisions, and business rules where agents can read them, and manage every change to them the way you manage code. That starts with the data. If your systems disagree on what counts as a customer or a closed deal, an agent will pick one answer and act on it at scale. Definitions, ownership, and quality come before autonomy.
- 3) The organization is an event log. Every trigger, action, decision, and outcome is recorded: who or what did it, and why. Store the decisions and links; raw content can stay where it already lives. You can't raise autonomy on work you can't see.
- 4) Work arrives where people already are. Agents take requests in the channels teams already use, and over time from events: a signed contract, a failed job, or a finished call. Nobody should have to open a new app to put an agent to work.
- 5) Autonomy is earned, one kind of work at a time. Every proposal gets an accept, an edit, or a reject, and every one is counted. That record decides what an agent may do on its own next quarter. Mandates get tools used. Only the record of accepted and rejected work tells you what is safe to hand over. Count accepted items and the cost of each one. Tokens used, changes opened, and "percent written by AI" are vanity metrics.
- 6) Design for review. Agents produce more than people can check, so make the work easy to check: break it into small pieces, let automated checks catch the routine mistakes, and make one person accountable for each piece.
- 7) Governance lives below the agent. Permissions are enforced by the system around the agent: a sandbox, short-lived credentials, and a gate on every action that fails closed. Many agent products run inside your network but decide what the agent may do from the vendor's cloud. For work on sensitive data, the gate and the log should run in infrastructure you control.
- 8) Nothing goes out without a person's name on it. Anything that reaches a customer or production has a named person who approved it, on record. Before your board, auditors, or regulators ask how much an agent can do, they will ask to see what it did and who allowed it.
What changes for people and budgets
Above level 2, most of people's time goes to directing and checking. Four jobs matter most:
- Owners hold the goal and the relationship, and sign off what goes out.
- Agent managers design the work for agents: the workflow, the instructions, the task specs, the autonomy levels, and the tests. When an agent fails, they fix what's behind it.
- Reviewers are domain experts who check what matters. Their decisions are the data that moves work up the scale.
- Platform engineers run the agents, the context, the gate, and the log, the way IT runs email.
Your future experts are learning the work today. Give early-career people real roles from the start, reviewing what agents produce and shaping how the work is done, so the judgment your business depends on keeps growing.
Treat AI-native as a growth plan. Companies that framed it as headcount cuts have had to walk it back [SOURCE NEEDED]. The point is to change what people spend their time on and put the gains into growth. Pew found 52% of U.S. workers are worried about how AI will be used at work (Pew). Reviewers who think they're training their replacements either wave work through or reject everything. Either way, the record that moves work up the scale stops being honest.
Budgets follow the work:
- Capacity is people times their agents. Plans carry agent capacity and AI spend as line items, next to headcount.
- AI spend is a cost of the work, tracked per task and per team.
- Pay for outcomes. When agents do the production, paying a vendor by the hour rewards it for being slow. Pay for deliverables and results, and fund internal functions the same way.
- The scorecard changes. Cost per accepted deliverable, share of work at each level, and time from request to accepted result. Headcount and hours stop being the measure of a function's value.
What can go wrong, even when you do it well
- Speed can be an illusion. In one controlled trial, experienced developers were 19% slower with AI tools while believing they were 20% faster (METR). Measure it directly.
- Long tasks fail more often. Agents are reliable on short, checkable steps and less so on long ones. Break the work down.
- Unchecked output moves the cost downstream. Someone pays for the errors later, usually at a higher price. That is why review comes before scale.
- Platforms change their terms. Keep your context, policy, and records in your own systems, and keep the agent replaceable.
Where to start
We believe every company will move up this scale in the next few years. The ones that start now will set the pace, and the rest will spend those years catching up. Starting takes one kind of work and one quarter.
- Map your work on the scale. One afternoon with the people who do the work. Most of it will be at level 0 or 1, which is normal.
- Pick one kind of work to move. Choose something frequent and well understood, where a miss is cheap to fix and a win is felt across the team. Name the result that would justify the cost before you build anything.
- Redesign it before you build. Walk the work end to end with the people who do it. Cut the steps that only move work between people or systems, decide where judgment sits, and define what a finished result looks like. Automating the process as it runs today is the most common way pilots stall.
- Build level 2 properly. A record of every action, a check before anything runs, a named approver, the team's know-how written down, and clean data with a named owner.
- Count every decision for a quarter: accepted, edited, or rejected, and why. Turn every rejection into a rule, a check, or a clearer task.
- Let the record promote it. When the data says a kind of work is ready, move it up a level, and pick the next one.
At OneSix, we're actively transforming how we operate, and we've helped other companies through the same shift, so we know where it stalls and what moves it forward. We'll help you see where your work sits, build what it needs to move up, and run it with you until your team owns it.
Anthropic recently named OneSix a Select partner in the Claude Partner Network, which reflects the data and AI depth this work depends on. During our Design engagements, we map your top kinds of work on the scale, pick the first one to move, and redesign it before anything gets built. Then we build level 2 with you and run it until your team owns it.
Bring us your five busiest kinds of work. We'll walk through which level each one sits at, what it needs to move up, and how to run it until your team owns it. Start the conversation.
Further reading
- Feng, McDonald and Zhang, Levels of Autonomy for AI Agents, Knight First Amendment Institute, June 2025
- Julien Bek, Services: The New Software, Sequoia, March 2026
- Anthropic, Effective context engineering for AI agents, September 2025
- Stripe, Minions: one-shot, end-to-end coding agents, February 2026
.png)
.avif)
