acceptodds
Under review as a conference paper at ICLR 2027

Do Proactive Agents Need an LLM to Decide When to Act?

Abstract

Proactive assistants continuously decide when to intervene and what context should support the intervention. Large language model (LLM) pipelines repeatedly interpret activity histories to make these decisions, paying an inference cost even when the assistant remains silent. We show that a small graph model can handle both decisions and improve the language agents it controls. Our key insight is that user activity has a native graph structure: events involve persistent entities whose recurrence connects interactions over time. Triggering and context selection map directly to predictions on event and entity nodes. We introduce a temporal-graph-learning (TGL) controller that learns these predictions jointly and supplies both outputs in one forward pass. The downstream language agent generates suggestions on triggered events using the activity history and scored entities. At 11.13 ms per event on a GPU server, TGL achieves the highest AUCs among nine trigger architectures and gives approximately 4–7× trigger-stage speedups over the two single-forward LLM triggers. A shared TGL model improves F1 across all 14 downstream backbones by a mean of 16.7 points. The controller also runs at 13.99 ms on a consumer laptop with an approximately 220 MiB BF16 resident footprint, bringing effective proactive control to on-device deployment.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
proactive agents, temporal graph learning, graph neural networks

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_AApsOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes a temporal-graph learning (TGL) controller, which uses a lightweight graph model to determine when an proactive agent invokes an action and what context should it read. This method achieves better performance than LLM triggers even when used for shorter durations. It is an interesting and highly efficient Graph4LLM approach. The authors elegantly demonstrate how structured information can benefit both models and agents, leading to performance gains.

Critical strengths

With a shorter runtime, the TGL method proposed in this paper achieved better results than directly invoking an LLM on the trigger of proactive agent, runnable on a consumer laptop.

More importantly, what this paper attracts me most is that it shows an elegant method to leverage structured graph information in an agent task, achieving both improvement in performance and decreasement in latency.

Critical weaknesses

I think the main issue with this paper lies in how the graphs are constructed. For two different benchmarks, the authors chose two entirely different graph-construction approaches, resulting in two distinct graph systems. This approach limits the method’s generalizability: for each similar task across different domains, the method requires the construction of a new graph-building workflow and a new graph system. While this validates the effectiveness of the graph-building paradigm for proactive agent, it leaves its generalizability open to question.

The two benchmarks do not actually evaluate the same capability. ProactiveAgent focuses on whether to intervene and which entities to focus on, while Fingertip-20k focuses on intent prediction and candidate retrieval. They use different graph structures, prediction heads, and downstream processes to evaluate different tasks. This also affects the generalizability of the methodology.

Questions for authors

What factors shaped the design approaches for the (two different) graph systems?

In ProactiveAgent, how effective are entity deduplication? Is there a way to quantify this using certain metrics?

3 comments

Thank you for recognizing the value of a compact graph model for proactive control. We clarify the common graph design and quantify entity reuse below.

Q1. Platform adaptation and shared graph design. The two benchmarks originate from different device platforms: desktop activity in ProactiveAgent and smartphone usage in FingerTip. Each provides records collected and processed by its own authors, with different data formats, available fields and supervision. We construct one pipeline for each dataset to map its released records into the same activity–entity graph design (Apps. B.1–B.2).

The on-device nature of proactive assistance makes the platform's activity interface central to this mapping. Evaluating across desktop and mobile environments therefore requires adapting to their respective interfaces, much as an application needs platform-specific integration when distributed through different app ecosystems. Within a platform, the construction rules are fixed and reused across sessions.

The table separates the design shared by both pipelines from the parts set by each platform's records and benchmark target (App. B).

ComponentShared designSet by each platform
Identity sharingEntities and categories with the same type and normalized value share one node within a graph—
Graph backboneInput projection, three relation-aware GATv2 layers and a Jumping Knowledge readout (Sec. 4.1)—
Node featuresFrozen text embedding, learned node-type embedding and time-offset embedding for every nodeText encoder for the data language (English or Chinese BGE)
Graph structureActivity nodes linked to typed entity and category nodes, with temporal edges between successive activitiesNode and relation vocabulary: applications, files, queries and URLs (desktop); applications, intent classes, scenarios, hours and user profile (mobile)
Input mappingFixed construction rules reused across sessionsExtraction from event descriptions (desktop); direct mapping of categorical fields (mobile)
Prediction headsNode readouts trained on the benchmark's released supervisionTrigger and entity relevance (desktop); next-intent embedding with application and class auxiliary targets (mobile)
Downstream useGraph outputs supply context to the downstream language agentScored current-event entities (desktop); retrieved intent candidates (mobile)

