The framework

The AI transformation roadmap

Q: What is the smallest viable version of each stage?

Pilot: one workflow, one baseline, one measured human-in-the-loop intervention rate. Expand: one pattern reused twice. Executize: a registry (a spreadsheet counts) plus one improvement proposed by the coordination-agent prototype. Transform: one new role with a charter and a business case. Autonomate: one workflow at L2 with a kill switch and a quarterly review.

Not a sequence you complete. A stack you build — five cumulative stages where each one depends on the substrate the last one produced. Organisations that skip ahead don't move faster; they stall later, with less ability to diagnose why.

Framework v1.0 · Published November 2026

Cumulative, not sequential

Most AI roadmaps are sequences: do A, then B, then C. This one is a stack. Each stage produces specific artifacts — a workflow map, a pattern library, a coordination layer, new role charters, an autonomy tier definition — and the stage above it depends on those artifacts being there.

That means the stages aren't phases you leave behind. An organisation that has reached Autonomate is still running Pilots every day. It's just also built everything else — the substrate that makes autonomy governable instead of reckless.

Skipping a stage isn't faster. It's slower, later — when you hit a wall and can't see which layer is missing.

Pilot Adds: a workflow map, a baseline, a measured HITL rate
Expand Adds: a pattern library, operators and strategists
Executize Adds: a workflow registry, coordination agent, decision log
Transform Adds: new workflows, roles, and functions
Autonomate Adds: autonomy tiers, kill switches, evaluation ceilings

The thicker the left edge, the more the stage builds on what's beneath it. Each layer stays in production.

Stage 1

Pilot

Prove one workflow can run better.

Full pilot guide

One existing workflow. Mapped end to end. Measured before and after.

Pilot is not a demo. It's an instrumented version of an existing workflow where every input, transform, integration, and output is documented — and where you have a baseline so you can prove which way the numbers moved.

At this stage you decide the automation posture: fully automated, extended with AI, or AI-assisted with human-in-the-loop review. Each has a HITL intervention rate, and that rate is the metric that tells you whether the workflow is stable.

Data in Start and mid-stage inputs — sources, formats, quality, permissions

Transforms Steps that change the data — decisions, rules, handoffs

Integrations In and out across stages — systems, APIs, people, approvals

Outputs Data out, finished work, downstream consumers, feedback loop

The decision: Which existing workflow to pilot — and whether to automate it fully, extend it, or run it with human-in-the-loop review.
Artifacts you ship: Workflow map · baseline · automation-posture decision · HITL rate
Canary metric: HITL intervention rate — if it's climbing, the workflow isn't stable.
The trap: Automating without mapping the data. If you don't know what enters at each stage, you can't instrument outputs or prove anything changed.
Skip tax: Every later stage inherits an unmeasurable foundation. You can build on top of an unmapped Pilot — you just won't know whether it worked.
Timebox: 4–8 weeks
Owner: Function leader + AI engineer + named workflow owner

The full pilot method Pilot Plan Worksheet Measure AI ROI

Stage 2

Expand

Turn one pilot into a pattern — and level up the people running it.

Full expand guide

The second and third workflows should not cost what the first one did.

Expand is where the work goes from one team doing one thing to many teams doing many things — but on a shared pattern, not a shared team. You codify the pilot into workflow archetypes, reusable integrations, and evaluation sets. Then you hand those patterns to the functions that need them.

This is also where employees become operators and strategists of the workflows. Operators run the workflow in production — handle HITL, tune thresholds, know what "normal" looks like. Strategists redesign the workflow — set the goal, own the automation-versus-risk tradeoff. Naming these roles is what makes them hireable, trainable, and measurable.

Operators Run the workflow in production. Handle HITL. Tune thresholds.

Strategists Redesign the workflow. Own the automation vs. risk tradeoff.

