As I work with companies on their AI adoption, the question I keep coming back to is: what happens when these workflows actually start running at scale? What new failure modes appear when you remove the natural friction that human processes used to provide? How do humans set boundaries for systems that operate continuously? These are new questions. We don't have good answers yet.
I put together a 4-Level AI Adoption Framework to help organizations figure out where they are and what the path forward looks like.
Level 1: Ad Hoc Assistants
This is where most teams start. Individual contributors use chat UIs (like ChatGPT or Claude) and occasional IDE autocomplete to speed up their personal workflows.
- What work looks like: Humans draft, summarize, and research using AI, but they still have to manually stitch the outputs into the actual work. It's a stop-start process.
- Governance: Minimal. There might be a vague policy about not sharing secrets, but there is little to no logging, and the value is mostly anecdotal.
Level 2: Standardized Copilots
At this level, teams begin to standardize AI usage. Organizations adopt enterprise-grade IDE copilots, repo-aware or doc-aware workspaces, and shared prompt libraries.
- What work looks like: AI helps with whole modules, consistent meeting notes, and code reviews. However, humans still drive the workflow and make all decisions.
- Governance: Basic controls are in place (approved tools, PII rules). Companies start measuring adoption and time saved, implementing lightweight quality rubrics.
Level 3: Integrated Supervised Agents
This is the inflection point where AI connects directly to your systems of record. Agents have bounded, multi-step execution capabilities from end to end, gated by human supervision. This is no longer theoretical. Tools like Claude Code, Cursor with MCP servers, and purpose-built agentic frameworks have made this level operational for early adopters today.
- What work looks like: Agents triage support tickets and draft CRM updates. They create pull requests, run tests, and prepare release checklists. Humans are no longer stitching work together. Instead, they approve merges, deploys, and customer-impact actions.
- Governance: Strong controls are required here. This means access scopes, comprehensive logging, evaluations, monitoring, and rollback capabilities. Organizations track outcome metrics like cycle time, error deflection, and lift.
Level 4: Agentic Operating Model (Aspirational)
This is a fundamentally different way of running a company. Agents don't wait for instructions. They operate like cross-functional teams, running continuously via queues and event-driven triggers. Humans set objectives and constraints, step in for exceptions, and manage the relationships that still require a human touch. The org chart looks nothing like what we have today.
- What work looks like: It's no longer "human request → AI action → stop." It's a continuous intake from data streams. Agents plan, execute, verify, document, and reprioritize in a continuous loop. Humans only step in for exceptions.
- Governance: Strict, bounded authority using the principle of least privilege, spend limits, and communication guardrails. Fully automated checks, agent-owned outcome KPIs, and clear escalation paths.
Framework Summary
| Level | What It Is | Typical Tools | Work Looks Like | Governance |
|---|---|---|---|---|
| 1: Ad Hoc Assistants | Individual, one-off AI help. No durable integration. | Chat UI in browser, occasional IDE autocomplete, manual copy/paste | Drafts, summaries, quick research. Humans stitch outputs into real work. | Minimal policy. Little logging. Value mostly anecdotal. |
| 2: Standardized Copilots | Team-level standardization. Shared patterns and context. | IDE copilots, repo-aware workspaces, prompt/template libraries | Whole modules, consistent meeting notes, code review. Humans still drive workflow. | Approved tools, PII rules. Measuring adoption and time saved. |
| 3: Integrated Supervised Agents | AI connected to systems of record. Bounded multi-step execution with human gates. | Tool calling via APIs, Jira/CRM/GitHub integrations, CI/CD hooks, MCP servers | Agent triages tickets, creates PRs, runs tests. Humans approve merges and deploys. | Access scopes, logging, evals, monitoring, rollback. Outcome metrics. |
| 4: Agentic Operating Model | Agents as cross-functional teams. Continuous operation via queues and triggers. | Multi-agent orchestration, durable task queues, event-driven triggers, verification pipelines | Continuous intake from streams. Plan/execute/verify/document loops. Exception-only human involvement. | Least privilege, spend limits, audit trails, agent-owned KPIs, kill switches. |
The Paradigm Shift in Product Building
As teams reach Level 3, the build bottleneck disappears. Discovery, specification, and QA become the hard part. Without a team of developers to push back on fuzzy requirements, the ability to deeply understand the customer and define a well-formed solution is what separates the winners. You may not need a large development team anymore. You may need a strong technical lead and much sharper product thinking.
The jump from Level 3 to Level 4 is the hardest. It's not a tools problem. It's an organizational design problem. Moving from "agents do tasks humans approve" to "agents run the operation continuously" requires rethinking reporting structures, accountability, and what people actually do all day. Nobody has solved this yet. That's what makes it interesting.
The Unsolved Question
I've spent my career at the intersection of technology transitions and organizational change. One pattern I've seen consistently: governance lags technology adoption. The tools arrive, teams start using them, value gets created, and then the failure modes emerge that nobody anticipated. The governance layer always takes longer to build than the technology itself.
We're at that inflection point now with AI-native operations. The opportunity is real and the speed advantage will compound. But we don't yet understand the pitfalls that appear when organizations operate this way. What breaks when you remove the natural friction of human-speed processes? How do leaders set guidelines for systems that evolve faster than they can review? What does accountability look like when agents make thousands of small decisions per day?
The companies that win won't just be the fastest adopters. They'll be the ones that figure out how humans guide, supervise, and course-correct organizations that run at machine speed. This is what I'm spending my time on right now.
