Context Graph: Researchers Teach Enterprise AI Agents to Work Without Being Asked

On July 10, 2026, a team of researchers published a paper on arXiv describing Context Graph, a live relational data structure that moves enterprise AI agents from a passive "wait for a question" mode to a proactive one. In tests on three business scenarios, the average time to get the needed information dropped from 47 minutes to under 30 seconds.

Why reactive mode slows down enterprise AI

The authors point to a fundamental problem with current RAG systems and agent frameworks: they wait for a query. An employee has to realize they need information, phrase the request correctly and go to the system, which adds a delay of anywhere from minutes to hours. A significant share of critical signals gets lost along the way: the person simply did not know they should ask, or was busy with another task when an important event occurred.

Context Graph changes this logic at its root. Instead of answering a query, the system builds a live model of the enterprise and sends a notification itself when a significant change appears. The graph stores business objects (contracts, incidents, deals, tasks), their relationships and the history of their transitions between states. Everything updates continuously in real time, with no user involvement.

How the three components work

The Context Graph architecture has three sequential layers, each with its own role in the chain from event to notification:

• Delta Detection Engine continuously monitors the graph for changes: status updates, changes of owner, new relationships, missed deadlines. This component is the one that "notices" that something has happened.
• Proactivity Scorer ranks potential notifications on three parameters: the urgency of the event, its relevance to a specific user, and fit with that user's role and context (persona-fit). The authors derived a single Proactivity Score formula that combines all three into one numeric priority.
• Surfacing Layer uses an LLM to generate the final message to the employee, with a rationale and context from the graph. In the authors' implementation, the Anthropic Claude API handles this layer.

The entire Python implementation is based on NetworkX and is provided in full in the text of the paper. It can be reproduced from scratch with no additional dependencies.

What the three enterprise cases showed

The system was tested on three deliberately "generic" scenarios, to demonstrate the architecture's generality rather than its tuning to a particular industry:

• Contract lifecycle management: tracking statuses, deadlines and changes of owner
• Incident response in engineering teams: early escalation before a developer "notices" the problem
• Sales pipeline "hygiene" tracking: monitoring stalled deals and missed activities

Final metrics compared with the reactive baseline:

• Precision@5 = 0.83: of the top 5 notifications, 83% turn out to be truly relevant
• False positive rate = 0.11: only 11% of notifications are unnecessary
• Average time to information: from 47 minutes (reactive mode) to under 30 seconds, a reduction of more than 90 times

What this means

The work moves the concept of a "proactive agent" from academic discussion to a working open-source prototype. If the results can be reproduced in production, enterprise AI systems will be able to deliver the right context at the right moment, without a query. That is especially valuable where delays in information cost money: engineering incidents, overdue contracts, a stalled pipeline.

Frequently asked questions

Which LLM generates the final notifications?

In the Surfacing Layer, the authors use the Anthropic Claude API. It generates notifications that explain the context and justify the priority for the specific employee.

Where can I find the implementation code?

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