The decision: How to run the next ten to twenty workflows without paying first-pilot cost every time — and how to level up the people running them.
Artifacts you ship: Pattern library · operating model · operator and strategist role definitions · reusable integrations and evals
Canary metric: Launch time per new workflow — should be falling, not constant.
The trap: Treating every workflow as a fresh pilot. You rebuild integrations, evals, HITL, and metrics each time — and cost scales linearly with workflow count.
Skip tax: Executize needs a registry. Without a pattern library, there is nothing to register, and no controller worth building.
Timebox: 1–2 quarters
Owner: Transformation office + function leaders

The full expand method AI adoption playbook Use-case scorecard

Stage 3

Executize

Build the coordination layer.

Full executize guide

From scattered workflows to a single, machine-readable system that can see itself.

Executize is where you stop being a collection of workflows and start being an organization with a nervous system. It requires three things, in order:

Registry. A machine-readable inventory of every workflow and the agents inside it. Controller. A coordination agent that sees them all, proposes extensions, and improves the agents within workflows. Decision log. An auditable record of every extension and improvement — revertible, reviewable, survivable under audit.

The trap is building the controller before the substrate. An "executive intelligence brain agent" without a registry, evaluations, and a decision log is a chatbot with grand ambitions — and it will not survive a risk review.

Registry Machine-readable inventory of every workflow and the agents inside it

Controller The coordination agent — sees all workflows, proposes improvements

Decision log Every extension and improvement — auditable, revertible, reviewable

The decision: Do you build the coordination layer — an executive intelligence agent that sees all workflows, proposes extensions, and improves the agents inside them?
Artifacts you ship: Workflow registry · coordination agent · decision log · evaluation harness · permission model
Canary metric: Accepted-improvement proposals per quarter — how many agent-proposed changes reached production.
The trap: Building the brain before the substrate. A controller without a registry, evaluations, and a decision log is a chatbot with grand ambitions.
Skip tax: Transform and Autonomate become ungovernable. There's no way to see what any of it is doing, or stop it cleanly.
Timebox: 1 quarter to design, 1–2 to trust
Owner: Transformation office + named agent owner + executive sponsor

The full executize method AI governance playbook AI strategy playbook

Stage 4

Transform

Design new work that couldn't exist before.

Full transform guide

From automating existing work to inventing new work.

Transform is the hardest stage to do and the easiest to fake. Every organization at this stage will feel pressure to call the work "transformed" when all they've done is put a tool on an old workflow. The test is concrete: is there a workflow, role, or function producing value that couldn't have existed before AI?

Three things to design, in this order. New workflows. What work now runs end to end that couldn't before. New roles. What a person does, and which decisions stay human. New functions. What team, budget, and mandate the new workflow requires.

Design the function last. If you design it first, you'll staff a team around an idea before you know what the workflow actually needs.

Workflow What work now runs end to end that couldn't before

Role What a person does — and which decisions stay human

Function What team, budget, and mandate this new workflow requires

The decision: What could your organization do that was impossible before AI — and what roles and functions does doing it require?
Artifacts you ship: New workflow designs · role charters · function definitions · business case for each
Canary metric: Percentage of value coming from new workflows versus amortized old ones. If it's small, this is rebranding.
The trap: Renaming old workflows "transformed." If the workflow runs the same way with a tool on top, it isn't transformation — it's a rebrand.
Skip tax: Autonomate then runs old work at scale, which is the worst possible outcome — high speed, high volume, no new capability.
Timebox: 2–4 quarters
Owner: Executive sponsor + function leaders + HR/people

The full transform method AI strategy playbook AI adoption playbook

Stage 5

Autonomate

Run deep autonomy inside guardrails.

Full autonomate guide

Autonomy is a per-workflow decision, not a program-wide one.

Autonomate replaces the binary "fully automated or with HITL" with a graded ladder from L0 to L4. Each workflow sits at its own tier. Each tier has its own guardrails, its own incident expectations, and its own review cadence. A workflow moves up a tier only when it has the guardrails to justify it.

