AI Transformation Lab

This episode starts in a supermarket. In 1956, Taiichi Ohno saw shelves that were never piled high — restocked only as customers took what they needed. The customer pulled. The store replaced. That became just-in-time, the second pillar of the Toyota Production System.

A few episodes ago, we built an agent that knows when to stop. This time I want to tell you about the day one of our agents did exactly what we asked.


On its first morning, it drafted about two hundred credit-and-rebills in roughly twenty minutes. It worked perfectly. And it buried the team it was built to help. A rule that had been sitting quietly in the process turned a pile of drafts into a pile of rework overnight.


We didn't have an agent problem. We had a flow problem.


I get into what just-in-time actually means, why so much batching in knowledge work was a human constraint all along, and the idea I keep coming back to: in the age of agents, capacity isn't the constraint anymore. Human attention is. Flow the machine work. Level the human work.


I also share how the bottleneck moved once we fixed the first one, how we plan to take a review step away on evidence, and why a process can get faster and slower at the same time.


If you take one thing away: pace your agents to your people. Never pace your people to your agents.


This continues the Lean AI arc, following Setting True North.


I'm Chris Bradley, CMO at Veritiv and head of the AI Transformation Lab. Subscribe for new episodes biweekly.

Most companies are experimenting with agents. Few can say where it's going. Chris Bradley argues that the missing piece isn't better technology — it's direction, and a method for drawing the road from the work itself.

The episode opens on hoshin kanri, the Japanese practice documented by Bridgestone in 1965: leadership sets a fixed direction, and the people closest to the work discover the path. Lean calls that direction True North, and distinguishes two speeds of moving toward it — kaizen, continuous improvement, and kaikaku, radical change.

Bradley defines AI-native plainly: agents do the routine work end to end, and people spend their time on the decisions only people should make. He then shows how Veritiv is charting that path for open orders ahead of its next Kaizen. The team asked every open order why it hadn't moved and found that none of the stops raised an alarm, named an owner, or started a clock. The customer was the alarm. From there: a daily list for each person that doubles as the agent roadmap, three stages organized around who types and who decides, and a rule that no stage is reached by date — only by evidence.

He is clear that the future stages are a proposal, not a result. The episode closes with a five-step method listeners can apply to their own processes, and a distinction worth keeping: kaikaku describes how far you're going, and kaizen is how you get there.

Part of the Lean AI arc — following Kaizen + Agentic AI, The Nine Wastes of AI, Jidoka for Agents, and AI Standard Work.

Taiichi Ohno posted standard work sheets at every workstation, in the open, written by the operators themselves. He wasn't interested in whether people followed them. He was interested in how often they changed — because a standard that sat untouched meant the improvement engine had stopped. Frederick Taylor had standardized to prevent change. Ohno standardized to make it possible.

Chris Bradley argues that distinction now decides whether an enterprise AI program compounds or stalls. Ohno's rule was that without a standard there can be no kaizen. The AI version is stricter: you cannot automate a process that was never standardized, because there is nothing for the agent to execute. Most failed pilots, he suggests, are operations problems that AI happened to expose.

He describes what Veritiv found when it had to define order entry precisely for the first time — experienced people each holding a different sound method, none of it written anywhere — and what happened on a separate credit-and-rebill project where an agent was built to follow an existing procedure faithfully. The problems that surfaced weren't deviations. They were everything the document didn't say: which cost belongs on a line when two versions of the procedure disagree in the same numbered step, what to do when two systems contradict each other about whether an original order exists, and a documented remedy that turned out to be a checkbox the system won't let you click.

From there: why SOPs are structurally incomplete rather than carelessly written, why building an agent skill is really the act of converting tacit human competence into explicit standard work, and the governance question almost nobody has answered — when the business changes, who updates the agent?

The episode closes on the finding he didn't expect. The documentation turned out to be worth more than the automation.

Sakichi Toyoda's breakthrough was not a loom that could handle a broken thread. It was a loom that noticed the thread had broken and stopped itself — which meant one operator could run dozens of machines instead of standing guard over one. That principle became jidoka, and Chris Bradley argues it is the most useful idea available to anyone deploying AI agents in an enterprise today.

