Technology has long struggled to capture the nuance of how people actually move through the world. Our systems exist outside the flow of time. Sure we have calendars, scheduling tools, timers. But all of those features are designed for us, and are calculated with raw math and complex libraries. But our systems can’t “feel” time.
Large Language models, the engines behind today’s chatbots, virtual assistants, and increasingly, creative collaborators are the first potential system we can use that have awareness of time, but they don’t. While these models are fast, fluent, and undeniably impressive, they remain fundamentally atemporal. Every exchange—whether separated by a millisecond or a month—is treated as if it occurred in the same instant. They can write code, answer questions, even riff on philosophy, but they can’t sense whether you’re rushing or hesitating, circling a problem or making headway. Agents carrying out multiple steps can’t tell if they’re “wasting time” (or have a concept of what that could be).
What if we could change that? Given what we know about LLMs, we may in-fact be able to overcome that limitation.
The Problem of Atemporality
This missing sense of time is a structural flaw. Human dialogue and collaboration depend on an awareness of pacing, delay, urgency, and the subtle signals that flow from timing. When an LLM can’t tell if you paused for dramatic effect or simply forgot to hit send, it can’t meet you where you are. When it gets stuck in a reasoning loop, it has no internal “clock” to signal that it’s spinning its wheels. And when multiple agents collaborate on a shared task, they have no common rhythm for dividing the work, waiting, or handing things off.
We can insert time into conversations, but that doesn’t matter if there is no “sense of urgency”. This gap in experience can erode trust and make digital conversation feel mechanical. But time is a significant component of what gives words and interactions meaningful.
The Time Token Hypothesis
What can data scientists and engineers do to enable LLMs to experience time? My answer is simple, but foundational: Embed time tokens directly into the data stream—making time a first-class citizen in every interaction. If we see the same emergent abilities in LLMs that we see with the inherent understanding of language vs. usage by humans, then LLMs will begin to truly understand time.
How the System Might Work
The core protocol could be constructed using systems humans already use, which are also easily encodable and decodable by our technology. Every message, reasoning step, or event is annotated with a time token, represented as an integer UNIX timestamp. There are two key types:
- Absolute Time Tokens mark the actual wall-clock time an event occurs, such as
<t:1718589205123>. These are injected at the start of each user input, system message, or logical step. - Relative Time Tokens represent the difference from a session zero-point. The first message is
<t:0>, and every subsequent token shows how many milliseconds (or seconds, depending on convention) have elapsed since the start, e.g.,<t:12000>. Negative numbers (e.g.,<t:-30000>) allow for referencing events prior to the current zero-point, supporting backwards planning or simulation.
There’s no need for unit suffixes; models simply learn the meaning from the data convention. Crucially, these tokens aren’t produced by the model—they’re injected by the middleware or application layer, then included in the training data so that the LLM learns to recognize and use them as context.
How Time Tokens Might Change Model Behavior
With consistent exposure to these tokens, the language model could potentially gain an implicit sense of temporal flow. It might:
- Distinguish between a quick reply and a thoughtful pause.
- Notice when it’s stuck in a loop—repeating a reasoning step with increasing time offsets.
- Calibrate its own pacing, flagging when something is taking longer than usual, or adapting to a user’s tempo.
- In multi-agent systems, coordinate handoffs, share a common “clock,” and anticipate how long tasks should take.
In practice, this means chatbots can respond with a human-like sense of presence. If you take a long time to reply, the AI can check in or adjust its approach. If it takes too long to reason, it can pause, explain, or escalate. Multi-agent workflows become more fluid and less brittle.
Agents have been spotted self-destructing over failed attempts to code. Now we can help them feel the same sense of dread over taking too long to complete a project.
A Hypothetical Example Workflow
- Suppose a conversation starts at time zero. The first user message is labeled
<t:0>. - If the model responds after 2.5 seconds, the next token is
<t:2500>. - If the user replies after another ten minutes, their next message is
<t:602500>.
In a more complex scenario—say, planning backwards from a desired outcome—tokens like <t:-30000> can mark events thirty seconds prior to the zero point. But in any scenario, all tokens are simply integers, making them trivial for both models and humans to parse.
In multi-agent systems, everyone shares the same timeline, allowing agents to anticipate each other’s moves, balance loads, and recover gracefully from delays.
Implementation and Training
No architectural changes to the underlying LLM are required. With this hypothesis in mind, all that would be needed is a mechanism to add the timestamp in the correct format in middleware or the frontend, and training data that reflects authentic, variable human rhythms: bursts of conversation, long pauses, interruptions, and iterative loops. The richer and more honest the data, the more nuanced the model’s sense of time becomes.
During training, models learn not just to predict text, but to use the time tokens as landmarks—helping them reason about pacing, duration, and when a process is veering off course. Crucially, models should not be punished for “taking time,” but rather rewarded for competence and transparency. The goal isn’t speed, but accuracy and presence.
Potential Real-World Applications
The range of applications is broad:
- Customer service bots can escalate issues when loops or delays persist.
- Tutoring systems can adapt to each learner’s natural pace, offering encouragement or extra time as needed.
- Even creative writing partners—AI and human—can riff off each other with a shared sense of timing, making the exchange feel alive.
Challenges and Considerations
There are, of course, real risks and limitations.
- Models might pick up on timing biases from their training data, misinterpret system lag as user intent, or be thrown off by adversarial manipulation of tokens.
- Building robust datasets that reflect true human tempo—not just idealized conversation—is no small feat.
- Cultural differences in pacing, hardware limitations, and edge cases (like batched processing) all require careful handling.
- Traning data may unintentionally train LLMs to simulate “panic” or take unnecessary shortcuts instead of taking efficient steps.
The Path Forward
My hope is that this approach will inspire researchers, engineers, and designers to treat time as a structural element of intelligent systems. The next steps are clear: build open datasets, develop easy-to-implement patterns to insert time tokens, and begin piloting time-aware models in real-world tasks to refine the approach and truly test the hypothesis.
I invite anyone working in this space to audit, stress-test, and improve on the protocol. The goal is not to own the idea, but to see it realized—and to make sure that, as our machines become more fluent, they also become more present.
Why Share This Now?
I don’t claim to be the first to notice that LLMs are blind to time; there’s emerging research on timestamp embeddings, multi-agent coordination, and temporal benchmarks. But I haven’t yet seen anyone formalize it as a universal token protocol—a tool that’s both trivial to implement and transformative in impact.
So I’m sharing this idea now as an open call. If you’re building the next generation of digital companions, give your models the gift of time. If this protocol finds its way into your work, I hope you’ll remember this obscure IT generalist who insisted that presence isn’t just about words—it’s about rhythm, memory, and a shared sense of when things happen.