The MAD Podcast with Matt Turck Watch original video

Levie Enterprise AI Diffusion Framework

Last updated: 31 May 2026

Map the real barriers slowing AI deployment inside a large enterprise and produce a sequenced action plan that accounts for token costs, data readiness, access controls, and the internal FTE motion — so your rollout survives the next model breakthrough.

// TL;DR

The Levie Enterprise AI Diffusion Framework is a sequenced playbook for moving agentic AI from demo to production inside a large enterprise. It maps the real barriers — token costs, data readiness, access controls, model selection, and the Internal FTE motion — so your rollout survives the next model breakthrough. Use it when planning, auditing, or accelerating an agentic deployment in a mid-to-large organization, or when advising a startup on where to compete in the enterprise AI stack. Trigger it any time you need to close the gap between 'the technology works in a demo' and 'the technology runs in production across the org.'

Framework

// When should you use the Levie Enterprise AI Diffusion Framework?

Use this skill when planning, auditing, or accelerating an agentic AI deployment inside a mid-to-large enterprise, or when advising a startup on where to compete in the enterprise AI stack. Trigger it any time the gap between 'the technology works in a demo' and 'the technology is running in production across the org' needs to be closed.

// What information do you need before applying the framework?

Organization typerequired
Size and industry of the enterprise (e.g. Global 2000 financial services firm, mid-market manufacturer). Determines change-management complexity and regulatory exposure.
Current AI maturity stagerequired
Where the org sits today: chat deployment, early agent pilots, or scaled agentic workflows. Use Levie's three-stage arc: Chat → Agent Pilots → Stateful Agentic Work.
Target use caserequired
The specific workflow or function the agent should improve (e.g. client onboarding, contract review, demand-gen campaigns, code delivery).
Existing data environmentrequired
How data is stored, how many systems hold it, and the current state of access controls and entitlements. Flag redundancy, shadow data stores, and undefined ownership.
Token budget visibilityrequired
Whether the org has any current mechanism to track, attribute, or cap AI compute spend by team or task. Can be 'none', 'partial', or 'FinOps-grade'.
Internal technical talent
Availability of people who can serve as Internal FTEs — technically fluent staff who can sit inside a business unit and wire up agentic workflows. Headcount estimate is fine.
Vendor/model landscape in play
Which models, platforms, and SaaS tools are currently being evaluated or deployed (e.g. Copilot, Claude, Cursor, Codeex, Salesforce MCP). Used to assess architecture lock-in risk.

// What are the core principles behind enterprise AI diffusion?

The Bridge Imperative

The enterprise AI job is never just 'deploy the best model' — it is to bridge super-advanced technology breakthroughs to real-world business workflows. Every decision should be evaluated against how well it closes that gap for the specific organization, not how impressive the underlying capability is.

Capability Overhang Paradox

Continuous model breakthroughs make prior implementations obsolete faster than enterprises can standardize on them. This means the rollout takes longer, not shorter, the better the technology gets. Assume no stable architecture target; design for replaceability from day one.

The Chat-to-Agent Jump

Chat AI (ask a question, get an answer) has a productivity ceiling rate-limited by human conversation speed. Agentic AI (stateful, autonomous task execution) is a categorically different deployment problem — it touches permissions, data integrity, cost modeling, and change management in ways chat never did. Do not extrapolate chat rollout lessons directly to agents.

Tokenmaxxing vs. Token Budgeting

Silicon Valley engineering culture optimizes for maximum token consumption to extract maximum capability (tokenmaxxing). Enterprise buyers are blindsided by the resulting bills. The right frame is not 'subsidization ending' but 'a fundamentally different cost model for a fundamentally more powerful tool' — and enterprises need new FinOps muscle to manage it.

The Data Problem Is the Agent Problem

Most agentic failures are inversions of data failures: the agent has access to too much (and roams into wrong answers), too little (and stalls), or incorrectly defined data (and returns results that are confidently wrong). Fix the data layer before scaling the agent layer.

Coding Is Not a Template for Knowledge Work

AI coding agents succeed because users are technical, models are hyper-trained on code, outputs are verifiably correct, context lives in the codebase, and access controls are clean. None of those conditions hold in general knowledge work. Do not use coding productivity gains as a benchmark for legal, marketing, finance, or operations rollouts.

