Decision Traces Are Just Receipts

In 1931, the philosopher Alfred Korzybski coined the phrase "the map is not the territory" to capture a deceptively simple truth: our representations of reality are not reality itself, and confusing the two leads us astray.

A map is useful precisely because it compresses, but that compression always loses something essential. Enterprise software has been building maps for decades, and we have gotten very good at it.

Today, there's a debate raging about how to build the next map for the AI first enterprise.

@JayaGup10 and @ashugarg argue we need Context Graphs composed of "decision traces"—stitching the exceptions, overrides, approvals, precedents, and cross-system context that happen in the orchestration layer to create a new system of record for decisions.

@akoratana argues we need "World Models," where agents act as "informed walkers" through these graphs of events and trajectories, learning the "physics" of the organization (how decisions flow, how exceptions propagate, who influences whom) enabling simulation and counterfactual reasoning.

They are both right about the problem: Systems of Record (CRMs, ERPs) are failing us because they store state (what is true) but ignore reasoning (why it is true).

But their approaches are flawed because they still try to build from the same lossy foundation.

At the end of the day, both are attempting to create a higher-fidelity map using stateful, sanitized artifacts: JIRA tickets, approval logs, state changes, and decision receipts.

A more detailed map – no matter how richly connected, traversed by agents, or simulated – still compresses away the dynamism of reality. The raw ambiguity, social nuance, hidden variables, fleeting intuitions, and unrecorded context that drive real decisions are irreversibly lost the moment they're forced into structured fields, logs, or even "traces" of orchestration outputs.

Companies don't need another map, even a smarter or dynamic one. They need a System of Memory.

The Question No Organization Can Answer

Every organization has a question it cannot answer about itself. A simple one: Why do we do it this particular way?

The answer exists, scattered across a Slack thread from 2021, a meeting no one recorded, a long dead email thread, a departed employee's intuition or a compromise that became precedent. The organization made the decision. It just doesn't remember making it. This is not a failure of documentation. It is the natural consequence of how organizations work.

Modern organizations are fragmented. Structurally by team boundaries, by communication channels, by systems of record each optimized for a narrow slice of reality; and by time itself as institutional knowledge decays with turnover. For over a century, management theory has responded to this complexity with one core idea: process.

The promise of "process" was: decompose work into repeatable steps, reduce ambiguity, and improve coordination. Enterprise software is the technological descendant of this worldview. SaaS emerged and grew by formalizing existing processes. CRM encoded sales. ERP encoded operations. HR systems encoded employee lifecycles.

This approach works. But only locally.

Processes scale within lanes, rather than across them. As organizations grow, they accumulate dozens of partially overlapping processes, each embedded in its own tool with its own schemas. Coordination across these systems falls to humans, via meetings, escalation calls, and informal negotiation.

This is how fragmentation emerges despite heavy investment in "best-in-class" tooling.

The "Process" is a Lossy Compression Algorithm

What is underappreciated is that every process is, by necessity, a form of lossy compression. Every process is a form of data deletion.

A process takes an ambiguous dynamic reality, whether that's customer leverage, political nuance, strategic trade-offs, and forces it into a simplified structured representation. This isn't necessarily a flaw.

But consider what this compression actually means:

• The deal negotiation (hours of calls, relationship nuance, unspoken rage) becomes a CRM stage change.
• The architecture debate (whiteboards, arguments, trade-offs) becomes a JIRA ticket.
• The strategic pivot (weeks of alignment) becomes a KPI target.
• The offhand comment in a hallway chat that sparked a product pivot becomes... nothing at all.

The moment a human enters data into a System of Record, they are sanitizing the context that produced that data. The problem amplifies when organizations stack compression on top of compression.

Take a decision trace like:

• A customer requests a pricing exception
• VP of Sales approved 15% discount
• This was based on Policy v2
• It happened 3 months ago

This is a receipt. It is useful for an audit, but it is useless for intelligence.

The receipt tells you the rule was applied and the exception granted.