Desktop supervision supplies task suggestions and acceptance information, which support wake-up and artifact-selection targets. FingerTip supplies the next-intent target and categorical usage fields, so its current-episode representation predicts an intent embedding for retrieval. These choices apply the common activity–entity representation to each benchmark's available records and target. FingerTip tests the portability of the graph-encoding design to mobile intent prediction. Desktop intervention timing is evaluated on ProactiveAgent.

The desktop mapping uses deterministic rules for the fields represented by its graph (App. B.1, Table 3):

Desktop entity classExtraction ruleAdded category nodes
ApplicationApplication-name aliases—
FileRecognised filename extensionFile extension and file category
Web addressWeb-address syntaxWebsite domain
Search querySearch or typing patternQuery-language category
Document artifactQuoted name after a document noun—

App. E.3 (Table 11) reports sensitivity to these node groups and feature channels, with the controller trained on each variant.

This construction reflects our broader design principle: represent the platform's available entities with a fixed schema and use conventional components throughout, including TGL itself. Our focus is what a small, standard GNN can achieve as a joint trigger and entity router for frozen language agents (Sec. 4.1 and App. F.2–F.6).

Q2. Entity deduplication. Applications are normalized through a fixed alias map. Other identities combine entity type with a normalized surface string. Equal identities are reused within each graph. Separate graphs have separate node states. This directly links repeated references to the same named artifact or category.

We quantify deduplication on the desktop test sessions with three structural measures over entity and category nodes:

MeasureValue
Node reduction relative to one node per mention65.9%
Nodes that recur within their session44.6%
Nodes linking events more than three steps apart38.0%

Shared nodes give the encoder long-range connections. Through temporal edges alone, the three-layer encoder reaches at most three preceding events. A shared entity node links any two events that mention it within two hops, and 85% of recurring nodes create such links beyond the temporal reach. Persistent identities also enable embedding reuse during streaming inference: recurring entities keep their cached text embeddings, so each update encodes only the current event and newly encountered entities (Sec. 4.1 and App. F.10).

The representation also supports new artifact instances: 100% of test query, file and URL identities are unseen in the controller's training graphs. Their text and type features are processed with shared model parameters, so graph construction naturally accommodates new names.

Thank you for the detailed responses. The clarifications on the shared graph design and the quantitative analysis of entity deduplication have addressed my main concerns. While some questions about cross-task generalizability remain open, I find the responses satisfactory and will maintain my original assessment.

Reviewer_kh9oOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper studies whether a compact graph model can make the continuous control decisions of a proactive assistant. It represents activity as a graph of events, recurring entities, category nodes, and temporal connections. A shared encoder predicts when to invoke a frozen language agent and ranks the entities that should anchor its suggestion. On ProactiveAgent, the same controller improves reward-model-assessed F1 across 14 backbones by a reported mean of 16.7 points. The paper also compares trigger architectures, measures server and laptop latency, and evaluates a separately trained mobile intent-prediction model.

Critical strengths
  1. The separation between continuous control and suggestion generation is practical and supported by broad evaluation. The same controller, threshold, and prompt are used across 14 frozen backbones, and Table 5 reports higher F1 for every backbone. Appendix D.3 also tests the trigger as a filter on existing fine-tuned agents while retaining their original suggestions. F1 increases by 1.4 and 0.9 points, with 25% and 21% fewer calls. This narrower experiment is useful evidence that a separate controller can complement proactive language-model fine-tuning.

  2. The resource comparison is concrete, and the implementation is documented in substantial detail. Sections 5.4–5.5 distinguish single-forward LLM triggers from generation-based triggering and include the frozen text encoder in the resource accounting. The reported controller latency is 11.13 ms on an A6000 and 13.99 ms on an M3 Pro. Appendices B, E, F, and G provide label derivation, training settings, system prompts, threshold analyses, retraining variation, and results for events without extracted entities. These details make the design and its reported trade-offs easier to assess.

Critical weaknesses
  1. The inference description does not establish strictly causal event-time evaluation. Appendix F.7 describes evaluating a session graph with backward temporal edges removed and future-node input representations masked (lines 1684–1686). However, event–entity links are bidirectional, and recurring entities share a node within each session (Section 4; Appendix B.1). If future nodes and their incident entity edges remain active, masking initial features alone can still allow them to affect attention normalization and later message-passing layers. Appendix E.1 provides useful evidence about temporal-edge direction, but both training variants use the same deployed inference procedure; it does not test equivalence to a graph containing only the observed prefix. This distinction matters because the online-control claim requires decisions to depend only on information available at that event. An explicit edge-mask specification and a prefix-invariance check would resolve the concern: changing an unseen suffix should leave the current trigger score and routing list unchanged.

  2. The controls establish a benefit from the complete interface, but do not sufficiently isolate learned graph structure and entity ranking. Random routes supplies training-vocabulary samples under a prompt that instructs the agent to quote its first routed entity (Section 5.3; Appendices D.1 and G.1). Its 8.6-point mean F1 gap therefore compares learned context with potentially misleading anchors, rather than isolating ranking among entities present in the observation. No TGL retains output-style rules but removes all three demonstrations, so its 12.7-point gap also includes a prompt change. In the architecture comparison, TGL receives session-graph context and entity-routing supervision, whereas the text and LLM triggers receive recent event text and trigger supervision (Section 5.4; Appendix D.2). The construction ablations in Appendix E.3 are helpful, but do not match these inputs and learning targets across architectures. A current-event entity baseline and a flat controller with matched history, features, supervision, and demonstrations would clarify what graph learning adds beyond the other interface changes.

