Fifteen Intelligences, No Brain

Eighteen months of sitting inside other people’s implementations, and here is the thing I did not expect to be writing about. Almost nobody has an agentic system in the sense the internet describes one. A handful of companies, worldwide, have anything close. And yet the software itself has already changed. Every product I open has grown an assistant since last spring. The systems started repositioning for a world that has not arrived yet — and in doing so, they are quietly making it harder to get there.

It is worth stepping back further than most of these conversations go.

The organization of work has not changed in a very long time. A person has an intention — an employee, a freelancer, anyone. That intention has to turn into an outcome. What converts one into the other is a process. Everything we have built, from double-entry bookkeeping to the industrial revolution to the first spreadsheet, has been an attempt to close that gap. The industrial revolution gave us force on demand. The last few years gave us intelligence on demand. In between, we invented the application.

And the application made a very specific bargain, one we accepted so long ago that we stopped noticing it. It made an isolated task faster.

Take the obvious example. Building a financial model on paper, with a slide rule and a ledger, was slow enough that only investment banks bothered. Excel made it fast. But nobody’s goal, ever, was to build a financial model. The goal was to make money — to read a market, price a signal, and turn that into cash flow. Excel closes one slice of that. To reach the actual goal you still need email to move the decision, a terminal to see the market, a messenger to reach the counterparty, a CRM to remember the relationship — and a person to carry state between all of them.

The person is the integration layer. That has not changed in forty years.

So: the format of isolated tasks changed beyond recognition. The format of the work did not.

The economics followed quietly. A market organized around isolated tasks will keep producing isolated tasks. Not out of bad faith — it is simply what the shape rewards. Every vendor is right about its own slice, and correctly optimizes it. Nobody is responsible for the seam. And the seams are where companies actually lose their time. In one engagement we found seven separate ledgers of the same operational truth — seven places where the company recorded how work really got done, none of which agreed with the others. Nobody built that on purpose. It assembled itself, one well-justified purchase at a time.

Now the part that keeps surprising me.

AI arrives, and each product embeds it inside its own boundary. The CRM gets an assistant. The ERP gets a copilot. The meeting tool writes summaries. Each one is genuinely useful, and each one knows only what its own contour knows. The entire promise was that we would stop being the integration layer. Instead we are being asked to be the integration layer for fifteen intelligences rather than fifteen applications. Same seam. Higher resolution.

The strongest argument against me is worth stating properly. The vendor is better positioned than anyone else: it owns the data, the schema, the write permissions, the context. Of course the assistant should live there. Inside its own domain, that is correct, and those assistants will keep getting better.

But the decisions that matter do not live inside one contour.

Whether to extend terms to this customer, whether to refund this order, whether to accept this deviation on this shipment — those need history from support, payment behaviour from finance, capacity from operations, and one more thing that no system holds at all: precedent. What did we do the last forty times a case like this came up, on what evidence, and did it turn out well. No vendor has that, and none can acquire it, because it was never written down. It lives in people’s heads and in the shadow loop — the real process, the one that keeps the company running while the documented process sits in a folder describing something that stopped being true two years ago.

Which is why the answer is not a better assistant inside a better product.

Software should keep doing the thing it is genuinely good at: holding data, making it available, and moving it under control through defined interfaces. What it cannot do — structurally, not for lack of effort — is be the place where decisions get made. That place has to sit above all of them, and it has to belong to the company rather than to any of its suppliers.

Call it the operating layer: the level between the systems a company runs on and the decisions it has to make.

The mechanics are less exotic than the phrase suggests. Its memory comes from work, not from interviews — you cannot document your way to it, and every attempt produces fiction. Whatever the layer cannot close becomes an exception routed to a human, and the human’s answer comes back as precedent the system reuses, so coverage grows precisely where the system was weakest. Work moves to an agent only when its outcome is objectively verifiable, its actions are reversible or contained, and there is enough precedent behind it. Autonomy is earned in stages — the human decides, then confirms, then audits a sample. The human stays on the switch, and can take it back in an afternoon.

There is an old line that the best process is the one that does not exist. I would put it differently now. The best process is not the one you run faster. It is the one nobody has to run. That is not an argument for deleting process — it is an argument about where execution should live.

So before the next seat, the next subscription, the next assistant inside the next product, it is worth asking a different question. Not “which tool makes this task faster,” but “what would have to be true for this decision to be made without me.” Answer that honestly and the stack stops being fifteen things you operate, and becomes one thing that operates — inside limits you set.

That is the layer worth building. It works for your business rather than for someone else’s roadmap.