AI implementation that changes how the company runs

Most companies implement AI like a software purchase. Buy a tool, connect it, watch for the productivity number to go up. It does not go up, or not by much, because the company still works exactly the way it did. People do the work. Software helps.

The current generation of AI can do the work itself. Implementing it means changing how work moves through the company, and that happens in layers. Each layer produces something the next one needs, which is why you cannot skip them, and why most implementations die. They start at the top of the stack with nothing underneath.

The order that works

Layer zero: own the surface your work lives on

Agents need a system they can reach into and act inside. A pile of SaaS subscriptions with thin, rate-limited APIs is not that system. Owning more of your software, shaped to how you actually work, is what makes everything after this possible.

It is the floor, not the house. New software alone changes what you run on, not how you work.

Layer one: every person works through AI directly

Not an AI team. Not a pilot with three volunteers. Everyone, on the work they are responsible for, every day.

This is where implementation actually starts, and only leadership can make the call. Partial adoption teaches the company nothing. Universal adoption surfaces how the work really gets done, moves people to the part of the job that needs judgment, and shows you where the company's judgment lives and where it lives in nobody.

Layer two: the company, written down and reachable

Agents need what a new hire needs. Plain-language documents for every process: what the work is, what good looks like, the exceptions, what must never happen. Your systems exposed so an agent can do what a person in the role can do. And the same access that person would have, inside the same boundaries.

Layer three: loops

Now agents run specific processes on their own. A trigger, a written mandate, a defined output, and a defined moment where it hands back to a person. Two rules: the verifier is never the doer, and the agent asks when a decision is consequential.

Layer four: employment

Real loops need what employees have: identity, authority, direction, accounting and record. Without them a company running twelve agents cannot answer the simplest question in management, which is who did that. I wrote about this layer in The layer everyone ignores is what makes agents scale.

What I do in an implementation

I work with leadership on the three decisions nobody else can make, and with the team on everything else.

• Get everyone working through AI. Practical, on their own work, with a shared way of doing it. For engineering teams that usually means Claude Code and Codex, used properly.
• Write the company down. Working documents your people maintain and agents load at the start of a task, not a wiki nobody reads.
• Make the systems reachable. Through MCP and the APIs you already have, or by replacing the software that will never let an agent in.
• Build the first loops. Chosen because they are valuable and ready, run with a person watching until they are reliable. See AI agents for business.
• Install the employment layer. So you can see what every agent did, what it was allowed to do, and what it cost.

Every engagement has a fixed scope, written success criteria and an executive sponsor on your side. You own what gets built, and you leave able to run it.

Three decisions only leadership can make

1. Every person works through AI directly, as part of the job, with the company's support behind them.
2. The company gets written down, in the words the work is done in, maintained by the people who do it.
3. Someone decides what agents may do without asking, per process, on paper.

Everything else is engineering, and the engineering gets easier every month. If you are ready to make those three calls, let's talk.