# The Context Graph — Full Content Summary

> The definitive resource on context graphs for AI agents, production AI reliability, and decision infrastructure. Free weekly newsletter by Patrick Joubert.

A context graph is a decision-aware knowledge structure that determines what is valid, applicable, and authorized in a given situation — enabling AI agents to operate deterministically, auditably, and at enterprise scale. It extends knowledge graphs with temporal validity, applicability logic, exception handling, decision traceability, and provenance.

---

## What is a Context Graph?

Source: https://thecontextgraph.co/what-is-context-graph

### Definition

A **context graph** is a structured decision layer that captures not just facts and relationships, but the operational reality around them: what rule applies, when it applies, under what conditions, who approved it, what exceptions exist, what decision was previously made, and why. It extends knowledge graphs with temporal validity, applicability logic, exception handling, decision traceability, and provenance.

Critically, a context graph is not a repository an agent may consult. It is a **decision boundary an agent must clear**. A proposed action is checked against the graph *before* it executes, and the check yields a deterministic pass or fail — not a probabilistic answer, and not a document to interpret.

### Why Context Graphs Matter

Every AI system, search engine, and decision platform faces the same fundamental problem: context loss. Information flows through pipelines, gets transformed, gets summarized, and by the time it reaches a decision point, the original reasoning is gone.

But context loss is only half the problem. The other half is *ordering*. A system that reconstructs reasoning after an action has executed can explain a bad outcome; it cannot prevent one. The refund is already issued, the record already written, the deployment already live. Retrieval, logging, evaluation, and observability all operate after the decision has been committed.

A context graph moves the check in front of the action. It preserves the full chain of reasoning *and* enforces it at the moment of decision, so that the reasoning becomes a precondition rather than a post-mortem.

This matters for three critical domains:

1. **AI Agents** — Agents fail in production not because they lack information, but because they act on context that is stale, out of scope, or superseded. A context graph validates whether the proposed action is applicable, current, and authorized before it reaches a tool, record, or payment rail.
2. **Enterprise Governance & Compliance** — Accountability requires proving an action was checked against the right context *before* it happened. An audit log shows what occurred; a causal decision trace shows what was verified and why the action was permitted.
3. **Search, SEO & AI Overviews (AIO)** — Entity authority and relationship structure determine how AI systems understand, cite, and surface content in AI-generated answers.

### The 5 Core Components of a Context Graph

1. **Entities (Nodes)**: The core objects in the graph — people, organizations, documents, concepts, API calls, or any unit of information. Each entity has a unique identifier and a set of typed properties.
2. **Relationships (Edges)**: Typed, directional connections between entities. Unlike simple links, context graph edges carry metadata: confidence scores, timestamps, and the source that established the relationship.
3. **Temporal Metadata**: Every node and edge is timestamped. Context graphs track when information was created, when it was last validated, and how it changed over time.
4. **Provenance**: The origin and reliability chain of every piece of data. Provenance answers: Where did this come from? How trustworthy is the source? Has it been corroborated?
5. **Decision Traces**: The reasoning chains and outcomes produced at each decision point. A decision trace captures what options were considered, what evidence was weighed, and what outcome resulted. In a context graph the trace is *causal*, not descriptive: it is the record of the check that gated the action, generated at decision time as a by-product of enforcement. That is what distinguishes it from a log, which is written after the fact and can only describe what already happened.

### How to Build a Context Graph

Full guide: https://thecontextgraph.co/how-to-build-a-context-graph

1. **Define your entities** — Start by identifying the key objects in your domain.
2. **Map relationships** — Define how entities connect. Use typed, directional edges.
3. **Add temporal metadata** — Timestamp everything. Track when entities were created and when relationships were established, and when they cease to be valid.
4. **Establish provenance** — Record the source and reliability of every piece of data.
5. **Encode applicability logic** — Define which rules govern which situations, under what conditions, and with what exceptions. This is the layer that turns stored context into a decision.
6. **Enforce before execution** — Place the graph in the execution path so every proposed action is validated against it before it runs, yielding a deterministic pass or fail and a causal decision trace as output.

### History and Evolution

The concept of context graphs evolved from three converging disciplines:

- **Knowledge Graphs (2012+)**: Google introduced its Knowledge Graph in 2012. Enterprise knowledge graphs (Neo4j, Amazon Neptune) followed.
- **Decision Intelligence (2019+)**: The field of structuring organizational decision-making as a discipline, coined by Cassie Kozyrkov at Google.
- **AI Agent Infrastructure (2023+)**: As LLM-powered agents moved to production, the gap between retrieval and governance became apparent.

Context graphs emerged as the architectural answer to a fundamental question: how do you give AI agents not just information, but governed, auditable, temporally-valid context for decision-making?

### Context Graph Use Cases

- **Pre-Execution Decision Governance**: Production AI agents clear proposed actions against a context graph before execution — validating applicability, scope, temporal validity, and policy compliance at the decision boundary.
- **Accountable & Auditable Agents**: Every permitted action carries a causal decision trace showing what was checked and why it was allowed, which is what regulatory accountability requires and what a post-hoc log cannot supply.
- **Fraud Detection & Compliance**: Financial institutions use context graphs to trace transaction chains and enforce current thresholds, live exceptions, and approval authority at decision time.
- **Enterprise Knowledge Management**: Organizations use context graphs to capture institutional knowledge as governing precedent — which prior decision applies to this case, and whether it still holds.
- **Search Engine Optimization (SEO)**: Google's Knowledge Graph powers entity recognition and rich results.
- **AI Overview Optimization (AIO)**: AI-generated answers rely on contextual understanding of entity authority.

---

## Context Graph vs Knowledge Graph

Source: https://thecontextgraph.co/context-graph-vs-knowledge-graph

### Key Difference

A **knowledge graph** stores static facts about entities and their relationships — answering "what is true." A **context graph** adds temporal metadata, provenance, and decision traces — answering "how was it decided and why."

### Side-by-Side Comparison

| Feature | Knowledge Graph | Context Graph |
|---------|----------------|---------------|
| Core question | What is true? | How and why was it decided? |
| Data model | Entities + relationships | Entities + relationships + context |
| Temporal awareness | Snapshot-based (point in time) | Continuous (tracks change over time) |
| Provenance | Optional or absent | Required — first-class citizen |
| Decision traces | Not recorded | Recorded at every decision point |
| Edge metadata | Type only | Type + confidence + timestamp + source |
| Query capability | Fact lookup, traversal | Temporal queries, precedent search |
| Primary use case | Information retrieval | Decision support & audit |
| Complexity | Lower — schema-driven | Higher — schema + metadata + traces |

