acceptodds
Under review as a conference paper at ICLR 2027

Agents Need Event Time: Freshness-Aware Reasoning over Delayed Tool Results

Abstract

Tool-using agents often treat the latest message as the latest state. Under asynchronous execution, this ordering is wrong: a result delivered last can describe a snapshot taken before the world changed. We introduce event-time reasoning, a runtime protocol that attaches snapshot versions and scope watermarks to tool results so agents can validate evidence against decision-time state. EventTimeBench makes this failure measurable with evolving SQLite, workflow-event, and Python-AST backends, while Watermark combines exact version invalidation with calibration-free query influence and optional service cost. Across 97,200 controlled tasks and 747,600 paired outcomes, a preregistered five-seed confirmation raises exact accuracy from 87.0% with version-only ranking to 90.1% with Watermark-I, a +3.09-point gain that also exceeds a direct answer-flip predictor; the gain remains +4.15 points under two unseen transition regimes. Natural code exposes a complementary requirement: when sources jointly determine an answer, selective refresh can create an incoherent state, so the cut must remain atomic. Frozen query-family allocation reaches 96.45% across 265 commits from ten unseen repositories; a frozen gate matches that accuracy at 96.50% while refreshing 48.7% fewer sources than full refresh. Executable OpenCode sessions across two model families demonstrate integration. Event time makes freshness an explicit, efficient reasoning primitive for agents operating over evolving state.

Primary area:
foundation or frontier models, including LLMs
Keywords:
language agents, tool use, asynchronous agents, event time, freshness, delayed observations, agent runtimes

Reviews

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

This paper studies stale tool results in asynchronous LLM agents. It combines versioned results with decision-time scope watermarks to detect outdated evidence. WATERMARK then prioritizes refreshes within a budget. Controlled experiments show accuracy gains, while natural-code experiments highlight the need for atomic refresh when mixing snapshots can produce inconsistent answers.

Critical strengths
  1. Clear distinction between snapshot freshness and result arrival order. Schedule equivalence provides a useful framework for testing order sensitivity.
  2. A simple controller with measurable gains. WATERMARK-I improves accuracy by 3.09 percentage points over version-only ranking, without LLM fine-tuning.
  3. Shows how partial refresh can mix incompatible snapshots. Atomic refresh provides a practical extension, tested on natural code changes.
Critical weaknesses
  1. Influence ranking is mainly tested on threshold, band, and argmax queries. It remains unclear how the influence rule would be defined for less structured agent tasks. And the authors could explain how to choose between partial and atomic refresh.
  2. The interactive evaluation lacks a canonical-order baseline (e.g. by scope ID, while preserving the versions, watermarks, and refresh budget) with the same evidence and refresh budget. This would help isolate benefits beyond reducing order sensitivity.
  3. The interactive evidence remains limited. As reported in Appendix D, no same-schedule repeats were completed, so model variability is not cleanly separated from delivery-order effects. The DeepSeek accuracy-gain interval also includes zero. Fixed-schedule repetitions would make the attribution of answer changes to delivery order more convincing.
Questions for authors
  1. How can real-world tools provide scope versions and current watermarks at reasonable cost? How would coarse versions or content hashes affect performance?
  2. Section 3.3 distinguishes invariance of the selected refresh set from empirical end-to-end consistency. What additional runtime or model assumptions would be sufficient to make the final answer invariant as well? The main controlled result uses WATERMARK-I, whereas the interactive experiments use WATERMARK-M. Does the calibration-free policy retain its benefits in the interactive setting?
  3. What happens if watermarks lag, or the environment changes between refresh and commit? Would another version check be needed?
2 comments
AuthorsOpenReview ↗

Response to Reviewer 3XC9 (1/2): canonical-order baseline, fixed-schedule repetitions, interactive Watermark-I

Thank you for the constructive review. You proposed two sharp tests, and we ran both.

In short, the answers are clear. Sorting the results makes no reliable difference on any model. The gain comes from choosing what to refresh. In live agents, the fit-free Watermark-I keeps that gain on two of the three models.

This comment covers W2, W3 and the second part of Q2. The next one covers Q1, the first part of Q2, Q3 and W1. All numbers are in the revised PDF (Section 5.3, Appendices G-H).

Setup of the new interactive experiments (Table R1)

