Coordination Is the Moat: AI's Real Value Isn't in What It Automates

Everyone is pricing AI by what it automates. After three years of watching it get bolted onto real businesses, I'm convinced the value sits somewhere else entirely: in the layer that coordinates the work.

By Chuck Griess

Last month I sat with the ops lead of a mid-market services company and mapped how a customer order actually moves through her business. We counted fourteen tools, nine manual handoffs, and three places where the same customer record gets re-keyed by hand. Then she asked me the question I hear in some version of every one of these conversations: "So which AI tool should we buy next?"

I've spent fifteen years building software systems, and the last three watching AI get bolted onto them, so I want to be precise about why that question is the wrong one. She doesn't have a tool gap. She has a coordination gap. Every one of those fourteen tools performs its task competently. None of them knows what the others are doing. Buying a fifteenth tool, however impressive its demo, adds another node to a network that has no protocol.

After enough of these conversations, Skip and I landed on a thesis that now organizes how we approach every engagement: the durable value of AI isn't in the tasks it speeds up, it's in how well the work around those tasks is coordinated. The companies that win won't be the ones that own the best models or the most tools. They'll be the ones that own the layer where the work actually comes together. Software commoditizes. Models commoditize. The layer that connects data, tools, agents, decisions, and people into one operating system is the part that doesn't.

This piece is my attempt to show why that thesis holds up against what we've actually observed, first inside codebases, now across whole businesses.

The thesis, stated plainly

Most AI buying decisions are made on automation logic. A task costs X hours of human time, the tool does it in minutes, multiply by volume, that's the ROI. Vendors price this way, analysts model it this way, and pilots get approved this way.

What that logic measures is the wrong thing. AI's deepest impact isn't how it performs a task. It's how it restructures the system around the task. When the cost of executing the work drops close to zero, the way that work was wired together stops holding, and the advantage goes to whoever rewires it into a configuration that actually fits. The task was never the moat. The configuration is.

The task was never the moat. The configuration is.

Here's the practitioner's translation. Automating a task inside a broken workflow gives you a faster broken workflow. Coordinating the workflow, so that data, tools, agents, and people share one source of truth about what's happening and why, changes what the business can do. The first is a cost saving that your competitors can buy off the same vendor catalog next quarter. The second is a capability that compounds and doesn't transfer.

Automating a task inside a broken workflow gives you a faster broken workflow.

That asymmetry is the whole game. Anything task-shaped is getting commoditized at a speed I have never seen in my career. The coordination layer is the part that accumulates.

Anything task-shaped is getting commoditized at a speed I have never seen in my career. The coordination layer is the part that accumulates.

We learned this inside the codebase first

If you've been reading since Series 1, you've seen this argument before in a narrower frame. We wrote about the orchestration bottleneck: three engineers, each working with AI tools, shipped three features in parallel over two days. Each feature was clean in isolation. Merged, the product was incoherent. Not merge conflicts. The code compiled and the tests passed. The features made incompatible assumptions about the data model, the user flow, and what the product was even optimizing for.

The lesson we took from distributed systems back then generalizes exactly. When you parallelize work, you need explicit coordination mechanisms, because parallel work without shared truth produces incoherent results. AI didn't break coordination. AI removed the constraint that made implicit coordination sufficient. Work used to move slowly enough that hallway conversations and standups kept everyone's assumptions roughly aligned. Collapse the cost of execution and the assumptions diverge faster than osmosis can reconcile them.

Now look at the mid-market business through the same lens. A company is a distributed system. Departments, vendors, contractors, and now AI agents are nodes. Manual handoffs are ad hoc message passing. The spreadsheet the COO reconciles on Sunday night is a consensus protocol, running on the most expensive compute in the building.

The spreadsheet the COO reconciles on Sunday night is a consensus protocol, running on the most expensive compute in the building.

Every AI tool you add increases the parallelism. Five systems working off shared assumptions have ten possible seams between them. Fifteen systems have over a hundred. The ops lead with fourteen tools isn't fourteen steps toward AI maturity. She's carrying roughly ninety seams that nothing in her stack is responsible for, and every new purchase adds more. This is why the pilot failure data keeps coming back so brutal: the tools work, and the system around them doesn't.