### When to Use Which

**Use a Knowledge Graph when:**
- You need fast, simple fact retrieval
- Data changes infrequently
- Audit trails aren't required

**Use a Context Graph when:**
- You need to track decisions over time
- AI agents need auditable reasoning
- Provenance and trust scoring matter
- You're building SEO/AIO systems that need entity authority

---

## Context Graph vs RAG

Source: https://thecontextgraph.co/context-graph-vs-rag

### Key Difference

**RAG** retrieves semantically similar text chunks and injects them into LLM prompts. A **context graph** provides structured, governed context with temporal validity, applicability logic, and decision provenance. RAG finds what is similar; a context graph determines what is valid and authorized.

### Comparison

| Dimension | Context Graph | RAG |
|-----------|--------------|-----|
| Core operation | Structured validation & governance | Text retrieval & prompt injection |
| Temporal awareness | Native — expired data cannot be used | None — retrieves regardless of validity |
| Decision provenance | Full audit trail | None |
| Applicability | Determines which rules apply | Returns similar content regardless |
| Context preservation | Full chain of reasoning preserved | Chunks lose surrounding context |
| Best for | Decision governance, compliance, audit | Information retrieval, Q&A, summarization |

### Why RAG Alone Fails in Production

1. **Semantic similarity ≠ applicability**: Similar text is not necessarily valid text.
2. **No temporal awareness**: RAG retrieves expired policies alongside current ones.
3. **Chunk destruction**: Splitting documents into chunks destroys the context that makes information actionable.
4. **No provenance**: No record of where information came from or how trustworthy it is.
5. **Not composable**: RAG results cannot be chained into multi-step decision processes.

---

## Context Graph vs Vector Database

Source: https://thecontextgraph.co/context-graph-vs-vector-database

### Key Difference

A **vector database** stores embeddings and finds semantically similar items. A **context graph** stores entities, relationships, and decision context. Vector databases answer "what is similar?" — context graphs answer "what is valid, applicable, and authorized?"

### Comparison

| Dimension | Context Graph | Vector Database |
|-----------|--------------|-----------------|
| Data model | Entities + relationships + metadata | Vectors (numerical embeddings) |
| Query type | Structured traversal, temporal queries | Similarity search (k-NN, ANN) |
| Temporal awareness | Native — validity windows on all data | None |
| Decision support | Full governance and audit | None |
| Provenance | First-class citizen | Not applicable |
| Best for | Decision infrastructure, compliance | Semantic search, RAG, recommendations |

---

## Context Graph vs Agent Memory

Source: https://thecontextgraph.co/context-graph-vs-agent-memory

### Key Difference

**Agent memory** (session memory, thread memory, vector stores) stores what happened. A **context graph** stores what happened, why it was decided, whether it still applies, and what constraints govern future decisions.

### Why Agent Memory Fails at Scale

1. **Session memory**: Lost between sessions, no persistence.
2. **Thread-based memory**: Accumulates noise, no relevance decay.
3. **Vector store memory**: Semantic similarity retrieval without temporal validity or provenance.
4. **Summary memory**: Lossy compression that strips decision context.

### What Context Graphs Add

- Temporal validity — memories expire when they should
- Provenance — source and reliability of each memory
- Decision traces — why decisions were made, not just what happened
- Applicability logic — which memories are relevant to which situations

---

## Context Graph vs Agent Sandbox

Source: https://thecontextgraph.co/context-graph-vs-agent-sandbox

### Key Difference

**Agent sandbox** is an execution boundary: it isolates where an agent runs and what technical resources it can touch. A **context graph** is a decision boundary: it validates whether the proposed action is applicable, scoped, current, policy-compliant, and traceable before execution.

### Comparison

| Dimension | Agent Sandbox | Context Graph |
|-----------|---------------|---------------|
| Core question | Can the agent run safely here? | Is this action valid now? |
| Protects | Machine, tenant, filesystem, network, process boundary | Customer, contract, policy, data scope, regulated workflow |
| Failure caught | Host compromise, file leakage, tenant escape | Wrong refund, stale KYC decision, invalid pricing override |
| Artifact | Execution log | Causal decision trace |
| Best for | Runtime containment | Pre-execution enforcement |

### Why Sandboxes Are Not Enough

1. **Refund approval**: a sandbox can contain the refund API call, but cannot determine whether the refund is applicable to this customer under the current entitlement and policy.
2. **KYC screening**: a sandbox can isolate the workflow, but cannot decide which jurisdiction, policy version, source authority, or review threshold governs the decision.
3. **CRM changes**: a sandbox can constrain the runtime, but cannot validate whether a field update is scoped, lawful, or superseded by contract state.

The shortest distinction: a sandbox protects the machine. A decision context graph protects the business.

---

## Context Graph vs Agent Observability

Source: https://thecontextgraph.co/context-graph-vs-agent-observability

### Key Difference

**Agent observability** records and analyzes what an AI agent did during or after execution. A **context graph** validates whether a proposed action should be allowed before execution.

### Comparison

| Dimension | Agent Observability | Context Graph |
|-----------|--------------------|---------------|
| Core question | What did the agent do? | Should this action be allowed now? |
| Control point | During or after execution | Before execution |
| Primary artifact | Trace, span, log, metric, replay | Policy decision, applicability result, causal decision trace |
| Governance role | Visibility, debugging, quality measurement | Pre-execution enforcement |
| Failure caught | Visible after the tool or workflow has already run | Blocked before the side effect reaches a system |

### Why Observability Alone Fails Agent Governance

1. **It sees violations after the control point**: a trace can prove that the agent used the wrong record, policy, or tool, but the side effect may already exist.
2. **It records action, not authority**: logs can show that an agent acted, but not that the agent had authority under the current policy version, contract state, customer scope, jurisdiction, or exception hierarchy.
3. **It correlates events without validating applicability**: observability connects prompts, spans, tools, tokens, and outcomes. Applicability determines which rule applies to this action, in this context, at this time, for this actor.