Four arms share the same cases, values, versions, watermarks and call limits:

  • Plain: the agent sees versions and watermarks and picks its own refreshes.
  • Canonical: Plain, with scopes sorted.
  • Watermark-I: the calibration-free ranking from the submission.
  • Watermark-M: calibrated scores, as in the original sessions.

We ran three new models, with repeated runs of every schedule.

W2. Canonical-order baseline (Table R2)

Sorting alone does not produce the gain. On all three models, Canonical is indistinguishable from Plain. Watermark-I does better than Canonical on two of the three models.

W3. Fixed-schedule repetitions (Table R3)

We repeated each fixed schedule to measure run-to-run noise, then compared it with disagreement across schedules. For one model, delivery order changes answers well beyond that noise, and a whole-session randomization test confirms it. The other two show no excess disagreement. These repeats are the variability control for the single-run DeepSeek differences in the submission.

Q2 (second part). Does the calibration-free policy keep its benefit in live agents?

Yes, on two of the three models, where it matches or beats the calibrated Watermark-M. In every session the controller enforces its frozen cut, which carries the cut invariance of Section 3.3 into agent execution.

AuthorsOpenReview ↗

Response to Reviewer 3XC9 (2/2): versions, final-answer invariance, lag and commit, partial vs. atomic refresh

Q1. How can real tools supply versions cheaply? Coarse versions and hashes? (Appendix J, Tables R6-R7)

Adapters can keep a revision column next to writes, use repository revision IDs, or use a strong HTTP ETag where offered. Lookup and hashing count as explicit operations, so their cost stays visible.

Missing versions fall back safely: an unknown source becomes a refresh candidate. Accuracy then declines gradually as metadata gets sparser, coarser or later, and it stays well above no-refresh even with no versions at all or a single revision domain. Hashes change nothing, because validation only needs equality.

Q2 (first part). What makes the final answer invariant, not just the refresh set? (Section 3.3, Appendix H)

The refresh cut is already identical for schedule-equivalent inputs, because it never looks at arrival time. The final answer is identical too when three conditions hold:

  • (1) the same refreshed read state;
  • (2) a decision view without arrival fields, so the model cannot see the order or timing of results;
  • (3) a deterministic readout, or a stochastic one with shared randomness.

With independent sampling, the output distributions are identical. Table R3 tests this on the model that is sensitive to delivery order. With arrival fields visible, answers still vary with the schedule, so a stable cut alone is not enough. With arrival fields masked, the schedule effect is no longer detectable.

Q3. What if watermarks lag, or the world changes between refresh and commit? (Tables R6 and R8)

Lag is a freshness trade-off: accuracy goes down as lag grows, but stays above no-refresh.

For a change between refresh and commit: yes, strict acceptance needs a version check at commit, and it must be atomic. We make validation and acceptance one atomic operation on the store. In our SQLite test it rejects every schedule with an intervening change and never accepts a stale state. A separate check followed by a write does accept stale states. Tools that only support read-based validation get best-effort freshness through budgeted revalidation.

W1. Partial versus atomic refresh, and less structured queries (Section 3.3, Appendix I)

The rule: independent consistency domains can share the budget partially. Sources tied by a snapshot invariant, meaning they jointly determine an answer and must come from the same snapshot, are refreshed together as one domain. The task adapter declares these domains; for natural code it is the commit-level source set. If a coherent refresh does not fit the budget, the controller keeps the complete older cut.

For less structured queries, the calibration-free Watermark-FD perturbs observed values and checks how often the answer changes. On bilinear, Boolean-DNF and relational-XOR queries it beats random and version-age selection at the same refresh cost (Tables R4-R5).

Thank you again for suggesting these experiments; they made the paper stronger. We think the core idea is simple and useful: before acting, an agent should check which state a result describes, not just when it arrived. We hope this work encourages others to build on it. If our answers address your remaining concerns, we would be grateful if you would consider raising your score. We are happy to answer any follow-up questions.

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

This paper introduces WATERMARK, targeting a problem of how asynchronous agent can mistake an old tool result for the latest state. It checks the version of each result and refreshes stale information that is most likely to affect the answer. Linked sources are refreshed together to avoid mixing wrong versions. And the experiments are conducted on synthetic tasks, repo commits, and small interactive LLM.

Critical strengths
  1. I think the problem studied is very clear and has practical uses. In practice. asynchronous agents indeed has the problem of matching the correct result on right time.

  2. I thin the proposed atomic refresh policy is a sensible response, and the partial refresh can combine different versions.

  3. The paper evaluates the method on several backends and includes test where only the order of tool replies changes.

