The last generation of enterprise software created a trillion-dollar ecosystem by becoming systems of record. Salesforce for customers. Workday for employees. SAP for operations. The next generation will be built on something different: systems of record for decisions, not just objects.
Foundation Capital's recent analysis of context graphs as AI's trillion-dollar opportunity crystallizes what many AI infrastructure teams are discovering: agents don't just need data. They need decision traces. The reasoning that connects data to action. The context that explains not just what happened, but why it was allowed to happen.
This is where Pixeltable fits in. Not as another agent framework or orchestration layer, but as the data plane that makes context graphs possible: the infrastructure that captures, versions, and makes queryable every decision trace your AI systems produce.
The Missing Layer: Decision Traces as Data#
Here's the distinction that matters:
- Rules tell an agent what should happen in general ("use official ARR for reporting")
- Decision traces capture what happened in this specific case ("we used X definition, under policy v3.2, with a VP exception, based on precedent Z")
Traditional systems store the outcome: "20% discount applied." They don't store the reasoning: the three SEV-1 incidents from PagerDuty, the open escalation in Zendesk, the prior approval precedent from last quarter, the policy version evaluated, and the approver who signed off. That context, the decision trace, dies in Slack threads and people's heads.
Pixeltable treats decision traces as first-class data. Every computation, every LLM call, every transformation is automatically versioned and linked in a queryable dependency graph. When your agent makes a decision, you don't just get the output. You get the complete lineage of how that output was derived.
Why Architecture Matters: Read Path vs. Write Path#
The Foundation Capital analysis identifies a critical architectural distinction: warehouses like Snowflake and Databricks sit in the read path: they receive data via ETL after decisions are made. By the time data lands in the warehouse, 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 it can't tell you why."
Pixeltable sits in the write path. Computations happen as data arrives, not after. When you define a computed column that calls an LLM, Pixeltable doesn't just store the result. It captures the full context at decision time:
Every row in this table is a complete decision trace. The inputs, the policy version, the prompt sent to the LLM, the full response, all captured at decision time, all versioned, all queryable. Six months later, you can ask: "Show me all escalation decisions for healthcare customers where the agent recommended override, along with the exact context it saw."
Dependency Graphs Are Context Graphs#
Foundation Capital describes context graphs as "a living record of decision traces stitched across entities and time so precedent becomes searchable." This is exactly what Pixeltable's dependency graph provides, but built into the infrastructure layer rather than bolted on after the fact.
When you create computed columns in Pixeltable, you're not just defining transformations. You're building a context graph:
The dependency graph shows exactly how recommended_action was derived: from the transcript (which came from the audio), combined with churn_risk (which came from sentiment analysis and customer data). This isn't metadata bolted on after the fact. It's the native structure of how Pixeltable processes data.
Time Travel for Decisions: Replaying Context#
The Foundation Capital article notes that Salesforce "knows what the opportunity looks like now, not what it looked like when the decision was made." You can't replay the state of the world at decision time.
Pixeltable's automatic versioning solves this. Every change to every row is tracked. You can query the exact state of your context graph at any point in time:
This is what makes decision traces auditable. Not "here's what the system says now," but "here's exactly what the agent saw, with this policy version, using this model, at this moment in time."
Multimodal Context: Beyond Text#
Here's where Pixeltable's unique architecture becomes even more relevant. Enterprise decision context isn't just text. It's:
- The support call recording where the customer threatened to churn
- The screenshot of the error message they submitted
- The video walkthrough from the sales demo
- The PDF contract with the custom terms
Traditional systems can't treat multimodal artifacts as first-class decision context. Pixeltable can. It's built for multimodal AI applications from the ground up:
The decision trace includes everything: the extracted contract terms, the call transcript, the competitor analysis. All versioned. All queryable. All linked in the dependency graph.
From Decision Traces to Searchable Precedent#
The real power of context graphs emerges over time. As Foundation Capital notes: "Captured decision traces become searchable precedent. And every automated decision adds another trace to the graph."
With Pixeltable's incremental embedding indexes, you can build this precedent search directly into your agent workflows:
Now your agents don't just follow rules. They learn from precedent. "Last quarter, for a similar healthcare customer with similar incident history, the VP approved a 15% exception. Here's why." The decision trace becomes organizational memory.
Incremental Context Graphs: Growing Without Rebuilding#
Context graphs need to grow continuously. Every new decision adds context. Every exception becomes potential precedent. Pixeltable's incremental computation model means the graph grows efficiently:
No ETL pipelines. No batch rebuilds. The context graph is always current because computation happens at write time, not read time. For more on this architecture, see our deep dive on building AI data infrastructure.
The Infrastructure Layer for Agentic Systems#
Foundation Capital identifies three paths for startups in the agentic era: replace existing systems of record, replace modules within systems, or create entirely new systems of record for decisions.
Pixeltable enables all three by providing the infrastructure layer beneath them. Whether you're building:
- An AI-native CRM that captures every sales decision with full context
- A support automation module that tracks escalation reasoning
- A decision audit system that makes agent reasoning queryable
You need the same underlying capabilities: multimodal data handling, automatic versioning, dependency tracking, incremental computation, and vector search over decision traces. That's what Pixeltable provides.
For building agents specifically, see our practical guide to AI agent architecture and building memory-powered stateful agents.
Getting Started: Your First Context Graph#
Building context graphs with Pixeltable starts with treating your agent's decision process as data:
Every row is a complete decision trace. Every computed column is a node in your context graph. Every version is preserved for replay and audit.
The Data Plane for the Agentic Era#
The question isn't whether systems of record survive the shift to agents. They will. The question is whether the infrastructure exists to capture what agents actually need: not just data, but decision traces. The reasoning. The context. The precedent.
Traditional data infrastructure can't do this. Warehouses sit in the read path. Operational systems store current state. Vector databases handle embeddings but not lineage.
Pixeltable provides the data plane that makes context graphs possible:
- In the write path: Computations happen at decision time, not after ETL
- Automatic versioning: Replay the exact state at any decision point
- Dependency graphs: Full lineage of how outputs derived from inputs
- Multimodal native: Images, video, audio, documents as first-class context
- Incremental: Context graphs grow without rebuilding
- Queryable: SQL + vector search over decision traces
The next trillion-dollar platforms will be built on systems of record for decisions. Pixeltable is the infrastructure layer that makes them possible.
Get started with Pixeltable and build your first context graph today.