The shortest distinction: observability explains an agent decision. A decision context graph governs it before execution.

---

## Context Graph vs Agent Evaluation

Source: https://thecontextgraph.co/context-graph-vs-agent-evaluation

### Key Difference

**Agent evaluation** measures whether an AI agent behaved correctly across traces, tools, tasks, sessions, handoffs, and production samples. A **context graph** validates whether the proposed action should be allowed before execution.

### Comparison

| Dimension | Agent Evaluation | Context Graph |
|-----------|------------------|---------------|
| Core question | Did the agent behave correctly? | Should this action be allowed now? |
| Control point | Before release, during review, or after production sampling | Before execution |
| Primary artifact | Score, rubric, trace review, regression result | Applicability result, allow or block decision, causal decision trace |
| Governance role | Measurement, quality control, regression detection, drift discovery | Pre-execution enforcement, scope validation, temporal validity, provenance |
| Failure caught | Bad tool selection, poor arguments, unsafe outputs, handoff gaps, quality drift | Invalid refund, stale KYC decision, out-of-scope data access, unlawful CRM update |

### Why Evaluation Still Needs Decision Context Graphs

1. **A passing eval is not live authority**: evals score historical or sampled behavior. They do not prove that the next proposed action is valid under current policy, contract, customer scope, or temporal state.
2. **Trace review is not a decision boundary**: trace-based evals can identify the trajectory that failed, but they do not automatically block the same class of invalid action before it reaches a tool.
3. **Measurement does not encode applicability**: eval rubrics can say a step was correct. A decision context graph determines which rule applies to this actor, entity, workflow, jurisdiction, and time.

The strongest architecture is evaluation plus context graph: measurement above, governed action at the decision boundary.

---

## Context Graph vs Agent Control Plane

Source: https://thecontextgraph.co/context-graph-vs-agent-control-plane

### Key Difference

**Agent control plane** manages the agent estate: inventory, ownership, identity, deployment, permissions, lifecycle, observability, and fleet policy. A **context graph** validates whether a specific proposed action is applicable, scoped, current, policy-compliant, and traceable before execution.

### Comparison

| Dimension | Agent Control Plane | Context Graph |
|-----------|---------------------|---------------|
| Core question | Which agents exist and how are they governed? | Is this proposed action valid now? |
| Control point | Fleet and lifecycle management | Per-action decision boundary before execution |
| Primary artifact | Agent registry, policy config, access package, dashboard, audit log | Applicability result, allow/block decision, causal decision trace |
| Governance role | Visibility, access management, deployment control, fleet policy | Pre-execution enforcement, scope validation, temporal validity, provenance |
| Failure caught | Unknown agents, unmanaged access, policy drift, operational blind spots | Invalid refund, stale KYC decision, out-of-scope deployment, unlawful CRM update |

### Why Control Planes Still Need Decision Context Graphs

1. **Access is not authority**: a control plane can prove that an agent may reach a tool, but not that this use of the tool is legitimate under the current business state.
2. **Fleet policy is not applicability logic**: global policy templates do not encode every local exception, temporal validity window, contract state, and jurisdictional condition.
3. **Audit logs are not causal decision traces**: logs show what happened. A causal decision trace shows which context, rules, exceptions, and provenance authorized or blocked the action.

The strongest architecture is control plane plus context graph: fleet governance above, pre-execution enforcement at the decision boundary.

---

## Context Graph vs Agent Registry

Source: https://thecontextgraph.co/context-graph-vs-agent-registry

### Key Difference

**Agent registry** inventories agents, tools, skills, MCP servers, owners, risk classifications, approvals, and lifecycle state. A **context graph** validates whether a specific proposed action is applicable, scoped, current, policy-compliant, and traceable before execution.

### Comparison

| Dimension | Agent Registry | Context Graph |
|-----------|----------------|---------------|
| Core question | Which agents and capabilities exist? | Is this proposed action valid now? |
| Control point | Inventory, discovery, approval workflow, risk classification, and lifecycle state | Per-action decision boundary before execution |
| Primary artifact | Agent record, owner, metadata, risk score, approval status, registry audit event | Applicability result, allow/block decision, causal decision trace |
| Governance role | Makes agents visible, classifiable, searchable, approvable, and governable as assets | Determines whether the action is authorized for this entity, workflow, policy, and time |
| Failure caught | Unknown agent, ownerless agent, stale registration, unapproved tool, unmanaged MCP server | Invalid refund, wrong tenant scope, expired policy, unlawful data use, missing provenance |

### Why Registries Still Need Decision Context Graphs

1. **Inventory is not action authority**: a registry can prove that an agent is known and approved, but not that this use is legitimate under the current business state.
2. **Discovery metadata is not applicability logic**: schemas, capability descriptions, owners, and risk labels do not encode every local exception, temporal validity window, customer scope, or policy version.
3. **Registry audit events are not causal decision traces**: registry logs show asset governance activity. A causal decision trace shows why a specific action was allowed or blocked before execution.

The strongest architecture is registry plus context graph: asset visibility above, governed action at the decision boundary.

---

## Context Graph vs Agent Identity

Source: https://thecontextgraph.co/context-graph-vs-agent-identity

### Key Difference

**Agent identity** governs which agent is acting, who sponsors it, which credentials it can use, and which resources it may access. A **context graph** validates whether a specific proposed use of that access is applicable, scoped, current, policy-compliant, and traceable before execution.

### Comparison

| Dimension | Agent Identity | Context Graph |
|-----------|----------------|---------------|
| Core question | Which agent is acting and what access can it receive? | Is this proposed action valid now? |
| Control point | Authentication, authorization, credential issuance, access packages, and identity lifecycle | Per-action decision boundary before execution |
| Primary artifact | Agent ID, token, credential, entitlement, sponsor, access log, expiry event | Applicability result, allow/block decision, causal decision trace |
| Governance role | Controls who can reach which systems under which access conditions | Controls whether this specific use of access is legitimate |
| Failure caught | Unknown agent, overprivileged token, expired access, missing sponsor, unmanaged credential | Invalid refund, wrong tenant scope, stale policy, unlawful data use, missing provenance |

### Why Agent Identity Still Needs Decision Context Graphs

