Do Proactive Agents Really Need an LLM to Decide When to Wake and What to Anchor?

2026-05-28 · Source: Computation and Language · Field: Technology & Digital — Artificial Intelligence & Machine Learning, Human-Computer Interaction · Depth: Expert, quick

Summary

A new approach for proactive agents, published on 2026-05-28, challenges the conventional method of using large language models (LLMs) to decide when to act and what to anchor based on user activity. Instead of converting structured user event streams into text for LLM processing, the proposed system treats these streams as graph updates. It employs a small temporal-graph-learning (TGL) model as an encoder, which performs a single forward pass per event to generate a trigger probability and an entity routing score. An LLM is only invoked downstream to formulate user-facing sentences when the TGL trigger fires. This TGL-based architecture significantly improves F1 scores across 14 backbones, with a mean increase of +16.7 and up to +46.0, while also demonstrating superior trigger AUCs and threshold stability. It achieves processing speeds of 11.13 ms per event on a GPU server and 13.99 ms on a consumer laptop, making it 4-7x and 12-83x faster, respectively, than LLM-as-trigger configurations. The model also boasts a compact 220 MiB BF16 resident footprint, enabling on-device deployment.

Key takeaway

For AI Engineers designing proactive agent systems, you should re-evaluate the necessity of using LLMs for initial event triggering and anchoring decisions. By adopting temporal-graph-learning (TGL) models to process structured user activity directly, you can achieve significant performance gains, with processing speeds 4-83x faster than LLM-as-trigger configurations. This approach also enables on-device deployment due to a compact 220 MiB BF16 footprint, enhancing privacy and reducing latency for user interactions.

Key insights

Proactive agents can replace LLM-based event processing with efficient temporal-graph-learning for significant speed and performance gains.

Principles

• User activity is natively structured graph data.
• Direct graph processing avoids text-to-LLM overhead.
• Small TGL models outperform LLMs for event triggering.

Method

Encode structured user activity as graph updates using a temporal-graph-learning model. Generate per-event trigger probabilities and entity routing scores, invoking an LLM only for final user-facing sentence generation when triggered.

In practice

• Implement TGL for proactive agent event processing.
• Deploy TGL models on-device for privacy.
• Reduce LLM calls to only final text generation.

Topics

• Proactive Agents
• Temporal Graph Learning
• Large Language Models
• Event Processing
• On-device AI
• Human-Computer Interaction

Best for: Research Scientist, AI Architect, MLOps Engineer, AI Scientist, Machine Learning Engineer, AI Engineer

Related on AIssential

• Evaluating Large Language Models as Live Strategic Agents: Provider Performance, Hybrid Decomposition, and Operational Gaps in Timed Risk Play — Live LLM agent performance in strategic, timed environments hinges on end-to-end system behavior, not just isolated planning capabilities.
• From Reactive to Proactive: Assessing the Proactivity of Voice Agents via ProVoice-Bench — ProVoice-Bench evaluates proactive voice agents, revealing significant performance gaps in current Multimodal LLMs.
• Memory is Reconstructed, Not Retrieved: Graph Memory for LLM Agents — LLM agent memory should be actively reconstructed and dynamically adapted to reasoning context, not statically retrieved.
• AsyncTool: Evaluating the Asynchronous Function Calling Capability under Multi-Task Scenarios — AsyncTool evaluates LLM agents' asynchronous tool calling in multi-task scenarios with realistic latency.
• Are Large Language Models Suitable for Graph Computation? Progress and Prospects — LLMs excel as graph computation planners but struggle as direct executors for large, exact tasks.
• EXG: Self-Evolving Agents with Experience Graphs — EXG uses a structured experience graph to enable LLM agents to systematically learn and improve from past interactions.

Open in AIssential →

Editorial summary, takeaway, and curation by AIssential. Original article published by Computation and Language.