Critical weaknesses
  1. The first suggestion is to increase the font in figure 1. The small words are hard to read and follow.

  2. I find this paper introduces lots of baselines in Section 4.3, but didn't show the comparison results of some methods in table 1. Also the improvement is limited, for example, compared with direct-flip, the proposed method only has 1% improvement across metics. Even in table 8, the deepseek accuracy decreases on SQLite and Workflow with watermark. So the experiments doesn't support a strong performance of the proposed method.

  3. The proposed method assumes snapshot versions and current status are available, but from my understanding, many third-party APIs and tools may not provide them. So do you have any backup plan to handle such cases? Otherwise, it will limit the use of the method.

Questions for authors
  1. What's the performance of the missed baselines, and why not put them into the main table to demostrate the comparison?

  2. When the task has unstructured results, how this method can be extended to such tasks?

3 comments
AuthorsOpenReview ↗

Response to Reviewer on3G (1/2): complete baseline results, size of the gain

Thank you for the thoughtful review, and for seeing the value of the problem setting and the atomic refresh policy. That is the heart of the paper, and we are glad it came through.

In short, Figure 1 is now updated. Meanwhile every baseline is now in the paper, and the result is clear. Watermark-I beats all of them on the same tasks, including the strongest one, which needs fit data. Watermark-I needs none. It also holds up when version metadata is missing. All results on are included in the paper honestly. Before they are hosted in the anonymous repo to control the length and readability of the paper

This comment covers the baselines and the size of the gain (W2, Q1). The next one covers the DeepSeek question, missing metadata (W3), unstructured results (Q2) and Figure 1 (W1). All numbers are in the revised PDF.

Q1 / W2. The baselines that were not in Table 1 (Appendix L, Tables R10-R14)

Table 1 shows the five policies that share one task draw. The other baselines in Section 4.3 were run on other draws, so they cannot be compared row by row with Table 1. Appendix L now lists every baseline, with one panel per study, so each comparison stays on a common draw. Section 5.1 also quotes the clock baselines.

The picture is the same in every panel. Clock-based policies and hazard-only trail the version-based ones, and version-aware influence ranking is best at matched refresh cost. Only full refresh, which costs far more, and an oracle that sees the test answer do better.

W2. "The improvement is limited"

The closest competitor is Direct-Flip, which is estimated from fit episodes. Watermark-I uses no fit data and still beats it. Against what a runtime would use without influence ranking, such as version-only, random invalidated or hazard-only refresh, the gains are larger. All of these comparisons are paired on the same tasks, and every interval is above zero (Appendix L).

The gain also holds under two unseen transition regimes, on the new nonlinear queries (Appendix I), and in live agents (next comment).

AuthorsOpenReview ↗

Response to Reviewer on3G (2/2): DeepSeek accuracy, missing metadata, unstructured results, Figure 1

W2 (continued). DeepSeek accuracy on SQLite and Workflow (Table 8)

Consistency and accuracy measure different things. Consistency is whether the answer stays the same across delivery schedules. Accuracy is whether it is correct. The fixed Watermark-M cut makes DeepSeek's answers identical across schedules and raises overall accuracy. It gains a lot on repository tasks and gives up a few points on SQLite and workflow.

An audit of the saved traces shows that every DeepSeek answer matches what the retrieved evidence implies. So the per-backend differences come from which sources the cut refreshed, not from the model.

We also tested selection on three more models with four matched arms (Table R1). Watermark-I gets more answers right than the plain agent on two of the three models.

W3. What if a tool provides no versions? (Appendix J, Tables R6-R8)

The fallback is simple: a source with an unknown version is not assumed to be fresh. It becomes a refresh candidate. Accuracy then declines gradually as versions go missing, and even with no versions at all the method stays well above no-refresh. Coarse metadata works too: one revision domain for the whole environment still clearly beats reuse.

  • Content hashes: hashing revision IDs leaves every cut unchanged, because validation only needs equality.
  • Where versions come from: revision columns in controlled tools, revision IDs in repositories, and strong ETags over HTTP where offered. Their cost is counted explicitly.
  • Strict consistency: an atomic revision check at commit rejects every schedule with an intervening change and never accepts a stale state. A separate check followed by a write does accept stale states.

Q2. Unstructured tool results