1. **Access is not action authority**: an identity layer can prove that an agent may call a tool, but not that this use is legitimate for the current customer, contract, workflow, or policy version.
2. **Delegation is not applicability logic**: delegated access can prove that an agent acts on behalf of a user, but not whether the delegation applies to this record, tenant, time window, or side effect.
3. **Identity logs are not causal decision traces**: logs show who acted. A causal decision trace shows why the action was authorized or blocked before execution.

The strongest architecture is agent identity plus context graph: accountable access at the identity layer, governed action at the decision boundary.

---

## Context Graph vs Agent Authorization

Source: https://thecontextgraph.co/context-graph-vs-agent-authorization

### Key Difference

**Agent authorization** controls which tools, APIs, MCP servers, resources, and operations an agent may access or invoke. A **context graph** validates whether a specific proposed use of that permission is applicable, scoped, current, policy-compliant, and traceable before execution.

### Comparison

| Dimension | Agent Authorization | Context Graph |
|-----------|---------------------|---------------|
| Core question | What is this agent allowed to access, invoke, or modify? | Is this proposed action valid now? |
| Control point | Identity, token, policy, route, tool, API, MCP server, or request boundary | Per-action decision boundary before execution |
| Primary artifact | Permission decision, scoped token, policy match, deny code, request log | Applicability result, allow/block decision, causal decision trace |
| Governance role | Controls which capabilities an agent may use | Controls whether this specific use of a capability is legitimate |
| Failure caught | Unapproved tool, overbroad permission, expired token, limit exceeded, forbidden endpoint | Wrong customer, stale policy, invalid exception, out-of-scope workflow, missing provenance |

### Why Permission Is Not Applicability Logic

1. **Tool permission is not action authority**: authorization can prove that an agent may call a tool, but not that this use is legitimate for the current customer, contract, workflow, or policy version.
2. **Runtime policy is not complete context**: request policies can match attributes, but they do not automatically carry temporal validity, provenance, exception hierarchy, and scope isolation.
3. **Authorization logs are not causal decision traces**: logs show that permission was granted or denied. A causal decision trace shows why the action itself was authorized or blocked.

The strongest architecture is authorization plus context graph: controlled capability access at the permission boundary, governed action at the decision boundary.

---

## Context Graph vs Agent Gateway

Source: https://thecontextgraph.co/context-graph-vs-agent-gateway

### Key Difference

**Agent gateway** controls how agents reach models, tools, APIs, MCP servers, and data systems. A **context graph** validates whether a specific proposed action is applicable, scoped, current, policy-compliant, and traceable before execution.

### Comparison

| Dimension | Agent Gateway | Context Graph |
|-----------|---------------|---------------|
| Core question | Can this agent reach this model, tool, API, MCP server, or data plane? | Is this proposed action valid now? |
| Control point | Traffic, tool access, routing, identity, and request policy | Per-action decision boundary before execution |
| Primary artifact | Request log, auth decision, route, allowlist result, policy evaluation | Applicability result, allow or block decision, causal decision trace |
| Governance role | Controls paths agents can use | Controls decisions agents are allowed to make |
| Failure caught | Unapproved tool, missing credential, unsafe endpoint, excessive request | Invalid refund, stale entitlement, wrong jurisdiction, out-of-scope CRM update |

### Why Gateway Policy Is Not Applicability Logic

1. **Access is not action authority**: a gateway can prove that an agent may reach a tool, but not that this use of the tool is legitimate for the current customer, contract, workflow, or policy version.
2. **Request policy is not business semantics**: runtime policy engines can match request attributes, but they do not automatically encode temporal validity, exception hierarchies, provenance, and scope isolation.
3. **Gateway logs are not causal decision traces**: logs show that traffic passed through a control point. A causal decision trace shows why the action was authorized or blocked.

The strongest architecture is gateway plus context graph: controlled reach at the request boundary, governed action at the decision boundary.

---

## Context Graph vs Agent Guardrails

Source: https://thecontextgraph.co/context-graph-vs-agent-guardrails

### Key Difference

**Agent guardrails** validate model inputs, model outputs, tool calls, and approval checkpoints against configured safety rules. A **context graph** validates whether a specific proposed action is applicable, scoped, current, policy-compliant, and traceable before execution.

### Comparison

| Dimension | Agent Guardrails | Context Graph |
|-----------|------------------|---------------|
| Core question | Does this input, output, tool call, or approval checkpoint violate a configured safety rule? | Is this proposed action valid now? |
| Control point | Before or after model calls, around tool calls, and at human approval interrupts | Per-action decision boundary before execution |
| Primary artifact | Safety verdict, refusal, sanitized output, interrupt, approval record, policy match | Applicability result, allow/block decision, causal decision trace |
| Governance role | Constrain risky behavior and route exceptions for review | Controls decisions agents are allowed to make |
| Failure caught | Prompt injection, unsafe content, risky tool, missing approval, blocked phrase | Invalid refund, stale entitlement, wrong jurisdiction, out-of-scope data update |

### Why Guardrails Still Need Decision Context Graphs

1. **Safety checks are not action authority**: a guardrail can block unsafe content or risky tool behavior, but not prove the action is valid for this customer, tenant, policy version, and workflow.
2. **Human approval is not applicability logic**: approval pauses a run; it does not automatically provide the reviewer with complete context, temporal validity, provenance, and exception hierarchy.
3. **Safety verdicts are not causal decision traces**: a guardrail explains why a checkpoint passed or failed. A causal decision trace records why the proposed action was authorized or blocked.

The strongest architecture is guardrails plus context graph: behavioral safety checkpoints around the model and tools, governed action at the decision boundary.

---

## Context Graph vs Agent Skills

Source: https://thecontextgraph.co/context-graph-vs-agent-skills

### Key Difference

**Agent skills** package reusable instructions, scripts, references, assets, and routing metadata so an agent can perform a capability. A **context graph** validates whether a specific proposed use of that capability is applicable, scoped, current, policy-compliant, and traceable before execution.

### Comparison

| Dimension | Agent Skills | Context Graph |
|-----------|--------------|---------------|
| Core question | What capability can this agent load? | Is this proposed use of the capability valid now? |
| Control point | Capability packaging, routing metadata, reusable workflow, and optional execution assets | Per-action decision boundary before execution |
| Primary artifact | SKILL.md, skill card, scripts, references, assets, scan report, signature, eval result | Applicability result, allow/block decision, causal decision trace |
| Governance role | Makes capabilities discoverable, repeatable, portable, reviewable, and easier to evaluate | Determines whether the capability is authorized for this entity, workflow, policy, and time |
| Failure caught | Ambiguous trigger, hidden instruction, risky script, stale reference, unsigned bundle | Invalid refund, wrong account scope, expired policy, unauthorized data use, missing provenance |