Headless + Seated Dual Model

Software does not go fully headless. By volume, agents will hit systems far more than humans ever did — but humans still need the graphical interface for complex, nuanced, or high-leverage tasks. Enterprise software will carry both a seat-based model (end-user component) and a consumption-based model (agentic operations). Design for both.

Jevons Paradox as Job Protection

When AI makes a capability cheaper or faster, demand for that capability expands — often creating more jobs than it eliminates. A designer empowered by agents enables companies that never had a designer to hire one. Model this dynamic before forecasting headcount reduction in any function.

The Internal FTE Motion

Successful agentic deployment requires a dedicated class of technical employees — Internal FTEs — embedded inside business units. Their job is to understand the workflow, wire up the data and agent correctly, manage human-in-the-loop checkpoints, and re-optimize every time the underlying model changes. This is not a one-time implementation; it is a sustaining role.

Mosaic of Models

No enterprise should route all workloads to the frontier model. Apply frontier capability (e.g. GPT-5-class, Opus-class) to high-complexity, unsaturated tasks. Once a task becomes reliably executable, peel it off to a lower-cost or open-source model. The average enterprise will run half a dozen models — plan the mosaic deliberately.

// How do you apply the Levie framework step by step?

1
Locate the organization on the Chat-to-Agent arc
Determine whether the org is still rolling out the chat system, running agent pilots, or attempting scaled stateful agentic work. Most Global 2000 companies are between stages one and two. Do not skip this — it sets the change-management scope. If they haven't finished chat rollout, agents will create whiplash, not productivity.
2
Audit the data environment for agent-readiness
Identify every system holding data the target use case needs. Flag: (a) redundant or ungoverned stores, (b) inconsistent metric definitions (e.g. FX-adjusted vs. unadjusted revenue), (c) access control gaps — accounts with too much or too little entitlement. The agent will expose all of these in production. Treat this as a blocking prerequisite, not a parallel track.
3
Map access controls and entitlements explicitly
For every data source the agent will touch, define who (and which agents) should have access at what permission level. Agents with excess access will return answers using data they shouldn't have; agents with insufficient access will stall. Unlike human knowledge workers, an agent cannot intuitively ask Bob for the right table — it will either fail silently or produce a confident wrong answer.
4
Define the token budget and cost attribution model
Establish before deployment: (a) which budget owns AI compute — IT or line-of-business; (b) how cost is attributed per task, team, and workflow; (c) what the ceiling per query or per agent run is. If no FinOps tooling exists for AI compute, treat that as a startup opportunity internally or procure a vendor. Warn the CFO and CMO before the first bill arrives — the 'uncomfortable acceptance surprise' is worse if it's actually a surprise.
5
Select the right model tier for the specific task (build the Mosaic of Models)
Do not default to the frontier model for every workload. Evaluate: Is this task high-complexity and unsaturated (use frontier)? Or is it a reliably executable, repeating task (peel to lower-cost or OSS model)? For tasks with locked regulatory accountability (e.g. contract execution, drug approval), budget for a human-in-the-loop final review regardless of model capability — the last mile will not be automated yet.
6
Identify or hire Internal FTEs and embed them in the target business unit
Internal FTEs are not IT generalists — they are technically fluent staff who understand the business workflow deeply enough to wire up agents correctly and re-optimize when models change. Sourcing options: reposition existing software engineers, hire from CS programs, or contract External FTEs from SI or vendor partners initially. Do not attempt scaled agentic deployment without this role in place; the blast radius of a misconfigured agent in a knowledge-work context is significantly larger than in coding.
7
Instrument the workflow for ROI measurement before launch
No current standard tooling exists for measuring per-token ROI. Before go-live, define: what output metric proves the agent created value (e.g. contracts reviewed per hour, onboarding time, campaign variants tested)? Establish a baseline. Without this, the finance team will cut the budget at the first large bill and the line-of-business owner will have no defense. This measurement layer is also what eventually justifies shifting AI spend from the IT budget to line-of-business OpEx.
8
Design for architecture replaceability, not architecture lock-in
Given the Capability Overhang Paradox, any architecture chosen today may be obsoleted by the next model breakthrough. Avoid multi-year vendor lock-in (no enterprise should sign more than one-year deals with labs currently). Build abstraction layers between the agent orchestration layer and the model layer so that swapping models does not require rebuilding the data plumbing and workflow wiring.
9
Design the headless + seated interface split for the target software
Determine which tasks agents will perform headlessly (high-volume, deterministic, data-retrieval-heavy) versus which tasks humans will still perform via GUI (complex, nuanced, high-leverage). Plan the consumption-based pricing model for headless agent operations and the seat-based model for end-user access. If the software vendor has an API-first architecture, headless integration is lower lift — verify this early.
10
Launch a human-in-the-loop pilot with change management built in
Start with a constrained workflow, a defined Internal FTE owner, a token budget ceiling, and explicit human review checkpoints. Track the five coding-vs-knowledge-work differentiators: user technical fluency, context completeness, output verifiability, access control cleanliness, and error recovery capability. Use pilot findings to scope the full rollout — do not extrapolate from coding benchmarks.
11
Run a Jevons Paradox audit on headcount assumptions
Before publishing any headcount reduction forecast, map the demand-expansion effect: which functions, if made 5x more productive, would unlock projects the org couldn't previously staff? Which small businesses or departments would now hire into a function for the first time? Net the expansion against the compression to get a realistic talent plan. Share this analysis with HR and the board before any public statements about AI and jobs.