But it doesn't capture the tone of the customer's voice that worried the VP. It doesn't preserve the real-life conversation where the policy was interpreted to mean "use your best judgment." Or that the CFO mentioned budget pressure in a side conversation.

By the time a decision reaches the orchestration layer, the critical context has already been stripped away. You are tracing the output of the decision, instead of the inputs that informed it.

This happens everywhere. Deals collapse into CRM records. Justifications live in meetings. Risks are debated in Slack. Finance records the number. Each system is internally coherent, but none preserves the reasoning that connected context to action.

World Models Can't Be Built on Sand

@akoratana proposed an interesting idea. He argues that if agents "walk" these decision traces enough times, they will build a "World Model" of the organization. A simulator that understands organizational physics.

This analogy works for robotics because gravity is consistent. It works for code because compilers are deterministic. But it fails for organizations because organizational physics are social, contingent, and often irrational – not mechanical.

If you train a World Model on sparse, compressed data (logs and traces), you get a low-resolution simulator that hallucinates causality.

The agent will see that "Discounts get approved on Fridays," and simulate that Friday is the best day to ask. It misses the hidden variable: The CFO is in a good mood because he plays golf on Friday mornings.

The agent will see that "Feature X was prioritized over Feature Y," but miss that it was only because a Key Customer threatened to churn in a private email thread.

A model training on decision traces is like a lawyer training only on verdicts, without ever reading the case files, the depositions, or the evidence. They might predict the outcome statistically, but they will never understand the law – or simulate novel scenarios reliably.

There's also a deeper issue: most organizational context doesn't crystallize at decision points. It accumulates continuously in how a customer relationship evolves over months, in the informal understanding a support lead develops about which accounts are actually at risk, in the background knowledge that one VP's approval means something different than another's.

Decision traces capture the moment of commitment. They miss the slow accretion of understanding that made the decision legible. If you build a context graph on top of today's rigid processes, you are indexing the bureaucracy. You are not capturing the essence of the business.

Systems of Record to Systems of Memory

What would it take to actually capture the business, and not just the bureaucracy? Decision traces try to preserve understanding by logging the path through formal systems. But the understanding they're trying to capture doesn't live in formal systems. It lives in the Zoom calls, the Slack threads, the email chains, the design docs, and the "quick syncs."

It lives, in other words, in memory. Not an individual's memory, which walks out the door when employees leave. Something more durable: organizational memory. Something persistent, queryable, continuously updated from the raw substrate of how work happens.

To build this, we must invert our assumptions. Structure should not be the input to the system; structure should be derived from the mess. Instead of starting with workflows or decision points, start with a simpler premise: organizational reality is unstructured, continuous, and context-rich, and software must accept this as a first-class constraint. A System of Memory must ingest the raw audio of the business.

What does this mean concretely?

• Don't just log that a merge request happened; it must ingest the PR comments and the design debate to understand why the code is fragile.
• Don't just log the deal close; it must ingest the six months of emails to understand who actually holds the budget.

When you have a System of Memory, you stop asking: "What is the state of this record?" You start asking the questions that actually matter – the ones only a founder or a tenured employee can currently answer:

• "Why do we actually win against Competitor X?" (Not what the CRM picklist says, but what the customer emails actually say)
• "Who is the real decision-maker on this account?" (Not the person listed as "Buyer" in the CRM, but the person who asks the hard technical questions on Zoom)

The "context graph" isn't something you build by stitching together APIs and approval logs. It is something you extract from the raw substrate of organizational life. Different roles see different projections over the same underlying organizational memory, governed by authority, permission, and intent. Processes then become views, not foundations.

People are correctly identifying that the "System of Record" is dying. But replacing it with a "System of Decision Traces" or simulated "World Model" atop traces is just adding a better audit log and simulator to a decaying, lossy form.

The next trillion-dollar platform won't be built by creating a new map. It will be built by living in real-time channels and crafting a new memory architecture that preserves reality before it's compressed. We don't need to simulate the organization from receipts. We just need to remember it truthfully.