The envelope carries the tool's text unchanged. Freshness checks use only source identity and versions, so they do not depend on the payload. The task-specific part is budget allocation: an adapter supplies the utility, for example a parser plus the public decision function, and declares which sources must be refreshed together. Watermark-FD is one working adapter of this kind (Appendix I).

W1. Figure 1

Figure 1 is redrawn with larger labels as a four-step flow: Observe -> Validate -> Refresh -> Evidence. The refresh-cut invariant and the readout conditions sit right under the flow.

Thank you again for your time and the helpful comments. We think the core idea is simple and useful: before acting, an agent should check which state a result describes, not just when it arrived. We hope this work encourages others to build on it. If the new baselines and results address your concerns, we would be grateful if you would consider raising your score. We are happy to answer any follow-up questions.

AuthorsOpenReview ↗

Follow-up on our response to Reviewer on3G

Thank you again for your helpful feedback. A quick follow-up on our response above: we would particularly welcome your thoughts on the baseline comparisons and the extension to unstructured tool outputs.

Could you let us know whether these address your main questions, or if any further clarification would be useful? We would be happy to follow up. Thank you for your time!

Reviewer_hZdSOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

A tool response arriving last may describe an older state than responses already received. The paper brings explicit snapshot versions and decision-time watermarks into agent execution, making freshness a property that can be checked.

Its contribution combines an executable benchmark, refresh-selection policies, and an evaluation that changes delivery order while holding the underlying world fixed. Specifically, the proposed bench EVENTTIMEBENCH uses evolving SQLite, workflow, and Python-AST backends. WATERMARK identifies stale observations through version comparisons and ranks refreshes using query influence, optionally incorporating change probability and service cost. For jointly constrained code sources, the paper introduces atomic policies that either retain the complete old snapshot or refresh the complete relevant set.

The overall conclusion is , WATERMARK-I lift accuracy from 87.0% to 90.1% over version-only ranking and keeps +4.15 under unseen regimes. Partial refresh harms natural code, but a frozen atomic gate reaches 96.5% on ten unseen repositories while refreshing 48.7% fewer sources than full refresh. In sessions, the controller removes all eight DeepSeek delivery-order disagreements and lifts GLM from 41.7% to 75.0%.

Critical strengths
  1. A clean, reusable formalization: the envelope, the watermark check, and counterfactual schedule equivalence as a causal test. Adoptable without model changes.
  2. Rigor and honesty: preregistration, frozen external replication, and explicit reporting that partial refresh failed its transfer gate on natural code.
Critical weaknesses
  1. The headline scale exceeds the breadth of the agent evidence. The three controlled backends share an evolving-state generator and structured query families. Natural-code queries are also constructed from AST features. These are useful experiments, but they leave uncertain how well influence scoring and required metadata transfer to open-ended agent decisions. The natural-code mechanism reduces to "refresh everything when risky". The gate (97.14%) ties a three-family rule (97.01%) and a cost-matched random atomic control (96.81%), and full refresh is 100% by construction. The paper's main technical idea does not transfer to this regime.

  2. The live-agent causal claim lacks a same-scheduled variability control. The paper reports no completed same-schedule repetitions. Consequently, some answer differences across schedules could reflect ordinary model variability. DeepSeek’s aggregate accuracy-improvement interval also includes zero, while the positive GLM result is based on only 24 cases.

Questions for authors
  1. What does the plain agent do when shown versions and watermarks, and does a stronger model already achieve schedule consistency?
  2. Why is DeepSeek consistency 100% while accuracy drops on two backends?
  3. How does the influence score generalize beyond linear threshold, band, and argmax queries? What happens with partial or approximate watermarks?
  4. On the 265-commit external replication, how does the frozen gate compare with a query/source-stratified random atomic policy at matched refresh cost? The earlier 154-commit comparison does not establish an accuracy advantage over that control.
3 comments
AuthorsOpenReview ↗

Response to Reviewer hZdS (1/2): same-schedule control, stronger model, DeepSeek consistency vs. accuracy

Thank you for the careful review. You asked the two hardest questions about this paper. Answering them made it stronger.

In short, the new controls confirm the effect and make it sharper. Delivery order really does change one model's answers, beyond run-to-run noise. The other two models are not affected, and we report all three. On natural code, the gain comes from refreshing linked sources together, at about half the cost of refreshing everything. The paper now says this plainly.

