Skip to content

Context Graphs for Proactive Enterprise Agents

🕒 Published (v1): 2026-07-04 14:37 UTC · Source: Arxiv · link

Why this paper was selected

Context graphs enable proactive enterprise agents; shifts harness from reactive to anticipatory

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

This paper proposes the Context Graph, a live, directed attributed multigraph for enterprise entities, as the substrate for proactive AI agents that surface actionable information before users ask. On top of it, a three-layer pipeline (Delta Detection Engine → Proactivity Scorer → LLM Surfacing Layer) continuously monitors state changes and delivers ranked, grounded notifications. A full Python implementation using NetworkX and the Anthropic Claude API is provided, evaluated on three enterprise case studies.

Problem

RAG and agentic frameworks are architecturally reactive: they produce output only when queried. Knowledge workers miss time-sensitive signals (expiring contracts, SLA breaches, blocked dependencies) not because data is absent but because no system watches entity relationships and fires on threshold crossings. Static knowledge graphs lack delta-awareness; existing agentic frameworks address task execution, not the prior question of what to work on and when.

Method

The system is formalized around five components:

  1. Context Graph \(G = (V, E, P_V, P_E, T)\): a directed attributed multigraph with a global logical clock. Every state mutation emits a Delta Event \(\delta = (\text{entity\_id}, \text{change\_type}, v_\text{old}, v_\text{new}, t_\text{wall}, T_\text{clock})\) appended to an immutable event log \(L\).

  2. Delta Detection Engine (DDE): evaluates registered threshold rules \(r: (G, \delta) \to \{\text{True}, \text{False}\}\) over all nodes. Firing rules emit Candidate Insights containing a normalized severity score and a \(k\)-hop BFS sub-graph snapshot (\(k=2\)) centered on the affected entity.

  3. Proactivity Scorer: ranks candidates per user via a weighted linear score: $\(P(c, u) = w_1 U(c) + w_2 R(c,u) + w_3 F(c,u) + w_4 K(c)\)$ where \(U\) (urgency) uses a sigmoid over rule severity and deadline time pressure, \(R\) (relevance) uses shortest-path hop distance in \(G\), \(F\) (persona fit) uses cosine similarity in a role–insight-type embedding space (approximated by a lookup table), and \(K\) (confidence) penalizes incomplete graph state scaled by empirical rule precision. Weights: \(w_1=0.35, w_2=0.30, w_3=0.20, w_4=0.15\).

  4. Surfacing Layer: the LLM (Claude) receives a structured JSON context snapshot and produces a fixed-schema notification (headline ≤15 words, 2–3 sentence grounded explanation, 1–2 next actions). Deduplication suppresses re-notification within a 4-hour cooldown window; co-located insights are batched.

  5. Orchestration (main.py): wires all modules; graph.py, delta.py, scorer.py, surface.py form a five-module end-to-end Python package.

Key Contributions

  • Formal schema for the Context Graph including node/edge taxonomy, property semantics, and the delta event model with change type vocabulary \(\Delta = \{\text{StateTransition}, \text{ThresholdBreach}, \text{RelationshipChange}, \text{Staleness}, \text{DependencyRisk}\}\).
  • Derivation of the Proactivity Score function \(P(c,u)\) with four interpretable, tunable components.
  • Complete, runnable Python implementation (five modules, NetworkX + Anthropic SDK).
  • Evaluation of Precision@5, false-positive rate, and mean time to surface across three enterprise domains (contract lifecycle, incident response, sales pipeline).

Results

  • Precision@5: 0.83 across three case studies.
  • False positive rate: 0.11.
  • Mean time to surface: reduced from 47 minutes (reactive baseline) to under 30 seconds.
  • Demo run: DDE fired three candidate insights (R-01 SLA breach on ticket-42 and ticket-17 at score 0.765 each; R-03 blocked >24h on ticket-17 at score 0.810).

Limitations

  • Evaluation uses three synthetic/generic case studies authored by the same paper; no independent real-enterprise datasets or blind evaluation.
  • Persona fit \(F(c,u)\) approximates role-profile embeddings with a static lookup table; production validity of learned embeddings is asserted but not demonstrated.
  • Proactivity Score weights \((w_i)\) and hyper-parameters \((\alpha, \beta, \gamma, \delta)\) are fixed by hand; no sensitivity analysis or learned calibration is presented.
  • Threshold rules are authored manually in Python; no automated rule discovery or rule-quality feedback loop.
  • The immutable event log \(L\) has no stated scalability bound; continuous polling of all nodes against all rules is \(O(|V| \cdot |R|)\) per tick without sharding or incremental evaluation.
  • No human-subjects study measuring real alert fatigue or worker productivity gain.

Relevance to Harnesses / Meta-Harnesses

This paper is a concrete instantiation of a multi-stage agent harness: it wraps an LLM inside a deterministic preprocessing pipeline (graph management → rule evaluation → scoring → prompt construction) and deliberately restricts the LLM to a single, bounded task (notification text generation), with all reasoning offloaded to earlier deterministic stages. This architectural separation—LLM as a "rendering" leaf node rather than an orchestrator—is a design pattern of direct interest to harness researchers evaluating how much reasoning to delegate vs. hard-code. The five-module layout (graph.py, delta.py, scorer.py, surface.py, main.py) mirrors the modular harness decomposition common in meta-harness work, and the delta event log with replay and audit capabilities echoes harness-level observability primitives. For researchers studying proactive or event-driven agent harnesses, this paper provides both a formal specification and a runnable reference implementation.