The next major value shift in enterprise software is not about who controls the data, but who captures reasoning and judgment—areas where incumbents built for an earlier era are fundamentally disadvantaged.
There’s a certain pattern in enterprise technology that repeats with each major platform shift: the layer that captures disproportionate value changes, and companies optimized for the old layer become structurally disadvantaged—not because they lack capability, but because their architecture was built to win a game that’s no longer being played.
In the mainframe era, the control point was hardware. IBM’s dominance came from owning the physical infrastructure. In the PC era, it shifted to the operating system—Microsoft captured the value while hardware commoditized. In the internet era, it moved again to aggregation and intent; Google didn’t need to own content, just the layer where users expressed what they wanted. And for the past two decades, the control point in enterprise software has been the System of Record.
Salesforce, SAP, ServiceNow, Workday—the defining enterprise companies of the SaaS era—all share a common trait: they became the authoritative source of truth for critical business objects. The customer record. The financial transaction. The employee file. The support ticket. Once you were the System of Record, you had gravity. Integrations pointed toward you. Workflows depended on you. Switching costs compounded annually.
As AI agents move from the periphery to the core, it becomes clear: the System of Record was valuable to humans who needed a canonical place to manage business state. Agents, however, require reasoning, not just data.
The Reasoning Gap
Consider what a System of Record actually captures. When a support ticket moves from “Open” to “Resolved,” the CRM faithfully logs the state change: Ticket #4471, Status: Closed, Timestamp: 2024-03-15 14:23:07. What it doesn’t capture is why that ticket was resolved the way it was.
Maybe the agent granted a refund outside the normal policy because the customer was flagged as high-value. Maybe they escalated to a specialist because the issue was related to a known bug in the latest release. Maybe they found a workaround documented in a Slack thread from six months ago. The reasoning—the chain of context, policy interpretation, and judgment that led to the outcome—lives in the operator’s head, scattered across email threads, or lost entirely.
This never mattered much when humans were the operators. Humans bring their own reasoning to the system. They read the ticket, assess the situation, recall relevant context, and act. The System of Record just needed to track the result.
AI agents can’t do this. They lack institutional memory, tacit knowledge, and a sense of “how we handle things here.” Feed an agent your Salesforce data, and it knows that Customer X had three support tickets last quarter. It doesn’t know why Customer X always gets expedited handling, or that the account is managed by someone with a specific communication style, or that there’s an unwritten policy about escalation paths for their industry vertical.
This is the reasoning gap. And it represents the most significant architectural mismatch between the SaaS era and the agentic era.
What Systems of Record Don’t Capture
The gap becomes concrete when you list what’s missing. The issue isn’t dirty or siloed data; the reasoning connecting data to action was never treated as data in the first place.
Exception logic that lives in people’s heads. “We always give healthcare companies an extra 10% because their procurement cycles are brutal.” That’s not in the CRM. It’s tribal knowledge passed down through onboarding and side conversations.
Precedent from past decisions. “We structured a similar deal for Company X last quarter—we should be consistent.” No system links those two deals or records, or explains why the structure was chosen.
Cross-system synthesis. The support lead checks the customer’s ARR in Salesforce, sees two open Zendesk escalations, reads a Slack thread flagging churn risk, and decides to escalate. That synthesis happens in their head. The ticket just says “escalated to Tier 3.”
Approval chains that happen outside systems. A VP approves a discount via Zoom call or Slack DM. The opportunity record shows the final price. It doesn’t show who approved the deviation or why.
This is what “never captured” means. The reasoning that connects data to action—the exceptions, overrides, precedents, and cross-system context—currently lives in Slack threads, deal desk conversations, escalation calls, and people’s heads. Agents encounter the same ambiguity humans resolve every day through judgment and organizational memory. But the inputs to those judgments aren’t stored as durable artifacts.
Why Incumbents Built the Wrong Thing
It’s worth understanding why Systems of Record evolved the way they did. The design constraints of enterprise software circa 2005-2020 were clear: store structured data reliably, enforce business rules deterministically, scale to millions of records, and pass audits. The schema was king. Every field typed, every relationship defined, every state transition validated.
This made perfect sense. Determinism is a feature, not a bug, when the goal is compliance, auditability, and data integrity. You want your ERP to calculate the same result every time. You want your CRM to enforce permissions identically across all users. The entire value proposition of enterprise software was predictability—these systems codified your processes so they’d run the same way regardless of which human was operating them.
The optimization function was always to make humans more efficient at interacting with business data. The interface was designed for human eyes (dashboards, forms, reports). The workflows were designed for human decisions (approval queues, notification emails, task assignments). The integrations were designed for human actions (button clicks triggering API calls).
None of this infrastructure contemplates a world where the primary user isn’t human.
When an AI agent needs to process a support ticket, it doesn’t want a dashboard; it wants structured context. It doesn’t want a notification email; it wants to query for precedent. It doesn’t want an approval queue; it wants to understand the policy logic well enough to act autonomously or know exactly why it can’t.
The incumbent architecture gives it none of this.
Two Failure Modes
The obvious response is: won’t incumbents adapt? Salesforce has Agentforce. ServiceNow has Now Assist. Snowflake is pushing Cortex. Databricks is building AgentBricks. They see what is coming.
The problem isn’t awareness; it’s architecture. There are two distinct failure modes, depending on the type of incumbent.
Operational incumbents are siloed and prioritize the current state. Salesforce is built on current-state storage: it knows what the opportunity looks like now, not what it looked like when the decision was made. When a discount gets approved, the context that justified it isn’t preserved. You can’t replay the state of the world at decision time, so you can’t audit the decision, learn from it, or use it as precedent.
These systems also inherit their parents’ blind spots. A support escalation doesn’t live in Zendesk alone. It depends on customer tier from the CRM, SLA terms from billing, recent outages from PagerDuty, and the Slack thread flagging churn risk. No operational incumbent sees this full picture because no operational incumbent sits in the cross-system path.
Warehouse players have the opposite problem: they’re in the read path, not the write path. Snowflake and Databricks are positioning themselves as the “truth registry” layer for AI. Warehouses do have a time-based view; you can query historical snapshots, track how metrics changed, and compare states across periods. But warehouses receive data via ETL after decisions are made. By the time data lands in Snowflake, the decision context is gone.
A system that only sees reads, after the fact, can’t be the system of record for decision lineage. It can tell you what happened, but not why.
Being close to where agents get built isn’t the same as being in the execution path where decisions happen. Capturing decision traces requires being present at commit time, not adding governance after the fact.
The Context Graph
The emerging answer to the reasoning gap is what might be called the Context Graph—a system of record for decisions, not for objects.
Unlike a traditional knowledge graph—which maps static relationships between entities (Customer A bought Product B from Salesperson C)—a Context Graph captures temporal decision traces: the inputs, the reasoning, the policies applied, the outcome, and critically, the exceptions. It’s the “why” layer sitting above the “what” layer of traditional databases.
Here’s what this looks like in practice: A renewal agent proposes a 20% discount. Policy caps renewals at 10% unless a service-impact exception is approved. The agent pulls three SEV-1 incidents from PagerDuty, an open “cancel unless fixed” escalation in Zendesk, and the prior renewal thread where a VP approved a similar exception last quarter. It routes the exception to Finance. Finance approves. The CRM ends up with one fact: “20% discount.”
The Context Graph captures the full trace: which inputs were gathered across systems, which policy was evaluated, which exception route was invoked, who approved, and what state was written. The “why” becomes first-class data.
Over time, these traces form a queryable structure. The entities the business already cares about (accounts, renewals, tickets, incidents, policies, approvers) get connected by decision events and “why” links. Agents can query for precedent: “How have we handled similar refund requests from enterprise customers in financial services?” becomes answerable, not because someone tagged all the relevant cases, but because the reasoning context was captured at execution time.
The Hard Problems
Intellectual honesty requires acknowledging that building this is harder than it sounds. Three problems lurk beneath the surface.
First, reasoning capture is inherently lossy. Language models don’t reason like humans; they generate token sequences that approximate reasoning. Capturing “why” without freezing brittle rationales, explanations that look coherent but don’t actually reflect the causal logic, is nontrivial.
Second, there’s a difference between post-hoc explanation and true reasoning. If reasoning traces are reconstructed after the fact, they risk becoming narratives rather than causal records. The system might generate a plausible-sounding justification that wasn’t actually the basis for the decision.
Third, storing detailed reasoning exposes the organization to legal liability. “We bent policy because this customer threatens churn” is exactly the kind of decision logic that becomes problematic in discovery. Organizations may resist capturing the very information that makes agents effective.
And there’s a deeper technical challenge: context graphs require joins across coordinate systems that don’t share keys. Traditional databases solved joins decades ago; you have a customer_id, an order_id, and a foreign key relationship. But organizational reasoning requires connecting what happened (events) to when it happened (timeline) to what it means (semantics) to who owned it (attribution) to what it caused (outcome). These are five different coordinate systems. None of them shares a primary key. The join condition isn’t equality; it’s probabilistic resolution across representations.
This suggests that the winners won’t simply “log chain-of-thought.” They’ll need abstraction layers on top of reasoning, similar to how databases abstracted over memory management. The company that solves this elegantly, capturing enough judgment to enable agent learning while managing the lossy, legal, and epistemological risks, will have built something genuinely new.
The “Headless CRM” Scenario
This brings us to what might be the central strategic threat facing SaaS incumbents: the risk of becoming headless.
Consider Sierra, the customer support agent company founded by Bret Taylor, which reportedly reached $100M in ARR in just 7 quarters. Sierra doesn’t replace Salesforce or Zendesk—it sits above them. It integrates with the System of Record, pulls the relevant customer data, but handles the actual interaction and reasoning. The agent does the work; the CRM just stores the result.
In this architecture, Salesforce becomes infrastructure. Necessary, yes: regulators still care about audit trails, money still settles somewhere, and when agents conflict or hallucinate, enterprises need a canonical ledger to arbitrate. But necessary is not the same as valuable. The intelligence, the customer relationship, and the workflow optimization—all live in the agent layer. The CRM is reduced to a write-back sink with reliable uptime.
This is the headless scenario, analogous to what happened to publishers when Facebook became the dominant distribution layer for content. Publishers still created the content; Facebook captured the audience relationship and the advertising economics. Similarly, the CRM still stores the data; the agent layer captures the interaction and the reasoning value.
Where New Systems of Record Emerge
There’s a useful heuristic for predicting where entirely new systems of record—systems of record for decisions—are likely to emerge: look for the glue functions.
RevOps exists because someone has to reconcile sales, finance, marketing, and customer success. DevOps exists because someone has to bridge development, IT, and support. Security Ops sits between IT, engineering, and compliance.
These roles are a tell. They emerge precisely because no single system of record owns the cross-functional workflow. The org chart creates a position to carry the context that software doesn’t capture.
An agent that automates a glue function doesn’t just run steps faster; it can persist the decisions, exceptions, and precedents the role was created to produce. That’s the path to a new system of record: not by replacing an incumbent, but by capturing a category of truth visible when agents are in the workflow.
Service-as-Software and Market Expansion
There’s a second-order effect of this shift that deserves attention: the collapse of the distinction between software companies and services companies.
Traditional SaaS competed for IT budgets—typically 5-7% of enterprise revenue. That spending was constrained by the number of people who needed access to the tools. Ten seats of Salesforce, fifty seats of Zendesk, two hundred seats of Office 365. The pricing model (per-user-per-month) both reflected and reinforced this constraint.
AI agents don’t consume seats; they consume compute. They don’t enhance human productivity; they replace human labor. This shifts the competitive frame from “tool budget” to “labor budget.” The market isn’t the $80 billion spent on CRM and support software. It is the $400+ billion spent on contact center labor. It’s not the $20 billion legal tech market. It is the $1 trillion+ legal services market.
The math is stark. A human support agent costs $50-150/hour fully loaded. An AI agent costs $0.50-5.00/hour in compute and API fees. That is a 10-100x cost advantage before considering availability, consistency, and scalability.
This cost structure enables Service-as-Software: companies that sell outcomes (a resolved ticket, a reviewed contract, a qualified lead) rather than access to tools. The economic model looks like software (70-80% gross margins) but competes in service markets (10-50x larger than the corresponding software categories).
Crucially, incumbents cannot embrace this without cannibalizing themselves. Salesforce can’t easily pivot to charging per resolved ticket when its entire revenue base depends on seats. Every support ticket resolved by an agent is a seat that might not get renewed. The incentives are precisely backward.
Precedent as the New Moat
Here’s the implication that matters most: in the agentic era, the defensible asset is not data, but precedent.
In the SaaS era, the moat was historical data plus switching costs. The more customer records in your Salesforce instance, the harder it is to leave. Data accumulated; gravity increased.
In the agentic era, the moat is accumulated decisions, plus exceptions, plus outcomes. Not what customers did, but how the organization behaves when rules collide with reality. The reasoning traces encode when policies were bent, which edge cases warranted escalation, and how conflicting priorities were resolved.
This is what the Context Graph actually captures when it works: organizational judgment turned into infrastructure. Culture made machine-legible. Once an agent system has processed 10 million edge cases, overrides, and exceptions, that corpus of precedent becomes the defensible asset, not the CRM rows beneath it.
The strategic implications are significant:
Early deployment matters more than feature completeness. The company that starts capturing decision traces now, even imperfectly, will have a compounding advantage over the company that waits for perfect architecture.
Scale of decisions, not scale of users, determines dominance. A startup processing millions of support resolutions builds a moat faster than an incumbent with millions of seats but no reasoning capture.
Winners may look unimpressive at first, but compound fast. Judgment accumulates. Each decision that gets captured, evaluated, and fed back into the system makes the next decision better. This is a flywheel that data gravity alone cannot match.
The Stakes
The question isn’t whether systems of record survive—they will. Regulators don’t care about your Context Graph; they care about audit trails. Money still settles somewhere. When agents conflict or hallucinate, enterprises need a canonical ledger.
The question is whether the next trillion-dollar platforms are built by adding AI to existing data, or by capturing the decision traces that make data actionable.
Systems of Record won’t disappear; they remain the necessary substrate for compliance, finality, and arbitration. But they’ll stop being the value-capturing layer. That role passes to whoever owns the reasoning.
The SaaS era monetized state. The agentic era will monetize judgment. And judgment compounds faster than data.