Context graphs are AI's trillion-dollar opportunity, we call it Computer Memory.

Jaya Gupta at Foundation Capital just published a thesis that stopped us mid-scroll: the next trillion-dollar enterprise platforms won't be built on better models. They'll be built on context graphs – persistent records of decision traces that capture why things happened, not just what.

She's right. And we know, because we've been proving it in production since 2024.

The thesis, in brief

Gupta's argument is sharp and worth reading in full. Here's the core of it:

Every enterprise runs on decisions. Not the kind that live neatly in a CRM field or a Jira status – the messy, human ones. The VP who approved a 10% discount for healthcare customers because procurement cycles are brutal. The engineer who chose Vendor A over Vendor B after a three-week evaluation that lives in a Slack thread nobody bookmarked. The support lead who escalated a ticket to Tier 3 based on a pattern she noticed across Salesforce, Zendesk, and an internal Slack channel.

These decisions – the exceptions, the precedents, the rationale – are the actual operating logic of a company. And none of it gets captured by traditional systems of record.

Gupta calls the missing layer a context graph: a living record of decision traces stitched across entities and time, so precedent becomes searchable and autonomy becomes possible.

She identifies four categories of context that systems of record don't capture:

• Exception logic in people's heads. Tribal knowledge that governs real behavior but lives nowhere permanent.
• Precedent from past decisions. Similar deals, similar bugs, similar escalations – with no systematic linkage or rationale.
• Cross-system synthesis. The insight that requires reading three tools simultaneously, which today only a senior human can do.
• Approvals outside systems. Decisions made on Zoom calls and in Slack DMs, where the record shows the outcome but not the reasoning.

Her conclusion: the startups positioned in the execution path – where decisions actually happen – have a structural advantage to build these context graphs. Incumbents like Salesforce and ServiceNow store current state, not decision history. Data warehouses like Snowflake sit in the read path, receiving data via ETL after decisions are made. Neither can capture the why at the moment it happens.

We agree with every word.

What Gupta is describing already exists

The architecture Gupta envisions – a context graph that captures decision traces at commit time, stitches them across entities, enforces permissions, and compounds over time – is a precise description of Computer Memory, by DevRev.

This isn't a pitch dressed up as a response to a VC thesis. It's a statement of fact. Computer Memory has been in production for two years, running at enterprise scale, with 14 patents behind it.

Here's what it is, concretely.

Computer Memory: the knowledge graph

Computer Memory is an AI-native knowledge graph – a living network that maps relationships between customers, products, teams, and every interaction between them. Structured and unstructured. Tickets, contracts, Slack threads, code changes, meeting notes, escalation patterns, approval chains – all connected as first-class entities with the relationships between them preserved.

It combines six integrated pillars: a search engine, SQL engine, graph database, time-series database, data warehouse, and workflow engine. This isn't a single-purpose store. It's an organizational brain that understands what happened, when, who decided, what the precedent was, and what came of it.

The graph doesn't just store data. It actively creates new connections and context – surfacing relationships that didn't exist in any single source system. A support ticket links to the engineering issue it triggered, which links to the product change that fixed it, which links to every customer who reported the same symptom. That chain of context is the decision trace Gupta describes.

AirSync: the two-way sync engine

Computer Memory is kept alive by AirSync – DevRev's patented, two-way sync engine. It connects to Salesforce, Jira, Zendesk, Slack, Google Workspace, and 50+ other systems of record. Not through batch ETL. Not through periodic crawls. Through continuous, bidirectional synchronization.

This matters because of the execution path argument Gupta makes. AirSync doesn't sit downstream of decisions. It's in the sync loop – reading and writing in real time. When an agent resolves a ticket, AirSync captures the full context at decision time: the inputs gathered, the policies evaluated, the exceptions invoked, the outcome written. And it writes resolution context back to the source systems.

The distinction from incumbents is exactly the one Gupta draws: Salesforce can tell you the opportunity closed at $400K. It can't tell you that the VP approved a discount on a Zoom call because of a precedent set in Q2 with a similar healthcare customer. Computer Memory captures both – the what and the why – because AirSync was in the loop when it happened.

Permission-aware at every node

Gupta mentions that context graphs need governance. Computer Memory enforces the permission model of every connected system at every node. SOC 2 compliant, GDPR ready, individual-level access controls. Every person sees exactly what they're supposed to see – nothing more.

This isn't an afterthought. It's foundational. The reason most enterprises can't just dump everything into a shared knowledge base is that access control is non-negotiable. Computer Memory inherits permissions from every source system automatically through AirSync. No manual permission mapping. No separate governance layer.

The four gaps – closed

