We are entering an era where AI agents have officially moved from acting as passive assistants to autonomously owning decisions. From incident response to credit approvals, agents now make recommendations and coordinate work across complex enterprise systems. However, this profound shift exposes a critical new bottleneck: context.

Drawing on the insights from our newly published white paper, Knowledge Graphs and Context Engineering, this article synthesizes the three-layered foundation enterprises need to make agentic AI reliable, auditable, and truly autonomous.

In production environments, the performance of an AI agent depends less on its underlying large language model and more on the context it can successfully reason over. The problem is that traditional enterprise data architectures were not built to capture reasoning. They capture current states, such as a logged customer, an open ticket, or a deployed version, but they completely miss the tacit history of precedents, waived policies, and granted exceptions that live in human heads or fragmented chat threads.

To solve this, organizations must embrace context engineering by building a layered, interconnected foundation: knowledge graphs, ontologies, and context graphs. As noted by Foundation Capital, this represents “AI’s trillion-dollar opportunity”.

Chapter 1: Knowledge graphs — Connecting what the enterprise knows

Traditionally, enterprise data has been structured in relational tables, isolating entities like customers or products into disconnected buckets. While this relational approach is excellent for transaction processing and reporting, it completely ignores how businesses actually operate. Most business questions are inherently relational: who bought what, which systems depend on each other, and how events unfold over time.

Knowledge graphs are explicitly designed to match this reality. Instead of storing facts in isolated tables, they represent information as a network of entities and explicit relationships, shifting the data paradigm from “strings” to “things”. Consider the challenge of building a true 360° view of a customer. In a traditional SQL database, discovering which customers opened a support ticket about a product bought via a specific campaign requires a slow, complex, and brittle multi-way join. In a knowledge graph, this same query is a single, intuitive traversal following named edges like PLACED, CONTAINS, or OPENED.

Crucially, knowledge graphs provide the flexibility needed to capture tacit knowledge, the invisible layer of business logic. Tacit knowledge, such as an experienced planner knowing which delivery delays are tolerable or which suppliers are reliable despite poor metrics, does not fit into a predefined relational schema. A knowledge graph accepts new entities, relationships, and exceptions as they are discovered without requiring downstream database migrations. This makes it the perfect foundation for agentic AI, allowing autonomous systems to navigate real business logic rather than loosely connected text.

Chapter 2: Ontologies and semantic governance — Defining what it means

Connecting enterprise data is only the first step; a graph without a defined structure is fundamentally unusable. To be reliable, a knowledge graph needs an ontology. An ontology provides the conceptual schema: it defines what the entities are, how they relate, and what operational rules apply.

The need for ontologies becomes blindingly apparent when looking at the limitations of standard Retrieval-Augmented Generation (RAG). At an enterprise scale, vector spaces become crowded. A meeting transcript, a Jira ticket, and a Slack thread about similar projects will all look mathematically identical to an embedding model, causing the AI to retrieve irrelevant or out-of-context facts. The solution is moving from RAG to GraphRAG. By using the ontology to organize retrieval around explicit relationships, GraphRAG grounds the AI’s answers in verifiable enterprise connections rather than mere surface-level text similarity.

Furthermore, as enterprises move unstructured content (like PDFs and conversations) into structured knowledge pipelines, ontologies act as a semantic contract. They provide deterministic perimeters for probabilistic LLMs. Specifically, an ontology ensures agent reliability in three vital ways:

  • Enforcing what must be true: Ontologies can restrict actions based on strict rules. For example, they can ensure an agent cannot move a loan to “approved” unless all required documents are explicitly verified, catching violations before they propagate.
  • Deriving new facts in real-time: If an ontology defines a “VIP customer” as someone with five completed orders, the system automatically infers and upgrades a customer’s status the moment that fifth order is placed. This instantly triggers new agentic workflows the moment the condition is met, without requiring any custom application logic.
  • Making decisions explainable: When an agent rejects a loan or prioritizes a ticket, the explanation is no longer “the model said so.” The decision is traced back to a shared business vocabulary that human teams can easily audit and understand.

Chapter 3: Context graphs and agentic AI — Turning knowledge into action

While knowledge graphs and ontologies describe what exists and the rules that govern it, real agentic systems require dynamic, operational context. They need to know what is happening right now and how the organization has behaved historically.

Systems of record like Salesforce, ServiceNow, or Workday are brilliant at recording the current state of the world, but they are fundamentally insufficient for agentic AI. A complex operational decision, such as an incident resolution, might span GitHub logs, deployment monitoring, and an extensive Slack discussion. In a system of record, only the final “resolved” status is stored. The causal chain, the trade-offs, and the historical precedents simply disappear.

This is exactly where context graphs come in. A context graph captures the reasoning behind decisions. It stores decisions as first-class entities linked to the policies applied, the exceptions granted, and the causal outcomes. One powerful observation from the white paper states:

“Software built for people captures what is true. Software built for agents needs to capture how it became true.” – Florence Benezit, Partner at Artefact

Without this layer, an AI agent is a stateless reasoner, starting completely from scratch every single time it is invoked. With a context graph, the agent can reason like a senior employee: citing historical precedent, understanding why a past exception was made, and anticipating downstream impacts.

To navigate this new landscape, leadership teams must clearly distinguish between three foundational layers of the agentic enterprise:

  • Knowledge graphs: Capture what the business knows (customers, products, regulations, dependencies). It is the shared, stable model of the enterprise.
  • Memory graphs: Capture what an agent remembers (user preferences, past interactions, episodic and semantic lessons learned). It ensures the agent doesn’t start from zero.
  • Context graphs: Capture how the organization decides (decision traces, precedents, applied policies, and reasoning paths). This is where organizational reasoning becomes computable.

Working together, these three layers create an environment where decisions compound over time. Eventually, this allows an enterprise to move beyond merely recording operations to creating a true “simulator” that can actively anticipate organizational behavior and downstream effects.

Conclusion: Where should enterprises start?

With so much theoretical ground to cover, the immediate question for organizations is: where do we begin? The answer is not to immediately attempt building a massive, monolithic enterprise graph. Instead, organizations should start strictly with the workflow.

Identify a recurring, high-stakes decision where the right answer currently relies heavily on the tacit experience of senior employees bridging fragmented systems. If the bottleneck is scattered information, start by building a knowledge graph. If the challenge is continuity between AI interactions, focus on memory. If the hurdle is understanding past decisions and auditing reasoning, build a context graph.

We are entering an era where AI unequivocally moves from answering questions to executing real-world operations. The winners of this new era will not be determined by computational power alone. Ultimately, the next decade of enterprise AI will not be won by the firms with the best models; it will be won by the firms with the best context supporting their agents.