Questions for authors
  1. At inference, are future nodes and all their incident edges excluded from message passing and attention normalization at every layer? Can you show that the current outputs match strict-prefix inference and remain unchanged when an arbitrary unseen suffix is appended?

  2. Is there an existing flat or sequence-controller comparison with the same observed history, entity features, and routing supervision? If so, what advantage remains for TGL under those matched conditions?

  3. What happens when the prompt receives the actual current-event entities in a fixed or random order, with the trigger and prompt held constant? This would separate learned ranking from supplying relevant artifact names.

  4. Can you provide a No TGL comparison with equivalent task demonstrations, or the existing Ours-versus-No TGL results restricted to the 34% of events without extracted entities? Either would help clarify the contribution of the prompt interface.

5 comments

Thank you for recognizing the deployment motivation and the submitted filtering and efficiency experiments. We address the two weaknesses (W1–W2) and four questions (Q1–Q4) below.

W1. Event-time causality. We compare controller outputs under the deployed procedure (App. F.7) and prefix-graph inference across five training seeds, test the deployed procedure with appended unseen suffixes, and compare downstream F1 across three training checkpoints (Q1). Prefix-graph inference, which uses only the observed history, reproduces the results of the deployed procedure.

W2. Graph, routing and prompt contributions. Table 1 compares trigger architectures, and each family receives the input form it is built to process: event features for LR and HGB, the latest five event texts for the BGE classifiers, the rolling session history for the Qwen triggers, and the event–entity session graph for TGL (Sec. 5.4 and App. D.2). For TGL, this input form is the graph structure under evaluation. Where a flat controller can receive the same information, we match history, features and supervision with full-history GRU and Transformer controllers (Q2). Adding TGL's entity/type inputs lowers both flat controllers, every variant remains below TGL, and the graph encoder uses the same information through shared entity nodes. We also provide fixed/random ordering of the same current-event entities, simple entity selection and routing-removal controls (Q3), and matched-demonstration and full-prompt controls, including the requested subset without extracted entities (Q4).

Q1. Strict-prefix inference. TGL scores each event with the deployed procedure (App. F.7), which evaluates the session graph used in training with backward temporal edges removed and future-node input representations masked. Future events therefore contribute neither input features nor backward temporal messages. App. E.1 already tests the backward-edge channel: adding backward edges at inference changes trigger AUC by less than 0.005 and preserves routing on every test event. Future nodes remain attached to shared entity nodes. To test whether this structure could affect current outputs, we compare the deployed procedure with graphs constructed strictly from the history available at each decision:

  1. TGL: the deployed procedure (App. F.7).
  2. TGL (prefix graph): rebuild the input graph at every decision using only observed events, entities already encountered and edges between those nodes. Future nodes and all their incident edges are absent throughout message passing. Temporal edges use the same forward direction as in submitted TGL.
Inference settingMust-fire AUCCan-skip AUCMust-skip AUC
TGL0.733 ± 0.0090.636 ± 0.0140.632 ± 0.024
TGL (prefix graph)0.733 ± 0.0080.637 ± 0.0140.632 ± 0.025

All values come from five-seed training, following App. E.3, and are reported as mean ± sample SD. Paired by training seed, prefix-graph inference changes must-fire AUC by +0.0006 ± 0.0018.

We also test the deployed procedure directly by appending an unseen suffix to every test session: the earliest events of a randomly drawn training session, whose recurring entities connect to the session's existing entity nodes. Relative to the same checkpoint without the suffix, the AUC change is −0.0002 ± 0.0003 for must-fire, 0.0000 ± 0.0002 for can-skip and +0.0002 ± 0.0004 for must-skip. These values are mean ± sample SD across the five training seeds, each averaging five random suffixes. Under prefix-graph inference, appending any suffix leaves every output unchanged by construction, since the graph at each decision contains only the observed prefix.

For downstream assistance, three training checkpoints are each evaluated under both procedures on five backbones (Qwen2-7B, Qwen3-4B, Qwen3-8B, LLaMA-3.1-8B and Gemma-3-12B) with three inference runs. Both procedures use the same language-model weights, prompt, three demonstrations, observation history, trigger threshold of 0.5, top-20 routing, decoding settings, parser and local reward model. Prefix-graph inference changes mean downstream F1 by +0.20 ± 0.40 points (paired difference, mean ± sample SD across the three training checkpoints).