// What does the framework look like in real enterprise scenarios?

A Global 2000 financial services firm wants to deploy an agent to handle client onboarding document review across 50 markets.

Start at step 2: the data environment almost certainly has documents stored in 5+ systems with inconsistent entitlements. Step 3 will surface that relationship managers have either too much or too little access to counterparty data. Step 5 dictates: use a frontier model for initial risk-flagging, but once flagging patterns stabilize, peel the repeating classification tasks to a lower-cost model. Step 6 is critical — embed an Internal FTE in the onboarding operations team, not in central IT. Step 7 measures cycle time and exception rate before and after. The last-mile compliance sign-off (step 5 note) remains with a human reviewer; the agent accelerates the review, not the final judgment.

A mid-market manufacturing company wants to use agents to accelerate marketing campaign production — a function they've historically understaffed.

This is a Jevons Paradox opportunity (principle 8). The company has one marketing generalist. An agent-empowered generalist can now test five times the campaign ideas. The correct output of the pilot is not headcount reduction — it is a business case to hire a dedicated marketing person to manage the agent workflows at scale. Steps 4 and 7 are the crux: the marketing budget is not accustomed to FinOps-style compute tracking, so token cost attribution must be set up before launch. The headless + seated split (step 9) means the agent runs campaign generation headlessly, but the generalist still uses a GUI to review, approve, and distribute creative assets.

A startup is deciding whether to build a vertical AI application for legal contract workflows or whether the labs will make that layer obsolete.

Apply the Bridge Imperative: the labs cannot simultaneously build deep vertical integration for every industry and every line of business. The startup's defensibility lives in the integration with client-specific data sets, the bespoke workflow wiring, the change management support, and the ongoing model-swap optimization (Capability Overhang Paradox means every model upgrade requires re-validation of the client's scaffolding). The startup should price on a hybrid seat + consumption model (principle 7), avoid over-indexing on any single lab (step 8: replaceability), and build Internal FTE support as a service offering for clients who don't have that talent in-house.

// What mistakes should you avoid when deploying agentic AI?

