💬 NLP

Your LLM Agents are Temporally Blind: The Misalignment Between Tool Use Decisions and Human Time Perception

This paper identifies "temporal blindness" as a critical limitation in LLM agents, where their failure to account for real-world time elapsed leads to misaligned tool-use decisions, and introduces the TicToc dataset and findings showing that while prompt-based fixes are limited, post-training alignment can effectively improve agents' temporal awareness to match human perception.

Original authors: Yize Cheng, Arshia Soltani Moakhar, Chenrui Fan, Parsa Hosseini, Kazem Faghih, Zahra Sodagar, Wenxiao Wang, Soheil Feizi

Published 2026-04-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yize Cheng, Arshia Soltani Moakhar, Chenrui Fan, Parsa Hosseini, Kazem Faghih, Zahra Sodagar, Wenxiao Wang, Soheil Feizi

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

The Core Problem: The "Amnesiac" Assistant

Imagine you hire a very smart, knowledgeable assistant to help you manage your day. This assistant has a superpower: it can instantly look up any information on the internet (like weather, stock prices, or bus schedules).

However, this assistant has a strange, critical flaw: it has no sense of time passing.

To the assistant, the conversation is a static list of words. If you ask, "What is the weather?" at 9:00 AM and get an answer, and then ask the same question again at 5:00 PM, the assistant treats the 9:00 AM answer as if it were just spoken a second ago. It doesn't "feel" that 8 hours have passed.

The researchers call this "Temporal Blindness."

The Two Ways the Assistant Fails

Because the assistant doesn't understand time, it makes two very different kinds of mistakes, which the paper calls Over-reliance and Under-reliance.

1. Over-reliance: The "Stale Sandwich"

The Scenario: You ask your assistant, "Is the surf good at the beach?" at 8:00 AM. The assistant checks the waves and says, "Yes, it's perfect!"
The Time Jump: You go to work. At 4:00 PM, you ask again, "Is the surf still good?"
The Mistake: Because 8 hours have passed, the tide has changed, and the waves are now terrible. But the assistant, being "blind" to time, thinks, "I just checked this! It's still perfect!" and tells you to go surfing.
The Analogy: It's like eating a sandwich you made 8 hours ago and assuming it's still fresh because you remember making it. You get sick because you ignored the time that passed.

2. Under-reliance: The "Paranoid Shopper"

The Scenario: You ask, "What is the radius of the Earth?" The assistant checks a database and says, "6,371 km."
The Time Jump: Five minutes later, you ask, "What is the radius of the Earth?"
The Mistake: The radius of the Earth doesn't change in five minutes. However, the assistant is so scared of being wrong that it checks the database again, wasting time and computing power.
The Analogy: It's like checking your bank balance every 30 seconds. You know the number won't change that fast, but you do it anyway because you don't trust your memory of the last check.

The Experiment: Building "TicToc"

To prove this was a real problem, the researchers built a new dataset called TicToc (like a clock ticking).

The Setup: They created 76 different "worlds" or scenarios. Some change slowly (like a library book list), and some change instantly (like a stock market ticker).
The Test: They simulated conversations where time passed between questions.
The Human Vote: Real humans were asked: "In this situation, should the AI check the internet again, or just use what it already knows?"
The Result: They found that even the smartest AI models (like GPT-4o or Qwen) failed to match human judgment. Even when they gave the AI the exact timestamps (e.g., "It is now 4:00 PM"), the AI still couldn't figure out if the old info was still good. The best AI only got about 65% right, which is barely better than a confused guess.

Why Doesn't "Thinking Harder" Help?

The researchers tried to fix this by:

Prompting: Telling the AI, "Hey, remember time passes!" (Like a sticky note on a monitor).
Reasoning: Forcing the AI to write out its thoughts before answering.

The Result: Neither worked well. The AI would write a long, logical paragraph saying, "Well, 8 hours have passed, so the weather might have changed..." and then, in the very next sentence, ignore that logic and give the old answer anyway. It's like a student who writes the correct formula on the test paper but then picks the wrong answer on the multiple-choice bubble sheet.

The Solution: Training, Not Just Talking

The paper found that simply talking to the AI (prompting) isn't enough. You have to retrain it.

They took a subset of their TicToc data and used a technique called DPO (Direct Preference Optimization). Think of this as giving the AI a "crash course" specifically on time management.

Before Training: The AI was like a tourist who doesn't know the local time zone.
After Training: The AI learned to "feel" the passage of time. It learned that for a stock price, 1 minute is a long time, but for a library book, 1 minute is nothing.

After this specific training, the AI's performance jumped significantly, finally aligning with how humans actually think about time.

The Big Takeaway

Current AI agents are like photographers who only take pictures but never develop them. They capture a moment (the data) but don't realize that the world keeps moving while they stand still.

To make AI truly useful in the real world, we can't just make them smarter at math or language; we have to teach them to respect the clock. We need to train them to know when to trust their memory and when to go check the news again.

1. Problem Statement: Temporal Blindness

The paper identifies a critical, overlooked limitation in Large Language Model (LLM) agents: Temporal Blindness. While LLM agents are increasingly used to execute tasks in dynamic environments using external tools (e.g., search engines, databases), they default to a stationary context assumption. They fail to account for the real-world time elapsed between messages.

This blindness leads to two primary failure modes in multi-turn interactions:

Over-reliance: The agent assumes previously retrieved information is still valid despite significant time passing, leading to decisions based on stale data (e.g., ignoring that weather conditions have changed).
Under-reliance: The agent fails to recognize that information is stable and redundantly calls tools for data that hasn't changed (e.g., re-checking the radius of the Earth), causing unnecessary latency and resource waste.

