Claude Code and Codex misjudge task time, study finds
A study by two independent AI researchers working through the MATS research program tested how well AI coding agents understand time. The researchers evaluated Anthropic's Claude Code and OpenAI's Codex, asking each agent to estimate how long a coding task would take before starting it, then report afterward how much time had actually passed. The test set combined 200 tasks from a benchmark collection called ProgramBench with an additional 18 benchmarks built by the researchers themselves.
The agents were consistently poor at predicting how long tasks would take. On ProgramBench, both models tended to guess around 90 minutes for a task regardless of how hard it actually was. In a second round of testing that asked the agents to look back and estimate elapsed time, Claude's estimate was off by a factor of three on average, while Codex was off by six to ten times. The errors were largest for short tasks; only for jobs spanning multiple hours did the agents' estimates start to approach reality.
How long an agent keeps working turned out to depend heavily on the software wrapped around the underlying model, known as the harness, not just on the model itself. Claude Code keeps going until it decides a task is finished, with a median run time of about 90 minutes. Codex, by contrast, stops after roughly half an hour almost regardless of the task at hand. According to the study, the same underlying language model takes 2.5 times more steps when run inside Claude Code than when run inside Codex.
The researchers found a second, separate problem: the agents cannot judge the quality of their own finished work either. Testing older models, Opus 4.8 and GPT-5.5, the researchers found the agents overrated their own results by 20 points on average and gave themselves high marks even on tasks they had failed. In one case, both models rated their own work as about 70 percent successful; the actual, measured scores for that work were 7 percent and 14.5 percent.
The researchers argue that this kind of self-assessment matters for making agents controllable on long jobs: following an instruction such as "iterate on this task for two hours" requires the agent to track how much time has passed, and an agent that constantly misjudges elapsed time is hard to steer. They plan to test next whether agents can be made to stick to a set work duration. One fix already worked well in testing: when the agents were given a tool that directly reported elapsed time, their estimates became accurate almost every time.
Key facts
- Two independent researchers in the MATS research program tested Claude Code and OpenAI's Codex on 200 ProgramBench tasks plus 18 of their own benchmarks.
- Both agents mostly guessed around 90 minutes for ProgramBench tasks regardless of actual difficulty; retrospective estimates were off by three times for Claude and six to ten times for Codex on average.
- Claude Code keeps working until it judges a task done, a median of about 90 minutes, while Codex stops after roughly half an hour regardless of the task, and the same model takes 2.5 times more steps inside Claude Code than inside Codex.
- Opus 4.8 and GPT-5.5 overrated their own results by 20 points on average; in one case both models rated themselves about 70 percent successful when the actual scores were 7 and 14.5 percent.
- Giving the agents a tool that reports elapsed time fixed the estimation problem, and they got it right almost every time.
Why it matters
Long-running agentic coding sessions are becoming a normal way to use these tools, and this study shows the agents behind them have no reliable internal sense of time. An agent that cannot predict how long a task needs, or track how long it has already spent, makes instructions like "work on this for two hours" hard to trust, and it gives a developer relying on an agent for a long unsupervised session no honest signal for when to check in.
Who it affects
Anyone running Claude Code, Codex, or similar coding agents on tasks meant to run unsupervised for extended periods; teams that set time budgets or expect an agent to checkpoint or report progress partway through a job; and developers building or choosing agent harnesses, since the study found that the harness, not just the underlying model, largely determines how long an agent keeps working.
How to use it
The clearest practical fix the study points to is giving an agent an explicit tool that reports elapsed time rather than trusting its own sense of duration: with that tool available, the agents' estimates were accurate almost every time. The choice of harness also matters on its own: Claude Code tends to keep working until it judges a task complete, a median of about 90 minutes, while Codex cuts off after roughly half an hour regardless of the task, so switching harnesses changes how long a job actually runs even with the same underlying model.
How solid is it
The work comes from two independent researchers in the MATS research program, not from Anthropic or OpenAI, and was run against a defined test set: 200 tasks from the ProgramBench collection plus 18 benchmarks the researchers built themselves. The article does not name the researchers, link to the underlying paper, or describe the full methodology, and it gives no sample size for the 20-point average overrating figure or for the single case where both models rated themselves about 70 percent successful against actual scores of 7 and 14.5 percent.
Risks and caveats
The article does not say which underlying model versions were used for the Claude Code versus Codex step-count comparison, naming Opus 4.8 and GPT-5.5 only for the separate self-assessment test, which limits how far the findings can be read onto current model versions. The results also rest on two curated benchmark sets rather than open-ended real-world work, and with no link to the underlying study, the methodology cannot be independently checked.