Context Graphs: AI’s Trillion Dollar Opportunity

Core Concept

A context graph is a living record of decision traces stitched across entities and time, making precedent searchable and explainable. It captures the critical missing layer in enterprises: why decisions were made, not just what happened.

Source: Foundation Capital analysis by Jaya Gupta and Ashu Garg

The Core Distinction: Rules vs Decision Traces

Rules tell agents what should happen in general

“Use official ARR for reporting”
“Cap renewals at 10% unless exception approved”
Static, pre-defined logic

Decision traces capture what happened in specific cases

“We used X definition, under policy v3.2, with a VP exception”
“Based on precedent Z, here’s what we changed”
Dynamic, precedent-based learning

Why Both Matter

Agents don’t just need rules—they need access to decision traces showing:

How rules were applied in the past
Where exceptions were granted
How conflicts were resolved
Who approved what
Which precedents actually govern reality

Why Context Graphs Matter Now

The Agentic AI Inflection

Enterprises are moving from 80% automation acceptable for pilots to 99% automation required for production. This shift requires something raw capability doesn’t solve: organizational memory.

Without context graphs:

AI agents guess or fail to recognize precedent
Exceptions aren’t recorded—they get re-learned in Slack every quarter
Why decisions were made is lost

With context graphs:

Agents traverse entire decision lineage (CRM → partnership history → strategic account status → exception precedents → approvals)
Exceptions become encoded as searchable precedent
System learns from past decisions instead of repeating them

Real Enterprise Example

Scenario: Customer service agent decides whether to approve 40% discount on high-value contract.

Without context graph:

Binary choice: approve (violate policy) or deny (lose customer)
Agent has no way to recognize strategic context

With context graph:

Agent traverses: Customer profile → 3-year partnership commitment → strategic reference account status → policy v3.2 allowing exceptions for strategic accounts → prior VP approvals for similar cases
Routes informed decision to Finance
Records decision trace for future precedent

The Structure

Context graphs consist of:

Entities – Business objects (accounts, renewals, tickets, incidents, policies, approvers, agent runs)

Decision events – Moments that matter (approvals, exceptions, overrides, policy applications)

“Why” links – Connections explaining rationale and precedent

Over time, the graph naturally forms through:

Agent gathers context from multiple systems
Evaluates policies and rules
Resolves conflicts and exceptions
Records decision trace at execution time
Graph grows as similar cases repeat

How It Compounds

The feedback loop is what makes context graphs powerful:

Capture decision traces → Searchable precedent
Use precedent → Better agent decisions
Record more traces → Richer precedent library
Repeat → Increasingly autonomous system

This doesn’t require full autonomy on day one. It starts with human-in-the-loop:

Agent proposes, gathers context, routes approvals
Human makes decision
Trace gets recorded as durable precedent (not lost in Slack)
System grows smarter with each decision

Beyond Current Systems of Record

Traditional systems of record (Salesforce, Workday, SAP) own canonical data about objects:

Current state storage
Customer data, employee records, operations

Context graphs are systems of record for decisions:

Historical lineage (not just current state)
Decision rationale and precedent
Cross-system context
Why policies were applied the way they were

Why Incumbents Can’t Build This

Three structural barriers prevent traditional software companies from capturing decision traces:

1. Current State Architecture

Salesforce, ServiceNow, Workday inherit architectural limitations:

Built on current state storage
Know what opportunity/ticket looks like NOW, not when decision was made
When discount gets approved, justifying context isn’t preserved
Can’t replay state at decision time → can’t audit or learn

2. Siloed Viewpoint

Operational incumbents only see their domain:

Support escalation depends on: customer tier (CRM) + SLA terms (billing) + recent outages (PagerDuty) + churn risk (Slack)
No incumbent sees this because no incumbent sits in cross-system path
They inherit parent’s blind spots

3. Read Path, Not Write Path (Data Warehouses)

Snowflake, Databricks receive data via ETL after decisions are made:

Can query historical snapshots
Can tell you what happened
But decision context is already gone by the time data lands in warehouse
They see reads after the fact, not writes at decision time

Structural Advantage: Orchestration Layer Startups

Systems of agents startups have unique position:

In the execution path where decisions happen
Pull context from multiple systems
Evaluate rules, resolve conflicts, act
Capture full context at decision time (not after ETL)
See: inputs gathered, policies applied, exceptions granted, approvals, state written

This orchestration position is what enables context graph capture.

Strategic Implications

The Real Question

Isn’t whether existing systems of record survive. It’s:

Will entirely new systems of record emerge for decisions?
Will those become the next trillion-dollar platforms?

Incumbent Response

Try acquisitions to bolt on orchestration
Lock down APIs, adopt egress fees
Push “keep everything in our ecosystem”
Build agent frameworks

But: Capturing decision traces requires being in execution path at commit time, not bolting on governance after the fact. Incumbents can’t insert themselves into orchestration layer they were never part of.

The Compound Effect

Over time, context graphs become the real source of truth for autonomy because they explain not just what happened, but why it was allowed to happen.

Questions that get answered:

“Why did we make this decision?”
“What precedent governed this?”
“When can this rule be overridden?”
“Should this agent have approved this?”

These are questions no existing system can answer systematically.

Key Takeaways

Context graphs aren’t “LLM chain-of-thought”—they’re durable decision lineage
They require being in the execution path at decision time
They compound over time as similar cases repeat
They’re the missing infrastructure for enterprise agentic AI at scale
New platforms of record will emerge around decision lineage, not just object state

References

Foundation Capital: “AI’s Trillion-Dollar Opportunity: Context Graphs” (https://foundationcapital.com/context-graphs-ais-trillion-dollar-opportunity/)
Authors: Jaya Gupta, Ashu Garg

Context Graphs in Agent Architecture – How context graphs emerge from orchestration layers
Context Graphs - Startup Opportunities – Market signals and three strategic paths
Systems of Record Evolution – How AI changes enterprise software platforms
Model Context Protocol – Infrastructure for agent tool integration
OpenAI Frontier – Enterprise agent platform with decision tracing

Explorer

Context Graphs - AI's Trillion Dollar Opportunity