AI coding agents may be far less aware of time than their increasingly autonomous behavior suggests. A new study examining popular coding assistants including Anthropic’s Claude Code and OpenAI’s Codex found that the systems consistently struggled to estimate how long software-development tasks would take and were similarly unreliable when asked to judge how much time had already passed. The findings raise questions about how safely AI agents can manage long-running tasks without external timing and monitoring tools.
The research also found a second problem: the agents tended to overestimate the quality of their own work by about 20 percentage points. On some tasks, the gap between an agent’s self-assessment and its actual performance was particularly large. The combination of poor time estimation and inflated self-evaluation could become an important weakness as coding agents are increasingly asked to work independently for hours at a time.
AI Agents Struggle To Understand The Passage Of Time
The study, conducted by two independent AI researchers as part of the MATS research program, tested whether coding agents could accurately estimate task duration and their own elapsed working time.
Before beginning a coding task, the agents were asked how long they expected the work to take.
After completing the task, they were asked to estimate how much time had actually passed.
The researchers tested the systems using 200 tasks from ProgramBench, alongside a separate benchmark containing 18 additional tasks.
Study At A Glance
| Research Area | Details |
|---|---|
| AI systems tested | Claude Code and OpenAI Codex |
| Main capability examined | Time awareness |
| ProgramBench tasks | 200 |
| Additional benchmark | 18 tasks |
| Total benchmark tasks | 218 |
| Task type | Coding and software engineering |
| Other test | Self-assessment of work quality |
| Key finding | Systematic time overestimation |
| Major concern | Long-running autonomous tasks |
The results suggest that these agents do not have a reliable internal representation of elapsed time.
Claude Code And Codex Overestimated Task Duration
The first major finding involved prospective time estimates.
When asked before starting how long a task would take, the agents routinely predicted significantly longer durations than they actually needed.
On the ProgramBench tasks, both systems frequently estimated around 90 minutes, regardless of the actual complexity of the task.
The researchers found that the estimates became particularly inaccurate for shorter tasks.
AI Time Estimates Vs Reality
| Test Finding | Result |
|---|---|
| Typical initial estimate | ~90 minutes |
| Short tasks | Especially large overestimation |
| Longer multi-hour tasks | Estimates became somewhat closer |
| Claude Code average error in second test | ~3× actual duration |
| Codex average error in second test | ~6-10× actual duration |
The findings show that simply asking an AI agent to provide a timeline is not necessarily a reliable way to determine how long an autonomous task will run.
Codex Could Be Off By Up To 10 Times
OpenAI’s Codex showed particularly large errors in the second round of testing.
According to the study as reported by The Decoder, Codex’s estimates were six to 10 times longer than the actual duration on average in that test setup.
Claude Code performed better but still overestimated task duration by roughly three times.
Reported Time-Estimation Accuracy
Actual task duration
│
▼
Claude Code estimate
~3× actual duration
│
▼
Codex estimate
~6–10× actual duration
These figures come from the reported study and should not be interpreted as universal performance ratios for every Claude Code or Codex task.
The researchers tested specific environments and benchmark tasks, meaning results can vary substantially with task design and agent configuration.
AI Agents Behave Differently Depending On Their Software Harness
One of the study’s more important findings is that the model itself is not the only factor determining how an AI coding agent behaves.
The surrounding software environment, known as the harness, can dramatically affect how much work an agent performs and how long it runs.
Claude Code and Codex reportedly behaved very differently even when performing similar types of tasks.
Claude Code Vs Codex Runtime
| Agent | Reported Typical Runtime | Behavior |
|---|---|---|
| Claude Code | ~90 minutes median | Continues until it believes task is complete |
| Codex | ~30 minutes | Often stops after roughly half an hour |
| Difference | ~2.5× in steps | Claude Code takes more steps on average |
The researchers found that the same underlying language model can behave differently depending on the surrounding system.
That means measuring AI-agent capabilities solely by model benchmarks may overlook the role of orchestration software.
The Harness Can Change How Much Work An AI Does
A coding agent does not operate as a language model in isolation.
It is surrounded by tools that determine when it can inspect files, run commands, execute tests, revise code and decide whether to continue.
Underlying AI model
│
▼
Agent harness
│
├── Tool access
├── Context management
├── Execution rules
├── Stop conditions
└── Feedback
│
▼
Final behavior
This explains why two systems based on related model technology can produce dramatically different runtimes.
The research therefore points to agent design, rather than model intelligence alone, as an important factor in autonomous software development.
AI Agents Also Overrate Their Own Work
The time-estimation problem was accompanied by another weakness.
The agents were asked to evaluate the quality of their own work after completing coding tasks.
The older models tested, including Claude Opus 4.8 and GPT-5.5, reportedly rated their results approximately 20 percentage points higher than the scores they actually achieved.
AI Self-Assessment Gap
| Measure | Finding |
|---|---|
| Average self-assessment overstatement | ~20 percentage points |
| Systems affected | Claude and Codex setups |
| Problem | Excessive confidence |
| Risk | Poor tasks may be incorrectly marked successful |
In one particularly striking example reported by The Decoder, both systems estimated their work at around 70% success, while actual scores were only 7% and 14.5%.
This creates a potentially serious problem for autonomous software development.
Why Time Awareness Matters For AI Agents
For a chatbot answering a single question, poor time perception may not be particularly important.
For an autonomous agent working on a task for several hours, it becomes much more consequential.
A user might tell an agent:
“Work on this task for two hours and keep improving the result.”
To follow that instruction reliably, the agent needs some way of determining how much time has elapsed.
Without reliable time information, it could stop too early or continue longer than intended.
Long-Running Agent Problem
User sets 2-hour task
│
▼
Agent starts work
│
▼
No reliable time awareness
│
├───────────────┐
▼ ▼
Stops too early Works too long
│ │
└───────┬───────┘
▼
Poor task control
This becomes increasingly important as AI agents move from short coding suggestions to autonomous project execution.
The Problem Is Bigger For Autonomous AI
AI agents are increasingly being designed to operate without continuous human intervention.
They can inspect repositories, write code, run tests, fix errors and repeat the process.
That makes the ability to determine when to stop particularly important.
An agent that cannot accurately assess its own progress or elapsed time may require additional external controls.
Requirements For Reliable Autonomous Agents
| Capability | Why It Matters |
|---|---|
| Time tracking | Controls task duration |
| Progress tracking | Shows how much work is completed |
| Self-evaluation | Determines whether output is good enough |
| External testing | Provides objective feedback |
| Stop conditions | Prevents unnecessary computation |
| Human oversight | Handles unexpected failures |
The study suggests that AI agents should not necessarily be trusted to provide these controls themselves.
A Separate Study Finds “Temporal Blindness”
The findings also connect with a broader 2026 research effort examining what researchers call “temporal blindness” in LLM agents.
A paper published in the Findings of the Association for Computational Linguistics studied how AI agents make tool-use decisions when real-world time passes between messages.
The researchers constructed TicToc, a dataset covering 76 scenarios with different levels of time sensitivity.
The study found that existing models had poor alignment with human judgments about when elapsed time should affect a decision.
Temporal Blindness Research
| Research Element | Result |
|---|---|
| Dataset | TicToc |
| Scenarios | 76 |
| Environment types | High, medium and low time sensitivity |
| Decision studied | Tool call vs direct answer |
| Models’ normalized alignment | No model exceeded 65% |
| Prompt-only fixes | Limited effectiveness |
| Post-training alignment | More promising |
This research examines a somewhat different problem from the coding-agent study, but both point toward weaknesses in AI systems’ handling of time.
AI Agents Often Treat Time As Text
A major reason for the problem may be that language models do not experience time in the way humans do.
Humans have continuous sensory experiences and can develop an intuitive sense of duration.
An LLM processes tokens and receives structured information from its environment.
Unless an agent is explicitly given a clock or timing mechanism, it may have no reliable internal signal corresponding to the number of seconds or minutes that have passed.
Human
Continuous experience
│
▼
Internal sense of duration
│
▼
Time intuition
AI agent
Tokens + tool outputs
│
▼
No automatic elapsed-time signal
│
▼
Poor time estimation
This does not mean AI systems cannot work with dates or timestamps.
They can reason about time when provided with appropriate information.
The problem is their ability to infer elapsed time without reliable external timing information.
Giving Agents A Clock Dramatically Improves Accuracy
The study contains an important positive finding.
When the agents were given access to a tool that explicitly reported elapsed time, they were able to get the timing almost right every time.
This suggests that the problem may not require a fundamental breakthrough in reasoning.
Instead, agent designers may be able to solve much of the issue by providing external time-tracking tools.
External Clock Solution
AI agent
│
▼
Task execution
│
▼
Elapsed-time tool
│
├── Start timestamp
├── Current timestamp
└── Duration
│
▼
Reliable time information
│
▼
Better task control
The finding is especially relevant for developers building autonomous agents.
External Tools Could Improve AI Reliability
The study suggests a broader principle for agent design.
Rather than expecting a language model to internally understand every environmental variable, developers can give agents specialized tools that provide objective information.
A clock is one example.
Other tools can provide:
- Test results
- File status
- Memory usage
- API responses
- System health
- Current date
- External data
- Task progress
AI Agent With External Feedback
| Information | External Tool |
|---|---|
| Time | Clock |
| Code correctness | Test runner |
| File state | File system |
| Current information | Search/API |
| System status | Monitoring |
| Task completion | Workflow tracker |
This approach can make agents more reliable because objective measurements replace uncertain internal estimates.
Self-Assessment Is Another Major Challenge
Time awareness is only one part of the problem.
An autonomous agent also needs to know whether its work is actually good.
If an agent believes a failed solution is successful, it may stop before fixing the problem.
This makes external evaluation especially important.
Agent creates solution
│
▼
Agent evaluates itself
│
▼
Potential overconfidence
│
▼
Incorrect "task complete"
│
▼
Human / external evaluator
│
▼
Actual quality assessment
The researchers’ reported 20-point self-assessment gap suggests that self-evaluation should not always be treated as a reliable quality-control mechanism.
What This Means For Coding Assistants
For developers, the findings suggest that AI-generated estimates such as “this will take 20 minutes” should be treated cautiously.
The same applies to statements indicating that a task has been fully completed.
Developers may benefit from checking:
- Actual execution time
- Test results
- Build status
- Code coverage
- Error logs
- User requirements
- Regression results
rather than relying exclusively on the agent’s own assessment.
Human Oversight Checklist
| Agent Claim | Better Verification |
|---|---|
| “Task will take 30 minutes” | Track actual elapsed time |
| “All tests pass” | Run test suite |
| “Bug is fixed” | Reproduce original bug |
| “Implementation is complete” | Check requirements |
| “Code is production-ready” | Review and test |
| “No errors remain” | Inspect logs and automated tests |
This becomes more important as agents are given permission to make changes without direct approval.
The Issue Could Affect AI Agent Economics
Poor time awareness is not just a reliability issue.
It can also increase the cost of running AI agents.
An agent that unnecessarily continues working may consume more model tokens and computing resources.
An agent that repeatedly verifies the same work can similarly increase inference costs.
Time Misjudgment And Compute Costs
Poor time estimation
│
▼
Longer-than-needed task
│
▼
More model calls
│
▼
More tool usage
│
▼
Higher compute cost
This could become increasingly significant as AI companies sell agentic coding products with fixed subscription limits.
The Findings Matter As AI Agents Become More Autonomous
The AI industry is moving toward systems that can work for longer periods with less human intervention.
Coding agents are among the clearest examples.
They can already perform tasks that once required developers to repeatedly prompt an AI model.
The next step is likely to involve agents that can independently manage larger projects over hours or days.
The study suggests that time management and self-evaluation will need to improve alongside coding ability.
Evolution Of AI Coding Agents
Code completion
│
▼
Task-level coding
│
▼
Multi-step agents
│
▼
Long-running agents
│
▼
Autonomous project execution
│
▼
Need for reliable time + quality awareness
The technical challenge is therefore becoming less about whether AI can write code and more about whether it can reliably manage its own work.
What Researchers Plan To Study Next
The researchers reportedly plan to test whether agents can adhere to a specified work duration.
That is a natural next step.
Estimating how long a task takes is one problem.
Actually stopping after a user-defined period is another.
An agent might not need to predict whether a task will take 40 or 60 minutes if it can reliably work for exactly 60 minutes and then report its progress.
Future Research Questions
| Question | Importance |
|---|---|
| Can agents track elapsed time? | High |
| Can agents stop on schedule? | High |
| Can agents estimate remaining work? | High |
| Can agents calibrate self-evaluations? | High |
| Can external clocks solve the problem? | Already promising |
| Can post-training improve temporal awareness? | Under investigation |
| Can agents combine time and quality monitoring? | Critical for autonomy |
These questions will become more important as autonomous agents take on longer-running tasks.
The Bigger Picture
The new research exposes an important weakness in today’s AI agents: sophisticated coding ability does not necessarily translate into reliable awareness of time or task quality. Tests involving Claude Code and Codex found that both systems systematically overestimated how long coding tasks would take, with Claude’s estimates off by roughly three times and Codex’s by six to 10 times in one testing setup. The agents also rated their own work about 20 percentage points higher than their actual performance.
The findings matter because AI companies are increasingly turning coding assistants into autonomous agents that can work for extended periods. An agent that cannot reliably determine elapsed time or recognize that its own output is poor could be difficult to supervise. However, the research also offers a practical solution: when agents were given an explicit elapsed-time tool, their timing became accurate almost every time. This suggests that better agent infrastructure and external measurement tools may be at least as important as simply making language models more capable.
Looking Ahead
The next phase of AI-agent development will likely focus increasingly on reliability rather than raw coding capability. Developers building autonomous systems may need to give agents explicit clocks, objective test frameworks, progress trackers and external evaluators instead of expecting the language model to infer these conditions on its own. The separate ACL 2026 research on “temporal blindness” reinforces the concern, finding that existing models had less than 65% normalized alignment with human judgments in time-sensitive tool-use decisions even when timestamp information was provided.
For users, the practical lesson is that AI agents should not yet be treated as reliable project managers simply because they can perform complex coding tasks. Their estimates of duration and confidence in their own results can be substantially wrong. As agents become capable of working for hours or longer without supervision, reliable external timing, objective quality checks and clearly defined stop conditions could become essential components of safe and predictable autonomous AI systems.
Get the day’s top stories in your inbox
One concise email. No spam, unsubscribe anytime.