The failure mode that ends projects is not autonomy itself. It's autonomy without a kill switch, or self-improvement without an evaluation ceiling, or decision-making without an audit trail. Each of these looks like a victory at first — and ends the same way: a workflow you can't stop.

L0 · Suggest Agent proposes; a human acts

L1 · Approve Agent acts, but only on approval

L2 · Exception Agent acts; escalates exceptions only

L3 · Self-improve Agent tunes itself within an evaluation ceiling

L4 · Self-extend Agent proposes new workflows — requires full guardrails

The decision: How far do you let autonomy go — and what guardrails must already exist before you go further?
Artifacts you ship: Autonomy tiers (L0–L4) · guardrail spec · kill switches · evaluation ceiling · self-improvement rules
Canary metric: Incidents per thousand agent actions, by tier. Watch the trend, not just the absolute.
The trap: Autonomy without a kill switch. Or self-improvement without an evaluation ceiling. Or autonomy without an audit trail. Each ends the same way — a workflow you can't stop.
Governance gate: Every workflow must have a kill switch, an audit trail, and an evaluation ceiling before it moves up a tier. Reviewed quarterly.
Timebox: Ongoing — quarterly review
Owner: Transformation office + risk + security + executive sponsor

The full autonomate method Governance for autonomous workflows Model evaluation

The contracts

What must be true to advance

Each stage hands off specific evidence to the next. If you can't point to it, you haven't advanced — you've just moved on. These are the gates, gathered in one place.

Advance conditions and required evidence between stages.
Handoff	Advance when	Evidence required
Pilot → Expand	The pilot beats its baseline on task time or quality under real working conditions, and the HITL intervention rate is stable and documented.	Baseline document · HITL log · workflow map (data in, transforms, integrations, outputs)
Expand → Executize	A function leader launches a new workflow from the pattern library without central-team help, and operators and strategists exist as named roles.	Launch-velocity metric · RACI for operator and strategist roles · pattern library inventory
Executize → Transform	The coordination agent's recommendations are acted on without re-derivation, and the decision log has survived an external review.	Decision-log export · external review memo · evaluation-harness results
Transform → Autonomate	A new role or function exists that produces value not attributable to an old workflow running faster — and the guardrails for autonomy are designed.	Role charter · business case with new-workflow attribution · guardrail spec
Autonomate · within stage	A workflow moves up a tier only when it has a kill switch, an audit trail, and an evaluation ceiling — reviewed quarterly.	Kill-switch spec · audit-trail sample · evaluation-ceiling definition · quarterly review memo

Where organizations actually sit

Most of the market is stuck — and where matters

The 2026 AI Transformation Baseline surveyed 340 transformation leaders across 12 sectors. The distribution isn't a criticism — it's the reason this model is descriptive, not aspirational.

Stage distribution today

Pilot 44%
Expand 31%
Executize 15%
Transform 8%
Autonomate 2%

75% of organizations sit in the first two stages. That's not a sign of slow adopters — it's a sign that expanding past Pilot is harder than piloting. The pattern library is the work, and it's the work most teams skip.

Executize is the unbuilt layer. Most "AI transformation" programs never build a coordination layer. They have twenty workflows and no controller, which is why their Transform and Autonomate stories never quite hold together.

Autonomate is rare for a reason. 2% isn't a failure — it's correct. Autonomate requires every stage below it to be solid, plus deliberate guardrails, plus quarterly review discipline. That's the right price.

How to know if you're stuck

Every workflow is a fresh pilot.
Your second, third, and fourth workflows cost as much to launch as the first. That's the pattern library missing — and it's the Expand work.
HITL rates are creeping up.
The workflow isn't stable. Adding reviewers to compensate is a symptom, not a fix.
The coordination layer doesn't exist.
"We're not there yet" is the usual answer at Executize. Usually, that means the substrate isn't either.
"Transformation" is rebranded automation.
You can't name a role or function that produces new value. If it's all faster old work, you're at Expand — not Transform.
Autonomy has no kill switch.
There's no workflow you can stop cleanly. That's not Autonomate — it's an unmanaged experiment with a compelling name.

