Context Graphs in Agent Architecture

The Agentic Layer Advantage

Context graphs emerge naturally from agent orchestration layers because of their unique position:

Agents sit in the execution path where decisions happen:

1. Pull context from multiple systems
2. Evaluate policies and rules
3. Resolve conflicts and exceptions
4. Make decisions (autonomous or with approvals)
5. Execute actions
6. Write state back

At each decision point, agents see the full picture: inputs gathered, policies applied, exceptions granted, approvals, state written. This is the moment to capture decision traces.

Practical Workflow Example: Renewal Discount Decision

Setup:

• Customer renewal coming due
• Policy: Cap discounts at 10% unless exception approved
• Agent proposes: 20% discount

What Agent Sees (Full Context):

1. Customer account data (Salesforce)
2. Three SEV-1 incidents from PagerDuty
3. Open “cancel unless fixed” escalation in Zendesk
4. Prior renewal thread showing VP approved similar exception last quarter

What Agent Does:

1. Routes exception to Finance with full context
2. Finance approves
3. Records decision trace: WHO approved, WHEN, WHY, with linked precedent

What Gets Captured:

Entity: Customer Renewal  
Decision: 20% Discount Approved  
Policy Applied: v3.2 (Exception Route)  
Exception Reason: Service Impact (3x SEV-1 incidents)  
Precedent Referenced: Prior VP exception Q3 2025  
Approval Chain: Agent proposal → Finance approval  
State Written: CRM update  
Decision Trace Recorded: Complete lineage preserved  

What Comes Next:
Next quarter, similar incident → agent queries context graph → finds this precedent → can recommend faster path or propose immediate approval.

Why Orchestration Layers Are Uniquely Positioned

Three Paths All Other Players Miss

Operational incumbents (Salesforce, ServiceNow, Workday):

• Built on current state storage
• Know opportunity/ticket NOW, not when decision was made
• Can’t replay state at decision time
• Can’t audit why decisions happened

Data warehouse players (Snowflake, Databricks):

• See data AFTER it lands via ETL
• By then, decision context is gone
• Only have read-path visibility
• Can tell you what happened, not why

Agent orchestration startups:

• See context AT decision time
• In the write path (executing workflow)
• Can capture full lineage in the moment
• Are the only layer that can preserve “why”

Building Context Graphs Incrementally

Context graphs don’t require full autonomy from day one. They grow through human-in-the-loop workflows:

Phase 1: Structured Proposals

• Agent gathers context from systems
• Routes to human for decision
• Records: context gathered, decision made, rationale

Phase 2: Routed Approvals

• Agent proposes action with context
• Routes to appropriate approver (Finance, VP, etc.)
• Records: proposal, approvers, decision path

Phase 3: Decision Pattern Recognition

• System has history of similar cases
• Can surface precedent to next decision-maker
• Accelerates approval process

Phase 4: Selective Automation

• For repeated, low-risk patterns, agent can auto-approve
• For edge cases, still routes for human review
• Graph keeps growing

Key insight: Even when humans still make calls, graph keeps growing because workflow layer captures inputs, approval, and rationale as durable precedent instead of letting it die in Slack.

The Feedback Loop

Decision traces become searchable precedent → Agents use precedent to make better decisions → Agents record more traces → Loop repeats

With each cycle:

• Better decision quality (agents learn from past)
• Faster decisions (precedent reduces analysis time)
• More automation possible (richer precedent library)
• Richer context graph (compound effect)

Exception-Heavy vs Deterministic Workflows

Routine, deterministic workflows:

• Fixed logic, few exceptions
• Don’t benefit much from context graphs
• Agent just executes

Exception-heavy, precedent-based workflows:

• Complex logic, many decisions depend on “it depends”
• This is where context graphs shine
• Use cases: deal desks, underwriting, compliance reviews, escalation management, customer success decisions

The interesting surfaces are where:

• Logic is complex
• Precedent matters
• Human judgment is required
• Similar-but-different cases repeat

Integration with Agent Observability

As decision traces accumulate and context graphs grow, agents need observability infrastructure:

Key observability needs:

• How agents reason through decisions
• Where they fail or diverge from precedent
• How their decisions perform over time
• Impact of policy changes on agent behavior
• Precedent drift (when agents stop following learned patterns)

This is the infrastructure layer where platforms like Arize (observability for AI systems) become essential.

Cross-System Context As Core Capability

Agents must traverse multiple systems to gather decision context:

Why this matters:

• Support escalation depends on: customer tier (CRM) + SLA terms (billing) + recent outages (PagerDuty) + churn risk flagged in Slack
• Deal desk decision depends on: ARR calculation (Finance) + customer health (CS) + market conditions (Sales Intel) + regulatory constraints (Legal)
• Engineering decision depends on: code changes (GitHub) + infrastructure impact (Kubernetes) + deployment history + customer impact (PagerDuty)

No single system sees these cross-functional connections. Only the orchestration layer does.

Competitive Dynamics

As context graphs become the core asset for agent systems:

Orchestration startups have first-mover advantage:

• Already in position to capture traces
• Can build observability/query tools on top
• Own the decision lineage that becomes institutional knowledge

Incumbents can acquire, but can’t insert:

• Can try to buy orchestration capabilities
• Can lock down APIs and raise egress costs
• Can’t retroactively insert themselves into execution path

Specialized orchestration players emerge:

• Domain-specific (deal desk orchestration, support orchestration, etc.)
• Own context graphs for their vertical
• Become source of truth for decision making in that domain

Key Principle

The orchestration layer sees the full picture. That’s where decision traces live. That’s where context graphs get built. That’s where the trillion-dollar value lies.

References

• Foundation Capital: “AI’s Trillion-Dollar Opportunity: Context Graphs”
• Related: OpenAI Frontier (built-in decision tracing and governance)
• Related: Agent observability and monitoring infrastructure