Treating the coding productivity benchmark as a template for knowledge-work agent deployment — the five structural conditions that make coding agents work (technical users, verifiable output, clean access controls, codebase context, fast error recovery) do not exist in legal, marketing, finance, or operations.
Launching agents before fixing the data environment — agents with access to ungoverned, redundant, or inconsistently defined data will produce confidently wrong answers at scale, destroying trust faster than the pilot builds it.
Absorbing AI compute costs inside the IT budget indefinitely — this caps AI investment at 3-7% of revenue and prevents the line-of-business productivity gains from scaling. Plan the budget migration to line-of-business OpEx from day one.
Signing multi-year architecture commitments with any single lab or orchestration platform — the Capability Overhang Paradox guarantees the next breakthrough will make the current reference architecture look suboptimal within 12-18 months.
Assuming the chat system rollout lessons transfer directly to agentic deployment — chat had no meaningful permission problem and a contained blast radius; agents connected to MCP servers and enterprise data stores have neither.
Forecasting headcount reduction without running the Jevons Paradox audit — demand expansion from AI-enabled productivity routinely exceeds the compression effect in organizations that are not already at saturation in that function.
Deploying agents without Internal FTEs embedded in the business unit — central IT cannot wire up domain-specific workflows effectively; the Internal FTE role is not optional, it is the diffusion mechanism.
Using only the frontier model for all workloads — the Mosaic of Models approach is both a cost imperative and an architecture best practice; routing everything to the Ferrari model is a tokenmaxxing pattern that enterprise budgets cannot sustain.
Treating agentic rollout as a one-time implementation — every model upgrade requires the Internal FTE to re-validate scaffolding, re-test outputs, and potentially redesign workflows; build ongoing iteration into the operating model from the start.
Conflating headless software with the elimination of GUIs — the dual model (headless consumption + seated end-user) is the stable endpoint, not a full transition to text-based interaction for all enterprise work.

// What key terms do you need to know for enterprise AI deployment?

Tokenmaxxing: The Silicon Valley engineering practice of maximizing token consumption to extract maximum model capability — the cultural opposite of the enterprise budget constraint mindset, where unexpected token bills are a top-three barrier to AI deployment.
Capability Overhang: The condition where model breakthroughs arrive faster than enterprises can implement a stable reference architecture, causing each new breakthrough to make the prior implementation obsolete and paradoxically extending the total rollout timeline.
The Chat-to-Agent Arc: Levie's three-stage model of enterprise AI maturity: (1) Chat — ask a question, get an answer, productivity rate-limited by human conversation speed; (2) Agent Pilots — early agentic task execution; (3) Stateful Agentic Work — agents running continuously in workflows, kicking off autonomously, producing real work at scale.
Headless Software: Enterprise software accessed entirely via API or agentic interface, with no human interacting through a graphical user interface. Levie's view is that headless consumption will vastly exceed human-seated usage by volume, but will coexist with — not replace — the GUI for end-user tasks.
Internal FTE: A technically fluent employee embedded inside a business unit (not central IT) whose job is to understand the domain workflow, wire up agentic systems correctly, manage human-in-the-loop checkpoints, and re-optimize when models change. A sustaining role, not a one-time implementation resource.
External FTE: Technical talent deployed by a vendor, systems integrator, or AI startup on-premise at the customer to make agentic deployments work — the enterprise-facing equivalent of the Internal FTE, typically used while the customer builds internal capability.
Mosaic of Models: The enterprise model portfolio strategy in which different AI models (frontier, mid-tier, OSS) are assigned to different tasks based on capability requirements and cost profiles, rather than routing all workloads to a single frontier model.
Token Budget: The compute cost ceiling assigned to an AI task, team, or workflow — the enterprise analog of a cloud FinOps budget. Currently a critical missing capability in most enterprise AI deployments, with no standard tooling or best practices.
The Data Problem: Levie's framing that most agentic failures are fundamentally data failures: agents have access to too much (wrong answers), too little (stalls), or incorrectly defined data (confidently wrong answers). The data layer must be fixed before the agent layer can scale.
Blast Radius: The scope of damage a misconfigured or over-permissioned agent can cause in an enterprise environment — used by Levie to contrast the contained risk of chat AI with the much larger systemic risk of agents connected to live enterprise systems via MCP servers and APIs.
Jevons Paradox: The economic principle — applied by Levie to AI and jobs — that making a resource or capability cheaper increases total demand for it, often creating more consumption and more associated jobs than existed before. Used to argue that AI productivity gains expand hiring demand rather than simply eliminating roles.
AI Psychosis Period: Levie's term for the phase many power users go through — intense weekend-long building sessions, euphoria about AI capability — before arriving at a sober understanding of the maintenance burden, error-catching overhead, and enterprise deployment constraints that follow the initial demo high.
Seat + Consumption Dual Model: The business model Levie predicts all enterprise software will converge on: a seat-based pricing tier for end-user (human) access, and a consumption-based pricing tier for headless agentic operations. The relative size of each tier will vary by software category.