The bottleneck inside the codebase was orchestration. The bottleneck across the business is the same thing wearing a different badge.

Coordination has artifacts, and we've been building them for six months

The trouble with most versions of this argument, including the ones we made early on, is that they stay abstract. "Own the coordination layer" sounds like strategy-deck language until you can name the artifacts. So let me name them, because CRAFT has two that readers of Series 2 already know, and they are not engineering artifacts. They never were. We just met them in engineering first.

The Context Graph is shared state for the whole operating system. In Series 2 we showed how we feed Claude the project context it needs: identity, constraints, current work, boundaries, known failure modes. When I measured what cold prompting cost without it, teams that assumed they were saving sixty to seventy percent of their time were netting thirty to forty after corrections. The business version is the same artifact with a wider scope. What does this company do, in what order, under what constraints, with what escalation paths? When that lives in one maintained place, every agent, vendor, and new hire starts from the same truth. When it lives in fourteen tools and six heads, every node starts from a different one.

Decision Records are the consensus log. We wrote in Series 1 about how teams stopped re-litigating decisions by writing down what was decided, why, and what it constrains. In the business context, the decision that matters isn't JWT versus session cookies. It's "we route refunds over $500 to a human, because of what happened in March." An AI agent that can read that record is governed. An AI agent that can't will resolve the open question on its own, plausibly and wrong. Decision Records are what make autonomy safe to grant.

Notice what these two artifacts have in common: neither performs a task. They coordinate everything that does. Which is exactly where the thesis says the value sits.

Why this is a moat and a tool is not

Run the commoditization test on each layer of the stack.

The models? Every quarter the frontier moves and last year's premium capability becomes this year's commodity API call. The tools? Category by category, features converge and prices fall. Whatever a vendor demos to you this month, their competitor demos a close cousin of it next month. Betting your AI advantage on tool selection is betting on the layer with the fastest depreciation schedule in the stack.

Now run the same test on a maintained Context Graph and three years of Decision Records. They're worthless to your competitor, because they encode how your business specifically coordinates work: your constraints, your escalation logic, your accumulated record of what was tried and why it was rejected. They appreciate with use, because every decision logged and every workflow mapped makes the next agent deployment cheaper and safer than the last. They can't be bought off a catalog, because by definition they don't exist until your business builds them.

Defensible, compounding, non-transferable. That's not a feature list. That's the definition of a moat.

Defensible, compounding, non-transferable. That's not a feature list. That's the definition of a moat.

One nuance worth being precise about, because we ask our clients to be precise about it too. When we install this layer, the client owns their data, their workflows, their agents, and their infrastructure. What InTech keeps is the method: the reference architecture and the playbook for installing the layer again. Both statements are true, and the second one is why we can write a series like this in public without giving anything away. The moat isn't the method. The moat is your business, coordinated.

Where I'll stop short

I don't have a finished map of where coordination value settles across every vertical, and I'd be suspicious of anyone who claims one in 2026. The patterns are still emerging. What I can tell you is what the evidence in front of us supports: in every engagement where we've installed the coordination layer first, the subsequent AI work compounded, and in every rescue engagement we've taken on, the failure traces back to tools deployed into a system with no shared truth. The sample is growing. The pattern hasn't broken yet.

For the operator reading this, the takeaway is a budget question. Look at your AI spend and ask what fraction is buying task performance and what fraction is building the layer that coordinates it. If the answer is all task and no layer, you're funding your vendors' moats and not your own. For the founder reading this, it's the same question one level down: the product companies pulling away right now aren't the ones with the most AI features. They're the ones where every feature inherits the same context, the same decision memory, the same telemetry. The coordination layer is what makes the tenth build almost free.

Next week, Skip and I take this thesis into the room where most mid-market AI initiatives first live or die: customer service. What to automate, what to augment, and what to leave alone, with a decision framework you can run against your own queue.

AI that runs your business. Not the other way around