This adoption canvas sets the success path for change-management — how people progress with AI and compound their systems.
Some teams implement AI from a centrally owned department. My bias is toward a PLG-style Hub & Spoke model, where AI foundations are centrally owned (governance, core KPIs, seeing the company as a product) and decentralized by department function (or “feature tracks”), where those closest to the use cases drive strategy and local integration for meaningful releases and a roll-up strategy. This unblocks the most upstream bottleneck to growth: the workflows of employee behavior.
| Team | 01 ONE-OFF AI | 02 CONNECTED AI | 03 AUGMENTED AI | 04 AUTONOMOUS AI | 05 AI NATIVE |
|---|---|---|---|---|---|
| General | Types a question, reads the answer, goes back to working the way they already worked. AI is a side tab, not a workspace. | AI lives inside the work. Context goes in first — Cowork, the right MCP, the relevant docs. Something the team actually uses comes out. | Builds agents that run while you're in other meetings. Teammates rely on the things you ship. Humans hit approve more often than author. | Software is cheap. You ship the tool your team needs this week — in production by Thursday. | Stopped building tools. Started building systems. The company moves differently because of what you ship. XFN: the systems you build stop respecting team lines. An agent picks up a workflow that used to belong to another function and runs it to a finished result you just review. |
| Example Summaries | Paraphrased outreach emails, AI-drafted headlines that still get re-edited in Google Docs, line-by-line autocomplete, exec-update summaries from a template. | Exec-update in 30 minutes instead of an afternoon; PRs arrive with tests and docs already drafted; research spans Gong/Notion/the company brain in one pass; the weekly note nobody asked for but everybody reads. | A nightly agent scores inbound leads and books the good ones; agents triage bugs into Linear, draft the PR, write the regression test; a feedback agent aggregates customer asks across Gong/Intercom/Slack; metrics compile overnight, Monday deck is generated. | Deal-room dashboards rebuilt the week before QBR; AE Slackbot that nags on stale pipeline fields; campaign-orchestration app that reallocates spend off pipeline signal; bespoke sprint reports and feature-flag dashboards; exec dashboards rebuilt for each leadership transition — in production by Thursday. | Outbound that books its own meetings; tickets & bug reports turn into merged PRs without a human. Services pick up ownership conventions from the last three services you shipped. XFN: a recurring bug pattern picks up its own root-cause analysis, ships the fix and the regression suite end to end, with the next series as green; you never knew there was a bug until seeing the changelog report. |
| Sales / GTM | Opens Claude after a Gong call for a summary, uses it to paraphrase an outreach email. Account plans still built from a blank doc. | Briefs AI with the last three calls, the Cowork workspace, and the CRM snapshot before drafting. Can tell you which prompt beats which for MEDDPICC. | A nightly agent scores inbound and books the good ones. A Slack shortcut turns any Gong call into a deal-risk read. | Deal-room dashboards for the big opps the week before QBR. An AE Slackbot nags on stale pipeline fields. | Outbound books its own meetings. Deal risk surfaces before the rep notices. The motion one builder shipped is the motion GTM runs. XFN: a churn signal triggers its own product-usage read and a tailored save play, to run end to end. |
| Marketing | AI drafts the headline; the second pass happens in Google Docs the way it always has. | Briefs start from a tuned prompt with SEO, CAC, and competitor context pulled from the Corporate Brain on the way in. | Content pipelines draft, edit, schedule, track. Competitor pages re-scrape themselves nightly. The marketer reviews on Monday. | A campaign orchestration app reallocates spend off pipeline signal. Budget moves in hours, not the next retro. | Every prospect gets a campaign variant with personalized copy tied to their industry and Gong history, triggered when mostly likely to be effective. The team sets strategy; agents run the calendar. XFN: an underperforming campaign spins up its own funnel analysis and a re-scoped follow-up experiment end to end; you review the gains report. |
| Engineering | AI autocompletes a line, explains a stack trace. Ship cadence and review cycles look the same as six months ago. | Claude or Codex in the IDE by default. Tests and docs get drafted before the PR opens. You can explain why this model for this file. | Agents triage bugs into Linear, draft the PR, write the regression test. Humans hit approve more often than author. | Claude Code ships bespoke internal tools to Vercel and Supabase between meetings. The tool nobody will rebuild is the one that runs forever. | Tickets & bug reports turn into merged PRs without a human. Services pick up ownership conventions from the last three services you shipped. XFN: a recurring bug pattern picks up its own root-cause analysis, ships the fix and the regression suite end to end, with the next series as green; you never knew there was a bug until seeing the changelog report. |
| Product | AI summarises a user call and drafts a bullet. The real PRD still happens in the doc the team has always used. | User research becomes re-queryable — AI pulls signals across hundreds of calls nobody could hold in their head. Specs ship to design in a day. | A feedback agent aggregates what customers ask for across Gong, Intercom, and Slack. Internal Q&A bots answer product questions before someone has to. | The PM ships bespoke internal apps: sprint reports, feature-flag dashboards, roadmap views. Built last month, not waiting in the eng backlog. | PMs merge PRs. Roadmap recommendations generated from an agent watching usage & synthesizing qual feedback, prioritized for directional edit. XFN: The next obvious tasks auto-start, and you steer as an exec reviewer. |
| Data / Analytics | Pastes a SQL error into Claude for an explanation, asks it to draft a one-off query, then rewrites it by hand in the warehouse. Dashboards get built the way they always were. | Briefs Claude with the schema, the metric dictionary, and last month's validated queries before asking. “Conversion by device” comes back in one pass, tied out against the source. Proven SQL patterns get saved and reused, not re-derived. | A pipeline frames the question, explores the data, drills to root cause, validates the numbers, and drafts the readout overnight. The analyst reviews Monday's story instead of assembling it. The nightly refresh regenerates the metrics. | Ships the bespoke analytics tool the team needs this week: a self-serve “ask the warehouse” Slackbot, a forecast app, a QBR deck generator, in production by Thursday and off the eng backlog. Hand it a defined question and it runs the whole analysis end to end. | A metric dips and the agent has already traced the root cause and drafted fix options before anyone noticed the dip. XFN: obvious fixes kickstart a new workflow to run the experiment & iterations end to end (across UX, Eng, Data). You read the report of finished work with increased CR. The team decides which questions matter; the system surfaces the ones no one thought to ask. |
| Ops / CoS | AI drafts the exec update summary. Meeting prep is a manual pass through a template that's been unchanged for a year. | Board memos and weekly digests start from a template that sharpen each cycle. Context flows from Cowork, not copy-paste. | Metrics compile overnight. Inbox and calendar triage happen before standup. The Monday deck is generated; the CoS writes the commentary. | Exec dashboards get rebuilt for every leadership transition. OKR tracking flags risk the week before quarter-end, not after. | An always-on CoS layer surfaces signals, coordinates launches, drafts quarterly reviews. The function runs when the human is on vacation. XFN: a board question triggers the metric pull, the analysis, and the draft narrative across teams end to end; the CoS reviews the finished memo. |
Some teams implement AI from a centrally owned department. My bias is toward a PLG-style Hub & Spoke model, where AI foundations are centrally owned (governance, core KPIs, seeing the company as a product) and decentralized by department function (or “feature tracks”), where those closest to the use cases drive strategy and local integration for meaningful releases and a roll-up strategy. This unblocks the most upstream bottleneck to growth: the workflows of employee behavior.
Types a question, reads the answer, goes back to working the way they already worked. AI is a side tab, not a workspace.
AI lives inside the work. Context goes in first — Cowork, the right MCP, the relevant docs. Something the team actually uses comes out.
Builds agents that run while you're in other meetings. Teammates rely on the things you ship. Humans hit approve more often than author.
Software is cheap. You ship the tool your team needs this week — in production by Thursday.
Stopped building tools. Started building systems. The company moves differently because of what you ship. XFN: the systems you build stop respecting team lines. An agent picks up a workflow that used to belong to another function and runs it to a finished result you just review.
These are things people build at each level — read your own to see what finished looks like from here, or the one above to see where it goes. Every project names the gate that makes it impossible a level down. Function-specific ones follow below.
Take one term or acronym from a recent meeting you did not fully follow. Ask for it three ways — to a new starter, to a sceptic, in one sentence — and keep the version that finally landed.
This is the L0 gate itself: a real work task, and one kept output that beat what you would have written alone. It needs nothing saved, nothing connected and nobody else, which is exactly why it sits below L1.
Take something you finished last week, ask two different tools for their version, and write down the three places each one was wrong about your work.
L0 is discovering what AI is good at and where its limits are, so the deliverable is the note about the limits — not the draft. Nothing here outlives the session, which is the difference from L1, where the learning gets written somewhere the AI reads it back.
Paste your raw notes from one meeting and get back decisions, owners and open questions in a shape you can send to the people who were in the room.
The first time your own material goes in rather than a generic question, and the first output someone else reads. It is still one meeting, pasted by hand: no saved context and no connection to where the notes live, so the Personal OS gate is untouched.
Write down every recurring task in your own role, then mark the three with a repeatable shape and a small blast radius. That list is the deliverable.
L0's climbing actions are finding one real example in your own role and naming the permission moment. The list is what makes the L1 work choosable instead of arbitrary, and it is the one project here that produces nothing an AI wrote.
One page the AI loads every session: your role, the projects you are on, the standards your work is held to, and how you want responses shaped. Saved where it is read automatically rather than pasted in.
This is the first half of the Personal OS gate, verbatim. Above L0 because the context persists without you retyping it; below L2 because you are the only person it improves — the Team OS gate asks for someone else's output to change.
Wire the AI to the place your work actually lives — the document store, your mail and calendar, the customer record, the warehouse — so it answers from your files instead of from what you remembered to paste.
The second half of the Personal OS gate. It stays L1 because the access is yours alone and the material behind it is organised for you: nothing about it is discoverable by a teammate, which is the whole of the L2 gate.
Five tuned prompts with the context each one needs already in them — the status update, the meeting recap, the requirements note, the customer reply, the weekly plan — kept somewhere you actually open.
A personal prompt library is an L1 action item, and the test at this level is that you reuse them. It is not L2 for one reason: they are yours. Nobody can find them, and nobody's work breaks if you delete them.
Pick the thing you write every week. Produce it once with your context loaded and once without, keep both, and write the short note on what the context changed.
The Personal OS gate asks you to name one output in the last fortnight that was measurably better because the context was loaded. This project's deliverable is that evidence, which is why it only exists once the context file does.
A single clean page with who you are, what you do and how to reach you, built and published in an afternoon. No template subscription and no page builder.
It is past L0 because the artifact outlives the session — L0's gate is one kept output, and a published page is a thing you keep editing. It stops short of L2 because nobody else touches it: no shared context, no connected system, nothing a teammate could pick up.
Point it at an exported statement and get back a page that groups the spending by category and lets you click into a month. Re-runnable when you export again.
The L1 gate is a system you can run twice without rebuilding it. Doing this once by hand is an L0 output; the version that takes next month's export without you re-explaining the categories is the L1 one. It is not L2 because the file still arrives by hand.
One place holding what everyone re-explains: how the team names things, who owns what, the last few decisions, the live numbers, the templates. Structured so the AI reads it directly and anyone can ask a question and get an answer rooted in it.
The Team OS gate is someone else pulling context out of this without being told it was there, and that is only possible once the knowledge is shared and readable by the tool. A personal context file cannot clear it at any level of polish, because the gate is about a colleague's output.
Write down the twenty questions a new joiner asks a human in their first fortnight, answer them in the shared knowledge base, and point the AI at it.
L2's own test is whether a new hire has the same context as a multi-year veteran. Someone you have never met getting a right answer without you in the room is the gate; at L1 that context lives in your head and your own files.
A standing brief — the weekly team note, the account summary, the project status — built from the actual systems rather than your clipboard, and posted where the team already reads.
No more copy-paste context is the defining L2 behaviour, and this one is written for the team rather than for you. It stops short of L3 on purpose: you still press the button, so nothing has run unattended.
Take the document your team keeps rebuilding from scratch and ship it as a template with the context and the prompt already inside, saved where they look first.
Shipping a shared file, template or bot the team reaches for without thinking is an L2 action item. It clears L1 because someone else's output now depends on it, and it is not yet L3 because it is one artifact, not a library of skills teammates run unprompted.
One page each morning that pulls from the feeds, newsletters and channels you actually read, summarises what is new, and says what changed since yesterday rather than restating everything.
It cannot exist without a live connection to a real source, which is exactly the L2 gate — an L1 version means pasting links in every morning, and that is the thing this removes. It is not L3 because it serves one reader and nobody else runs it.
The three requests you get more than twice a month, written up as reusable skills with their inputs, their steps and their definition of done, in one place the team can find.
The Function OS gate asks for three shared skills teammates reach for unprompted, and for you to name them without looking. One shared template is L2; a named, maintained set that other people run without asking you is L3.
A workflow that pulls from one system and writes to another on its own — the tracker into the deck, the shared inbox into the queue, the warehouse into the channel — with no step where a human carries the output across.
Chaining two tools end to end with no copy-paste is written into the L3 gate. At L2 the context flows in but you still carry the result out by hand, which is the exact step this removes.
Take the recurring report you assemble by hand, put it on a schedule or a trigger, route the result to where people already read, and let it run a fortnight without being watched.
The gate wants one skill that has run seven days or more unattended. That forces a written definition of what a clean run looks like, which an L2 brief never needs because a human reads every one before it goes out.
The single-purpose app your team needs and nobody will fund: a request queue, an intake form that routes itself, a view joining the two systems people keep open side by side. Built with AI, in production, owned by you.
One bespoke internal app or dashboard built primarily by AI is a clause of the L3 gate. It cannot happen at L2, where the output of the work is documents and context; here the output is software other people log into.
The handful of things you explain from scratch every week, each written down once as a one-line command with the steps, the format and the checks inside it. You type the name; it does the rest.
The L3 gate is a teammate using something you built, and a named command is the smallest unit that survives being handed over. An L2 saved prompt still needs you in the room to explain it; this is the version someone else can run cold.
Everything the team keeps re-reading — decisions, past answers, the good examples — indexed so a question gets a sourced answer instead of a search result, and so a new starter can ask it before asking a person.
It clears L3 because its value is measured in other people's use: the test is a colleague querying it without being told it exists. An L2 version is the same content in a folder only you navigate.
The workflow that dies in the gap between functions — request to build to sign-off, enquiry to onboarding, incident to fix to notice — rebuilt as a system that carries the work across the boundary and only stops for a decision.
The Agent OS gate is a system felt by two functions outside your own. An L3 chain stays inside your team and only has to satisfy your standards; this one has to carry two other teams' definitions of done, which is what makes it a different build rather than a bigger one.
Take your highest-volume recurring output, add a second agent whose only job is checking the first against a written pass or fail standard, and stop reviewing the output once the standard holds.
The other half of the gate is stopping touching outputs on a major workflow, which needs an eval rather than an automation. At L3 the skill runs unattended but you still approve what it produced — the review is the thing being removed here.
Rebuild your own week so recurring work arrives finished and sorted — drafted, checked, and flagged where it genuinely needs judgment — and your day opens on decisions rather than production.
L4's usage signal is spending most of your time refining systems rather than producing the outputs they make. It is unreachable at L3, where the skills exist but run when somebody remembers, so the queue is never full when you arrive.
A standing review of everything you have shipped: what ran, what nobody opened, what gets deleted this quarter, and what the deletion tells you about the next build.
L4 names a retire rate — how often you delete a tool that did not earn its keep — and a rate needs a portfolio to be a rate. At L3 you own a handful of skills you can still hold in your head, so there is nothing to audit.
Give it the question and what a finished answer looks like. It plans the steps, gathers across connected sources, and leaves a structured brief with its sources shown — no prompt per step.
L4 is the outcome-and-test handoff: you set what done means, not the sequence. An L3 version is a skill you drive through each stage; this one decides its own stages and you read the result. It is not L5 because it serves your question, not another function's work.
Take an existing automation that can only follow rules and give it the one step it cannot do — read this and decide which way it goes, summarise this well enough to route it, flag the exception a rule would miss.
The gate is a system two other functions feel, and a routing decision changes what lands in someone else's queue. At L3 the automation still hands every judgment call back to a person; here the call is made and only the edge cases surface.
Take the cross-team system you own and design out the places it needs you: a written escalation, a fallback path, a named human for each decision it cannot make, and a log of what it did while you were away. Then take five consecutive days off and read the log.
This is the Company OS gate as a project. At L4 the systems run, but they run because you are watching them; the work here is specifically the removal of the watcher, and the log is the only artifact that can prove it.
Wire one system to keep its own knowledge and its own pass or fail threshold current: it notices what changed, revises what it reads, and records the change for a human to review after the fact rather than before.
The gate names one system that self-updated its context or eval threshold without you. Everywhere below L5 that maintenance is done by hand by whoever owns the system, which is the dependency this removes.
Find the three overlapping versions of the same workflow living in different teams, pick the one that stays, migrate the others onto it, and delete them.
Pruning and merging overlapping systems across teams is an L5 action, and it requires standing outside every team involved. At L4 you can only retire your own tools — nobody has asked you to switch theirs off.
Hand one of your systems to someone in another team to run and to change — their context, their thresholds, their release notes. Your job becomes answering questions about it, not operating it.
L5 is compounding that does not depend on you, and the gate's week off is not passable while every system has exactly one person who understands it. Handing over the operating role, not just the output, is the move L4 never has to make.
Narrower than the set above: these are levelled against the same gates, but written for one function rather than for anyone.
One page before every first conversation, assembled from the customer record, the last few calls and whatever anyone on the team wrote down — rather than from whoever last read the account end to end.
The context comes from the real systems rather than from a rep's clipboard, and it is written once for everyone who touches the account. That is the L2 gate: the colleague covering your holiday pulls the brief without being told it exists.
A system that watches the deal record and the conversation history, raises the deals going quiet, drafts the specific next step, and routes anything that needs another team straight to that team.
It is felt outside sales — marketing and delivery both receive work from it — and the rep stops producing the flag list at all. Both halves of the Agent OS gate. An L3 version tells you which deals to look at; this one moves the work.
Approved claims, the phrasing to avoid, and real examples of how the brand sounds, in the shared knowledge base and readable by the tool — so a first draft starts inside the guardrails instead of being pulled back into them.
L2 is where one person's learning reaches the whole team. Someone drafting on a Tuesday inherits your voice work without asking you for it, which is the gate; the same file kept privately is an L1 context file.
The brief landing in the tracker triggers first drafts of the whole asset set — headline options, the long form, the mail, the short cuts — into the shared workspace, ready to be edited rather than started.
It chains the tracker to the workspace with no copy-paste in the middle, and it is a skill the team runs rather than a document they open. Both are L3 gate clauses. At L2 the brief is better fed; here it triggers the work.
Conventions, how tests are named, the deploy path, and the things that look wrong and are not — held where the tool reads it every session and reaches the code directly instead of through pasted snippets.
Persistent context plus a live connection to one real system is the Personal OS gate. It is L1 and not L2 because it describes one service to one person: nobody else's pull request is different because it exists.
It takes the report, reproduces it, drafts the fix and the regression test, and hands a reviewer a decision. It starts when the report arrives, not when someone remembers to look.
Support and product feel this, not just engineering, and the fix stops being an output you author. The L3 version drafts the pull request when you ask; the Agent OS gate is the run you no longer touch.
Every call, ticket and complaint in one place the AI can search, so a question about demand gets answered from the record instead of from whoever has been here longest.
The gate is someone else pulling from it unprompted — a colleague building a case for the quarter finds the evidence without coming to you. Held in your own notes it is L1; held where the team's questions land, it is L2.
A packaged skill that turns a problem statement into a spec with the sections your team argues about already filled in: the decision, the scope cut, the open questions, and how you will know it worked.
A named shared skill teammates reach for unprompted is the first clause of the Function OS gate. A template is L2 because it still has to be filled in by hand; a skill is L3 because it runs.
Every metric with its definition, its source table, its owner and its known caveats, in one place the tool reads before it writes a query.
It clears the Team OS gate two ways: the schema stops being pasted in, and an analyst on an unrelated question pulls a definition into their own work without being told the dictionary is there.
The sanity checks someone runs by hand, on a schedule: which passed, which moved further than the threshold, and which source did not arrive at all — named, so a check that failed to run shows up as missing rather than as a pass.
A skill on a schedule that runs unattended is the L3 gate clause, and it forces a written definition of a clean run. Run by hand each Monday it is an L2 brief; the level is in the unattended week, not in the queries.
The recurring meetings, the papers each one needs, and the open items you are carrying, assembled the evening before from your own calendar and mail rather than from memory.
Personal OS: a connection to one real system, plus the standing description of what a good pack looks like. It stays L1 because it is your week — nobody else's preparation changes if you stop.
The review pack — the numbers, the draft commentary, the risk flags — pulled from each function's own systems with the gaps named out loud, so the time goes into the narrative rather than the assembly.
It reads from every function's systems and returns something each of them uses, which is the two-functions-outside-your-own half of the Agent OS gate. And the pack stops being produced by hand, which is the other half.
