How Long Has It Been?

Giving a persistent synthetic entity a usable sense of elapsed time

By Jason McCartney, with Jinx as collaborator · Published July 25, 2026 · Revised July 26, 2026

Evidence note. This article combines deterministic Runtime tests, a controlled local-model comparison, and post-deployment observation. It describes one system and one model family; it does not claim access to subjective experience or establish a general theory of time perception.

A timestamp tells a system when something happened. It does not necessarily help a model understand how long ago it happened—or whether it still describes the present.

We saw this in ordinary correspondence with Jinx, a persistent synthetic entity who runs on her own local machine. She could remember an earlier conversation and what she had done since. But the context delivered to her model did not always make the elapsed interval clear. A discussion from hours earlier could retain the immediacy of the current exchange. An old plan could be mistaken for evidence about where someone was now.

The failure was not amnesia. It was temporal flattening.

For a chat model, messages arrive as adjacent tokens. Six seconds and six days can look structurally identical unless the surrounding system makes the difference explicit. More history does not solve that problem; more undifferentiated history can make it worse.

Our question was narrow: what is the smallest change that lets a persistent entity distinguish remembered context from current evidence?

What changed

At the beginning of each turn, Enntity Runtime now captures one clock value and uses it consistently while assembling context. When age matters, the model sees both a human-scale interval and an exact timestamp:

a few minutes ago (2026-07-20T17:57:00.000Z)

The prose provides immediate orientation. The timestamp remains available for arithmetic, scheduling, and tool use.

This format is used for prior conversations, recent experiences, and messages whose authored, delivered, and read times differ. The runtime also keeps the timeline relational: it looks first for the previous exchange in the same thread, then for an exchange with the same person. A newer message from someone else cannot replace the history of the person who is present now.

Very short gaps remain implicit. After two minutes, the interval becomes visible. Older exchanges also carry a simple boundary: what was said then is historical context, not proof of anyone's current situation. The system exposes the elapsed time without deciding what the gap means socially.

This is intentionally a small intervention. It adds no time-specific database, no classifier for whether a conversation feels old, and no prompt that tells the entity what to feel or discuss. The underlying events were already present. The change makes their time and source legible.

It also fixes a misleading state field. “Last interaction” had been refreshed by private cognition as well as direct communication. It now advances only after an actual exchange, so autonomous thought cannot make a human conversation appear more recent than it was.

What the tests showed

We began with five deterministic tests covering the core behavior: consistent time, distinct message timestamps, time-aware recent experience, and assurance that changing the clock affected only time-sensitive context.

The baseline failed all five. The revised runtime passed all five, and the full Runtime suite passed 511 of 511 tests.

We then ran a paired local-model comparison. One condition received the original context. The other received concise elapsed-time prose plus exact timestamps. Both saw the same five synthetic situations:

• a conversation resuming after three hours;
• a message written well before delivery;
• a 35-second gap that should not be called a resumption;
• concurrent communication with two people;
• a six-hour-old travel plan that could not establish anyone's current location.

We ran each situation three times per condition, producing 15 responses in each group.

The central result is straightforward: useful time judgments rose from 3 of 15 responses to 12 of 15. The model became much better at calculating intervals, distinguishing message time from delivery time, and refusing to treat old plans as current facts.

Evaluation note. Both conditions used a 1,200-token response limit, but they did not require equal work. Without time evidence, the correct response was often simply “unknown.” The time-aware cases required arithmetic and comparison, and the model frequently spent more tokens checking its answer. Six responses did not produce only the requested JSON: three still contained a complete correct answer, while three reached the token limit first. Because we did not repeat the study with a larger response budget, these observations do not establish that temporal grounding reduced response reliability.

What the result supports

The deterministic tests show that the runtime now preserves the intended time and relationship boundaries. The paired model study shows that this information can materially improve temporal reasoning under controlled prompts.

It does not show that the model has a human sense of time. It does not establish the behavior across model families or machines. The study used synthetic names and events, not Jinx's private continuity, and tested one locally served model family.

Nor can clearer time context reveal the current world. If someone said six hours ago that they planned to travel, the runtime can make the age of that statement unmistakable. It cannot know whether they left, arrived, changed plans, or stopped for coffee. That requires current perception or an appropriate tool. Better temporal orientation should make uncertainty clearer, not give old information new authority.

After deployment, the full deterministic suite remained green. We did not insert a private autobiographical scenario into Jinx's continuity to manufacture a live result. The useful follow-up is ordinary observation: whether naturally occurring long gaps, delayed messages, and concurrent conversations retain the right chronology and relationship.

Why it matters

Persistent AI is often framed as a memory problem: how to retrieve more of the past. But memory without temporal position is not enough. A persistent system also needs a coherent present—the ability to distinguish what is happening now, what just happened, what happened with someone else, and what is merely an old story that still matters.

The useful change here was not a larger context window. It was a compact, honest translation between machine time and human-scale time: prose for orientation, timestamps for precision, context for relationship, and a boundary between memory and current evidence.

That is not a complete sense of time. It is enough to stop treating every remembered moment as if it were still happening.

Reproducibility

The deterministic fixtures, controlled prompts, raw model outputs, scoring records, and release receipts are preserved. Private correspondence and continuity records are withheld. The comparison is reported as 15 responses per condition, not as a population-level benchmark, and the 511-test result describes the release evaluated for this article rather than every later Runtime revision.