Writing

AI agents won't replace the system of record—they'll wrap it

There's a sharp debate about whether AI agents will replace the systems of record that run most companies. On one side, agents create demand for integrated, high-quality domain data. On the other, the systems that hold that data are not going anywhere soon. The conclusion I keep coming back to is less dramatic than either side.

Don't replace the system of record; wrap it.

The case for AI-native systems

AI agents are only as good as the data they can read and act on. That means integrated, high-quality domain data, not a set of disconnected silos. Lightweight systems of action that sit on top of messy enterprise data won't cut it. The agent needs a coherent model of customers, orders, assets, or whatever the domain is. Startups can build systems of record from clean foundations, designing schemas and access patterns with agents in mind. Incumbents struggle with legacy schemas and siloed access, which makes it harder to expose that same quality of data. That gap opens real market turnover. And the revenue model shifts from per-seat software pricing to automated labor and outcomes; paying per seat makes little sense when an agent, not a person, is doing the work.

The case against replacing core systems

But core systems of record are sticky for reasons that have nothing to do with AI. Auditability, compliance, integrations, and years of accumulated edge-case logic make them hard to move. Most agents today can read data but can't reliably write back under transaction guarantees. A write that violates an invariant or bypasses a validation rule is worse than no write at all. Replacing that layer is a multi-year bet, not a feature release. That is not a technology problem as much as an institutional one.

Where I land

So the path I'd take is not to replace the system of record, but to wrap it. Expose legacy backends through APIs, event streams, and clean domain models. Let agents read and act through a governed abstraction layer, with lineage, access controls, and write validation. That means the legacy system remains the source of truth, but the agent interacts with a consistent interface that can enforce rules before anything hits the transaction path.

The abstraction layer is not a thin proxy; it has to carry real governance. Lineage tells you where a piece of data came from. Access controls limit what an agent can see. Write validation ensures that an action is allowed before it touches the system of record. That is what makes the wrap approach viable in production, not just in a demo.

This is the same pattern as microservices adoption. Teams didn't rewrite monoliths overnight; they carved out bounded contexts and evolved gradually. The monolith remained, but it was no longer the only interface. A similar move works here: start with read-only APIs for agents, then add event streams for changes, then add write validation for actions that need it. Over time, the abstraction layer becomes the system of engagement for agents while the legacy backend stays as the system of record.

Battery's piece, Defying Gravity: The System of Record in the Age of AI, is worth reading for the strategic framing. It lays out the tension more fully than I can here. My conclusion is simple: the next few years won't be about replacing existing systems of record with agent-native alternatives. They'll be about building the data and governance layer that lets agents use what's already there. That layer is the real near-term opportunity.

Originally covered at battery.com ↗