The Substrate War — Will Your Data Platform Become Your System of Record?

In a previous post I argued that agent swarms are eating the enterprise stack top-down — engagement first, intelligence next — and that what survives is the system of record and the governed data substrate beneath it. That leaves a sharper, more uncomfortable question hanging. If the record is really becoming a governed substrate — data plus lineage, policy and accountability — then where does that substrate actually come from? And what happens to the systems of record enterprises run today?

The obvious move: grow the data platform into the substrate

Most large enterprises already have a central data platform — a lake or lakehouse that holds an analytical copy of nearly everything. Today it mostly serves reporting and models. But the trajectory is hard to miss: bolt real governance onto it — a catalog, lineage, access policy, an audit trail — and that analytical mirror starts to look like something more ambitious. Not a place you copy the truth to, but the place the truth lives. Put agent swarms on top of that, and you have the architecture the last post pointed at: a governed substrate, with agents doing the work that used to live inside applications.

Which raises the question everyone circles but few say plainly: if the data platform becomes the governed system of record, what is left for the systems of record themselves?

The gate everyone points to — and why it’s dissolving

The standard objection is technical, and it’s a good one. Data platforms grew up analytical: append-heavy, columnar, built to scan huge histories. Systems of record are transactional: they exist to update a single row correctly, right now, with absolute integrity and strict concurrency. For years those were different machines, and “run your record on the lake” was a category error.

That line is now being erased. The clear direction of travel is a single data substrate that carries transactional and analytical work on one copy of the data — the same store that a transaction writes to is the one agents and analytics read from, with no copy, no pipeline, no lag. I’ll keep the details generic, but the point is simple: the enabling technology for this thesis is no longer hypothetical. The substrate can hold the live truth, not just yesterday’s export.

So does the system of record die? No — the app does

Here is the distinction that keeps the argument honest. A “system of record” is two things wearing one name: the record — the authoritative data and the rules that govern it — and the application — the interface, the workflow, and the captive database you log into to touch it. Those two are separating.

The application is what’s genuinely at risk. When agents can read and write the substrate directly, and the workflow becomes an agent’s plan rather than a sequence of screens, the app-you-log-into has very little left to do. But the record doesn’t vanish with it. The authoritative truth, and the rules that keep it correct, don’t disappear — they migrate onto the substrate. The right way to say it isn’t “systems of record die.” It’s: the record consolidates, and the application dissolves. No more system of record as a place you log into; the record itself lives on, lower in the stack.

The real fight: who becomes the substrate

If the record is going to consolidate onto a governed substrate, the strategic question is simply whose substrate. And there are two paths to the same architecture — which is why this is a contest, not a coronation.

• The data platform grows up. The neutral platform absorbs transactional work and hard governance, becomes the system of context, and the record applications thin into agents running on top of it. The substrate is the data layer everyone already shares.
• The system of record grows down. The incumbent doesn’t sit still. Its pitch is potent: the authoritative, transactional truth already lives here — your agents are only as trustworthy as the record underneath them. So it extends downward, claims the substrate role itself, and embeds its own agent swarm.

Notice that both paths produce the same end-state — a governed substrate with agents on top and thin applications above. What they disagree on is who owns the layer that matters. That is the substrate war, and it is nowhere near settled.

What actually decides it: governance, not gigabytes

It is tempting to assume the biggest data lake wins by default. It won’t. Whoever becomes the substrate has to clear two bars that have nothing to do with raw scale:

• It has to be trustworthy enough to be the record. Lineage, access policy, correctness guarantees, and an auditable trail of every change and every agent action. A naked data lake — a place you dump data with no governance — is not a system of record; it’s a liability with good economics.
• It has to carry the rules, not just the data. A record isn’t only what happened; it’s what is allowed to happen — what a valid change looks like, who may make it, and how each one is proven. Those rules were buried inside the old applications. On the substrate they have to be re-expressed as deterministic services — not handed to probabilistic agents to improvise. This is the same discipline from the last post, one layer down: keep the deterministic core deterministic, and let the agents operate around it.

The winning substrate isn’t the largest one. It’s the governed one — the one an enterprise can trust with the truth.

A slow unbundling, not a cliff

None of this happens on a launch date. Replacing the authoritative record of a large enterprise is a multi-year, high-consequence program, wrapped in compliance and decades of embedded process. The realistic verb is exactly the one that started this: enterprises slowly expand the data platform into the substrate, move workloads onto it as trust is earned, and let the applications thin out over a decade — not overnight. The demise of the app-you-log-into is a long unbundling, and the record is the last thing to move, precisely because it matters most.

What leaders should do now

• Treat your data platform as a candidate system of record, not just an analytics tool. The governance you add today — lineage, policy, audit, transactional integrity — is what decides whether it can hold the truth tomorrow.
• Move the rules to deterministic services. The logic trapped inside your record applications is the real migration. Get it out into explicit, testable services on the substrate before you point agents at it.
• Decide the substrate deliberately. Neutral platform or incumbent, this is the lock-in that will matter for the next decade. Choosing it by accident — letting whoever you already pay the most quietly become your substrate — is the expensive default.
• Don’t bet on a naked lake. Economics without governance loses this race. Fund the governance, or you’re building a data swamp the agents can’t safely stand on.

The record moves; it doesn’t die

The instinct is to ask which category of software gets killed — and to picture the systems of record toppling. The truer picture is quieter and more consequential: the applications dissolve into agents, and the record slides down onto a governed substrate that something has to own. The winner of the agent era won’t be whoever ships the most agents, or whoever hoards the most data. It will be whoever owns the governed substrate the record consolidates onto — because that is where the truth, and the leverage, finally sit.

The Agentic Stack — a five-part series

1. Agents Eat the Stack Top-Down
2. The Substrate War — you are here
3. Buy, Build, or Orchestrate
4. Service-as-Software
5. The Frontier Labs — Squeezed Middle