// FREQUENTLY ASKED QUESTIONS

What is the Levie Enterprise AI Diffusion Framework?

It's a sequenced action plan for deploying agentic AI inside a large enterprise, based on Aaron Levie's analysis of what actually slows rollouts. It accounts for token costs, data readiness, access controls, model selection, and the internal talent (Internal FTE) motion needed to wire up and maintain agents as models keep improving.

What is tokenmaxxing and why does it matter for enterprise AI?

Tokenmaxxing is the Silicon Valley engineering practice of maximizing token consumption to extract maximum model capability. It matters because enterprise buyers get blindsided by the resulting bills. The right frame isn't 'subsidies ending' — it's a fundamentally different cost model for a more powerful tool, requiring new FinOps muscle to track, attribute, and cap AI compute spend.

How do I know if my organization is ready to deploy AI agents?

Locate your org on the Chat-to-Agent arc first: finished chat rollout, running agent pilots, or scaling stateful agentic work. Most Global 2000 firms sit between stages one and two. Then audit your data environment for redundancy, inconsistent metric definitions, and access-control gaps. If chat rollout isn't finished or data is ungoverned, agents will create whiplash, not productivity.

How do I control AI token costs before the first bill arrives?

Define a token budget and cost-attribution model before deployment: decide which budget owns AI compute (IT or line-of-business), how cost is attributed per task and team, and what the ceiling per query or agent run is. Warn the CFO and CMO early — the 'uncomfortable acceptance surprise' is far worse if the bill is an actual surprise.

How does this framework compare to just deploying the best AI model?

Deploying the best model is the easy 10%; the framework handles the hard 90%. Levie's Bridge Imperative says the job is connecting breakthrough technology to real workflows, not showcasing capability. It forces you to fix data, map entitlements, budget tokens, embed Internal FTEs, and design for model replaceability — none of which a 'best model' mindset addresses.

When should I use the Levie framework instead of a standard IT project plan?

Use it whenever you're moving beyond chat into agentic, stateful AI that touches live enterprise data. Standard IT plans assume a stable architecture target; agents don't have one because of the Capability Overhang Paradox. Use the framework when permissions, data integrity, cost modeling, and change management all intersect — conditions chat rollouts never faced.

What results can I expect from applying this framework?

A sequenced rollout that survives model breakthroughs: instrumented ROI measurement, a defensible token budget, clean access controls, the right model tier per task, and embedded Internal FTEs who re-optimize as models change. You get fewer confidently-wrong agent outputs, controlled compute spend, and a realistic headcount plan that accounts for Jevons Paradox demand expansion.

Why can't I use AI coding agent success as a model for other functions?

Because coding agents succeed on five structural conditions that don't hold elsewhere: technical users, hyper-trained code models, verifiable outputs, context living in the codebase, and clean access controls. Legal, marketing, finance, and operations lack most of these. Extrapolating coding productivity gains to knowledge work sets false expectations and misjudges the blast radius of errors.

What is an Internal FTE in agentic AI deployment?

An Internal FTE is a technically fluent employee embedded inside a business unit — not central IT — who understands the domain workflow, wires up agents correctly, manages human-in-the-loop checkpoints, and re-optimizes every time the underlying model changes. It's a sustaining role, not a one-time implementation, and it's the actual diffusion mechanism for agentic AI.

Does AI really eliminate jobs, or does it create them?

Levie applies Jevons Paradox: making a capability cheaper expands demand for it, often creating more jobs than it eliminates. A designer empowered by agents enables companies that never had a designer to hire one. Run a Jevons Paradox audit — net demand expansion against compression — before publishing any headcount reduction forecast.

What is the Mosaic of Models approach?

It's the enterprise strategy of routing different tasks to different models based on complexity and cost, rather than sending everything to the frontier model. Apply frontier capability to high-complexity, unsaturated tasks; once a task becomes reliably executable, peel it to a lower-cost or open-source model. The average enterprise will run about half a dozen models deliberately.

// GET THIS SKILL — FREE