Prefix-graph inference, which uses only the observed history, therefore reproduces the results of the deployed procedure.

Q2. Existing sequence baselines and additional matched controls. The submitted study compares TGL with eight baseline trigger architectures across four families: rule-based, tabular, text-encoder and LLM models (Table 1 and Appendix D.2). The baselines use conventional configurations within their respective families. The suite includes linear and nonlinear feature models (LR/HGB), frozen and fine-tuned variants of TGL's BGE text encoder, and Qwen models trained through LoRA classification or full-parameter proactive SFT. Together, these configurations cover different input representations, adaptation strategies and inference costs relevant to continuous monitoring.

The Qwen3-0.6B and Qwen3-8B classifiers are trained Transformer sequence models: they process the rolling event history and current observation to predict the trigger. Sequential modeling is therefore already represented in the submitted comparison, where TGL leads all three trigger-AUC measures.

The trigger AUC and latency columns are from Sec. 5.4, Table 1. Configurations are specified in App. D.2. Server and local timings use an A6000 and M3 Pro, respectively. TGL latency includes the frozen text encoder.

TriggerMust-fire AUCCan-skip AUCMust-skip AUCServer (ms)Local (ms)
TGL0.7380.6580.63911.1313.99
Rule0.5850.5810.4960.00030.0001
LR0.5800.5340.4990.130.03
HGB0.6360.5510.5007.295.73
BGE-frozen + MLP0.5740.5180.4606.5911.95
BGE-FT + MLP0.6210.5860.5536.8611.06
Qwen3-0.6B0.6680.5820.50440.4162.3
Qwen3-8B0.6440.6180.59778.61156.8
Proactive-Qwen3-0.6B (SFT)0.5050.5080.485392711966

These results support our conclusion that a small graph controller provides accurate, low-cost triggering. To examine how this advantage depends on history, entity inputs and supervision, we additionally evaluate GRU and Transformer controllers trained from scratch on frozen BGE-base features. Each event is represented by its text embedding and a learned embedding of the inter-event time gap. Entity/type variants additionally concatenate the mean entity-text embedding, summed type embeddings and log-scaled entity count. Each test decision uses the full observed event history.

Both controllers have three layers, hidden size 256, dropout 0.2, residual connections and layer normalization. The GRU is unidirectional. The Transformer uses four attention heads, a 1,024-dimensional feed-forward layer, learned positional embeddings and a causal attention mask. The projected input and outputs of all three layers are concatenated and passed to an MLP trigger head.

All variants use TGL's trigger training labels. Auxiliary-routing variants also use its entity-label targets: the routing head combines the mean hidden state of events containing an entity with that entity's text and type embeddings.

ControllerEntity/type inputsRouting supervisionMust-fire AUC
TGL (five training seeds)YesYes0.733 ± 0.009
GRUNoNo0.674 ± 0.036
GRUYesNo0.612 ± 0.025
GRUYesYes0.660 ± 0.031
TransformerNoNo0.649 ± 0.006
TransformerYesNo0.576 ± 0.026
TransformerYesYes0.534 ± 0.018

Concatenating the same entity/type information into flat sequence controllers does not help: both perform best without it, including when routing supervision is added. The graph encoder uses this information through shared entity nodes and reaches 0.733 ± 0.009.

Each sequence variant follows TGL's training recipe: two epochs with AdamW (learning rate 3×10⁻⁴, weight decay 10⁻⁴) and gradient clipping at 1.0. The trigger loss is binary cross-entropy with positive-class weight 0.15 and loss coefficient 0.3. Auxiliary routing uses binary cross-entropy with coefficient 1.0. The sequence encoder and prediction heads are randomly initialized. BGE remains frozen. We report epoch-2 results as mean ± sample SD over three training seeds. The entity-cap audit confirms that every extracted entity is retained. The TGL reference follows the five-seed protocol of App. E.3.

Q3. Current-entity selection and routing ablations. The routing ablation in Sec. 5.3 and App. D.1 supports using activity-grounded entities to guide the downstream agent. We additionally compare learned routing with simple rules over the same current-event candidates. All routing ablations retain TGL's original trigger decisions, system prompt, three demonstrations, model weights, decoding settings, output parser and reward model.

Ordering and selection controls use the same current-event candidates and retain TGL's entity extraction, candidate construction and observation history. Ordering controls keep the full candidate list under the top-20 cap, with the same entity count and the same numerical score at each list position. TGL places entities in descending learned-relevance order, fixed order follows the current event's entity list, and random order shuffles that list. Selection controls supply one entity with a fixed score of 1.0. First and Last select the first and last entries in the current event's entity list. Newest selects the candidate whose first observed occurrence in the session is latest, breaking ties by the order in that list. These controls only reorder or select among the current-event candidates. With at most one candidate, there is nothing to reorder or choose between, so we compare them on events with multiple candidates.

