The five phases of AI adoption

Every company we work with wants the same thing, described in roughly the same words: we want to be an AI native company. Almost none of them can say what that means operationally, which is fair — nobody has been one for very long. What they can usually tell you is where they are: a subscription everyone has, a few prototypes, one thing in production that half the company argues about.

Those aren't random data points. They're positions on a route, and the route has a shape. Companies move through it in the same order, get stuck in the same places, and — this part is consistent enough to be useful — believe they're one phase further along than they are.

This is a map of that route. Five phases, from a company that has never deployed anything to one that runs on this capability. It's a map, not a maturity model with a scorecard; the point isn't the label you assign yourself, it's recognizing which transition is in front of you, because the transitions are where all the difficulty and all the value live.

Phase 0 — Tools

Everyone has a chatbot. Maybe the company bought an enterprise plan; maybe people are quietly using their personal accounts, which is more common than leadership thinks and worth knowing either way. Individuals are getting genuinely faster at drafting, summarizing, researching, coding.

This phase is real. The gains are real, they're just structurally invisible: every one of them is bounded by a person sitting there driving, and none of them touch a number on a report. That's not a failure of the tool. It's what a tool is. Close the tab and the productivity stops.

The trap is mistaking a site license for a strategy. A company at Phase 0 can truthfully say "we've rolled out AI to the whole company" and have changed nothing about how the company works. This is the single most common self-misclassification we see: leadership believes they're mid-transformation because procurement signed a contract.

You've left Phase 0 when someone builds a thing that runs when they aren't watching it.

Phase 1 — Experiments

Now there are builds. Someone in procurement wired a model to a spreadsheet export. Someone in billing has an agent that drafts denial appeals. Someone in marketing built something nobody else has seen. They're scattered, bottom-up, close to the pain, and unglamorous.

This is the healthiest phase in the sequence and the one most often described as a mess. It should be scattered. The people building these things have correctly identified where the company hurts, and their choices are better evidence than any survey or interview would surface, because they're the ones living it. Every homegrown agent is a flag planted on a real problem by the person closest to it — which makes this phase the best input a scoping exercise could ask for.

The trap is that Phase 1 is extremely comfortable. It produces a constant supply of good news — new demos, visible momentum, a slide with twelve pilots on it — and it never requires anyone to tell a colleague their project is being retired. Companies can sit here for years, and the longer they do, the more the duplication compounds: three agents doing one job, each a success story, none of them the system. Activity gets measured, so activity is what you get.

There's a second reason companies stay here, and it isn't a failure of will. The people building these experiments are doing it in the margins of jobs they already have. A buyer, a billing lead, a maintenance planner — none of them signed up to write production software, and none of them should have to. So the experiments plateau in a predictable shape: robust enough to demo, not robust enough to carry a task end to end, and usable by the person who built it rather than by a team. That ceiling isn't about talent or effort. It's that finishing the job is a different job, and nobody's week has room for it.

You've left Phase 1 when somebody's actual, funded job is to look across the experiments, decide which one ships, and take it the rest of the way — a real function, not a memo. Most companies discover they need that team right here, at the exit from Phase 1, well before they need the platform that comes later.

Phase 2 — Systems

One thing is in production. It has a name, an owner, a number it's accountable to, and real plumbing into the system of record — the ERP, the EHR, the case management system. People who did not build it depend on it. If it broke on a Tuesday, you'd hear about it within the hour.

This is the hardest transition on the map by a wide margin, and it's where most companies stall out permanently. The reason is that Phase 1 and Phase 2 are separated by a kind of work that doesn't resemble Phase 1 at all. Experiments live at the edges of the real systems — an export here, a copy-paste there. Production means writing back into a decades-old ERP with no usable API, or an EHR where every touch has HIPAA implications, or a workflow where the audit trail isn't optional. Auth, permissions, logging, validation, an escalation path for the cases the system won't handle, and a way to prove it's still working next quarter.

