Context Graph: researchers taught enterprise AI agents to work without queries

Researchers on July 10, 2026, published a paper on arXiv with a Context Graph architecture—a living relational data structure that moves corporate AI agents from passive "wait for a query" mode to proactive: in tests on three business scenarios, the average time to obtain needed information dropped from 47 minutes to under 30 seconds.

Why reactive mode slows down corporate AI

The authors identify a fundamental problem with modern RAG systems and agent frameworks: they wait for a query. An employee must realize they need information, formulate it correctly, and ask the system—creating delays from minutes to hours. Meanwhile, significant critical signals are lost: the person simply didn't know to ask, or was occupied with another task when the important event occurred.

Context Graph fundamentally changes this logic. Instead of answering queries, the system builds a living model of the enterprise and independently sends notifications when significant changes occur. The graph stores business objects—contracts, incidents, deals, tasks—their relationships and history of state transitions. Everything updates continuously in real time, without user intervention.

How the three components of the system work

The Context Graph architecture consists of three sequential layers, each performing a separate role in the chain from event to notification:

• Delta Detection Engine — continuously monitors the graph for changes: status updates, responsibility shifts, new relationships, deadline violations. This component "notices" when something has happened.
• Proactivity Scorer — ranks potential notifications by three parameters: event urgency, relevance to the specific user, and alignment with their role and context (persona-fit). The authors derived a single Proactivity Score formula combining all three metrics into one numerical priority.
• Surfacing Layer — LLM generates the final message for the employee with justification and context from the graph. In the authors' implementation, this layer is handled by the Anthropic Claude API.

The entire Python implementation is based on NetworkX and provided in full in the paper text—it can be reproduced from scratch without additional dependencies.

What three corporate use cases demonstrated

The system was tested on three intentionally "generic" scenarios to show architectural universality rather than industry-specific optimization:

• Contract lifecycle management—tracking statuses, deadlines, and responsibility changes
• Response to incidents in engineering teams—early escalation before a developer "notices" the problem
• Tracking "hygiene" of the sales pipeline—monitoring stalled deals and missed activities

Final metrics compared to reactive baseline mode:

• Precision@5 = 0.83—in top-5 notifications, 83% are genuinely relevant
• False positive rate = 0.11—only 11% of notifications are unnecessary
• Average time to information delivery: from 47 minutes (reactive mode) to under 30 seconds—a 90+ fold reduction

What this means

The work translates the concept of "proactive agent" from academic discussion into a working open-source prototype. If results reproduce in production, corporate AI systems could deliver the right context at the right time—without a request—which is especially valuable where information delays cost money: engineering incidents, overdue contracts, stalled pipelines.

Frequently Asked Questions

Which LLM handles the final notifications?

In the Surfacing Layer, the authors use the Anthropic Claude API—it generates notifications with context explanation and priority justification for the specific employee.

Where can the implementation code be found?

The complete end-to-end Python implementation on NetworkX and Anthropic Claude API is included directly in the arXiv paper 2607.07721, available free at arxiv.org.