Let's walk through Gupta's four categories of missing decision context and show how Computer Memory addresses each one.

Exception logic in people's heads

Gupta's example: "We always give healthcare customers an extra 10% because their procurement cycles are brutal." This lives in tribal knowledge – until someone leaves.

With Computer Memory, the moment that exception is applied to a deal, the graph captures it in context: the customer, the discount, the rationale (if noted in any connected system – Slack, email, deal desk notes), and the approval chain. The next rep facing a similar healthcare deal doesn't need to ask around. They ask Computer, and it surfaces the precedent with the full decision trace.

This is exactly what we described in the "Team Intelligence" thesis: memory that compounds, not memory that decays. Every exception applied becomes a searchable precedent for every future decision.

Precedent from past decisions

Gupta notes that enterprises structure similar deals repeatedly but never systematically link them. The result: each deal starts from scratch.

Computer Memory links deals through shared entities – customer type, deal structure, approval patterns, clause language. When a new deal resembles an old one, the graph surfaces it – not as a keyword match, but as a structural similarity across the relationship network. The same principle applies to engineering decisions, support escalation patterns, and product roadmap calls.

Cross-system synthesis

Gupta's scenario: a support lead synthesizes data from Salesforce (ARR), Zendesk (escalations), and Slack (internal context) to make an escalation decision. The ticket only records "escalated to Tier 3."

This is the exact problem AirSync was built to solve. Because it maintains a live, two-way connection to all three systems, Computer Memory doesn't need a human to stitch context together. The knowledge graph already connects the customer's ARR to their support history to the internal discussion. The decision trace – including the cross-system context that informed it – is captured as a first-class relationship, not lost in a status change.

Approvals outside systems

VPs approve discounts on Zoom calls. Engineering leads greenlight exceptions in Slack DMs. The opportunity record shows the final price, not the reasoning.

AirSync continuously syncs with Slack, meeting transcripts, and email. When those approvals happen in connected systems, Computer Memory captures the context – the conversation, the participants, the timestamp – and links it to the entity it affected. The approval chain becomes part of the decision trace, not a gap the next person has to fill by asking around.

Why incumbents can't build this – and we already have

Gupta's analysis of why incumbents won't win this layer is precise, and our two years of production experience confirms it.

Operational incumbents (Salesforce, ServiceNow, Workday) store current state. They're architecturally designed to tell you what the record says right now – not why it says that, or what the decision chain looked like. Bolting on a context graph would require rewriting foundational assumptions about their data model.

Warehouse players (Snowflake, Databricks) sit in the read path. They receive data via ETL after decisions happen. They can run analytics on historical data, but they can't capture decision-time context because they're not in the execution loop.

Computer Memory sits in the execution path. AirSync's two-way sync means it's not waiting for a batch job. It's there when the decision happens, capturing inputs, reasoning, and outcomes as they occur. And because it writes back to source systems, the decision trace stays connected to the canonical record.

This isn't a theoretical advantage. Enterprises have been running on it:

• 30 million+ records migrated and continuously synced at Paytm.
• BILL achieved 70% of tickets fully resolved without a human – in 15 weeks.
• FAME shifted from "where can I find this?" to "what do I need to know?" – a cultural transformation powered by unified memory.

From context graph to Team Intelligence

Gupta frames context graphs as the foundation for AI agent autonomy. We'd take it one step further: context graphs are the foundation for Team Intelligence – the moment when an organization's collective knowledge compounds instead of decays.

The difference matters. Agent autonomy is a capability. Team Intelligence is an outcome. It's what happens when every decision your team makes – every deal structured, every ticket resolved, every bug fixed, every exception granted – gets captured, connected, and made searchable for every future decision.

A context graph gives your agents memory. Team Intelligence gives your organization memory.

That's the compounding effect Gupta describes: the more decisions flow through the graph, the richer the precedent network becomes, the better every future decision gets. Not because the model improved – but because the context did.

Five years from now, two companies in the same industry will compare notes. The one that started building its context graph early will have something the other literally cannot buy: a living, queryable, permission-aware record of everything its teams have ever figured out. The decision traces. The exception logic. The approval chains. The cross-system reasoning.

That's not a trillion-dollar opportunity in the abstract. It's the compounding asset that makes every AI agent, every workflow, every team decision better than the one before.

We've been building it for two years. And it's getting sharper every day.

Computer Memory – DevRev's patented, permission-aware knowledge graph – captures decision traces across every system your enterprise runs on. AirSync, our two-way sync engine, keeps it in continuous sync with 50+ systems of record. Together, they create the context graph that Foundation Capital calls AI's trillion-dollar opportunity. It's been in production since 2024.

See the context graph in production →