None of that is what made the prototype good. That's why the transition so often fails with a working prototype sitting right there — a failure mode common enough that it gets its own post.

The trap is the plateau: an agent that drafts the answer while a human still carries it into the system that counts. It's useful. It is also permanently capped, because the value was always in completing the transaction, not in producing a suggestion.

You've left Phase 2 when a non-technical person's daily work assumes the system exists.

Phase 3 — Infrastructure

The second system costs half what the first one did. The third costs less than that.

That drop is the entire signature of Phase 3, and it's the phase almost nobody talks about because it's the least photogenic. What changed isn't the models — it's that the second project didn't have to re-solve identity, permissions, data access, evaluation, deployment, observability, and human escalation from scratch. Somebody built the shared layer. New use cases stop being projects and start being configuration.

This is where that team's mandate changes. Escaping Phase 1 required people who could take an experiment and finish it. Phase 3 asks for something different: own the layer everyone else builds on. The job was never to own AI — that's the silo failure — but here the distinction turns concrete, because the team's output stops being systems and starts being the thing other people's systems are made of.

The trap cuts both ways here. Build the platform before you have two systems that need one and you get an elaborate internal framework serving nothing, which is a very expensive way to be at Phase 1. Never build it and every use case pays the full integration cost forever, which is why some companies have shipped six AI projects and still can't ship the seventh any faster than the first.

You've left Phase 3 when a new use case goes from idea to production in weeks and nobody treats that as remarkable.

Phase 4 — Native

The organization is different. Not "the organization uses AI" — the organization is shaped differently: roles have changed, processes were redesigned around what's now cheap instead of being preserved and automated, the objective is instrumented well enough that the whole system can be aimed and re-aimed. Headcount doesn't shrink so much as change composition.

This is the state where the compounding actually happens, and where the advantage stops being about tools at all. It's the argument we've made elsewhere: at machine speed, coherence and correct aim compound, and incoherence compounds against you just as fast. Phase 4 isn't a finish line. It's the first point at which you're running the company as one instrumented system rather than a set of departments that each bought some software.

The trap is thinking you can start here. Companies that try to jump straight to Phase 4 — a transformation program, a new operating model, a consultancy's slide deck — reliably land back at Phase 1 with a bigger budget, because the reorganization had nothing underneath it to reorganize around.

What the map is actually for

Three things fall out of this that are more useful than the phases themselves.

Phases are per-function, not per-company. A manufacturer can be at Phase 3 in procurement and Phase 0 on the floor. A health system can be at Phase 2 in billing and Phase 1 everywhere else. Diagnosing the company produces a useless average; diagnosing each function tells you where the next dollar goes. Almost always it goes to the function closest to leaving Phase 1 or Phase 2, because those are the transitions with the steepest payoff.

You can't skip, but you can move fast. Every phase produces something the next one requires: Phase 1 tells you where the pain is, Phase 2 proves one thing can actually reach the system of record, Phase 3 makes the fourth project cheap. Skipping means guessing at the thing you skipped. But the timeline is not fixed — a focused company can go from Phase 1 to a working Phase 2 system in a quarter, and the reason it usually takes two years isn't technical.

The transitions have different failure modes, so they need different work. 0→1 needs permission and a little slack. 1→2 needs integration and evaluation capability the functional teams don't have. 2→3 needs an architectural decision and someone senior enough to make it. 3→4 needs organizational authority, not engineering. Bringing engineers to a 3→4 problem or a transformation program to a 1→2 problem is the most expensive category of mistake in this whole space, and it's usually made by smart people who correctly diagnosed that something was wrong.

The honest summary is that most companies reading this are at Phase 1 and believe they're at Phase 3. That's not embarrassing — it's the default outcome of doing the right thing at Phase 1 for slightly too long. But it does mean the work in front of you probably isn't another pilot. It's finishing one.

If you're trying to place your own operation on this map, the neighboring posts go deeper on the specific transitions: why pilots don't ship for 1→2, what to settle before you build for 0→1, and buy, build, or partner for how to resource any of it.