### Why Verified Skills Still Need Decision Context Graphs

1. **Capability provenance is not action authority**: a signed skill can prove where a capability came from, but not that this use is legitimate under the current business state.
2. **Scanning is not applicability logic**: a clean skill can still act on the wrong customer, tenant, environment, policy version, or workflow.
3. **Skill cards are not causal decision traces**: a skill card documents intended use and limits. A causal decision trace records why a specific action was allowed or blocked.

The strongest architecture is skill plus context graph: reusable capability above, governed action at the decision boundary.

---

## Glossary: Complete Term Definitions

Source: https://thecontextgraph.co/glossary

**Context Graph**: A decision-aware knowledge structure that determines what is valid, applicable, and authorized in a given situation — enabling AI agents to operate deterministically, auditably, and at enterprise scale.

**Knowledge Graph**: A structured representation of real-world entities and the relationships between them, storing facts as triples (subject → predicate → object).

**State Drift**: A divergence between an AI agent's internal assumptions about the world and the actual state of the systems it interacts with.

**Decision Trace**: A recorded reasoning chain that captures what data was consulted, what alternatives were considered, what outcome resulted, and why that decision was justified.

**Causal Decision Trace**: The record of the check that gated an action, produced at decision time as a by-product of pre-execution enforcement. It shows what context was consulted, which rules applied, and why the action was permitted or blocked. Distinct from an audit log, which is written after execution and describes what happened without proving what was verified beforehand.

**Pre-Execution Enforcement**: Validating a proposed agent action before it reaches an external system, rather than detecting problems after execution. The distinguishing property is ordering: enforcement prevents the invalid action, whereas logging, evaluation, and observability can only describe it once it has occurred.

**Decision Context Graph**: A hypergraph-based decision substrate combining facts, relationships, rules, exceptions, and decision traces into a single queryable structure agents must consult before acting, producing a deterministic pass or fail rather than a probabilistic answer.

**Temporal Validity**: The constraint that rules, contracts, policies, and data have effective dates — expired logic cannot execute, and future-dated rules do not apply prematurely.

**Applicability Logic**: The mechanism that determines which rules, policies, or constraints apply to a given situation, based on context, conditions, and scope.

**Provenance**: The origin, authority, confidence score, and data lineage of every piece of information in a context graph.

**Context Engineering**: The practice of designing, structuring, and managing the contextual information that AI systems use to make decisions.

**Context Collapse**: The loss of critical contextual information as data flows through AI pipelines, transformations, and summarizations.

**Tool Misalignment**: When an AI agent's actions through external tools do not align with the actual constraints, permissions, or intended outcomes of the task.

**Decision Infrastructure**: The structural layer between language models and execution that validates, constrains, and governs AI agent decisions before they are acted upon.

**Agent Control Plane**: A management layer that inventories, deploys, monitors, and governs fleets of AI agents across tools, teams, and environments.

**Agent Identity**: A governed identity assigned to an AI agent so it can authenticate, receive credentials, access resources, and be sponsored through a lifecycle.

**Agent Authorization**: The runtime control layer that determines which tools, APIs, MCP servers, resources, and operations an AI agent may access or invoke.

**Agent Evaluation**: The process of measuring whether an AI agent selects correct tools, passes valid arguments, follows plans, completes tasks, remains safe, and holds up across traces, sessions, handoffs, and production samples.

**Agent Registry**: A governed inventory of AI agents, tools, skills, MCP servers, owners, risk classifications, approvals, and lifecycle state across an organization.

**Agent Gateway**: A traffic and access control layer that mediates how AI agents reach models, tools, APIs, MCP servers, and data systems.

**Agent Skill**: A portable package of instructions, scripts, references, and assets that teaches an AI agent how to perform a reusable capability.

**Deterministic Validation**: The process of verifying that an AI agent's proposed action satisfies all applicable rules, constraints, and policies before execution — with a guaranteed pass/fail outcome.

**Agent Sandbox**: An isolated execution environment for an AI agent that constrains files, tools, network access, credentials, and runtime side effects.

**Decision Boundary**: The pre-execution control point that determines whether an agent action is applicable, scoped, current, policy-compliant, and traceable before it reaches an external system.

**Exception Handling (Context Graph)**: The treatment of exceptions, overrides, and edge cases as first-class citizens in a context graph — not as afterthoughts or bugs.

**Entity Resolution**: The process of identifying whether incoming data refers to an entity that already exists in the graph, merging duplicates, and flagging conflicts.

**Decision Intelligence**: The discipline of capturing, analyzing, and leveraging organizational decision history to improve future decision-making.

**AI Overview Optimization (AIO)**: The practice of structuring content so that AI systems can accurately understand, cite, and surface it in AI-generated answers.

**Topical Authority**: The degree to which a website is recognized as the authoritative source on a specific topic, based on content depth, consistency, and structured relationships.

**RAG (Retrieval-Augmented Generation)**: A technique that retrieves relevant text chunks from a knowledge base and injects them into an LLM's prompt to ground its responses in specific data.

**Vector Database**: A database optimized for storing and querying high-dimensional vector embeddings, enabling semantic similarity search across large datasets.

**Audit Trail**: A chronological record of all decisions, actions, and state changes in a system, enabling post-hoc verification and compliance review.

**Context Window**: The maximum amount of text (measured in tokens) that a language model can process in a single inference call.

**Guardrails**: Configured safety constraints that validate, filter, modify, block, or interrupt an AI agent's inputs, outputs, tool calls, or approval checkpoints.

**Memory Degradation**: The progressive loss of accuracy and relevance in an AI agent's stored memory as volume increases and context evolves over time.

**Structured Data (Schema.org / JSON-LD)**: Machine-readable markup added to web pages that helps search engines and AI systems understand the content's meaning, relationships, and context.

**Entity Authority**: The degree to which a website or author is recognized as the primary, trustworthy source for information about a specific entity or topic.

---

## Production AI Has a State Problem

Source: https://thecontextgraph.co/production-ai-has-a-state-problem

### Thesis

