There’s a familiar anxiety doing the rounds. You can hear it in boardrooms, investor calls, and the comment threads under every AI announcement: AI is going to replace software.

Last week, almost a trillion dollars was wiped from software and services stocks in six trading days. Thomson Reuters fell 16% in a single session. Relx shed 14%. The S&P 500 software and services index dropped 26% from its October peak. Investors scrambled to work out which companies would survive and which wouldn’t.

The fear is real. But the framing is wrong.

Not because it’s overblown — if anything, the disruption ahead is larger than most people are pricing in. The problem is that “AI replaces software” points at the wrong layer. Software isn’t being replaced. It’s being bypassed. The applications are still there. They’re just quietly losing the thing that made them valuable: their role as the place where work gets coordinated.

This isn’t a story about tools getting smarter. It’s a story about where work actually happens — and what it means when that answer changes.

How work used to be organised (and why software mattered)

For the last twenty-odd years, most knowledge work has followed a familiar pattern. You had discrete applications — a CRM here, a project management tool there, an ERP system somewhere in the middle. You had defined workflows. And you had humans moving work between systems, applying judgement at each step, translating context from one tool to the next.

It was slow. It was often frustrating. But it worked, because the applications weren’t just tools — they were containers for work. They were where decisions became visible, where processes could be audited, where the pace of things was slow enough that someone could notice a mistake before it compounded.

The org chart mapped to the application stack. Marketing owned HubSpot. Finance owned the ERP. Legal owned the contract management system. Each team’s authority was partly defined by which systems they controlled. The software was the territory.

Nobody designed it that way. It just accumulated, one SaaS contract at a time.

What long-running agents change: time, continuity, intent

Something shifted in the last few months. Not in the way most coverage would suggest — this isn't about a single product launch or a benchmark result. It's about a change in what AI systems can now hold in their heads.

Previous AI tools were reactive. You asked a question, you got an answer. The interaction was atomic — a single prompt, a single response, and then the slate wiped clean. Useful, but fundamentally a productivity multiplier bolted onto existing workflows.

The new generation of agents is different. They hold intent over time. They operate across tools. They decide what to do next, not just what to respond with. And critically, they work on objectives — not steps.

As one AI startup CEO put it recently, the shift is “going from having a conversation to actually having agents do incredibly productive, useful work”. The unit of interaction has changed from a single exchange to an ongoing engagement. The agent doesn’t need you to break the problem down. You describe the castle, and it gets built.

The unlock here isn’t intelligence. It’s time horizon. Once a system can persist — can hold context, maintain a plan, and iterate on its own work — the unit of work changes from “a task someone assigned” to “an outcome someone wanted”. And that changes everything about where software sits in the stack.

"Eaten from below": how the application layer gets hollowed out

Here's the phrase that matters: eaten from below.

AI agents aren’t competing with applications head-on. They’re not building a better CRM or a smarter ERP. They’re routing around them entirely. They use applications the way you might use a screwdriver — a necessary instrument, but not the thing directing the work.

In this model, applications become:

  • Data sources — places where information lives, to be queried on demand
  • Execution surfaces — interfaces where actions get carried out
  • Commodity capabilities — interchangeable components in a larger system
But they are no longer the place where work is coordinated or understood.

This is the Amazon analogy that several analysts reached for during last week’s selloff, and it’s apt. Amazon didn’t set out to destroy bookshops or department stores. It built a logistics and distribution layer underneath them that made the shop itself irrelevant. The products were still there. The transactions still happened. But the coordinating intelligence — the thing that decided what to stock, how to price it, when to deliver — had moved to a layer below.

That’s what’s happening now with software. The applications are still running. Data still flows through them. But the agent sitting above (or below, depending on your vantage point) is increasingly the thing deciding what work gets done, when, and how. The application is just along for the ride.

This is why investors panicked. Not because any single AI tool had already replaced Westlaw or Bloomberg or Salesforce, but because they could suddenly see the architecture of a world in which those products become plumbing.

Why this feels like magic to users — and chaos to organisations

Talk to anyone who's used these newer agents seriously — the ones that can maintain context over hours or days, that can pick up a task, break it down, and execute without constant supervision — and the language is remarkably consistent.

“Less handholding.” “It just gets it.” “I describe the intent and it figures out the steps.” One engineer described it as going from watching over the AI’s shoulder to simply reviewing its output the next morning. Product managers are performing complex data analysis that previously required specialists. Designers are writing production code.

For individuals, this feels genuinely transformative. The friction that defined knowledge work — the context-switching, the manual translation between systems, the overhead of breaking big tasks into small ones — is evaporating.

But here’s what doesn’t get enough attention: ease for the individual often means opacity for the system.

When a person navigates work through a sequence of applications, each step creates a trace. An entry in the CRM. A ticket in Jira. An approval in the workflow tool. These traces aren’t just records — they’re the mechanism by which organisations understand what happened and why.

