There’s a thesis making the rounds that I think is half right in a way that matters.
The argument, most sharply articulated by Foundation Capital in their “context graphs” piece, goes like this. The last generation of enterprise software — Salesforce, Workday, SAP — became worth billions by owning what happened. The final price. The approved discount. The closed ticket. But those systems record outcomes and throw away the reasoning that produced them. The next trillion-dollar layer, the argument goes, will own why it happened: a living record of decision traces, captured as agents execute workflows, stitched across time so precedent becomes searchable.
I think they’re right about the prize. The “why” is the thing enterprises have never systematically kept, and it’s the thing that turns out to matter most the moment you try to get an AI agent to act on anyone’s behalf. An agent with rules but no precedent is a liability. So far, so good.
Where I think the thesis is wrong is the part everyone has glossed over: where the why actually lives.
The commit point is a fiction
The context-graph argument assumes a decision is an event with a location. Somewhere there’s a moment — a commit point — where reasoning gets emitted as a structured byproduct of work. The whole strategic debate that’s followed has been an argument about that point: should you sit in it as it happens (the “write path”), or reconstruct it after from logs and warehouses (the “read path”)? Being in the write path is treated as the winning position, the thing startups can do that incumbents can’t, because you’re present at the moment the decision commits.
Here’s the problem. For the decisions that are actually worth understanding, there is no such moment.
Let me make it concrete, from the world I build in. A property manager pulls up a unit’s record. The system of record is clean: repair completed, owner responsible for cost, invoice issued. Every field correct. So the new manager — the last one left eight months ago — bills the owner. Except three years earlier, buried in an email thread between the previous manager, the council president, and a lawyer, the board had quietly accepted responsibility for that repair as part of settling a dispute. Billing the owner doesn’t collect a receivable. It reopens a legal fight the organization already paid to close. The system of record wasn’t wrong. It was silent — because the decision that mattered never touched it.
That’s not an exotic failure. That’s how most consequential decisions work. The choice wasn’t made at an instant and then recorded. It emerged. There were three calls. A thread that went sideways. Someone’s quiet reservation. A meeting where the room slowly turned. By the time anyone typed the outcome into a system, the deciding was already over. The record isn’t the decision. It’s the residue of the decision.
So ask the question the write-path camp can’t answer: when someone joins two years from now and asks why — what commit point is going to tell them? What structured event, captured by what orchestration layer, is going to reconstruct the argument that actually produced the choice? None. The event log says what was selected. The reasoning — the whole reason the question is worth asking — happened in a conversation that no piece of software was ever in.
The write path captures execution, not institutional judgment
Notice which examples the context-graph thesis always reaches for. Triage this support ticket. Approve this discount below threshold. Resolve this incident. These are real, and they genuinely do have a commit point an agent can sit at — because they’re transactional: one actor, one step, a rule plus maybe an exception. An agent executes the workflow, and the trace falls out as a byproduct.
And to be fair: that’s real value. The transactional traces agents generate will make routine work dramatically more consistent, and the companies building that layer are building something worth building. But it’s a different asset than the one the thesis promises. Nobody convenes three meetings to approve a fifty-dollar refund. The expensive decisions — the ones with real money or risk or consequence attached, the ones someone will interrogate years later — are the opposite of transactional. They’re deliberative. Multi-party. Spread across channels and across weeks. And here’s the uncomfortable correlation: the value of a decision and its deliberativeness rise together. The more a decision matters, the less likely it is to have happened at a commit point, and the more likely it is to have been argued into existence through sustained communication.
Which means the write path systematically captures the trivial decisions and systematically misses the valuable ones. It’s not the wrong layer — it’s a different layer, doing operational work while wearing the language of the crown jewels. Execution memory and decision memory are orthogonal assets, and only one of them was ever going to be found at a commit point.
Decisions are discourse
Here’s the reframe I’ve landed on after a year of building in exactly this problem: a real decision is not an event. It’s a discourse.
The unit isn’t a commit. It’s a conversation that converges. And once you see it that way, the entire write-path-versus-read-path debate looks like an argument about the wrong thing — two camps fighting over where the button is, when there was never a button. The “why” was never going to be found at the commit, because the why is the conversation, and the commit is just what’s left when the conversation ends.
You cannot bolt orchestration onto a hallway conversation. You cannot put an event schema on the call where the CFO talked the CEO out of vendor B. When the decision is deliberative, the orchestration layer is exactly as blind as the data warehouse it looks down on.
The obvious objection: someone already owns the conversation
If decisions live in email, chat, documents, and meetings, then the honest reader is already asking the hard question: doesn’t Microsoft own this? Google? They own the pipes the discourse flows through. Copilot sits on top of Outlook, Teams, and SharePoint. If the why is in the correspondence, haven’t the communication incumbents already won?
No — and the reason is the most important distinction in this whole argument: owning the storage of a conversation is not the same as being able to read a decision out of it.
What Copilot does with your email is recall. Find the thread. Summarize the meeting. Answer “what did Sarah say about the budget?” That’s retrieval over text, and the horizontal players will do it well. But recovering a decision is a different operation entirely. It requires knowing what a decision looks like in a given domain — what counts as a matter, who has authority to close it, what supersedes what, when a thread that went quiet actually converged versus merely stalled, which precedent binds and which was a one-off exception. A general-purpose assistant reading a governance dispute sees fourteen emails. A system with a theory of the domain sees a decision with a rationale, an authority chain, a settlement condition, and a landmine attached to a unit number.
That’s not a summarization problem. It’s a reconstruction problem, and reconstruction requires domain structure the horizontal players have no incentive to build for any single industry. The pipe owners will win recall everywhere. Decision memory will be won vertical by vertical, by whoever builds the domain theory that turns correspondence back into judgment. The moat was never access to the email. It’s knowing what the email means.
Where the residue is dense
One more piece of honesty, because it sharpens rather than weakens the thesis. Written residue is a biased sample of deliberation. Some of the real argument was a phone call, a whiteboard, a hallway. Any product claiming to capture “the why” in full is lying — and worse, in domains where the decisive conversations happen off the record, a confidently reconstructed wrong why is more dangerous than no why at all.
Which is exactly why this isn’t a build-anywhere thesis. The recoverable fraction of the why varies enormously by industry, and the place to build is where deliberation is forced into artifacts — domains where governance, regulation, or liability require the argument to happen in writing. Board decisions that must be minuted. Approvals that must be correspondence. Disputes where the paper trail is the legal record. In those domains, the residue isn’t a lossy shadow of the discourse; it’s most of the discourse, deposited under obligation. The selection bias that dooms this approach horizontally becomes a market-selection principle vertically: go where the conversation cannot legally stay in the hallway.
That’s also where the pain is worst. Governance-heavy industries run on volunteer boards and high-turnover staff. The person who was in the room leaves, and the reasoning leaves with them — while the obligation to act consistently with past decisions stays. The record persists; the judgment evaporates. That gap is where organizations step on their own settled decisions, over and over.
Why this matters beyond any one product
If you accept that decisions are discourse, a lot of the current AI-agent gold rush looks like it’s digging in the wrong spot. Enormous effort is going into agents that sit at commit points and capture structured traces — and that effort will produce real value for the transactional half of the work. But the reasoning a company most needs its agents to understand — the judgment, the precedent, the “why we do it this way here” that walks out the door when an experienced person leaves — was never at a commit point to begin with. It’s in the correspondence. It always was.
The organizations that figure out how to recover it — to turn the conversation that produced a decision back into something a person or an agent can query two years later — are the ones whose institutional knowledge will actually compound instead of evaporating with every departure. And the companies that build that recovery won’t be the ones with the biggest pipes or the most commit points. They’ll be the ones who understood a specific domain deeply enough to read its conversations back.
The decision was never in the software. It was in the conversation the whole time. The work — the hard, unglamorous, worth-it work — is learning to read it.