60 seconds, no signup

Which stage are you in?

Five questions. Answer yes or no. Your stage is the highest one where every answer was yes — and the next one is where your effort belongs.

Pilot
Do you have at least one workflow with a documented baseline, a workflow map (data in, transforms, integrations, outputs), and a measured HITL intervention rate?
Expand
Has a function leader launched a new workflow using your pattern library without help from the central team — and are operators and strategists named roles?
Executize
Do you have a machine-readable registry of every AI workflow, a coordination agent that proposes improvements, and a decision log that has survived an external review?
Transform
Do you have at least one role or function that didn't exist before AI, with a charter and a business case — producing value not attributable to an old workflow running faster?
Autonomate
Do you have workflows running at autonomy tier L2 or higher, with kill switches, evaluation ceilings, and quarterly reviews in place?

Cross-cutting requirements

Three things that enter at Pilot and never leave

Governance, measurement, and ownership don't belong to one stage. They grow with the model — and each stage raises the bar on all three.

How each cross-cutting requirement scales across the stages.
Requirement	At Pilot	At Expand	At Autonomate
Governance	A named reviewer for the workflow, with a documented approval step.	Tiered review sized to risk; a shared bar for what requires escalation.	Review by autonomy tier; kill switches; evaluation ceilings; quarterly audit.
Measurement	Baseline and HITL rate for one workflow.	Launch velocity, unit cost trend, HITL trend across the library.	Registry-wide analytics; drift detection; incidents per thousand actions by tier.
Ownership	A named workflow owner, accountable for the baseline and the outcome.	Operators and strategists as named roles, with RACI attached.	An agent owner and an executive sponsor, accountable for autonomy decisions.

Frequently asked

Questions about the model itself

Is this a maturity model?

No. A maturity model scores you on a scale. This model names substrate — the specific artifacts each stage produces. You can be at Autonomate on one workflow and Pilot on another at the same time, in the same organization. That's not a gap; that's a portfolio.

Can we skip a stage?

You can try. Skipping looks like speed and feels like progress until you hit the wall — usually in governance or measurement. Executize without Expand produces a coordination agent with nothing to coordinate. Autonomate without Transform runs old work at scale. The trap is real: skipping often costs more time later than it saves up front.

What if we've been piloting for a year and haven't advanced?

The usual cause is treating every workflow as a fresh pilot. Check whether your second, third, and fourth workflows were cheaper and faster to launch than the first. If they weren't, the pattern library is missing — and that's the Expand work.

Who owns the roadmap?

The transformation office holds the model and the standards. Function leaders own their workflows. An executive sponsor signs off on the sequence and the guardrails. A named agent owner exists in Executize and beyond.

How long does each stage take?

Pilot: 4 to 8 weeks. Expand: one to two quarters. Executize: about one quarter to design, another one or two to trust. Transform: two to four quarters. Autonomate: ongoing, reviewed quarterly.

Do we need all five?

You need Pilot. Beyond that, it depends on your ambition. But Executize is the layer most organizations are missing — and it caps what Transform and Autonomate can be. Skipping it is a decision, not a shortcut.

What's the smallest viable version of each stage?

Pilot: one workflow, one baseline, one measured HITL rate. Nothing more. Expand: one pattern reused twice — not ten workflows, two that share a pattern. Executize: a registry (a spreadsheet counts) plus one improvement proposed by the coordination-agent prototype. Transform: one new role with a charter and a business case. Autonomate: one workflow at L2 with a kill switch and a quarterly review.

Cite this framework

If you reference this model in a report, article, or research paper, cite it directly. Machine-readable copies are available.

Transformation.ai. AI Transformation Roadmap, v1.0. November 2026. https://transformation.ai/roadmap

Markdown version JSON state model

Next, choose your stage.

Each stage has its own method, its own artifacts, and its own traps. Read the one that matches where you are — not where you wish you were.

Find your stage Browse playbooks