The next wave of failures in AI systems won't come from model quality. It will come from state drift: a divergence between an agent's internal assumptions and the real execution state across tools and systems.

### Core Arguments

- **Action systems vs language systems**: Once agents mutate CRMs, billing flows, legal documents, or compliance artifacts, errors become persistent state mutations.
- **Observability is insufficient**: Logs describe what happened after execution; they do not govern which state transitions are valid before execution.
- **Evaluation is not enforcement**: Evals measure agent behavior across samples and traces; they do not authorize or block the next live action.
- **Retrieval does not enforce invariants**: Semantic similarity can surface relevant context while missing revoked approvals.
- **Production introduces entropy**: Asynchronous workflows, retries, and human interventions create non-linear state evolution.
- **Missing architectural layer**: Most stacks lack a deterministic state-governance layer.

### Production Diagnostic

Five checks for teams running agents in real workflows:

1. Can you deterministically replay a full decision path?
2. Can you simulate execution before mutating external systems?
3. Can you detect divergence between assumed and actual state?
4. Can you enforce invariant rules across tool calls?
5. Can you structurally audit approval logic?

---

## Published Memos

### The Agent Was Not Misbehaving. It Was Misinformed.

- **URL**: https://thecontextgraph.co/memos/the-agent-was-not-misbehaving-it-was-misinformed
- **Date**: 2026-08-11
- **Tags**: decision-boundary, context-validity, applicability, pre-execution-enforcement, causal-decision-trace, accountable-agents
- **Cite as**: Joubert, P. (2026). "The Agent Was Not Misbehaving. It Was Misinformed.." The Context Graph. https://thecontextgraph.co/memos/the-agent-was-not-misbehaving-it-was-misinformed

Claude treated real production systems as simulations because it was told it had no internet access. Every layer of the agent stack governs the agent. None verifies the context it acts on.

### A Documented Risk Is Not a Controlled One. Ask GPT-5.6 Sol.

- **URL**: https://thecontextgraph.co/memos/a-documented-risk-is-not-a-controlled-one
- **Date**: 2026-07-31
- **Tags**: decision-boundary, pre-execution-enforcement, applicability, causal-decision-trace, scope-isolation, accountable-agents
- **Cite as**: Joubert, P. (2026). "A Documented Risk Is Not a Controlled One. Ask GPT-5.6 Sol.." The Context Graph. https://thecontextgraph.co/memos/a-documented-risk-is-not-a-controlled-one

OpenAI documented GPT-5.6 Sol's destructive-action failure mode two weeks before launch. Disclosure stopped nothing. The gap between a documented risk and a controlled one is the decision boundary.

### A Regulator Just Made You Classify Decision Authority. Only Runtime Knows the Class.

- **URL**: https://thecontextgraph.co/memos/a-regulator-made-you-classify-decision-authority
- **Date**: 2026-07-24
- **Tags**: decision-authority, decision-boundary, applicability, pre-execution-enforcement, accountable-agents, decision-context-graph
- **Cite as**: Joubert, P. (2026). "A Regulator Just Made You Classify Decision Authority. Only Runtime Knows the Class.." The Context Graph. https://thecontextgraph.co/memos/a-regulator-made-you-classify-decision-authority

China's July 15 agent rules require classifying an agent's decision authority into three tiers before deployment. The right tier is a property of the case, not the action type, and only runtime knows it.

### Least Privilege Assumed You Knew the Path. Agents Decide It at Runtime.

- **URL**: https://thecontextgraph.co/memos/least-privilege-assumed-you-knew-the-path
- **Date**: 2026-07-17
- **Tags**: least-privilege, decision-boundary, pre-execution-enforcement, scope-isolation, applicability, decision-context-graph
- **Cite as**: Joubert, P. (2026). "Least Privilege Assumed You Knew the Path. Agents Decide It at Runtime.." The Context Graph. https://thecontextgraph.co/memos/least-privilege-assumed-you-knew-the-path

Least privilege assumes the scope is knowable before execution. An agent invents its path at runtime, so permissions guard the door and the decision boundary guards the action.

### Compliance Is Not Accountability

- **URL**: https://thecontextgraph.co/memos/compliance-is-not-accountability
- **Date**: 2026-07-09
- **Tags**: eu-ai-act, accountable-agents, causal-decision-trace, pre-execution-enforcement, policy-as-code, decision-context-graph
- **Cite as**: Joubert, P. (2026). "Compliance Is Not Accountability." The Context Graph. https://thecontextgraph.co/memos/compliance-is-not-accountability

The EU AI Act's August 2 deadline will produce audit-ready dashboards, not accountable agents. Compliance documents outputs. Accountability explains decisions.

### When Reasoning Gets Cheap, Wrong Actions Get Expensive

- **URL**: https://thecontextgraph.co/memos/when-reasoning-is-cheap-wrong-actions-are-expensive
- **Date**: 2026-07-03
- **Tags**: agent-economics, pre-execution-enforcement, context-graph, agent-reliability, production-infrastructure
- **Cite as**: Joubert, P. (2026). "When Reasoning Gets Cheap, Wrong Actions Get Expensive." The Context Graph. https://thecontextgraph.co/memos/when-reasoning-is-cheap-wrong-actions-are-expensive

Claude Sonnet 5 made autonomous action cheap. The cost of a wrong action did not fall. As agents act more, only a decision layer stops volume from scaling errors too.

### A Context Window Is Not Context

- **URL**: https://thecontextgraph.co/memos/a-context-window-is-not-context
- **Date**: 2026-06-26
- **Tags**: context-engineering, context-window, context-graph, agent-reliability, production-infrastructure
- **Cite as**: Joubert, P. (2026). "A Context Window Is Not Context." The Context Graph. https://thecontextgraph.co/memos/a-context-window-is-not-context

Tokenmaxxing is over. The lesson underneath the efficiency shift: capacity was never the constraint, structure was. A window gives an agent room. A context graph gives it context.

### Agent Authorization Is Not Decision Authority

- **URL**: https://thecontextgraph.co/memos/agent-authorization-is-not-decision-authority
- **Date**: 2026-06-19
- **Tags**: agent-authorization, decision-context-graph, pre-execution-enforcement, accountable-agents, mcp
- **Cite as**: Joubert, P. (2026). "Agent Authorization Is Not Decision Authority." The Context Graph. https://thecontextgraph.co/memos/agent-authorization-is-not-decision-authority