When an agent routes around those applications, completing objectives rather than following defined workflows, those traces become patchy or disappear entirely. The work still gets done — often faster and better. But the organisational fabric that made work visible, auditable, and interruptible? That starts to dissolve.

Nobody complains when it happens. That’s the problem.

Judgement doesn't disappear — it just moves

One of the most persistent fears about AI is that it eliminates human judgement. That's not quite right. What's actually happening is subtler, and in some ways more concerning.

Judgement hasn’t been automated away. It’s been displaced. It now lives:

  • In model behaviour — the way the system decides to approach a problem, which options to consider, what to prioritise
  • In tool selection — which applications the agent chooses to query, which data it treats as authoritative, which it ignores
  • In invisible defaults — the assumptions baked into the agent's configuration, its instructions file, its system prompt
  • In after-the-fact review — because the work is already done by the time a human sees it, the review becomes reactive rather than directive
This is the shift from "writer to editor" that several people in the industry have described. The human is no longer producing the work — they're evaluating work that's already been produced. The skill, as one AI founder put it, is no longer syntax or rote creation. It's taste and judgement.

But here’s the catch: we’ve built entire organisations around the assumption that judgement happens at specific points in a process. Approval chains, sign-off workflows, peer review — all of these depend on judgement being visible and located. When judgement migrates into a model’s default behaviour or an agent’s tool selection logic, it doesn’t disappear. It just becomes much harder to see.

The danger isn’t a loss of judgement. It’s a loss of awareness of where judgement now lives.

The governance lag: why organisations won't notice until it's too late

Here's the part that's easy to miss.

When something breaks dramatically, organisations respond. A system outage, a data breach, a compliance failure — these produce immediate signals that force action. But the hollowing out of the application layer doesn’t break anything. In fact, it looks like everything is working better than ever.

Productivity improves. Turnaround times shrink. Costs look good. Individual teams are shipping faster, producing more, solving problems that used to take weeks in hours.

Under the surface, though, something else is happening:

  • Decision pathways that used to be explicit become implicit
  • Accountability that used to be embedded in process becomes diffused
  • Data that used to flow through auditable systems now routes through agent interactions that may or may not leave traces
  • Institutional knowledge that used to accumulate in applications and their usage patterns instead accumulates in agent configurations and prompt histories
None of this shows up as a problem on a dashboard. There's no red alert when oversight migrates from a structured workflow to a retrospective review of agent output. The risks accumulate quietly, invisibly, and in exactly the places most organisations aren't looking.

This is where “eaten from below” really matters. By the time leaders ask where control went, it’s already been redistributed. Not maliciously, not through negligence, but through the perfectly rational decisions of individuals who found a faster way to get things done.

And the market confusion of the past week is a lagging indicator of this realisation. Investors aren’t just repricing software companies — they’re repricing the assumption that applications are where economic value accrues. If the coordinating intelligence moves to the agent layer, the value follows.

Designing for a world where applications are no longer the unit

So what do you actually do with this?

The instinct is to reach for a framework — a maturity model, a governance checklist, a set of policies. Resist that instinct. The situation is too fluid and too fundamental for a neat set of recommendations.

But there are questions worth sitting with.

Where do we insist on human accountability? Not human involvement — that’s the wrong bar. Accountability means someone can explain, after the fact, why a decision was made. If an agent made the decision, can someone explain why it made that decision? If not, you have a governance gap that no policy will fill.

Which decisions must stay interruptible? One of the great advantages of the old application-centric model is that workflows had natural pause points — moments where someone had to click “approve” or “submit”. Long-running agents don’t have those pauses by default. You have to design them in. The question is where.

How do we surface judgement in long-running systems? If judgement has migrated into model behaviour, tool selection, and invisible defaults, then the organisation’s task is to make that judgement visible again. This might mean logging, observability, or simply asking different questions in reviews. But it starts with accepting that the current visibility model — built around applications as the unit — no longer reflects how work actually happens.

None of these questions have tidy answers. But they point in the right direction: away from “which AI tool should we adopt?” and towards “how do we maintain organisational coherence when the locus of work has shifted?”

Software still matters — just not in the way we're used to

Applications aren't dead. Data still needs to live somewhere. Transactions still need to be executed. Compliance requirements still demand structured, auditable systems. For a long time yet, the infrastructure layer will be built from the same enterprise software we've been buying for decades.

But applications are no longer in charge.

The organisations that struggle in the next few years won’t be the ones that missed the AI wave. Most companies will adopt agents, one way or another, because the productivity gains are too obvious to ignore. The ones that struggle will be the ones that kept designing — kept governing, kept structuring, kept thinking — as if applications were still where work lives.

Work has moved. The coordinating intelligence is migrating to a layer below the one we’ve been watching. And the view from up here looks deceptively calm.