Veritiv's order entry agent was originally given the goal a person would have: complete the order. When it hit something ambiguous, it asked. That design turned every edge case into a round trip — ask, wait, answer, continue — and the waiting became the single biggest brake on adoption of the system.

The fix was not a smarter agent. It was a different goal. Book the order, provided nothing needs a human. Otherwise stop where you are, leave the work already done, and hand it back with a specific account of what stopped it.

Chris walks through what that change surfaced. How to define friction as needing a person rather than hitting a problem. Why the quality of the stop message decides whether work is removed or merely moved. The hard rule that facts come from the system and only tone comes from the model — earned after a message confidently reported inventory concerns on an order whose inventory was fine. And why the log of reasons an agent stops is not an error report but a prioritized improvement backlog, generated by the work itself.

The episode closes on the finding he did not anticipate: an agent that cannot compensate for inconsistent data becomes an instrument that shows you exactly where a process was never standardized — including the difficulty experienced people had been absorbing silently for years. Plus the discipline that keeps that instrument honest: two buckets, and no scorecard.

The vocabulary of agentic AI has turned over five times in about eighteen months — prompt engineering, context engineering, harness engineering, loop engineering, and now graph engineering. For a business leader, the reasonable reaction is to tune it out.

Chris Bradley argues the churn is hiding something worth understanding. Those terms don't replace each other; they stack. And each one names a layer of the same discovery: that the model is not what separates an AI program that works from one that doesn't.

He starts with the picture that makes the stack obvious — the brilliant new hire seated at a desk with no system logins, asked to process an order. From there he walks the context layer and its two halves, access and knowledge, and why grounded context is the highest-leverage way to reduce the verification burden that comes with confident, fluent, wrong output. Then the harness — the runnable environment around the model, and the reason Veritiv built its own for order processing across multiple ERPs and heavily customized systems, deliberately model-agnostic. Then the loop, where reliability actually comes from: what the agent checks its work against, what happens on failure, and when it stops. And finally the graph — coordinating many agents, which turns out to be an org design problem with familiar failure modes.

He closes with an escalation ladder for choosing the layer, a caution against re-platforming every time the field renames something, and the principle that holds as these systems get more elaborate: work distributes across nodes, accountability does not.

Most AI programs cannot prove they paid off. That is the trap this episode is built to help you avoid — a portfolio of pilots that all demo well, and nothing you can defend when the budget review comes.

Chris Bradley takes on the number that reset the enterprise AI conversation — a widely-cited MIT study finding 95% of pilots delivered no measurable return — and locates the real cause. Much of what is sold as agentic AI is generative AI wearing an agent title. It advises. A person still completes the work. And the promised time savings were never structurally possible.

His frame is two kinds of leverage. Decision leverage sharpens one person's judgment — real value, capped at one seat. Labor leverage completes operational work across the tens or hundreds of people who do it — order entry, financial operations — and that is where return becomes provable. He walks the two measurement instruments the Lab uses: the time study for labor value, and value stream mapping for the larger prize — revenue sitting in an order backlog, cash held up by credit-and-rebill delays, margin leaking one pricing error at a time.

He closes on the half of the equation leadership owns: directing freed capacity into growth and customer service — Efficiency AI funding Opportunity AI — and a four-move method for valuing any use case before anyone writes a business case.

Part of the Enterprise Transformation arc.

The cheapest AI model is often the most expensive. That is the trap this episode is built to help you avoid: sending routine work to a frontier model, or cheap work to a model that fails and hands the mess to a person, and paying for both mistakes on every run.

In this episode, Chris Bradley makes sense of a landscape that shifted fast in June and July. A new most-capable model. A family that ships in three deliberate sizes. And a wave of open-weight models from the US and China that companies can run inside their own walls. His frame for all of it is rightsizing: matching the model to the work the way a manager matches a person to a task. He sorts the work into three tiers, the Clerk for high-volume routine work, the Operator for the reliable execution that runs the business, and the Expert for the hard, high-stakes reasoning.

The heart of the episode is a single idea: stop comparing sticker prices. The number that matters is cost per success, total cost divided by the jobs actually completed. Chris explains how the Lab measures exactly that with VeritivBench, an internal framework that scores models against real recorded workflows rather than public leaderboards. Then he walks the two levers that make rightsizing real at scale, routing work to the right tier automatically and caching the context you reuse, and closes on tokenization, the hidden reason two models at the same price can leave you very different bills.

