Foundation Capital’s trillion-dollar thesis rests on one structural observation: whoever sits in the execution path at the moment a decision is made is best positioned to capture the decision trace. It’s a compelling argument. The problem is that Foundation Capital — and the broader VC ecosystem circling this opportunity — may have identified the right mechanism while underestimating who actually occupies the execution path.
01 Start with the Foundation Capital Insight — Then Follow It Somewhere Uncomfortable
Foundation Capital’s trillion-dollar thesis rests on one structural observation: whoever sits in the execution path at the moment a decision is made is best positioned to capture the decision trace. That’s why they bet on vertical agent startups — an AI sales agent that negotiates a discount sees the full context (the customer’s strategic value, the precedent from last quarter, the VP who invoked an exception) in a way that a CRM recording the final price never does.
It’s a compelling argument. And we agree with the structural logic. The problem is that Foundation Capital — and the broader VC ecosystem circling this opportunity — may have identified the right mechanism while underestimating who actually occupies the execution path.
When Claude negotiates a contract, when GPT-5 routes a support escalation, when Gemini processes an expense approval — the model provider’s platform is the execution path. Every tool call, every conditional branch, every exception the agent handles flows through the provider’s infrastructure. The decision trace that Foundation Capital says is worth a trillion dollars is already being generated. The only question is whether anyone persists it.
That framing is directionally correct — for agent-mediated decisions. But it elides two things. The first is something fundamental about how these models actually work, which reshapes who can capture the prize. The second is something the entire “context graph” discourse has been remarkably quiet about: most organizational decisions aren’t agent-mediated at all.
The VP who approved the pricing exception did it in an email. The unwritten escalation rule lives in a tenured employee’s head. The “one-time” discount that quietly became policy was negotiated in a Slack thread that expired from retention last month. These human decisions — scattered across email, messaging, approval workflows, and institutional memory — are the bulk of the trillion-dollar gap Foundation Capital identified. Agents will generate clean, structured decision traces as a byproduct of execution. But today’s gap exists because decades of human decisions were never captured.
The context graph needs to absorb both. Let’s start with the architectural constraint, then return to the capture problem.
02 The Platform Primitives Are Already Shipping
First, let’s establish what’s real. The building blocks for “model-provider-as-context-platform” aren’t theoretical. They shipped in the last four months.
That’s an impressive and accelerating list. And reading it, you’d be forgiven for concluding that the model providers are assembling a context graph — piece by piece, feature by feature — as a natural extension of making agents work better.
But here’s where we need to put a finer point on the architecture. Because there’s a fundamental property of every one of these models that changes who actually owns the context capture opportunity.
03 The Stateless Core — Why This Matters More Than Anyone Is Saying
This sounds like a technicality. It isn’t. It fundamentally changes who can build a context graph — and who has a structural lock on it.
It’s tempting to say “the model provider is the execution path” and leave it there. But that’s not precise enough. The model is a stateless function: context in, completion out, forget everything. The platform — the containers, the memory tools, the session persistence — is a separate layer of infrastructure wrapped around that stateless core. And here’s the critical implication: that wrapping layer can be built by anyone.
Anyone who can write to the context window can provide organizational memory.
The model provider’s advantage is positional, not architectural.
This diagram is the most important one in the series. If the model were stateful — if Claude actually remembered your organization’s decisions the way a human employee does — then Anthropic would have an unchallengeable lock on the decision trace layer. Every interaction would build the model’s internal state, and switching providers would mean losing accumulated organizational intelligence. That would be a true moat.
But that’s not how any of this works. The model is a blank slate on every call. The “memory” is an external system that writes files and injects them into the prompt. And external systems can be built by anyone who sits in the request path — which includes the model provider, yes, but also includes middleware, metadata platforms, agent frameworks, or a new category of company that doesn’t exist yet.
An Atlan MCP server that intercepts agent queries can log every tool call and its result. A LangGraph workflow can persist decision traces at every state transition. A startup sitting between the enterprise and the API can capture the full request-response cycle, build a decision graph from the tool calls, and inject relevant precedent into future sessions — using the exact same mechanism that OpenAI’s Conversations API uses internally.
Statelessness democratizes the capture opportunity. It means the context graph is necessarily an external system. And building external systems that organize, persist, and serve context is exactly what metadata platforms have been doing for years.
But there’s a second constraint that cuts even deeper — and it has nothing to do with model architecture.
An email from a VP saying “approved, but don’t make this a habit.” A Slack thread where three people negotiate an exception. A Jira ticket where the real context is in the fifth comment, not the description. A meeting where the decision was made verbally and never documented. This is where the trillion-dollar gap actually lives right now — not in agent traces that don’t exist yet, but in human decision context that was never captured.
Model provider proximity — sitting in the API execution path — gives you no advantage for this half of the problem. But that doesn’t mean models are irrelevant to human-decision capture. Quite the opposite. The raw data is increasingly accessible: MCP connectors to Gmail, Slack, Jira, and Confluence already exist. Meeting transcripts flow through Otter, Fireflies, and Grain. The plumbing to reach human decision channels is a technical problem that’s being solved.
The harder problem is cognitive. The VP’s email says “approved, but don’t make this a habit.” A human reader with organizational context understands that this means: the exception is reluctant, it shouldn’t set precedent, and the next request will probably be denied. Extracting that structured decision context from unstructured language — identifying the decision, the reasoning, the precedent implications, the stakeholders — is exactly the kind of reasoning LLMs are good at. Arguably uniquely good at. No rules-based system or traditional NLP pipeline could reliably do it.
So the real architecture for human-decision capture is three layers: connectors pull raw communication from email, Slack, Jira, and meetings (technical plumbing). An LLM analyzes the content and extracts structured decision context (cognitive analysis). The structured output gets persisted in a decision trace store and linked to the graph (infrastructure). The model isn’t just a consumer of the context graph — it could be the engine that builds it. But the model provider’s platform proximity doesn’t help here. Any LLM can do the extraction. The advantage goes to whoever has the connectors to feed it and the graph infrastructure to store the output.
So the context graph faces a dual-capture problem with different architectures for each half. Agent decisions will be natively digital, structured, and programmatically loggable — capture is a byproduct of execution. Human decisions require a pipeline: connectors to pull unstructured communication, LLM analysis to extract structured decision context, and graph infrastructure to persist and link it. The first half is about proximity to the execution path. The second half is about connector depth, extraction intelligence, and graph infrastructure — three competencies that no single player dominates.
04 Two Paths to the Same Destination — and a Third Nobody’s Discussing
With the statelessness constraint in view, the competitive landscape sharpens. There are still two paths to building a context graph, but the advantage is more nuanced than “whoever is the runtime wins.”
Path A — The Metadata Platform Approach (Bottom-Up)
Build connectors to 100+ enterprise systems. Crawl schemas, lineage, and quality metadata. Layer in a business glossary with semantic definitions. Add governance policies and access controls. Then extend upward into operational context by intercepting agent interactions via MCP and persisting what agents decide.
Structural advantage: Model-agnostic by nature. An Atlan context graph works regardless of whether the agent runs on Claude, GPT, or Gemini. This maps directly to the “multi-vendor reality” barrier from Part 1 — and statelessness makes it even stronger, because the model has no memory loyalty. Crucially, metadata platforms have the connector infrastructure to reach human decision sources — email, Slack, Jira, Confluence, CRM approval workflows. And because any LLM can serve as the extraction engine for turning unstructured human communication into structured decision records, the metadata platform can use whichever model does it best without being locked to a provider.
Structural weakness: Sits in the agent’s reference path, not the execution path. An agent queries Atlan for metadata but doesn’t make decisions through Atlan. Capturing agent decision traces requires intercepting the full tool-call flow, which is architecturally awkward from the reference position. The human-capture advantage is real but the agent-capture gap is a genuine limitation.
Path B — The Model Provider Approach (Top-Down)
Start by being the platform where agents execute decisions. Every tool call flows through your infrastructure. Add persistent memory, persistent compute, and session state. The decision trace is generated as a byproduct of agent execution — but only if you deliberately build the infrastructure to capture and persist it.
Structural advantage: Closest to the execution path at the platform layer. When PTC runs tool calls inside Anthropic’s sandbox, Anthropic sees the inputs and outputs at a level deeper than external middleware. Easiest path from “agent ran” to “decision was traced.”
Structural weakness: Single-provider. A context store owned by Anthropic doesn’t help when GPT is running the finance workflow. Statelessness means the model itself doesn’t accumulate organizational knowledge — the platform has to do it, which is engineering work that competes with their core mission of making better models. And while the model could extract decision context from human communication — and the connectors to email, Slack, Jira, and approval systems already exist — the provider platforms aren’t building the integrated pipeline that would turn those raw communications into structured decision records in a queryable graph. Their memory tools are designed for agent sessions, not for ingesting and structuring the organizational communication backlog. Provider proximity is an advantage for the agent-mediated slice. It’s underutilized for the human slice.
Path C — The One Nobody’s Discussing (The Interception Layer)
Build a model-agnostic middleware that sits between the enterprise and any model provider. Intercept every API call — system prompts, tool definitions, tool call inputs, tool call outputs, final responses. Persist the full decision chain. Build a graph from the accumulated traces. Inject relevant precedent into future sessions by modifying the system prompt before it reaches the model.
Structural advantage: Model-agnostic. Sees everything the model sees. Doesn’t need connectors — the tool calls themselves carry the operational context. Doesn’t need the model to be stateful — it provides the state externally.
Structural weakness: Requires being in the API request path, which means enterprises must route traffic through it. This is an infrastructure sale, not a SaaS sale. Latency sensitivity. Model providers could block or compete with interception layers by encrypting tool results or restricting API proxying. And like the provider approach, Path C only captures agent-mediated decisions. The human decision trail — email, Slack, meetings — flows through entirely different channels that an API proxy never sees.
Path C is the one that statelessness enables. Because the model can’t tell the difference between context injected by Anthropic’s memory tool and context injected by a third-party proxy, the context graph doesn’t need to be built by the model provider. It can be built by anyone with access to the request path.
But notice what all three paths have in common: they’re all oriented around agent-mediated decisions. Path A captures agent queries to metadata. Path B captures agent tool calls in the sandbox. Path C intercepts agent API traffic. None of them, on their own, solve the harder problem of capturing the human decision trail — the emails, the Slack negotiations, the verbal approvals, the institutional knowledge that lives in people’s heads. The most complete context graph would combine Path A’s connector depth to human systems, Path B or C’s agent-trace capture, and an LLM-powered extraction pipeline that turns unstructured human communication into structured decision records. The pieces exist. The integration doesn’t.
This is genuinely good news for the metadata platforms and for the VC thesis — but with a catch. The window for Path C depends on model providers not closing it. If Anthropic encrypts PTC tool results so only their sandbox can read them, or if OpenAI restricts API proxying for “security” reasons, the interception opportunity narrows. The openness of MCP cuts both ways. And the human-capture problem remains open regardless — it’s orthogonal to the agent infrastructure fight.
05 Four Scenarios for Who Wins
Model providers formalize their existing memory tools into structured decision records. Every agent action gets a persistent trace. But because the model is stateless, these traces are just files — and enterprises demand the ability to export, query, and integrate them with model-agnostic systems.
Providers build the capture. Metadata platforms build the cross-provider unification layer. Neither owns the full picture alone.
As MCP becomes universal, the protocol itself becomes the interception point. A middleware layer that speaks MCP can sit between any agent and any tool, log the full interaction, and build a decision graph from the traffic — without needing to be built by any model provider.
Google’s A2A protocol and the Open Responses spec accelerate this by standardizing cross-agent communication. The context graph emerges from the protocol layer, not the platform layer.
Model providers make their memory tools increasingly proprietary. Claude’s knowledge bases only work with Claude. OpenAI’s Conversations API only persists within the OpenAI ecosystem. Decision traces become platform-locked.
This is the nightmare scenario for enterprises and the dream scenario for metadata platforms, which become the necessary neutral layer to stitch together siloed decision context from three or four providers.
Someone — possibly the Linux Foundation’s Agentic AI group, possibly a consortium of metadata platforms, possibly a well-positioned startup — defines a standard format for agent decision traces. Like OpenTelemetry did for observability. Every model provider, every framework, every MCP server emits traces in this format.
The context graph becomes infrastructure, not a product. Value accrues to the tools built on top of the standard, not to whoever controls the pipe.
The statelessness insight shifts the scenario probabilities. In a world where models were stateful, Scenario 3 (walled gardens) would be the most likely — because switching providers would mean losing accumulated intelligence. In a world where models are stateless, Scenarios 2 and 4 (open protocols, neutral middleware) have genuine structural support, because the model has no memory loyalty. The context lives outside it, and outside can be anywhere.
06 The Barrier Assessment — What Statelessness Changes
Two barriers stand out as structural rather than merely durable. “Statelessness Itself” prevents any single player from having an unchallengeable lock on the agent-decision layer — the model’s architecture is deliberately forgetful, so the context graph is necessarily external and contestable. “Human Decision Gap” prevents the agent-infrastructure fight from being the whole story — the larger, harder half of the context graph requires connectors to human systems, LLM extraction to structure what those connectors pull, and graph infrastructure to make it queryable. The model can serve as the extraction engine, but that’s a commodity capability — any LLM can do it. The durable advantages are in the connectors and the graph. Together, these two constraints mean the context graph will be built by multiple players solving different pieces of the problem, not by one player absorbing the whole stack.
07 The VC Conversation
Foundation Capital framed context graphs as a trillion-dollar opportunity for a new category of companies. After three posts of analysis, here’s where we land:
The surface-level read of the evidence in Section 02 is alarming: model providers are shipping persistence primitives, they sit closest to the execution path, and they’re assembling the building blocks of a context store as a natural extension of making agents work. If you stop there, the trillion-dollar opportunity looks like it accrues to Anthropic, OpenAI, and Google — not to a new category of companies.
But that read misses the architectural constraint at the center of everything. The model itself is stateless.
This is both good news and bad news for the VC thesis.
Good news: Statelessness means the context graph isn’t going to be monopolized by Anthropic, OpenAI, or Google. There’s a genuine lane for independent companies — whether they’re metadata platforms extending upward or new entrants building interception middleware. The multi-vendor reality plus statelessness means enterprises need a neutral context layer. That’s a real market.
Bad news: The same openness that prevents provider monopolization also prevents startup lock-in. If the context graph is just “files injected into context windows,” then it’s commodity infrastructure — valuable, but hard to build a high-margin SaaS business around. The defensibility has to come from somewhere other than the capture mechanism itself: from the analytical context (connectors, lineage, governance), from the graph intelligence (pattern recognition across decision traces), or from network effects (the more agents that use it, the smarter the precedent database gets).
The blind spot in most pitches: Nearly every “context graph” startup we’ve seen pitches agent decision traces as the core product. But agent-mediated decisions are a small, recent, and growing slice. The far larger — and more immediately valuable — opportunity is capturing human decision context: the approval chains, the exception negotiations, the institutional knowledge that currently lives in email, Slack, Jira, and people’s heads. An organization with zero agents deployed still has a trillion-dollar gap. The pieces to close it exist today: connectors to human communication channels are mature, and LLMs are capable of extracting structured decision context from unstructured communication. But nobody has integrated the full pipeline — connectors, extraction, graph persistence — into a product. The startup that does, making both human and agent decision context queryable in a single graph, has a broader product than anything the model providers are building toward with their memory tools.
The question every context graph pitch needs to answer:
The trillion-dollar opportunity may be real. But in a world of stateless models, it’s an ecosystem opportunity — likely distributed across protocol standards, platform primitives, and purpose-built intelligence layers — rather than a single-company opportunity. And if it’s an ecosystem opportunity, the exit math in the pitch deck needs revisiting.
Where This Leaves the Stack
Three Posts In — The Sharpened Picture
The analytical context half is real, mature, and defensible. Metadata platforms have genuine moats in connector depth, governance compliance, and enterprise trust. Statelessness doesn’t change this — if anything, it reinforces the value of model-agnostic infrastructure.
The agent framework layer is being commoditized from below by model providers absorbing orchestration into their runtimes. Frameworks that survive will be the ones that moved to stateful workflow management and multi-agent coordination.
The operational context half — the “trillion-dollar” part — is contested but not locked. Model providers have a proximity advantage: they control the sandbox, they see the tool calls, and they’re shipping the persistence primitives. But the model’s statelessness means this advantage is positional, not architectural. The model itself doesn’t accumulate organizational knowledge — the platform does. And platforms can be built by anyone.
The most durable advantages in this stack belong to whoever solves three problems simultaneously: capturing agent decision traces close to the execution path (where providers have an edge), building the extraction pipeline that turns unstructured human communication into structured decision records (where LLMs provide the cognitive layer but connectors and graph infrastructure provide the moat), and unifying both into a single queryable graph across multiple model providers (where no one has an established position). That’s a harder problem than any single player is set up to solve — and it’s the problem that doesn’t have an obvious owner yet.
Here’s the uncomfortable truth for the VC ecosystem: the trillion-dollar gap that Foundation Capital identified is real, but it may not produce a trillion-dollar company. The gap is actually two gaps — the agent-mediated slice (structured, clean, programmatically capturable) and the human-decision slice (unstructured, scattered, often unwritten, far larger). The trillion dollars of value will likely distribute across model providers who capture agent context within their platforms, metadata platforms who provide analytical context, human-system connectors, and cross-provider neutrality, protocol standards that enable interoperability, and intelligence layers that derive insight from the combined human-and-agent graph. That’s a vibrant ecosystem. It’s just not a single line item on a term sheet.
The stack is moving. The model is stateless. Most decisions are still human — but the model itself may be the best tool for extracting structured decision context from the unstructured mess of human communication. The context graph will be an external system that absorbs decision context from both human and machine sources, using LLMs as the extraction engine and connectors as the plumbing. The real moat isn’t the model or the capture mechanism — it’s making the combined graph intelligent across providers, across decision-makers, and across time. That’s a harder company to build than a pitch deck suggests. It’s also a more important one.
