💬 NLP

Anticipate and Learn: Unleashing Idle-Time Compute in Proactive Agents

This paper introduces ProAct, a proactive agent architecture that leverages idle-time compute to anticipate and prepare for future user needs, alongside the ProActEval benchmark, demonstrating significant improvements in task efficiency, user effort reduction, and hallucination mitigation compared to reactive baselines.

Original authors: Haoyi Hu, Qirong Lyu, Xianghan Kong, Weiwen Liu, Jianghao Lin, Zixuan Guo, Yan Xu, Yasheng Wang, Weinan Zhang, Yong Yu

Published 2026-05-26

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Haoyi Hu, Qirong Lyu, Xianghan Kong, Weiwen Liu, Jianghao Lin, Zixuan Guo, Yan Xu, Yasheng Wang, Weinan Zhang, Yong Yu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a very smart personal assistant who is incredibly good at answering questions, but only after you ask them. If you ask, "What's the weather?" they tell you. If you then ask, "Should I bring an umbrella?" they check again. They are reactive: they wait for the command, then act.

The paper introduces ProAct, a new kind of AI assistant that changes the rules. Instead of just sitting idle and waiting for your next command, ProAct uses the "dead time" between your questions to think ahead and prepare.

Here is the breakdown of how it works, using simple analogies:

1. The Problem: The "Dormant" Assistant

Current AI agents are like a chef who only starts chopping vegetables after you yell, "Make me a salad!" They sit still and do nothing while you are thinking about what to order next. This wastes time.

2. The Solution: The "Proactive" Assistant

ProAct is like a chef who, while you are deciding on your main course, is already:

Reading your past orders (Memory) to guess you might want a salad.
Washing the lettuce and prepping the dressing (Idle-Time Compute) so it's ready the moment you ask.
Checking the fridge to make sure they have the right ingredients (Fact Verification).

When you finally say, "I'll have a salad," the chef doesn't just start chopping; they hand you a perfectly prepared bowl instantly.

3. How It Works: The Two-Step Dance

The paper describes ProAct as having two main "muscles" that work together during those quiet moments:

Step A: The Crystal Ball (Future-State Prediction)
The AI looks at what you just said and your long-term history. It asks, "What is this person likely to ask next?"
- Example: If you just scheduled a meeting for tomorrow, the AI guesses you will soon need a summary of the project to discuss. It doesn't wait for you to ask; it predicts this need.
Step B: The Smart Saver (Idle-Time Acquisition)
Once the AI has a guess, it doesn't just guess blindly. It checks: "Is this guess useful? Do I already know the answer? Do I need to go look up new facts?"
- If the answer is "Yes, this is valuable," it spends its "idle time" gathering the facts, checking them for accuracy, and organizing them.
- If the answer is "No, this is probably a waste of time," it saves that thought for later or ignores it.

4. The "Value Gate": Don't Be Annoying

