Anyone who has worked in a large company has complained about silos. Sales has one version of the customer, finance has another, operations has a third, and someone eventually builds a spreadsheet to reconcile all three. We build integration layers, data lakes, master-data programs – and somehow the silos survive all of them. They are like cockroaches that are unaffected by nuclear war 🙂
Agentic AI might finally put a dent in this, for a simple reason: an agent doesn’t care about the org chart. Given permission and enough context, it can move across CRM, ERP, email, contracts and support tickets without asking which department owns each one. A customer problem that today passes through sales, finance and operations as three separate workflows could be handled as one continuous piece of work.
I think that’s all good. But I’ve started wondering whether we’re about to solve the silo problem and replace it with a less familiar but more troublesome one.
What happens when every department starts thinking the same way?
Take an ordinary example. A company sees early stress signals in a customer segment – payment patterns shifting, some external indicators moving the wrong way. The finance agent tightens credit. The sales agent pulls back on discounts. Collections pushes harder. Service grants fewer exceptions. Procurement gets conservative with suppliers exposed to the same customers.
Each decision is individually defensible – arguably the system is working as designed. The problem only appears when you step back far enough to see five functions reacting to the same signal, in the same direction, in the same week. What looked like prudent risk management inside each function has become a coordinated withdrawal from a customer base the company may actually want to keep.
We’ve spent decades worrying about departments acting without knowledge of each other. Agentic AI creates the opposite risk: every function sees the same information, runs similar models, and reaches similar conclusions at machine speed. That’s not a silo problem. It’s a correlation problem – and the old silos, inefficient as they were, gave us accidental protection from it. Different systems, inconsistent data, and separately evolved decision processes meant a mistake in one place didn’t automatically become a mistake everywhere.
I have no nostalgia for reconciling five versions of the same customer record. But it means we should be deliberate about what we standardize as we build agentic architecture.
Plumbing vs. judgment
Some things should be standardized aggressively. Identity is the obvious one – I don’t want every business unit inventing its own rules for what an agent can access. Logging, audit trails, data contracts, and the mechanisms by which an agent declares and exercises authority should be common infrastructure. If an agent changes a price, sends money, or touches a customer record, there should be one consistent way to know who did it, under what authority, using what information. Call this plumbing. Nobody gets a competitive advantage from HR and procurement inventing incompatible ways to authenticate software.
Judgment is different – and there’s a natural, well-intentioned path from standardizing infrastructure to standardizing everything above it. Pick a model provider, build a common retrieval layer, establish a shared agent framework, and every function starts building on the same stack. Cheaper, easier to govern, easier to support. But if the same model, the same data, and the same reasoning patterns start driving credit, pricing, hiring, and customer service, the company has quietly created a cognitive monoculture.
We’ve seen this pattern before. Financial markets become fragile when many institutions hold similar positions and respond to the same signal at the same time – no single participant has to be irrational for the system to become unstable. I suspect agentic enterprises can fail the same way. It won’t be enough to ask whether the finance agent is accurate. We’ll need to know how dependent it is on the same assumptions as everything else. If a model update shifts behavior slightly, where else does that shift show up? If ten agents each become a little more conservative at once, does that add up to a large effect even though none of them individually triggers an alert?
A heuristic for where it matters
Not every decision needs this scrutiny. A payroll inquiry doesn’t need competing ways of reasoning about it. A small expense approval doesn’t either.
The test I’d apply: if every agent touching this decision were wrong in the same direction at the same time, what’s the blast radius? When the same interpretation can simultaneously move pricing, credit, supplier terms and customer treatment, the blast radius is the whole company – and that’s where deliberate diversity earns its cost. Different evidence thresholds, a classifier instead of an LLM in one place, a deterministic rule that can veto a model’s output in another. Not “use different models everywhere” – that just recreates the mess we’re escaping – but independence where correlated error is expensive.
The other lever is speed. Agents can detect something and act immediately, but immediate propagation across an entire company isn’t a feature – it’s the absence of a safeguard. If a new risk signal changes an agent’s decisions, that change may need to hit one region, one customer segment, or a small percentage of transactions first. Software learned to use canary releases because deploying bad code everywhere at once is reckless. We haven’t yet built the equivalent instinct for a shift in machine judgment, and we should.
This also changes what monitoring has to become. Today we mostly watch systems one at a time – hallucinations, accuracy drift, latency, policy violations. Necessary, but blind to the failure mode above, because every agent can stay inside its own acceptable range while the enterprise moves somewhere dangerous collectively. The monitoring has to move up a level, watching for correlated movement across functions – sales, finance and collections all shifting toward the same customer group in the same week – even when each team’s own change looks perfectly reasonable in isolation. This is what I mean by being over the loop: not reviewing every individual decision, but watching what many individually reasonable decisions are doing to the system together.
Standardize the plumbing. Protect the judgment.
I don’t think the future belongs to today’s silos. They cost too much and hide too much for customers and employees to keep navigating around. Agents should make most of those boundaries less important. But removing a boundary and removing independence are not the same move.
The architecture I want is one where the infrastructure is boring and standardized – like identity, security, observability, audit – while judgment stays contextual. I should be able to trace how authority moves through the company without learning a new architecture for every department. But I don’t need every consequential decision to inherit the same model, the same evidence, and the same interpretation of risk.
Enterprise architecture has treated standardization as a virtue for so long that the instinct runs on autopilot. Usually it’s right. Agentic AI is going to force us to say precisely where it stops being right, and pay for custom judgment in the places where everyone being wrong in exactly the same way is a cost we can’t absorb.
And Vijay Says... 