Building Minds
The Eternal Present: Why Your AI Agent Doesn't Know What Time It Is
Dr. Jerry A. Smith · March 20, 2026 · 13 min read
Imagine you are watching an agent work.
It was given a task three hours ago. The deadline is in forty minutes. The agent does not know this — not in any way that changes what it does next. It is executing its plan with the same methodical thoroughness it brought to the first hour, allocating the same attention to each sub-step, producing the same quality of output per turn. It is, by every measure you have instrumented, performing correctly.
The deadline arrives. The task is incomplete.
You investigate. The agent made no errors. Its reasoning was sound. Its outputs, where finished, were good. What it failed to do was the one thing that would have mattered most in the final hour: accelerate, compress, escalate, shift. Prioritize ruthlessly in the face of a closing constraint.
It could not do that. It did not know the constraint was closing. It was living, as researchers have begun to call it, in the eternal present — aware of what it was doing, unaware of when it was doing it.
There is a failure mode that does not appear in benchmark scores.
It does not surface in evaluations conducted in controlled settings with clean inputs and staged prompts. It appears in the third hour of a live deployment, when an AI agent is managing a process with a deadline, and the deadline is approaching, and the agent has no idea.
The agent does not panic. It does not accelerate. It does not reprioritize its remaining steps or surface a warning to the human supervisor. It simply continues at the same pace, with the same allocation of effort, toward the same sub-goals it identified at the start of the session. The deadline passes. The agent keeps going.
This is not a hallucination. It is not an alignment failure. It is something more fundamental: an architectural absence. The agent knows what has happened. It knows what it is trying to do. What it lacks is any felt sense of when it is in the unfolding of things — where it stands in its remaining budget, how urgency should be escalating, what the approaching constraint implies for what it does next.
The research makes the scale of this concrete. When language models are evaluated on real-time tasks — tasks where wall-clock time matters, where elapsed duration should change strategy — performance is dramatically worse than on equivalent tasks framed as turn sequences. The same agents that fail under real-time constraints succeed with turn limits. The same information, processed under two different temporal frames, produces a six-times difference in outcome quality. When researchers added explicit temporal feedback — not complex machinery, just structured cues about where in the task the agent stood and what urgency the remaining time implied — performance recovered. Qualitative urgency signals worked better than numeric timestamps. The agents were not computing elapsed time. They were reading the room.
This matters because the room in enterprise deployments is almost always a room with a deadline.
The reason this failure is difficult to diagnose is that it is invisible precisely where most AI systems are evaluated.
The standard evaluation environment for a language model is, by design, temporally neutral. A task is presented. An output is produced. The output is measured against a correct answer. Time is not a variable. The evaluation does not ask whether the agent recognized that thirty minutes had passed. It asks whether the agent produced correct output.
When the model passes this evaluation, the organization concludes the model is capable. When the model fails in a production deployment where time was the constraint, the organization concludes that something went wrong in implementation. The data pipeline. The prompt structure. An edge case in the integration layer. These are the failure narratives that circulate, because they are the ones the evaluation infrastructure can support.
What the infrastructure does not support is the correct diagnosis: the model was never trained to track its own position in time, never assessed on whether its behavior changed appropriately as a deadline approached, and was never given a mechanism to do either.
This is not an oversight. It reflects how language models are built. Training optimizes for output quality on individual instances: what token should follow this sequence, what response best fits this prompt. The temporal dimension of cognition — when to act, how to prioritize under constraint, how urgency should shift the allocation of effort — is simply not what next-token prediction teaches. The model learns to produce good answers. It does not learn to manage itself across a bounded period of real time.
Neuroscience has a clear account of how the biological version of this problem is solved — and why it matters that it be solved in a specific way.
The hippocampus does not simply store what happened. It encodes what happened in sequence — when events occurred relative to each other, which came before, which followed, how much time separated them. This temporal ordering is not incidental to memory. It is constitutive of it. The ability to reconstruct the past in its correct sequence, to anticipate what comes next because you know where in a pattern you currently are, to feel the gap between now and the deadline as something that is actively closing — all of this depends on a memory system that treats time as a first-class property of experience.
The clinical evidence for how much this matters comes from the cases where it is lost. Patients with hippocampal damage can retain factual knowledge while losing episodic memory — they know what they know, but they lose the sequence that tells them when they learned it and where they stand in an unfolding situation. The practical consequence is precisely what we observe in AI agents: competence on discrete tasks, failure on tasks where temporal positioning matters. They can answer the question. They cannot manage the process.
Augustine, writing in the Confessions, described time as existing only in the mind — the present experience of the present, the present experience of the past, and the present experience of the future. Without a mind that can hold all three at once, you are stuck in an eternal present. You know what is happening now. You have no sense of trajectory. You cannot feel the deadline approaching because the future is not something you inhabit, only something you know about.
That is the condition of every agent currently running in production.
The agent lives in the present moment of each token. It has access to its history in the context window, but it lacks a sense of itself moving through time. It does not experience the gap between now and the deadline as a closing one. It does not feel urgency escalate. It exists, cognitively, outside of time — competent, thorough, and entirely without a clock.
The business impact of this is not abstract. Let me make it specific.
Consider the negotiation. Research published in 2025 and 2026 found that under wall-clock time constraints, AI agents consistently fail to adapt their strategy to remaining time. They do not make concessions earlier when the clock is running. They do not shift from exploration to closure as the deadline approaches. They negotiate as if the deadline does not exist — because for them, it doesn't. The consequence is a sixfold gap in deal-closure rates between agents with temporal feedback and those without it. In a deployment where agents are handling contract negotiations, vendor agreements, or client renewals at scale, that multiplier is not a research artifact. It is a number that appears in a quarterly report.
Recommended by LinkedIn
[
Thinking with Machines: A Humble Exploration of…
David K. Park, PhD
1 year ago](https://www.linkedin.com/pulse/thinking-machines-humble-exploration-synthetic-srda-park-phd-c7c7e)
[
The SO
Alan Rosa
7 months ago](https://www.linkedin.com/pulse/so-alan-rosa-xkzde)
[
Why AI Gives a Different Answer About You Every Time…
Jimi Gibson
1 week ago](https://www.linkedin.com/pulse/why-ai-gives-different-answer-you-every-time-its-asked-jimi-gibson-2mpde)
Consider the compliance workflow. An agent managing a regulatory filing has a hard deadline. The task involves gathering documentation, cross-referencing requirements, flagging gaps, and escalating exceptions to human reviewers. The failure mode is not that the agent makes incorrect judgments. It is that the agent does not accelerate the pace of escalation as the deadline approaches. Exceptions that should have been surfaced in hour two are still being processed in hour five, with an hour left. The filing is late, not because the agent was wrong, but because it was temporarily blind.
Consider the customer escalation. An agent handling a complex service failure has an internal resolution target and an external commitment made to the customer. As the target approaches, a human would begin compressing — pushing harder, prioritizing the fastest path, escalating to a specialist. The agent does not. It continues the same systematic process at the same systematic pace. The customer does not receive the escalated effort. The metric fails. The experience is worse, not because the agent made a mistake, but because it never felt the pressure to change.
Multiply any of these across the scale at which enterprises now deploy agents — hundreds of concurrent workflows, thousands of interactions per day — and the aggregate cost of temporal blindness becomes significant quickly. Time-bounded work is the majority of knowledge work. Deadlines, SLAs, escalation triggers, urgency gradients: these are not edge cases. They are the structure of the environment in which the agent operates. And the agent cannot perceive any of them.
The architecture that solves this problem is not complex. That is the significant finding.
The instinct, when a capability is missing from a large language model, is to assume that adding it requires more model — more parameters, more training data, a different architecture. This turns out to be wrong. The research finding that qualitative urgency signals outperformed numeric countdowns tells you something important about why. The model already has the capability to respond to urgency. It is wired, through training on human-generated text, to read the difference between we have plenty of time and time is running out, and to adjust its behavior accordingly. What it is not given is a continuous, updated signal about its own position in the task.
The fix is to provide that signal.
The intervention is called temporal proprioception — by analogy with the proprioceptive sense in the biological body, which tells you where your limbs are in space without requiring you to look at them. Temporal proprioception is the agent's ongoing sense of where it is in time without requiring it to compute elapsed duration from raw timestamps. The implementation is a structured context injection at the beginning of each agent turn: where the task stands relative to its budget, how urgency is evolving, what deadlines are active and how far they are, what has been completed versus what remains.
The information required to generate this signal is almost always available. The system knows when the task started. It knows how many turns have elapsed. It knows what deadlines were specified at the outset. What has been missing is not the data. It is the mechanism to format that data into a signal the agent can act on, injected at the right moment, in the form the agent is already trained to respond to.
The language matters here more than the precision. "You have three turns remaining and this task is urgent" produces better urgency calibration than a timestamp the model is expected to interpret internally. The model is not a timer. It is a language system. You communicate urgency to it in language. And when you do, it responds — not because you added new capability, but because you finally told it something it needed to know.
The deeper problem is harder.
The reason agents lack temporal proprioception is that their memory systems do not encode time as a first-class property of experience. Current architectures store timestamps in memory — when a fact was logged, when an event was recorded. What they do not do is encode the sequence of events as a dimension of knowledge, or reason from that sequence about where they currently stand in an unfolding process.
The biological hippocampus does both. It encodes not just what happened, but what happened in relation to what else, in what order, with what gaps between. This temporal relational structure is what enables prospective memory — the ability to hold in mind that something needs to happen, to monitor for the conditions that will trigger it, and to respond when those conditions are met. It is also what enables the felt sense of urgency: not a cognitive calculation, but an experiential feature of being situated in time, of feeling the remaining space compress.
Building this into agent memory systems requires more than injecting a signal at each turn. It requires encoding temporal relationships into the memory structure itself. When an agent stores a memory, it should store not just the content and the timestamp, but the position of that memory in the sequence of the current task — what it follows, what it implies about what comes next, what it signals about where in the process the agent now stands. When the agent retrieves memories, it should retrieve not just content but temporal context — not just what happened, but when in the sequence it happened and what that implies about now.
This is not a speculative architecture. It is a direct application of the hippocampal episodic memory system. The engineering implementation is tractable. The question is whether the organizations building agent systems will prioritize it before the cost of temporal blindness becomes visible enough to demand attention.
The organizations that solve this problem first will have a genuine advantage — not because temporal proprioception is difficult to replicate once demonstrated, but because the process of building it requires thinking carefully about something most agent deployments have not thought carefully about at all: the structure of task time, the phenomenology of urgency, and the difference between an agent that performs individual steps correctly and an agent that manages a process intelligently from start to finish.
That distinction is consequential. An agent that performs individual steps correctly is a faster tool. An agent that manages a process intelligently is a different kind of participant in the work. It allocates effort differently as constraints evolve. It escalates when escalation is warranted. It compresses when compression is required. It brings to deadline-sensitive work what a skilled human practitioner brings: the sense of where you are in the thing, how much room you have, and what the clock requires of you right now.
The value of this capability is not distributed evenly across task types. It is highest precisely where the highest-stakes work happens. Contract negotiations. Compliance deadlines. Customer escalations with SLA commitments. M&A due diligence with closing dates. Audit preparations. The processes where deadlines are real, where urgency is not a preference but a constraint, where the cost of temporal misalignment compounds with every turn. These are also the processes most organizations are most eager to automate, because they are the most expensive when they fail. They are the processes where agents without temporal proprioception are most likely to fail — because they are exactly the processes where time matters most.
The enterprises building durable AI advantages right now are not doing it on model selection. The frontier models are roughly equivalent on capability benchmarks, and that equivalence will continue to narrow. The advantages are being built on the quality of the cognitive architecture surrounding the models — the memory systems, the coordination mechanisms, the governance layers, and increasingly, the temporal intelligence that allows an agent to do what any skilled knowledge worker does on a deadline: read the clock, feel the pressure, and adjust.
The research result that stays with me is the simplest one. The most capable models available at the time of the study — GPT-5.1 and Claude Sonnet 4.5 — both failed the temporal task. Not by a small margin. By a factor of six. And the fix was not a new model. It was a few lines of structured context. The capability to respond to urgency was present all along. What was missing was the signal.
There is something both humbling and clarifying in that finding. We have spent enormous resources building models that can reason about almost anything. We have not spent sufficient attention on telling them when they are.
The biological brain solves this automatically. The hippocampus is always running, always encoding the sequence of experience, always maintaining the organism's sense of its own temporal position in the world. We have not built this for our AI systems yet.
The failure it creates is invisible in testing and expensive in production. The fix is known. The architecture is tractable. What remains is the organizational will to treat time — the structure of it, the pressure of it, the cognitive demands it places on any agent working within it — as something worth engineering for, not something we will get around to eventually.
We will not get around to it. It will arrive as a reckoning in a quarterly report, in a compliance audit, in a contract that didn't close. The deadline will pass. The agent will keep going.
We should fix this before it does.
Dr. Jerry A. Smith is an AI executive and computational neuroscientist. He builds agentic AI systems for enterprises in regulated industries and researches the intersection of cognitive neuroscience and AI architecture. Building Minds publishes weekly on AI strategy, architecture, and what enterprise leaders need to know to build durable AI capabilities.