Current-entity routing (events with multiple candidates)Mean downstream F1 (%)
TGL learned order70.45 ± 0.69
Fixed order66.81 ± 1.23
Random order67.68 ± 1.02
First entity66.96 ± 1.03
Last entity62.50 ± 0.92
Newest entity68.27 ± 1.14

Values are rerun downstream F1 (%) averaged over the five open-weight backbones, reported as mean ± sample SD over three inference runs. Random order averages the three predefined permutation seeds within each inference run. Learned routing improves F1 by 3.6 points over fixed order, 2.8 points over random order and 2.2–8.0 points over the three selection rules.

We also remove routing entirely. The routing-removal controls give the agent raw observations with an empty routing list. One retains the original observation history. The other uses only the latest observation.

SettingChange to TGLMean downstream F1 (%)
TGLNone72.84 ± 0.37
Raw history and current observationRemove routed-entity input70.78 ± 0.34
Latest raw observation onlyRemove routed-entity input and history67.84 ± 0.54

This table covers all test events, with the same five backbones and three inference runs. Each run first averages the five backbone F1 values. The table reports the mean and sample SD of those three averages.

Reviewer_QXNhOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

The paper proposes TGL, a lightweight graph controller that uses activity histories to decide whether to invoke a downstream LLM and which entities should guide its suggestions. The experiments evaluate suggestion quality across multiple language models and measure the controller’s inference cost.

Critical strengths

The paper develops a lightweight controller and evaluates it across multiple language-model backbones, with runtime measurements on server and consumer hardware.

Critical weaknesses
  1. The practical benefit of filtering is not sufficiently established. Most events still invoke the downstream LLM, and the evaluation does not clearly show the trade-off between saved computation and missed assistance opportunities.
  2. The comparisons do not clearly establish the benefit of graph modeling. Differences in input history, feature representations, and supervision make it difficult to attribute the improvements to the proposed graph structure.
  3. The routing evaluation and supervision are insufficiently justified. Unrelated random entities provide a weak comparison, while assigning each entity its final session-level label may not reflect its relevance at individual decision points.
  4. It is unclear whether evaluation fully excludes future information. The described masking procedure needs clarification to establish that each decision uses only the available history.
Questions for authors
  1. How were the 65-dimensional handcrafted features defined, and why were BGE and HGB selected? Can TGL be compared with a lightweight sequence model using the same history, entity information, and supervision?
  2. Beyond threshold–F1 curves, can the authors compare TGL with the strongest trained baselines at matched filtering rates? Please report exact call reductions, total inference cost, precision/recall changes, and the fraction of necessary assistance opportunities incorrectly filtered out.
  3. Can learned routing be compared with simple selection from the same current-event entities, keeping the prompt and demonstrations fixed? Why is an entity’s final session-level label used for supervision when its relevance may change across events?
  4. Are future nodes and all their connections excluded from message passing during inference? Please verify the results using graphs constructed strictly from the history available at each decision point.
  5. Can the joint trigger and routing model be evaluated on unseen users, applications, or activity distributions? The FingerTip experiment addresses intent prediction and does not establish whether intervention timing generalizes.
7 comments

Thank you for the review. We address the four weaknesses (W1–W4) and five questions (Q1–Q5) in their original order.

W1. Practical benefit of filtering. In the trigger ablation, we compare the downstream agent with and without the TGL trigger, keeping all other TGL components unchanged. Without the trigger, the agent is called at every event. Using the TGL trigger improves mean F1 by 3.2 points across all 14 backbones, with per-backbone gains of 2.2–5.3 points (Sec. 5.3 and App. D.1). Mean ablation results are given in W3.

We also use the TGL trigger to decide whether two fine-tuned proactive agents are allowed to act: their existing suggestions are released only when TGL fires. Their suggestions, prompts and decoding remain unchanged (App. D.3).

Fine-tuned proactive agentOriginal F1With TGL triggerFewer calls
LLaMA-3.1-8B-Proactive66.2567.6625%
Qwen2-7B-Proactive66.4767.3821%

We additionally compare trigger F1 at matched fire rates and quantify call savings and retained must-fire opportunities (Q2).

