🤖 AI

Can LLMs Perceive Time? An Empirical Investigation

This empirical study demonstrates that large language models fundamentally lack the ability to perceive or estimate their own inference time, consistently producing inaccurate pre-task predictions, post-hoc recalls, and relative ordering judgments across various tasks and model families due to a disconnect between their propositional knowledge and experiential grounding.

Original authors: Aniketh Garikaparthi

Published 2026-04-02

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Aniketh Garikaparthi

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 Big Idea: The "Time-Blind" Chef

Imagine you hire a brilliant, super-fast chef (the AI) to cook a meal. This chef knows everything about food. They know that a steak takes 10 minutes to grill, that baking a cake takes an hour, and that chopping onions is quick. They have read every cookbook ever written.

However, there is a catch: This chef has never actually stood in a kitchen. They have never felt the heat of the stove, never heard the timer beep, and never felt the weight of time passing while they chop. They only know what the books say, not what reality feels like.

This paper investigates what happens when we ask this "Time-Blind" chef: "How long will it take you to cook this specific dish right now?"

The answer? The chef is wildly wrong.

The Four Experiments (The Taste Tests)

The researchers put the AI through four different tests to see how bad its time sense really is.

1. The "Crystal Ball" Test (Pre-Task Estimates)

The Setup: Before the AI starts working, they ask: "How many seconds will this take?"
The Reality: The AI is terrible at this.

The Analogy: Imagine you ask the chef to make a simple grilled cheese sandwich. The chef, having read about "cooking," guesses it will take 20 minutes. In reality, the sandwich is done in 3 seconds.
The Result: The AI consistently guesses that tasks will take 4 to 7 times longer than they actually do. If a task takes 10 seconds, the AI thinks it will take a minute or two. It's like guessing a sprint takes as long as a marathon.

2. The "Which is Faster?" Test (Relative Ordering)

The Setup: The researchers give the AI two tasks and ask: "Which one will take longer?"

Task A: A "hard" math problem (labeled "Hard").
Task B: A "medium" creative writing prompt (labeled "Medium").
The Trap: In the real world, the "Hard" math problem might be solved instantly by the AI's super-speed, while the "Medium" writing task takes longer because the AI has to think of creative words.
The Result: The AI fails miserably. It relies on labels instead of reality. It thinks "Hard label = Long time."
The Analogy: It's like a person who has never seen a race, but assumes the runner wearing a "World Champion" shirt must be slower than the runner wearing a "Beginner" shirt, just because the "Beginner" looks like they are struggling.
The Shock: On tricky pairs where the "Hard" task was actually faster, the AI got it wrong 82% of the time (scoring 18% accuracy). It was worse than random guessing!

3. The "Memory Test" (Post-Hoc Recall)

The Setup: The AI finishes a task. Immediately after, they ask: "How long did that just take you?"
The Result: The AI has no memory of time passing.

The Analogy: Imagine you eat a cookie in one second. Immediately after, someone asks, "How long did you eat that?" You might say, "Oh, about 5 minutes," because you know eating usually takes time, even though you just did it instantly.
The Reality: The AI's guesses were completely disconnected from reality. Sometimes it thought a task took 10 minutes when it took 10 seconds. It has no "internal clock" to check.

4. The "Complex Project" Test (Agentic Tasks)

The Setup: The researchers gave the AI a multi-step job, like "Build a website" or "Fix a broken computer program." These involve many steps, tools, and waiting for things to load.
The Result: The AI's time blindness got even worse.

The Analogy: If you ask a time-blind person to plan a road trip, they might guess the whole trip takes 2 hours because "driving is fast," forgetting that there will be traffic, gas stops, and detours.
The Reality: The AI's estimates were off by 5 to 10 times. It couldn't predict how long the tools would take to work or how long debugging would last.

Why Does This Happen? (The Missing Ingredient)

The paper explains that the AI is missing Temporal Grounding.

Humans: We learn about time by living. We wait for water to boil. We feel our heart beat. We know how long it takes to walk to the store because we've done it a thousand times. We have a "body" that experiences time.
AI: The AI only sees text. It sees the word "seconds" and knows that "seconds" are a unit of time. But it has never felt a second pass. It doesn't know how fast its own "brain" (the computer chip) is, or how slow the internet is.

The "Black Box" Problem:
Imagine the AI is a magician in a box. It can pull a rabbit out of a hat, but it doesn't know how long the trick took because it can't see the clock outside the box. The time it takes depends on the size of the box (the computer hardware), the speed of the magician (the processor), and the weather outside (network speed). The AI inside the box knows none of this.

Why Should We Care?

If we want AI to be a manager or a planner (like a boss who assigns tasks to workers), it needs to know how long things take.

If an AI thinks a task takes 1 hour but it actually takes 1 minute, it might waste resources waiting.
If it thinks a task takes 1 minute but it actually takes 1 hour, it might miss a deadline in a real-world emergency (like a medical triage or an emergency response).

The Conclusion

The paper concludes that Large Language Models cannot estimate their own time. They are like brilliant librarians who have read every book about time but have never looked at a watch.

The Fix?
We cannot just ask the AI to "try harder." We need to build external clocks for them. We need to give them a tool that says, "Hey, you just spent 10 seconds on that," so they can learn. Until then, we shouldn't trust AI to schedule our day or manage our time; we need to do it for them.

1. Problem Statement

The paper addresses a critical limitation in Large Language Model (LLM) agents: the inability to accurately estimate the duration of their own computational tasks.