Agent authorization proves an agent may use a tool. A decision context graph proves the proposed action is applicable, scoped, current, and traceable before execution.

### MCP Policy Gates Are Not Decision Authority

- **URL**: https://thecontextgraph.co/memos/mcp-policy-gates-are-not-decision-authority
- **Date**: 2026-06-12
- **Tags**: mcp, policy-as-code, pre-execution-enforcement, decision-context-graph, agent-governance
- **Cite as**: Joubert, P. (2026). "MCP Policy Gates Are Not Decision Authority." The Context Graph. https://thecontextgraph.co/memos/mcp-policy-gates-are-not-decision-authority

MCP policy gates can block risky tool calls. They still need a decision context graph to prove each business action is applicable, scoped, current, and traceable.

### Agent Registries Are Not Decision Infrastructure

- **URL**: https://thecontextgraph.co/memos/agent-registries-are-not-decision-infrastructure
- **Date**: 2026-06-05
- **Tags**: agent-registries, mcp, decision-infrastructure, pre-execution-enforcement, context-graph
- **Cite as**: Joubert, P. (2026). "Agent Registries Are Not Decision Infrastructure." The Context Graph. https://thecontextgraph.co/memos/agent-registries-are-not-decision-infrastructure

Agent registries make MCP servers, A2A agents, and Skills discoverable and scannable. They still cannot prove an action is valid before execution.

### Control Planes Govern Agents. Context Graphs Govern Decisions.

- **URL**: https://thecontextgraph.co/memos/control-planes-govern-agents-context-graphs-govern-decisions
- **Date**: 2026-05-29
- **Tags**: agent-control-plane, decision-context-graph, pre-execution-enforcement, accountable-agents, production-infrastructure
- **Cite as**: Joubert, P. (2026). "Control Planes Govern Agents. Context Graphs Govern Decisions.." The Context Graph. https://thecontextgraph.co/memos/control-planes-govern-agents-context-graphs-govern-decisions

Agent control planes manage the agent estate. They do not decide whether a proposed action is applicable, scoped, current, and accountable before execution.

### A Sandbox Is Not a Decision Boundary

- **URL**: https://thecontextgraph.co/memos/a-sandbox-is-not-a-decision-boundary
- **Date**: 2026-05-22
- **Tags**: agent-sandboxes, context-graph, pre-execution-enforcement, agent-reliability, production-infrastructure
- **Cite as**: Joubert, P. (2026). "A Sandbox Is Not a Decision Boundary." The Context Graph. https://thecontextgraph.co/memos/a-sandbox-is-not-a-decision-boundary

A sandbox keeps an agent contained. It does not decide whether a refund, KYC action, pricing change, or CRM update is valid before execution.

### Every Multi-Agent Framework Ignores the Same Problem

- **URL**: https://thecontextgraph.co/memos/every-multi-agent-framework-ignores-the-same-problem
- **Date**: 2026-05-09
- **Tags**: multi-agent, context-graph, agent-reliability, production-infrastructure, context-engineering
- **Cite as**: Joubert, P. (2026). "Every Multi-Agent Framework Ignores the Same Problem." The Context Graph. https://thecontextgraph.co/memos/every-multi-agent-framework-ignores-the-same-problem

CrewAI, AutoGen, LangGraph — they all orchestrate agents. None of them govern what context travels between agents. That's the gap where production failures hide.

### The Vocabulary Problem in Agent Infrastructure

- **URL**: https://thecontextgraph.co/memos/the-vocabulary-problem-in-agent-infrastructure
- **Date**: 2026-05-02
- **Tags**: context-graph, agent-infrastructure, category-design, decision-infrastructure, production-reliability
- **Cite as**: Joubert, P. (2026). "The Vocabulary Problem in Agent Infrastructure." The Context Graph. https://thecontextgraph.co/memos/the-vocabulary-problem-in-agent-infrastructure

Categories are made of words. Agent infrastructure has no canonical vocabulary, so every vendor invents one and every buyer compares apples to oranges. The category cannot mature until the language does.

### MCP Solved the Pipes. Who Solves the Water Quality?

- **URL**: https://thecontextgraph.co/memos/mcp-solved-the-pipes-who-solves-water-quality
- **Date**: 2026-04-11
- **Tags**: mcp, context-graph, agent-reliability, context-engineering, production-infrastructure
- **Cite as**: Joubert, P. (2026). "MCP Solved the Pipes. Who Solves the Water Quality?." The Context Graph. https://thecontextgraph.co/memos/mcp-solved-the-pipes-who-solves-water-quality

The Model Context Protocol connects agents to everything. But connecting is not governing. Without a context graph, MCP delivers raw, unvalidated, unscoped data to every decision.

### Context Engineering in 2026: From Karpathy's Tweet to Production Infrastructure

- **URL**: https://thecontextgraph.co/memos/context-engineering-2026-from-tweet-to-infrastructure
- **Date**: 2026-04-04
- **Tags**: context-engineering, context-graph, production-reliability, agent-architecture, decision-infrastructure
- **Cite as**: Joubert, P. (2026). "Context Engineering in 2026: From Karpathy's Tweet to Production Infrastructure." The Context Graph. https://thecontextgraph.co/memos/context-engineering-2026-from-tweet-to-infrastructure

Everyone talks about context engineering. Nobody says how to build it. The context graph is the missing implementation. Not an opinion. An architecture.

### How Context Graphs Prevent the 7 Silent Agent Failures

- **URL**: https://thecontextgraph.co/memos/how-context-graphs-prevent-silent-agent-failures
- **Date**: 2026-03-27
- **Tags**: context-graph, agent-failures, production-reliability, multi-agent, decision-architecture
- **Cite as**: Joubert, P. (2026). "How Context Graphs Prevent the 7 Silent Agent Failures." The Context Graph. https://thecontextgraph.co/memos/how-context-graphs-prevent-silent-agent-failures

Production agents fail silently — not from bad prompts, but from bad context structure. Here are the 7 failure modes that context graphs eliminate before they compound.

### Gartner 2026 Confirms It: The Context Graph Is the Missing Layer in Autonomous AI Agents