This comment covers the agent evidence (W2, Q1, Q2). The next one covers natural code and generalization (W1, Q3, Q4). All numbers are in the revised PDF (Section 5.3, Appendices G-M).

W2. Same-schedule variability control (Table R3)

We ran every fixed schedule several times on three more models. This separates the effect of delivery order from ordinary run-to-run noise. For one model, answers differ across schedules much more than across repeats of the same schedule, and a whole-session randomization test confirms it. The other two show no excess disagreement. These repeats also serve as the variability control for the single-run DeepSeek differences in the submission.

Q1. What does the plain agent do, and is a stronger model already consistent? (Tables R1-R2)

The plain agent already sees versions and watermarks and picks its own refreshes. We compared it with three arms on identical inputs: a canonical-order agent, Watermark-I and Watermark-M.

  • Stronger model: yes, GPT-6.1 Sol is already schedule-consistent on its own. The controller still helps it pick better evidence, so Watermark-I gets more answers right at the same refresh cost.
  • Across the new models: Watermark-I gets more answers right than the plain agent on two of the three.

Q2. Why is DeepSeek fully consistent while accuracy drops on two backends?

Consistency asks whether the answer is the same under every schedule. Accuracy asks whether it is correct. The fixed cut gives DeepSeek the same evidence every time, so its answer is stable. Whether that answer is right depends on which sources the cut refreshed: it gains a lot on repository tasks and loses a little on SQLite and workflow tasks (Table 8).

We checked this directly. In the saved traces, every DeepSeek answer equals what the retrieved evidence implies. So the model reads the evidence faithfully, and the accuracy change comes from which evidence was selected. The new runs show the same split: better evidence does not always become a better final answer, because that also depends on how the model reads it.

AuthorsOpenReview ↗

Response to Reviewer hZdS (2/2): natural code, nonlinear queries, approximate metadata

W1 and Q4. Natural code: the gate versus cost-matched random atomic refresh (Table R9)

We ran the control you asked for on the full external replication, across ten repositories. The random atomic policies match the gate's exact refresh cost within each stratum.

At matched cost, the gate does about as well as random atomic refresh. So your reading is right: on natural code the gain comes from coherent cuts, not from fine-grained ranking. Refreshing linked sources together keeps answers accurate at about half the cost of full refresh. Section 5.4 now says this directly, and Section 3.3 gives the rule for when to refresh partially and when to refresh a whole group.

On breadth: the agent study now covers three more models, with repeated schedules and four matched arms (previous comment).

Q3 (first part). Does influence work beyond threshold, band and argmax queries? (Tables R4-R5)

Yes. We added Watermark-FD, a calibration-free adapter. It perturbs each observed value and checks how often the answer of the public query changes. It needs nothing beyond the public query and the observed values. At the same refresh cost, FD beats random and version-age selection on bilinear, Boolean-DNF and relational-XOR queries, and the gain holds in each family.

For text tools, the envelope carries the payload unchanged, and a task adapter supplies the utility and the consistency domain. FD is one working adapter of this kind.

Q3 (second part). Partial or approximate watermarks (Tables R6-R7)

If a version is missing, the source is simply treated as a refresh candidate. Accuracy then declines gradually as metadata gets sparser, coarser or later. Even with no versions at all, or with a single revision domain for the whole environment, the method stays well above no-refresh. Hashed IDs change nothing, since validation only checks equality.

Where this is in the revised PDF

  • Section 5.3 and Appendices G-H: repeated sessions, four arms, schedule sensitivity and readout.
  • Section 5.4 and Appendix K: matched random atomic control on the natural-code replication.
  • Section 5.2 and Appendices I-J: Watermark-FD and the metadata experiments.

Thank you again for your time and the thoughtful questions. We think the core idea is simple and useful: before acting, an agent should check which state a result describes, not just when it arrived. We hope this work encourages others to build on it. If our answers address your concerns, we would be grateful if you would consider raising your score. We are happy to answer any follow-up questions.

Overall, the revised version of paper and author responses offer stronger evidence for a narrower contribution: a reproducible framework for studying stale evidence, separating schedule effects from model variability, and evaluating refresh decisions.

However, my remaining concerns are primarily about the declared scope. Provided from revision paper , the new agent evidence is mixed: WATERMARK-I improves Gemini, but not improving Luna's final accuracy/

Overall, I find the revised controlled evaluation and framework is useful to support weak acceptance.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.