Chaos, Complexity, and Why “Just Add Agents” Makes Everything Worse
Most enterprises think their operations are “complicated.” In reality, many have tipped into chaos.
Nobody can explain the full end-to-end flow. Different teams hold contradictory truths. Systems have grown in layers over years of quick fixes.
Into this environment, the market is offering a seductive message:
“Don’t worry about the mess. Just add AI agents to orchestrate it.”
This is a trap.
If you introduce agents into a chaotic system, they don’t magically simplify it. They inherit the chaos.
Internally, this means faster bad decisions and new shadow workflows.
Externally, it means the new wave of “agentic browsers” (buying on behalf of your customers) will quietly route around you because your APIs are unreliable and your outcomes are unpredictable.
The Shift: You cannot “orchestrate” a mess. You have to architecture your way out of it.
In Part 2 of this series on the Next Era of the Enterprise, I break down:
Why “Orchestration” is failing inside the enterprise.
The difference between Complicated (Jet Engine) and Complex (Economy) systems, and why it matters.
Three practical moves to reduce complexity before the agents arrive in force.
A challenge for this week: Pick one critical workflow (e.g., onboarding, ordering). Map every step, handoff, and system. Highlight the steps where nobody is quite sure what really happens.
If you find chaos but don’t know where to start fixing it, hit reply (or DM me). I’m opening a few spots for “Red Pen” reviews to help you simplify before you automate.
Read the full analysis below. 👇
Chaos, Complexity, and Why “Just Add Agents” Makes Everything Worse
If your operating model is already messy, agents don’t bring leverage. They bring faster chaos, inside your walls and out at the edge.
Most organisations think they have “complicated” operations.
In reality, many have tipped into complexity:
Nobody can explain the full end-to-end flow.
Different teams hold contradictory truths about how things “actually” work.
Systems and processes have grown in layers over years of restructuring, acquisitions, and quick fixes.
You see the symptoms everywhere:
Projects that stall because nobody can agree who owns the outcome.
Data pipelines that don’t reconcile, even though they “should”.
KPIs that move in opposite directions when you change one process.
Into this environment, the market is now offering a powerful message:
“Don’t worry about the mess. Just add agents.”
Not just inside your enterprise, but outside:
agentic browsers that scan dozens of sites and APIs at once,
orchestration layers that manage work across multiple vendors,
domain-specific agent apps that sit between your customers and the whole market.
On paper, it all sounds perfect.
In reality, it’s a recipe for making your existing problems move faster – and for external agents to quietly route around you.
Complicated vs complex vs chaotic
It’s worth drawing a simple line:
Complicated: Lots of moving parts, but cause and effect are still understandable. A jet engine is complicated.
Complex: Cause and effect are blurred. Small changes ripple in unpredictable ways. An economy, a social network, or a large yet well run organisation would sit here.
Chaotic: No reliable patterns. You’re reacting, not designing.
Most enterprises sit somewhere between complex and chaotic in key parts of their operation:
Legacy processes that nobody owns.
Shadow flows running in Excel and email.
Workarounds layered on top of workarounds.
When you introduce internal agents into this world, they don’t magically simplify it.
They inherit the chaos.
When external agents hit this same world – via your APIs, portals, SLAs, and contracts – they hit the same inconsistent states, unclear ownership, and opaque failure modes.
The result: they either downgrade you in their recommendation logic, or avoid you altogether.
What agents actually do in a messy environment
In a tidy operating model, an internal agent can:
observe state,
make a decision,
trigger an action,
and log what happened.
An external agent, say, an agentic browser acting on your customer’s behalf, can:
query availability, price, and risk,
compare options across multiple providers,
place an order,
track fulfilment.
In a messy operating model, both types of agents are forced to:
infer state from partial, conflicting data,
guess who owns what,
work around missing permissions and broken integrations,
and route edge cases to humans who are already overloaded.
Internally, that becomes:
faster bad decisions,
new shadow flows to fix agent errors,
opaque failure modes nobody can untangle.
Externally, it becomes:
agents abandoning your APIs because they can’t trust the responses,
retries and timeouts that mark you as “high friction”,
unfulfilled transactions or ordered left in a limbo state no one can understand,
external agents preferring suppliers whose capabilities are simpler and more predictable.
You get speed without reliability.
Throughput without understanding.
And you become less attractive to the external agents that will increasingly decide where demand flows.
The illusion of “AI orchestration”
A lot of enterprise AI roadmaps talk about “orchestrating” work with agents.
The diagram always looks clean:
An event happens.
An internal agent detects it.
Tasks are routed to other agents or humans.
External agents connect to a neat API layer.
Everything syncs back to a single source of truth.
But orchestration only works if:
states are well-defined,
ownership is clear,
systems behave in relatively predictable ways.
If your current world looks more like:
three versions of the truth,
four teams involved in every decision,
and five overlapping systems in the same process,
then “orchestration” quickly turns into “herding”.
Internal agents end up:
looping between conflicting rules,
escalating to humans who have no idea what’s already happened.
External agents end up:
hitting inconsistent responses,
getting different answers for the same query,
discovering that the “real” process still runs in email and spreadsheets.
From the outside, you become a high-friction node in a low-friction network.
This is not a call to wait
The wrong conclusion here is:
“Our world is too messy. We’ll wait until the tech matures.”
That’s a good way to be invisible when the next wave of agentic platforms goes mainstream.
The better conclusion is:
“If we want agents, both inside and outside, to work for us later, we have to deliberately reduce chaos and complexity now.”
This forces uncomfortable questions:
Which processes are we keeping alive out of habit, not value?
Where do we have more steps than outcomes?
Where are we using structure as a substitute for trust?
What would an external agent see if it tried to interact with us end-to-end?
You’re not aiming for a perfectly engineered organisation. That’s a fantasy.
You’re aiming to:
reduce unnecessary complexity,
expose clear, composable capabilities that any agent can call,
design for transparency, so humans and agents see the same reality.
Practical ways to reduce complexity before agents arrive in force
You don’t need a multi-year programme to start this. You can begin with three moves that matter inside and at the edge.
1. Map a single flow – including the external touchpoints
Pick one critical flow – onboarding a customer, fulfilling an order, booking a procedure, provisioning a service.
Map every step from external trigger to final outcome.
Include where customers, partners, or regulators touch the flow.
For each step, record: who does it, in what system, with what input and output.
Highlight the steps where nobody is quite sure what really happens.
This isn’t about a perfect diagram. It’s about surfacing where reality already diverges from the neat version your future external agents will see.
2. Remove one layer of unnecessary indirection
Find steps where:
work bounces between teams without adding value,
approvals exist mainly because “something went wrong once”,
or data is re-keyed or re-shaped three times.
Then deliberately remove or consolidate one layer:
merge two handoffs into one,
turn three approvals into one accountable decision-maker,
expose a single integration instead of five.
Everything you simplify internally makes you easier for external agents to trust and integrate with.
3. Standardise the minimum you need for agents to be useful
Agents – internal and external – don’t need perfection. They need:
consistent identifiers,
stable APIs or event streams,
clear rules about who can do what,
predictable behaviour under load and failure.
Pick a narrow slice of your world and standardise just enough for an agent to observe and act without guesswork.
That might mean:
agreeing a canonical customer ID,
exposing a single “quote” and “order” capability,
or emitting reliable events when key states change.
Now an internal agent can orchestrate across teams, and an external agent (an agentic browser, a partner’s integration) can do something useful without human intervention.
The payoff: less chaos now, more demand later
If you do this, two things happen:
Your current operations get smoother.
You spend less time firefighting issues caused by invisible complexity and conflicting truths.You become legible to external agents.
As browsers, sidecars and agent platforms start brokering more work, they see a set of clean capabilities and predictable behaviour – not a fuzzy, high-friction black box.
The agentic economy is not a Field of Dreams “build it and they will come”. It’s:
Design your organisation so that when agents, inside and outside, arrive in force, they amplify good structure instead of accelerating chaos, and they actively route demand your way instead of around you.
That starts with being honest about where you sit today on the spectrum from complicated to complex to chaotic, and taking deliberate steps to move in the right direction.