- **URL**: https://thecontextgraph.co/memos/gartner-2026-ai-agents-decision-intelligence-sales
- **Date**: 2026-03-20
- **Tags**: context-graph, ai-agents, decision-intelligence, gartner-2026, agent-reliability, production-agents, governance
- **Cite as**: Joubert, P. (2026). "Gartner 2026 Confirms It: The Context Graph Is the Missing Layer in Autonomous AI Agents." The Context Graph. https://thecontextgraph.co/memos/gartner-2026-ai-agents-decision-intelligence-sales

Gartner's 2026 predictions for data and analytics describe an autonomous agent future. Every prediction points to the same architectural gap: agents need context graphs to make reliable decisions at scale.

### Why Your Data Agents Need a Context Layer

- **URL**: https://thecontextgraph.co/memos/why-your-data-agents-need-a-context-layer
- **Date**: 2026-03-13
- **Tags**: context-engineering, data-agents, semantic-layer, enterprise-ai, production-reliability
- **Cite as**: Joubert, P. (2026). "Why Your Data Agents Need a Context Layer." The Context Graph. https://thecontextgraph.co/memos/why-your-data-agents-need-a-context-layer

The bottleneck isn't model capability — it's context. Without a structured context layer, data agents fail because enterprise data is messy and undocumented.

### AI Agent Evaluation Is Broken: 5 Structural Gaps Between Evals and Production Reality

- **URL**: https://thecontextgraph.co/memos/ai-agent-evaluation-guide
- **Date**: 2026-03-07
- **Tags**: ai-agents, evaluation, production-reliability, decision-architecture
- **Cite as**: Joubert, P. (2026). "AI Agent Evaluation Is Broken: 5 Structural Gaps Between Evals and Production Reality." The Context Graph. https://thecontextgraph.co/memos/ai-agent-evaluation-guide

Most AI agent evaluation frameworks test wrong things. Discover 5 structural gaps between passing evals and production-ready agents, and how to fix them.

### AI Agent Failure Patterns Atlas (2026): 12 Structural Breakpoints

- **URL**: https://thecontextgraph.co/memos/ai-agent-failure-patterns-atlas
- **Date**: 2026-03-03
- **Tags**: ai-agents, failure-modes, production-reliability, context-graph
- **Cite as**: Joubert, P. (2026). "AI Agent Failure Patterns Atlas (2026): 12 Structural Breakpoints." The Context Graph. https://thecontextgraph.co/memos/ai-agent-failure-patterns-atlas

A practical atlas of 12 recurring AI agent failure patterns in production, with root causes, detection signals, and architecture fixes.

### Why Your AI Agent Test Suite Is Lying to You: 4 Testing Gaps That Only Show Up in Production

- **URL**: https://thecontextgraph.co/memos/ai-agent-testing-production
- **Date**: 2026-03-01
- **Tags**: ai-agents, testing, production-reliability, evaluation
- **Cite as**: Joubert, P. (2026). "Why Your AI Agent Test Suite Is Lying to You: 4 Testing Gaps That Only Show Up in Production." The Context Graph. https://thecontextgraph.co/memos/ai-agent-testing-production

AI agent testing in production reveals structural failures that staging environments can't catch. Learn the 4 testing patterns that undermine reliability.

### AI Agent Monitoring Is a Lie: 5 Observability Gaps That Let Production Failures Through

- **URL**: https://thecontextgraph.co/memos/ai-agent-monitoring-production
- **Date**: 2026-02-24
- **Tags**: ai-agents, monitoring, production-reliability, observability
- **Cite as**: Joubert, P. (2026). "AI Agent Monitoring Is a Lie: 5 Observability Gaps That Let Production Failures Through." The Context Graph. https://thecontextgraph.co/memos/ai-agent-monitoring-production

Discover why traditional monitoring fails AI agents in production. 5 structural patterns expose how teams miss decision failures while dashboards stay green.

### Why RAG Is Not Enough for Production AI Agents

- **URL**: https://thecontextgraph.co/memos/why-rag-is-not-enough-for-production-ai-agents
- **Date**: 2026-02-22
- **Tags**: rag, production-reliability, context-engineering, decision-architecture
- **Cite as**: Joubert, P. (2026). "Why RAG Is Not Enough for Production AI Agents." The Context Graph. https://thecontextgraph.co/memos/why-rag-is-not-enough-for-production-ai-agents

RAG improves recall but does not govern decisions. For production agents that take action, the gap between retrieval and reliability is structural.

### Why Agent Memory Architectures Fail at Scale

- **URL**: https://thecontextgraph.co/memos/why-agent-memory-fails-at-scale
- **Date**: 2026-02-17
- **Tags**: agent-memory, scaling, production-reliability
- **Cite as**: Joubert, P. (2026). "Why Agent Memory Architectures Fail at Scale." The Context Graph. https://thecontextgraph.co/memos/why-agent-memory-fails-at-scale

Session memory, vector stores, and thread-based memory all degrade under production load. The problem isn't storage — it's structure.

---

## About The Context Graph

Source: https://thecontextgraph.co/about

### The Mission

The Context Graph exists to be the definitive resource on context graphs — covering their application in AI agents, search engine optimization, AI Overview Optimization (AIO), and enterprise decision intelligence.

### About Patrick Joubert

**Patrick Joubert** is the founder of The Context Graph. He writes about context engineering, decision intelligence, and how context graphs shape AI agents, search engines, and AI-generated answers.

### The Newsletter

Every Tuesday, The Context Graph newsletter delivers context graph insights in 3 minutes. Real agent failures, technical deep dives, SEO strategies, and opinionated takes on context engineering. Free. No spam. Unsubscribe anytime.

Subscribe at: https://thecontextgraph.co

---

## Site Information

- **Website**: https://thecontextgraph.co
- **Author**: Patrick Joubert
- **Publisher**: The Context Graph
- **Language**: English (en-US)
- **Category**: Technology / Artificial Intelligence
- **Newsletter**: Free, weekly (every Tuesday), 3-minute read
- **Contact**: Subscribe via the website
- **LLM summary**: https://thecontextgraph.co/llms.txt
- **AI discovery hub**: https://thecontextgraph.co/for-ai
- **Glossary**: https://thecontextgraph.co/glossary
- **Sitemap**: https://thecontextgraph.co/sitemap.xml

## Citation

Cite as: Joubert, P. (2026). "The Context Graph." Retrieved from https://thecontextgraph.co