Consumer platforms built one of the most powerful business models of the last two decades around a compounding loop: every user interaction became a signal that improved the system. Netflix, Meta, Amazon, TikTok, and Google did not just record outcomes. They instrumented behavior with extraordinary granularity, what you clicked, what you ignored, what you hovered over, what you abandoned, what brought you back and fed those signals into systems that learned. That loop: capture, learn, improve, capture again - became one of the great compounding assets of the internet era.
Enterprise software has never had an equivalent loop. Not because enterprise decisions are less frequent, but because they were harder to observe.
Consumer systems operate inside controlled interfaces where a single user acts within a product the company fully owns. Enterprise decisions are fundamentally different: they are multiplayer negotiations across sales, finance, legal, operations, security, and management with each carrying different incentives, different authority, and different constraints. Sales wants velocity. Finance wants margin. Legal wants precedent control. These decisions are negotiated, not merely clicked. To date, enterprises have lacked instrumentation of the reasoning that connected action to outcome.
B2C companies have been compounding behavioral signals for two decades. B2B companies largely have not. Now, for the first time, that is starting to change.
The old model is breaking
SaaS multiples have compressed because AI is commoditizing the feature layer that justified premium pricing. When an LLM can generate a competent first draft of almost any workflow, the value of "better UI on a known process" collapses — and companies whose moats were features, not data, are the ones being marked down. They built workflows but never built compounding loops
The question is what replaces features as the durable source of enterprise value. The answer is the compounding loop that enterprise software never had, built not on behavioral traces, but on decision traces.
What enterprise software actually captured, and what it missed
is what happens when that layer becomes structured, queryable, and connected across systems, actors, and time.Enterprise systems were built to record end state, not reasoning. A discount field tells you the final number, not why that number was justified. A redlined contract tells you the final clause, not which fallback positions were rejected along the way. A resolved ticket tells you the incident is closed, not why one escalation path was chosen over another. Decision traces sit in that missing layer between event and outcome. Acontext graph
The relevant signals were also sparse, fragmented, and embedded inside human workflows rather than captured as first-class telemetry. Enterprise decisions happened partly in a meeting, partly in someone's head, partly in an email thread, partly in a side conversation, and partly inside systems that did not talk to one another.
And there was no reason to store it. Decision data was treated as process exhaust—ephemeral, disposable—because no system existed that could learn from it. Even when fragments were captured, they rarely compounded. Companies had transcripts, email threads, comments, and approvals, but no practical way to extract structured decision artifacts from them, connect them across systems, and link them to outcomes. The raw material existed in pieces, but the loop did not.
What's changed
Enterprise work now lives on instrumentable surfaces. Work has become distributed and asynchronous. Decisions increasingly get made in comment threads, document suggestions, ticket histories, approval flows, and call recordings. Reasoning that once lived only in someone's head now leaves an increasingly rich trail in the workflow itself.
Language models make the unstructured data computable. For years, companies had transcripts, chat logs, document comments, and ticket histories, but these were mostly searchable, not learnable. Now an LLM can extract decision artifacts from them.. Language models do not eliminate the need for structure or evaluation, but they make it possible to turn previously inert collaboration data into something a system can reason over.
Agents create decision checkpoints automatically. This is the most important shift. Agents propose actions inside workflows, which humans approve, modify, or escalate. An agent drafts a pricing proposal; the sales rep adjusts the discount from 25% to 30% and adds a note: "competitive pressure from Vendor X, need to match their offer." That edit is a decision trace.
The model's proposal is a structured prior, what the system thought was right. The human's modification is the judgment signal, what actually matters that the model missed. As agents insert themselves into more workflows, more judgment is forced to become explicit through edits, approvals, exceptions, and overrides. The instrumentation is no longer o…
continue on X ↗
▶