Part of the Enterprise Transformation arc.

For thirty years, build versus buy had a comfortable default: you bought. Agentic coding broke it. Building got cheap — a first version that took a quarter now takes days — while every vendor started baking AI into the products you already pay for. Both sides of the decision shifted at once, and the call got harder, not easier.

In this episode, Chris Bradley turns that call from a gut check into a decision you can defend. The move is a better question — not “build or buy?” but “how much orchestration does this work actually need?” That question sorts every AI decision into the Three Tiers of Agentic Orchestration. Tier one: work that lives inside a single app — buy the AI already there. Tier two: work that crosses standard systems — bridge them with an orchestration platform. Tier three: work that runs through your customized core, where the pre-built connectors run out — build it, with a custom agentic harness.

He walks each tier with real examples — including the order-processing harness Veritiv built, why buy couldn’t reach the customizations and bridge couldn’t connect what only they run, and how a small team got working versions in weeks, not quarters. Humans stay on the exceptions and the judgment calls; accountability stays with people.

Then the trap: lock-in. Buying an AI platform means adopting an entire AI operating system. Building means one non-negotiable — stay model-agnostic, so the layer that makes a model reliable also makes it replaceable. And the honest limit: the cost that collapsed is the cost of the first version, not the cost of ownership. The maintenance didn’t vanish. It moved downstream.

Buy the plumbing. Build the edge. And point the people you free toward the customer.

AI doesn’t remove waste — it just makes it faster, and often moves it somewhere you’re not looking. That’s the trap this episode is built to help you avoid: pointing a powerful agent at a process and accelerating every redundant, wasteful step inside it at machine speed.

In this episode, Chris Bradley borrows a seventy-year-old lens from the Toyota Production System and applies it to knowledge work. He walks the seven process wastes — waiting, inventory, handoffs, motion, defects, rework, and overprocessing — grouped into three families: work that waits, work that moves, and work that misfires. For each, he shows the same pattern: automate without redesign, and the agent preserves the waste, then relocates the cost downstream onto whoever has to sift through or correct the output.

Then he goes past the classic list. The eighth Lean waste — non-utilized talent — reframes the whole point: AI’s real payoff isn’t speed, it’s reclaiming the judgment and creativity the process had buried. And there’s a ninth the factory never had, because only AI could create it — verification, the new and quietly exhausting labor of checking work that reads exactly like the truth and isn’t. The Lean mnemonic DOWNTIME becomes DOWNTIME-V. He’s specific about how to manage it, including how to use a verification agent to narrow the burden without ever handing over the accountability.

The episode closes with the Delete Test — Delete, Collapse, then Automate — the discipline that makes sure you remove waste before you cement it in code, and a Lean practice for spotting it: go to the gemba, the real place the work happens.

Two things to try this week are included.

AI won't fix a broken process — it just helps you run it faster. That's the trap most organizations are walking into: pointing powerful agents at workflows that were never worth doing in the first place, and cementing the waste in place.

In this episode, Chris Bradley makes the case that Continuous Improvement is the non-negotiable core of agentic AI. Recorded from Veritiv's Customer Service center in Jacksonville — the day before a three-day Kaizen — he lays out a simple model for bringing AI to any process: three levels, Automate, Improve, and AI-Native Rebuild. Level one paves the cow path. Level two strips the waste with Lean before automating. Level three rebuilds the process from scratch around what agents can now do — and you can't earn it without doing level two first.

He's specific about what an AI-native process looks like in practice: work no human could do, running headless and multithreaded, an agent dropping into an API to do in half a second what a person never could. And he shares the design rule that's mattered most — have agents meet people where they already work, in Salesforce, Slack, or Teams, rather than building a new app nobody wants to learn. The argument is grounded in McKinsey's finding that workflow redesign is the single biggest driver of AI's bottom-line impact — and that only twenty-one percent of organizations have actually done it.

This opens a new arc — from individual fluency to transforming the operational workflows the enterprise runs on.

Two things to try this week included.