W2. Graph modeling and comparison coverage. Table 1 compares nine trigger architectures across five families (Rule, Tabular, Textual, LLM and Graph) on decision quality and monitoring cost (Sec. 5.4). An architecture comparison gives each family the input form it is built to process: the event verb for the rule, 65 event features for LR and HGB, the latest five event texts for the BGE classifiers, the rolling session history and current observation for the Qwen triggers, and the event–entity session graph for TGL. A tabular model or text classifier given a graph would become a different model. For TGL, the input form is the activity graph itself, so this representation difference is the graph structure under evaluation. Everything else is held fixed: the classifier triggers learn from the same event labels in the released training set, and every trigger is evaluated on the same test events with the same routing list, downstream prompt and language-agent backbones (App. D.2). Each family uses conventional configurations, as does TGL (Sec. 4.1 and App. F.2–F.6).

Requiring identical inputs across architectures would remove the very difference an architecture comparison measures. To show what forced matching does, we use the flat counterpart that can take TGL's history, entity information and supervision: a lightweight sequence model over the observed event history, as requested in Q1. GRU and Transformer controllers are trained from scratch on the full observed history (input history), use frozen BGE event embeddings with and without TGL's entity/type information (feature representations), and are trained on TGL's trigger labels alone or together with its routing targets (supervision), following TGL's training recipe. Adding the entity/type information lowers mean must-fire AUC from 0.674 to 0.612 for the GRU and from 0.649 to 0.576 for the Transformer, and adding routing supervision does not restore it. The best sequence variants, both without entity/type information, reach 0.674 ± 0.036 (GRU) and 0.649 ± 0.006 (Transformer) over three training seeds, compared with 0.733 ± 0.009 for TGL under five-seed training following App. E.3. Giving the sequence controllers TGL's history, entity information and supervision therefore does not close the gap, so TGL's advantage does not come from these inputs (Q1 below).

TGL is a small GNN built from standard components and runs at 11.13 ms per event on the server, including text encoding (Secs. 5.4–5.5).

W3. Routing evaluation and supervision. The original routing ablation tests the contribution of the routed entity context to downstream assistance. The agent receives observation history together with a routed entity list. We replace that list with an equal-length list of randomly sampled entities, keeping the observation history, trigger and downstream prompt fixed. Using the learned list improves mean F1 by 8.6 points across the 14 backbones (Sec. 5.3 and App. D.1).

The table summarizes the original pipeline ablations from App. D.1, Table 4. Each value is downstream F1 (%) averaged across the 14 backbone means, with each backbone evaluated over three runs. No trigger retains learned routing and calls the agent at every event. No TGL uses language-agent self-gating with the style-only prompt and omits routing instructions and task demonstrations.

BackboneTGLNo triggerRandom routesNo TGL
Mean73.9670.7165.3761.26

We additionally compare learned routing with simple alternatives built from the same current-event entities. These controls use fixed or random entity ordering and First, Last or Newest selection. We also remove the routed list and give the agent raw observation history, with a separate control that uses only the latest observation. The trigger, downstream prompt and demonstrations remain fixed across these added routing controls. Q3 provides their definitions and results.

Routing supervision comes from entities extracted from recorded training tasks and matched to the event graph (App. B.1). Because a recurring entity is one persistent node, it carries one session-level routing target, taken from its last labeled occurrence. Decision-level relevance comes from inference: the model recomputes entity scores at each decision and restricts routing to entities connected to the current event.

To assess sensitivity to entities that receive conflicting labels within a session, we additionally audit these cases and train TGL with the affected entity targets excluded from the routing loss. Q3 reports the audit, trigger AUC and downstream F1.

W4. Available history at inference. TGL scores each event with the deployed procedure (App. F.7), which evaluates the session graph used in training with backward temporal edges removed and future-node input representations masked. Future events therefore contribute neither input features nor backward temporal messages. App. E.1 already tests the backward-edge channel: adding backward edges at inference changes trigger AUC by less than 0.005 and preserves routing on every test event. Future nodes remain attached to shared entity nodes. To test whether this structure could affect current outputs, we additionally evaluate the trained controller by rebuilding the graph at every decision. Each graph contains only events observed so far, entities already encountered and edges between those nodes. Future nodes and all their incident edges are absent throughout message passing.

These AUC values come from five-seed training, following App. E.3. Must-fire AUC is 0.733 ± 0.009 for TGL and 0.733 ± 0.008 with prefix-graph inference, a paired change of +0.0006 ± 0.0018. Across three training checkpoints, prefix-graph inference changes downstream F1 by +0.20 ± 0.40 points (paired). Appending an unseen suffix to every test session changes must-fire AUC under the deployed procedure by −0.0002 ± 0.0003. Under prefix-graph inference, suffixes leave every output unchanged by construction (Q4 below).

Prefix-graph inference, which uses only the observed history, therefore reproduces the results of the deployed procedure.

