Your Agent Should Not Wait for Your Prompt

Most production agents are still query-response systems. The user types a prompt, the agent answers, the interaction ends. That is not an agent. That is a chatbot with extra steps.

The value of an agent is in what it does when nobody is watching. Google Information Agents monitor user-selected topics and proactively send updates, synthesizing sources and explaining relevance before the user repeats a search query. Microsoft Scout collects emails and messages requiring user decisions, keeping a human in the loop while still acting autonomously to gather. The pattern is clear. The most useful agents do not wait for permission. They act, then ask for approval.

Reactive is not a virtue. It is a limitation. If your agent only works when a human types a prompt, it is a chatbot, not an agent. The next architecture shift is from reactive to proactive, and the Context Graphs paper just proved it is implementable today.

The Context Graph Architecture

A new arXiv paper, "Context Graphs for Proactive Enterprise Agents" (arXiv:2607.07721, submitted July 4, 2026), proposes a live relational data structure that models enterprise entities, their relationships, and state transitions over time. This is not theory. The paper provides a complete Python implementation using NetworkX and the Anthropic Claude API. You can copy, paste, and run it.

The system has three components.

First, the Delta Detection Engine continuously monitors state changes in connected data sources. It watches your CRM, your incident tracker, your contract repository, whatever systems matter to your operation. When something changes, the engine notices.

Second, the Proactivity Scorer ranks candidate insights by urgency, relevance, and persona-fit. Not every change matters equally. A stalled deal in your sales pipeline is more urgent than a typo fix in documentation. The scorer weights these signals and produces a ranked list of what the user actually needs to know.

Third, the LLM-powered Surfacing Layer delivers ranked notifications with grounded explanations. The agent does not just say "something changed." It says: "Deal X with Acme Corp has been in negotiation for 14 days, three days past your typical close window. The last touchpoint was an email with no reply. Here is the thread."

The user did not ask. The agent knew.

In evaluations across contract lifecycle management, engineering incident response, and sales pipeline hygiene, the approach achieved Precision at 5 of 0.83, a false positive rate of 0.11, and reduced mean time to surface from 47 minutes to under 30 seconds. That is not a marginal improvement. That is a different category of system.

Think about what this means for a sales pipeline agent. Instead of waiting for a rep to ask "what changed in my deals," the Context Graph agent detects a stalled opportunity, scores it as high urgency, and surfaces the insight with context. The rep gets the information before they know they need it. That is the difference between a tool and a teammate.

Sandboxed Autonomy: Why Code Airlock Matters

Proactive agents need autonomy. Autonomy without isolation is recklessness.

The fundamental tension in AI-assisted coding is that agents are most useful when they act without asking permission for every command, but that autonomy creates security risks if the agent has unfettered access to the host system. You want the agent to install packages, run tests, and iterate freely. You do not want it deleting your production database or exfiltrating your credentials.

Code Airlock is an open-source tool that wraps coding agents like Claude Code, Codex, and OpenCode inside disposable microVMs. The agent gets full freedom within the VM. It cannot touch the host's files, network, or credentials. All work is committed as git changes that the developer reviews from the host. The agent is a junior developer who can write code but does not have root access to production.

The pattern is straightforward. Give the agent a sandbox, let it work, review the diff. That is how you ship autonomous code generation without shipping your security posture. The project has gained traction on GitHub because developers increasingly rely on autonomous coding agents and need safe ways to let them operate unattended.

The principle is simple. Autonomy without isolation is recklessness. Isolation without autonomy is useless. The architecture that wins combines both.

Fleet Management: From One Agent to Many

Production is not one agent completing one task. It is ten agents working on different parts of a codebase, three agents monitoring infrastructure, and two agents drafting documentation, all at once.

AgentKindergarten is an open-source project that provides a managed runtime environment for AI coding agents, handling scheduling, resource allocation, and task queuing across multiple agent sessions. It acts as a daycare for agents, allowing developers to spawn multiple coding agents, monitor their progress, and manage their lifecycle without manual intervention. The challenge is shifting from "can an agent write code" to "how do you manage a fleet of agents working in parallel."

The orchestration problem is real. Agents may need to coordinate or avoid conflicts. Without a scheduler, they step on each other. AgentKindergarten addresses the growing operational complexity of running multiple AI agents simultaneously, particularly in CI/CD pipelines and large codebases.

This connects directly to the Shepherd pattern for managing isolated sub-agents in parallel exploration. AgentKindergarten is the operational layer that makes that pattern runnable at scale. You can have the architectural concept, but without the runtime infrastructure, it stays a concept.

Here is a concrete operational metric: agent utilization. In a reactive system, utilization is near zero between prompts. The agent sits idle until a human initiates. In a proactive, fleet-managed system, utilization is a function of how many tasks the agents can discover and execute without human initiation. The goal is not faster responses. It is fewer prompts needed.

The Spam Objection

A fair question: does proactive surfacing just create notification spam?

The answer is in the architecture. The Proactivity Scorer is not a firehose. It ranks every candidate insight by urgency, relevance, and persona-fit before anything reaches the user. A Precision at 5 of 0.83 means that when the system surfaces five items, over four of them are genuinely useful. The false positive rate of 0.11 means fewer than one in ten notifications is noise.

The difference between proactive and annoying is the difference between a ranked list and a firehose. A system that surfaces everything is spam. A system that scores, ranks, and explains is a teammate. The Context Graph architecture is explicitly designed to be the latter. If your proactive agent is annoying, your scoring layer is broken, not the concept.

The Bottom Line

The agent stack is maturing from "can it write code" to "how do we run a fleet safely." The three layers form a complete architecture for production agent deployment.

Proactive context comes from Context Graphs. The live relational data structure, the delta detection engine, the proactivity scorer, and the surfacing layer give agents the ability to surface information before users ask. That is the intelligence layer.

Sandboxed autonomy comes from Code Airlock. The disposable microVMs give agents freedom to act without giving them freedom to damage. That is the security layer.

Fleet operations come from AgentKindergarten. The managed runtime handles scheduling, resource allocation, and task queuing across parallel agent sessions. That is the operations layer.

A reactive agent is a tool. A proactive agent is a teammate. The difference is architecture, not model size.