The core issue is a misalignment between the agent's decision-making process and human temporal perception, where humans intuitively gauge whether a time gap warrants re-verifying information based on the context's volatility.

2. Methodology: The TicToc Dataset and Evaluation

To systematically study this phenomenon, the authors constructed TicToc (Time-aware conversational Tool-calling), a comprehensive dataset and evaluation framework.

A. Dataset Construction (TicToc)

Scale: 1,864 high-quality multi-turn user-agent trajectories.
Scenarios: 76 distinct scenarios categorized by Time Sensitivity:
- Low Sensitivity (29): Static data (e.g., regulations, archival records).
- Medium Sensitivity (25): Periodic changes (e.g., weather forecasts, hotel availability).
- High Sensitivity (22): Rapidly changing data (e.g., stock markets, live GPS).
Trajectory Variants: The dataset includes both Read-Only (retrieval) and Read+Write (action) settings with specific variants like "Repeated Ask," "Comparison," "User Confirmation," and "State Change."
Temporal Injection: Every message is assigned ISO 8601 timestamps. The dataset creates three versions of each trajectory with varying time gaps ( $\Delta t$ ) before the final user query: Small, Medium, and Large, scaled relative to the scenario's sensitivity.
Human Preferences: Annotators evaluated 5,592 samples (1,864 trajectories $\times$ 3 time gaps) to determine the preferred action: Direct Answer (rely on context) vs. Tool Call (re-fetch data). Ambiguous cases were filtered out, resulting in 3,016 high-confidence samples.

B. Evaluation Setup

Models: Evaluated 18 contemporary LLMs (both open-weight like Qwen, Llama, Ministral, and proprietary like GPT-4o, o3, o4-mini).
Conditions:
1. No Timestamps: Agents see only text.
2. With Timestamps: Agents see explicit ISO 8601 timestamps injected into the prompt.
3. Explicit $\Delta t$ : (Appendix) Agents are given the explicit time difference rather than absolute timestamps.
Metrics:
- Normalized Alignment Rate (NAR): Measures how well the model's tool-call decision matches human preference. 50% is random guessing.
- Attempt Rate: The proportion of times the model attempts a tool call.

3. Key Results

A. Poor Alignment Performance

Without Timestamps: Models perform near random guessing (max NAR ~55%).
With Timestamps: Even when provided with explicit time information, no model achieved an NAR above 65%. The best-performing models (e.g., GPT-4.1, o3) showed only marginal improvements.
Failure Modes:
- Models often increase their tool-call attempt rates across both "prefer-Tool" and "prefer-noTool" samples when given timestamps, indicating they fail to distinguish when a tool is actually needed.
- Conversation Length Heuristic: Models tend to rely on the number of conversation turns as a proxy for "staleness" rather than the actual elapsed time. As conversation length increases, tool-call frequency rises, and NAR drops.

B. Reasoning Does Not Help

CoT Analysis: Using Chain-of-Thought (CoT) reasoning (e.g., in Qwen3 reasoning models) yielded no significant improvement in alignment.
Missing Temporal Cues: In reasoning traces, explicit timestamps were mentioned in <4% of cases, and the word "timestamp" appeared in <1.5%. Models fail to spontaneously integrate temporal data into their logic.
Think-Answer Mismatch: A significant portion of errors (False Positives) occurred because the model's internal reasoning concluded "Direct Answer," but the final output triggered a "Tool Call" (Type 2 mismatch). This was particularly prevalent in smaller models (e.g., 61% of FP errors in Qwen3-1.7B).

C. Alignment Strategies

Prompting: Adding general reminders ("Be aware of time") had no effect. Providing few-shot examples with rules for time sensitivity improved alignment slightly for advanced reasoning models (o3, o4-mini) but failed for most others.
Post-Training (DPO): The most effective solution was Direct Preference Optimization (DPO). Fine-tuning models on the TicToc training split resulted in massive alignment gains, pushing NAR significantly higher across all tested models. This suggests that temporal alignment is a capability that requires targeted training, not just prompting.

4. Key Contributions

Identification of Temporal Blindness: Defined and characterized the specific failure mode where LLM agents cannot align tool-use decisions with the passage of real-world time.
TicToc Dataset: Introduced a diverse, high-quality benchmark (1,800+ trajectories, 76 scenarios) specifically designed to evaluate multi-turn tool-use alignment with human time perception.
Comprehensive Evaluation: Demonstrated that current SOTA models, even with explicit time signals and reasoning capabilities, fail to align with human expectations.
Solution Pathway: Proved that while prompting is insufficient, targeted post-training (DPO) is a viable and necessary path to mitigating temporal blindness.

5. Significance and Future Work

Real-World Impact: Temporal blindness leads to erroneous outputs in dynamic fields (finance, healthcare, logistics) and inefficiencies in static ones. Addressing this is crucial for deploying reliable autonomous agents.
New Alignment Dimension: The paper expands the scope of LLM alignment beyond safety and instruction following to include temporal perception, a fundamental aspect of interacting with the physical world.
Limitations: The current dataset is text-only; future work should explore multimodal tools (e.g., vision-based monitoring). Additionally, DPO experiments were limited to models $\le$ 8B parameters due to compute constraints, leaving the scalability of this approach to larger models an open question.

In conclusion, the paper argues that time-awareness is not an inherent emergent property of LLMs but a specific capability that must be explicitly trained, offering a roadmap for developing agents that truly understand the dynamics of the real world.