Q1. Trigger-architecture coverage and additional sequence controls. The submitted study compares TGL with eight baseline trigger architectures across four families: rule-based, tabular, text-encoder and LLM models (Table 1 and Appendix D.2). The baselines use conventional configurations within their respective families. The suite includes linear and nonlinear feature models (LR/HGB), frozen and fine-tuned variants of TGL's BGE text encoder, and Qwen models trained through LoRA classification or full-parameter proactive SFT. Together, these configurations cover different input representations, adaptation strategies and inference costs relevant to continuous monitoring.

The Qwen3-0.6B and Qwen3-8B classifiers are trained Transformer sequence models: they process the rolling event history and current observation to predict the trigger. Sequential modeling is therefore already represented in the submitted comparison, where TGL leads all three trigger-AUC measures.

The trigger AUC and latency columns are from Sec. 5.4, Table 1. Configurations are specified in App. D.2. Server and local timings use an A6000 and M3 Pro, respectively. TGL latency includes the frozen text encoder.

TriggerMust-fire AUCCan-skip AUCMust-skip AUCServer (ms)Local (ms)
TGL0.7380.6580.63911.1313.99
Rule0.5850.5810.4960.00030.0001
LR0.5800.5340.4990.130.03
HGB0.6360.5510.5007.295.73
BGE-frozen + MLP0.5740.5180.4606.5911.95
BGE-FT + MLP0.6210.5860.5536.8611.06
Qwen3-0.6B0.6680.5820.50440.4162.3
Qwen3-8B0.6440.6180.59778.61156.8
Proactive-Qwen3-0.6B (SFT)0.5050.5080.485392711966

These results support our conclusion that a small graph controller provides accurate, low-cost triggering. To examine how this advantage depends on history, entity inputs and supervision, we additionally evaluate GRU and Transformer controllers trained from scratch on frozen BGE-base features. Each event is represented by its text embedding and a learned embedding of the inter-event time gap. Entity/type variants additionally concatenate the mean entity-text embedding, summed type embeddings and log-scaled entity count. Each test decision uses the full observed event history.

Both controllers have three layers, hidden size 256, dropout 0.2, residual connections and layer normalization. The GRU is unidirectional. The Transformer uses four attention heads, a 1,024-dimensional feed-forward layer, learned positional embeddings and a causal attention mask. The projected input and outputs of all three layers are concatenated and passed to an MLP trigger head.

All variants use TGL's trigger training labels. Auxiliary-routing variants also use its entity-label targets: the routing head combines the mean hidden state of events containing an entity with that entity's text and type embeddings.

ControllerEntity/type inputsRouting supervisionMust-fire AUC
TGL (five training seeds)YesYes0.733 ± 0.009
GRUNoNo0.674 ± 0.036
GRUYesNo0.612 ± 0.025
GRUYesYes0.660 ± 0.031
TransformerNoNo0.649 ± 0.006
TransformerYesNo0.576 ± 0.026
TransformerYesYes0.534 ± 0.018

Concatenating the same entity/type information into flat sequence controllers does not help: both perform best without it, including when routing supervision is added. The graph encoder uses this information through shared entity nodes and reaches 0.733 ± 0.009.

Each sequence variant follows TGL's training recipe: two epochs with AdamW (learning rate 3×10⁻⁴, weight decay 10⁻⁴) and gradient clipping at 1.0. The trigger loss is binary cross-entropy with positive-class weight 0.15 and loss coefficient 0.3. Auxiliary routing uses binary cross-entropy with coefficient 1.0. The sequence encoder and prediction heads are randomly initialized. BGE remains frozen. We report epoch-2 results as mean ± sample SD over three training seeds. The entity-cap audit confirms that every extracted entity is retained. The TGL reference follows the five-seed protocol of App. E.3.

The handcrafted vector contains 65 event-level features encoding actions, applications, entity statistics and inter-event timing, shared by LR and HGB (App. D.2).

Comments on the paper

4 comments

Dear Area Chair and Reviewers,