A major fear with proactive AI is that it will interrupt you with useless information (like a waiter bringing you dessert before you've finished your soup).

ProAct has a strict Value Gate. It only pushes information to you if:

It is highly relevant to what you just did.
It saves you effort.
It is factually correct.

If the information is good but not urgent, it quietly stores it in its "back pocket" (memory) to use the next time you ask a related question.

5. The Results: The "ProActEval" Test

To prove this works, the authors created a massive test called ProActEval. Imagine a video game with 200 different scenarios (like planning a trip, managing a budget, or organizing a project) where the "right" answers are already known.

They tested three types of assistants:

The Reactor: Waits for questions.
The Busybody: Works during idle time but guesses randomly without a plan.
ProAct: Works during idle time with a smart plan.

The Winners:

Faster: ProAct finished tasks 14.8% faster (fewer back-and-forth turns).
Less Effort: Users had to ask fewer questions (11.7% less effort) because the AI often answered before they asked.
Fewer Mistakes: The AI made 28.1% fewer hallucinations (made-up facts) because it had time to double-check its work before speaking.

6. The Catch (Limitations)

The paper is honest about the limits:

It's a Simulation: The tests were done in a controlled, synthetic environment (like a flight simulator), not necessarily in the messy real world yet.
Cost: Doing this extra thinking costs computer power. The paper found that doing too much preparation can actually slow things down or annoy the user. It's a balance, not a "more is always better" situation.
Privacy: Because the AI is constantly analyzing your history to guess your needs, real-world use would need strict privacy controls to ensure it doesn't overstep.

Summary

ProAct turns the AI from a passive waiter who waits for your order into an active sous-chef who anticipates your needs, preps the ingredients while you decide, and serves you a perfect meal the moment you are ready. It uses the "boring" waiting time to learn and prepare, making the actual conversation faster, smarter, and more accurate.

Technical Summary: ProAct – Anticipate and Learn: Unleashing Idle-Time Compute in Proactive Agents

1. Problem Statement

Current AI agents, despite advancements in reasoning and tool use, operate fundamentally as reactive systems. They compute responses only after explicit user prompts, leaving the "idle time" between interactions unused. This paradigm fails to leverage the opportunity to anticipate future user needs, refine understanding of user preferences, or prepare supporting evidence before a query is initiated.

The authors contrast this with the psychological concept of proactive coping, where individuals anticipate demands and accumulate resources before they fully materialize. The core challenge identified is how to transform idle time into useful, grounded preparation without overwhelming the user with irrelevant, premature, or weakly supported suggestions. Existing memory-augmented agents (e.g., MemGPT, MemoryBank) and proactive dialogue systems largely remain request-driven or rely on user-defined schedules, lacking autonomous anticipation of unstated future needs.

2. Methodology: The ProAct Architecture

The paper introduces ProAct, a unified agent architecture designed to convert idle intervals into a structured cycle of anticipation and learning. ProAct operates as a closed-loop decision problem driven by two tightly coupled modules:

A. Future-State Prediction

This module generates a compact set of candidate future needs ( $Z_t$ ) based on the dialogue history ( $H_t$ ) and persistent memory state ( $M_t$ ).

Sources: It combines local scenario prediction (extrapolating from recent turns) and related expansion (proposing adjacent topics based on user profiles and stored facts).
Memory-Gap Augmentation: It actively converts identified memory gaps (stale, incomplete, or missing knowledge) into candidate future needs.
Filtering: Candidates are filtered by confidence thresholds and deduplicated against existing memory artifacts.

B. Idle-Time Acquisition

This module evaluates predicted candidates and allocates background compute budget.

Value-Gated Selection: A score $S(z)$ $S (z)$ is computed for each candidate based on four weighted factors:
- $r_z$ : User relevance.
- $g_z$ : Knowledge gap (missing information).
- $v_z$ : Incremental value beyond existing memory.
- $\tau_z$ : Timeliness.
  Only candidates exceeding a value threshold $\theta_{val}$ proceed to acquisition.
Incremental Acquisition: The system checks existing memory coverage first. If partial, it searches only for missing subtopics; if low, it performs iterative search. This avoids redundant full restarts.
Artifact Generation: Retrieved evidence is synthesized into compact knowledge artifacts ( $A_z$ ) with provenance linking them to source facts, ensuring factual grounding.

C. Utility-Aware Delivery Policy

A policy $\pi$ decides the delivery mode ( $d_z$ ) for each artifact:

Push: Immediate notification if expected utility exceeds interruption cost.
Queue: Integrated into a future response if useful but not urgent.
Store: Silent storage in memory for later retrieval if not appropriate for immediate delivery.

The system optimizes for future utility while penalizing interruption costs, budget usage, and hallucination risks.

3. Evaluation Framework: ProActEval

To rigorously evaluate proactive capabilities, the authors introduce ProActEval, a benchmark comprising:

Scale: 200 scenarios across 40 domains (e.g., finance, healthcare, project management).
Structure: Each scenario includes a fictional fact sheet and an ordered sequence of user needs. Crucially, it defines predictable_after links, establishing which future needs become anticipatable after specific prior interactions.
Cognitive Archetypes: Scenarios cover five types of anticipatory demands: Foundational Memory, Translation/Gap Resolution, Trace/Dependency Reasoning, Handoff/Consistency Control, and Readiness/Follow-through.
Protocol: A user simulator traverses the need sequence. If the agent proactively covers a need, the simulator skips the explicit user question, translating anticipation into reduced user effort. The system is evaluated on runtime-visible information only, without access to gold metadata.

4. Key Results

Empirical evaluations on ProActEval and MemBench demonstrate significant advantages over reactive baselines:

ProActEval Performance:

Efficiency: Reduces required interaction turns to reach 100% coverage ( $T_{100}$ ) by 14.8% (from 8.11 to 6.91 turns).
User Effort: Decreases explicit user effort (turns where the user must ask) by 11.7%.
Factual Integrity: Reduces hallucination rates by 28.1% (from 13.2% to 9.5%), attributed to the grounding of proactive artifacts in retrieved evidence.
Anticipation: Achieves an Anticipation Recall of 0.428, significantly outperforming both a reactive baseline (0.0) and an "Undirected Idle" variant (0.0), proving that prediction direction is critical.
Comparison: Outperforms a adapted ProactiveAgent baseline (0.020 recall) by anticipating 703 of 1,572 predictable needs versus 32.

MemBench Performance:

Reflective Accuracy: ProAct achieves state-of-the-art reflective accuracy in inferring user preferences and emotions from history: 84.3% at 10k tokens and 86.3% at 100k tokens, surpassing prior baselines like Generative Agents and MemoryBank.

Ablation & Budget Analysis:

Direction vs. Volume: An "Undirected Idle" variant (searching without prediction) yields minimal gains over a purely reactive baseline, confirming that prediction-guided direction is the primary driver of efficiency, not just increased compute volume.
Diminishing Returns: Increasing the search budget improves anticipation recall but does not monotonically reduce user effort or turns. Excessive search can introduce low-value pushes that alter conversation trajectories negatively, suggesting proactive compute is an operating-point trade-off rather than a parameter to maximize.

5. Significance and Claims

The paper claims to establish a new proactive human–AI collaboration paradigm where agents view idle time not as empty delay, but as an opportunity to learn and prepare.

Architectural Shift: ProAct moves away from "request-response" models to a continuous cycle of prediction, acquisition, and delivery, effectively turning background compute into grounded preparation.
Validation of Idle-Time Compute: The results provide controlled evidence that prediction-guided idle-time compute can significantly reduce user effort and hallucination rates while maintaining factual integrity.
Limitations: The authors modestly note that these results are derived from a closed-world synthetic benchmark. They caution that real-world deployment requires user controls, rate limits, and monitoring to prevent "proactive backfire" (e.g., interrupting users with low-value content or competing with reactive answers). The system's success relies on the existence of predictable need chains and auditable evidence sources.

In summary, ProAct demonstrates that by leveraging persistent memory and predictive modeling during idle intervals, agents can transition from static responders to proactive partners, reducing cognitive load and improving the quality of interactions without compromising factual accuracy.