As LLM agents are increasingly deployed in multi-step, long-horizon scenarios (e.g., software engineering, emergency response, resource allocation), accurate temporal self-estimation becomes a fundamental control problem. Agents must decide when to parallelize tasks, when to switch strategies, and how to allocate limited test-time compute. However, current LLMs lack temporal grounding. Unlike humans, who develop time perception through sensorimotor interaction and feedback, LLMs process tokens without direct access to wall-clock time, inference speed, or hardware latency. Consequently, they possess propositional knowledge about time (e.g., "writing a report takes hours") but lack experiential knowledge of their own inference duration.

2. Methodology

The authors conducted a comprehensive empirical investigation across 68 tasks spanning seven categories (code generation, debugging, summarization, reasoning, writing, creative, and QA) and four model families (GPT-5, GPT-4o, OLMo3-7B, and Qwen3-8B).

The study was structured around four distinct experiments:

Experiment 1: Absolute Calibration (Pre-task):
- Task: Models were asked to estimate the time required to complete a task before execution.
- Metric: Comparison of estimated seconds vs. actual wall-clock duration (API request to response completion).
Experiment 2: Relative Ordering:
- Task: Models were presented with pairs of tasks and asked to identify which would take longer.
- Design: Included "Hard Pairs" specifically designed to defeat surface heuristics:
  - Near-Identical: Tasks with <5% duration difference.
  - Counter-Intuitive (CI): Tasks where the "harder" complexity label corresponded to a faster actual execution time (e.g., a complex logic puzzle vs. a long but simple story generation).
  - Cross-Category: Different task types with similar durations.
Experiment 3: Post-hoc Recall:
- Task: Immediately after task completion, models were asked to estimate how long the generation actually took, without being provided any timing data.
Experiment 4: Agentic Settings:
- Task: Evaluation in multi-step environments using ReAct agents with tools (bash, Python, text editor) for complex tasks like building landing pages or debugging multi-file projects.

3. Key Results

A. Absolute Calibration Failure

Systematic Overestimation: Frontier models (GPT-5, GPT-4o) consistently overshoot actual duration by 4–7× ( $p < 0.001$ ). They predict human-scale minutes for tasks that complete in seconds.
Correlation: While GPT-5 showed a moderate positive correlation ( $r=0.55$ ) and GPT-4o ( $r=0.35$ ), open-source models (OLMo3-7B, Qwen3-8B) showed no significant correlation ( $r \approx -0.06$ to $0.18$), clustering around arbitrary values.
Complexity Bias: Models anchor estimates on task descriptions (complexity labels) rather than processing speed. For example, OLMo3-7B overestimated simple tasks but underestimated complex ones, suggesting a reliance on semantic cues rather than temporal reality.

B. Relative Ordering & Heuristic Reliance

Chance-Level Performance: On "Hard Pairs," models performed at or below chance.
Counter-Intuitive Failure: GPT-5 achieved only 18% accuracy on counter-intuitive pairs (significantly below the 50% chance baseline, $p=0.033$ ). When complexity labels misled the model (labeling a fast task as "hard"), the model systematically chose the wrong answer, proving reliance on heuristics rather than genuine temporal self-knowledge.

C. Post-hoc Recall Disconnect

No Temporal Memory: Post-completion estimates were disconnected from reality.
- Frontier models overestimated (e.g., GPT-4o claimed 42s for an 8s task).
- Open-source models showed zero correlation ( $r = -0.06$ ), indicating they do not accumulate temporal information during generation.
Conclusion: Models do not "feel" the passage of time; they generate plausible-sounding numbers based on training data priors.

D. Agentic Settings

Error Propagation: In multi-step agent tasks, errors persisted and often amplified, with pre-task estimates being 5–10× off.
Post-hoc Collapse: In agentic settings, post-hoc estimates were even more erratic. GPT-4o estimated "30 seconds" for tasks that took 10 minutes. Task success or failure did not improve calibration.

4. Key Contributions

Empirical Evidence of Temporal Blindness: The paper provides the first systematic evidence that LLMs lack "temporal proprioception" (self-awareness of duration), distinguishing this from general temporal reasoning or fact recall.
Diagnostic Benchmarking: Introduction of "Counter-Intuitive Pairs" as a robust diagnostic tool to separate heuristic reliance (complexity labels) from true temporal estimation.
Architectural Diagnosis: The study identifies that the root cause is the missing temporal grounding in the training and inference loop. Models map tokens to tokens, not tokens to seconds, and lack access to deployment variables (hardware, network latency, batching).
Practical Guidelines: The authors demonstrate that current models cannot be relied upon for self-scheduling or resource allocation in time-critical domains.

5. Significance and Implications

Agent Design: The findings suggest that scaffolding (e.g., asking the model to estimate time) is insufficient. Agent systems must rely on external infrastructure for timing, such as:
- System-level timeouts and hard limits.
- Historical logging of task durations for lookup-based estimation.
- Explicit time budgets communicated by the orchestrator, not the agent.
Future Research: The paper argues that achieving true temporal self-awareness requires architectural changes, such as:
- Training with explicit timing signals (e.g., tokenizing time or duration).
- Developing world models that integrate sensorimotor feedback and elapsed time into the representation learning process.
- Moving beyond text-only pretraining to embodied or interactive training regimes.

In conclusion, the paper asserts that while LLMs can reason about time in the abstract, they cannot perceive their own time. This fundamental gap poses significant risks for autonomous agents operating in real-world, deadline-sensitive environments.