Our rebuttal addresses the main concerns about event-time causality, the controller's contribution, comparison coverage, and graph construction. Below we summarize the added evidence and clarifications, with pointers to the detailed responses.

  1. Inference-graph comparison (kh9o Q1 and QXNh Q4). With five-seed training following App. E.3, must-fire AUC is 0.733 ± 0.009 for TGL and 0.733 ± 0.008 with prefix-graph inference. Across three training checkpoints, prefix-graph inference changes downstream F1 by +0.20 ± 0.40 (paired). Appending unseen suffixes changes must-fire AUC by −0.0002 ± 0.0003 under the deployed procedure. Prefix-graph inference, which uses only the observed history, therefore reproduces the results of the deployed procedure.

  2. The gains persist with matched demonstrations and prompts (kh9o Q4). Across five backbones and three inference runs, TGL reaches mean F1 72.84 versus 64.21 for No TGL with the same three demonstrations: +8.63 points, with gains on every backbone. A further control retains the complete TGL prompt and demonstrations, supplies an empty routing list, and always calls the agent. Under the same three-run protocol, TGL gains +6.09 F1 on all events and +10.2 on events without extracted entities. In the latter subset, inputs to the language agent are identical whenever called. TGL's trigger determines which suggestions are retained.

  3. Additional sequence controls extend the architecture comparison (kh9o Q2 and QXNh Q1). We add full-history GRU and Transformer controllers, including variants with entity/type inputs and TGL's routing-supervision targets. Under the reported two-epoch, three-training-seed protocol, their best mean must-fire AUCs are 0.674 and 0.649, respectively, compared with 0.733 for TGL (five seeds, App. E.3). Entity/type inputs do not help either sequence controller, whereas the graph encoder uses them. The original study already includes eight alternative triggers across rule, tabular, text-encoder and LLM families.

  4. Routing controls separate context provision from entity ordering (kh9o Q3 and QXNh Q3). We compare learned, fixed and random ordering of the same current-event candidates, First/Last/Newest selection, and removal of routed entities. Across five backbones and three inference runs, learned-order TGL reaches 72.84 F1 versus 70.78 with raw history and no routed entities. On events with multiple candidates, where ordering and selection matter, learned routing improves F1 by 3.6 points over fixed order, 2.8 over random order and 2.2–8.0 over First/Last/Newest selection. We also audit conflicting entity labels and train TGL with them excluded from the routing loss (three training seeds). Relative to paired controllers trained on the original targets, must-fire AUC changes by −0.010 ± 0.019 and downstream F1 by −0.16 ± 0.30.

  5. Filtering has measurable practical benefits (QXNh W1/Q2). At the deployed threshold on the benchmark test split, TGL reduces calls by 18.9% while retaining 98.2% of must-fire events. We report matched-fire-rate comparisons and total-time estimates including the controller. The original submission already shows +3.2 mean F1 from triggering across 14 backbones and, for two existing fine-tuned agents, 25%/21% fewer calls alongside +1.4/+0.9 F1.

  6. Graph construction and reuse are quantified (AAps Q1/Q2 and QXNh Q5). Desktop and mobile pipelines map their platform-specific records into a common activity-entity graph design, with heads matched to each benchmark's task. The desktop evaluation covers held-out sessions and unseen file/query/URL identities. FingerTip tests mobile intent prediction. Shared entities reduce entity/category nodes by 65.9%, and 38.0% of them link events more than three steps apart.

Thank you for your time and attention.

The Authors

AuthorsOpenReview ↗

A narrated video of our responses

Dear AC and reviewers,

Thank you again for your reviews. Our responses cover many new experiments, and reading all of them as text takes time within a short discussion period. We therefore prepared a narrated video of about eight minutes that briefly recaps the paper and then walks through our responses topic by topic (supplementary material, tgl_author_response_video.mp4).

The video is grouped by topic, so you can go directly to the part you are most interested in:

  • 0:00, a short recap of the paper
  • 1:21, Topic 1, graph construction across platforms and entity reuse
  • 2:59, Topic 2, rebuilding the graph from the observed history gives the same results
  • 4:05, Topic 3, the gains hold with the same demonstrations and the complete prompt
  • 5:06, Topic 4, sequence controllers given the same information
  • 6:06, Topic 5, routing over the same candidate entities
  • 6:48, Topic 6, what filtering saves

We hope you will take a look.

Best regards,

The authors

AuthorsOpenReview ↗

Discussion closes soon: we would appreciate your feedback

Dear Area Chair and Reviewers,

We posted our responses to all three reviews on November 9, more than a week ago, and have not yet received a reply from any reviewer. The author–reviewer discussion closes on November 18. We would be grateful if each reviewer could let us know before then whether our responses address their concerns, so that we can still answer any remaining question.

The responses can be read quickly in three ways:

  • The general response summarizes the new evidence in six items, each tagged with the review questions it answers.
  • The narrated video (about eight minutes, supplementary material, tgl_author_response_video.mp4) walks through the same evidence topic by topic.
  • The reply under each review responds to each weakness and question in that review.

If our responses resolve your concerns, we would be grateful if you could update your assessment accordingly.

Thank you for your time.

The Authors

AuthorsOpenReview ↗

Follow-up: the discussion closes soon

Dear Area Chair and Reviewers,

With the author–reviewer discussion closing soon, on November 18, we would like to send a brief reminder. We understand that this is a busy period for everyone. We posted our responses to all three reviews on November 9, and we would be grateful to hear whether they address your concerns, so that we can still answer any remaining question before the discussion closes.

For a quick read, the general response summarizes the new evidence in six items, and the narrated video (about eight minutes, supplementary material, tgl_author_response_video.mp4) walks through it topic by topic.

If our responses resolve your concerns, we would be grateful if you could update your assessment accordingly.

Thank you very much for your time.

The Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.