🤖 AI

ChronoState: Hidden Elapsed-Time Conditioning for Temporal-State Action Selection in Frozen-Backbone Language Models

The ChronoState paper demonstrates that a frozen language model can effectively compose hidden, non-token elapsed time with symbolic task state to select temporal actions under direct supervision, achieving high accuracy on specific benchmarks while failing to generalize to unseen families or outperform simple prompt-injected timestamp baselines.

Original authors: Sam Siavoshian, Omar Ramadan, Amir K. Saeed, Benjamin A. Johnson, Amin Mohamed El-Amin Diab, Benjamin M. Rodriguez

Published 2026-08-11

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Sam Siavoshian, Omar Ramadan, Amir K. Saeed, Benjamin A. Johnson, Amin Mohamed El-Amin Diab, Benjamin M. Rodriguez

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are talking to a very smart robot that has read almost everything written on the internet. This robot is great at following instructions, but it has a funny blind spot: it doesn't actually know what time it is. To the robot, a minute feels exactly the same as a year unless you explicitly write "It is 3:00 PM" in the chat. This is a problem for real-world tasks. If a robot is managing a library, it needs to know when a book is overdue. If it's running a security system, it needs to know if a password has expired. Usually, we just tell the robot the time by typing it into the chat, like a human giving a hint. But what if we could whisper the time directly into the robot's brain without it ever seeing the words? That is the big question this paper explores. It asks: Can we feed a "hidden" time signal directly into a frozen robot's brain so it can make better decisions, even if the robot can't read the time as text?

The researchers behind this study, led by Sam Siavoshian and colleagues from Johns Hopkins University, built a special test called ChronoState to answer this. They wanted to see if they could inject a "hidden" time signal into a language model (the robot's brain) that wasn't part of the visible text. Think of it like this: usually, if you want a robot to know how long it's been waiting, you have to type, "You have been waiting for 5 minutes." In this experiment, the researchers tried a different trick. They kept the text exactly the same but secretly fed a number representing "5 minutes" directly into the robot's internal wiring. They called this Chronometric Injection. It's like giving the robot a secret earpiece that only it can hear, telling it exactly how much time has passed since a specific event, like a job starting or a cache filling up.

The team used a specific type of robot brain called Qwen2.5-3B-Instruct. They "froze" the main part of its brain, meaning they didn't let it learn new facts or change its core knowledge. Instead, they added a tiny, trainable "adapter" (a small patch of new wiring) that could listen to this secret time signal. They tested the robot on six different scenarios, like deciding if a computer cache is still fresh, if a background job is done, or if a user's session is too old to trust. The robot had to choose between actions like "Reuse," "Wait," "Refresh," or "Ask for confirmation."

The results were a mix of impressive success and clear limits. When the robot received the correct hidden time signal, it got the answers right about 93% of the time. This is a huge jump from the 55% it got when the time signal was missing or set to zero. Even more interesting, when the researchers shuffled the time signals (giving the robot the wrong time, like telling it 5 minutes had passed when it was actually 2 hours), the robot's accuracy dropped to about 33%. Crucially, the robot didn't just ignore the wrong time; it actually followed the wrong signal and made the wrong decision based on it. This proves the robot was truly "listening" to the hidden signal and using it to calculate its answer, rather than just guessing.

However, the paper is very careful not to overhype this as a magic solution. The researchers found that while the hidden time trick worked well, it wasn't the best way to give the robot time. When they simply typed the time into the chat (like a normal prompt) and trained the robot on that, the robot got it right 99% of the time. So, the hidden signal isn't a "win" in terms of raw accuracy. Instead, its value is that it's a separate, controllable channel. It allows a system to test the robot's reaction to time without the time being visible in the text, which could be useful for security or for testing how the robot handles conflicting information.

The study also found where the robot's brain hits a wall. While it got really good at handling new templates and different time durations, it struggled when asked to apply what it learned to a completely new type of task it hadn't seen before (specifically, a "quota" reset task). It got this right only about 50% of the time, which is basically a coin flip. This suggests the robot learned to follow the rules for the specific tasks it saw, but didn't fully understand the abstract concept of "time limits" well enough to apply it to totally new situations.

In the end, the paper concludes that yes, you can successfully whisper time into a frozen robot's brain, and it will use that whisper to make decisions. It's a working, controllable interface. But it doesn't mean the robot has developed its own sense of time, nor does it mean this hidden method is better than just telling the robot the time out loud. It's a neat trick for researchers to study how robots process time, but for building real-world systems, the old-fashioned way of just writing the time in the prompt is still the most reliable champion. The authors suggest this method is a great tool for defense and security AI, where you might want to control a robot's timing without exposing that timing in the text logs, but they warn that you still need to be careful and double-check the time sources, because if the secret signal is wrong, the robot will confidently make the wrong choice.

Technical Summary: ChronoState – Hidden Elapsed-Time Conditioning for Temporal-State Action Selection

1. Problem Statement

Deployed language model (LM) systems often interact with external states where decisions depend on both symbolic task state (e.g., "cache filled," "job started") and elapsed wall-clock time (e.g., "5 minutes ago," "quota reset tomorrow"). In many scenarios, such as defense and security workflows, writing explicit timestamps into the user-visible prompt is suboptimal or risky: it can leak system timing, mix with untrusted text, or be buried in long contexts.

The central research question is whether a frozen-backbone language model can utilize a non-token, system-side scalar representing elapsed time ( $\tau$ ) to compose with visible symbolic state ( $s$ ) for temporal action selection. The paper investigates if this "hidden" time (hidden from the token stream but accessible to model computation) can causally drive deterministic decisions without requiring the model to autonomously track time or replace symbolic controllers.

2. Methodology

2.1 Chronometric Injection (CI) Interface

The proposed interface, Chronometric Injection, encodes elapsed seconds into a continuous feature vector and injects it into the residual stream of a frozen LM backbone.

Time Encoding: Elapsed time $\tau$ is mapped to a 31-dimensional fixed feature vector $\chi(\tau)$ using a sinusoidal-plus-logarithmic encoding:
$\chi(\tau) = [\sin(\tau/T_1), \cos(\tau/T_1), \dots, \sin(\tau/T_{15}), \cos(\tau/T_{15}), \log(1 + \tau)]^\top$
where $T_k$ are specific divisors ranging from 2 to 604,800 seconds.
Modulation: The encoded time vector modulates the residual hidden states $h_\ell$ at transformer layer $\ell$ via gated FiLM (Feature-wise Linear Modulation):
$h'_\ell = h_\ell + \alpha_\ell \odot (\gamma_\ell \odot h_\ell + \beta_\ell)$
Here, $\gamma_\ell$ and $\beta_\ell$ are affine transformations of $\chi(\tau)$ , and $\alpha_\ell$ is a learned per-channel gate.
Initialization: The conditioning projectors are zero-initialized ( $\alpha_\ell=0$ , weights=0, biases=1 for scaling) so that at the start of training, the model behaves exactly like the frozen backbone, avoiding abrupt distribution shifts.
Adaptation: A Rank-8 LoRA surface is applied to attention projections and the language model head to learn the action selection policy over the modulated states. The backbone parameters remain frozen.

2.2 The ChronoState Benchmark

ChronoState is a forced-choice benchmark designed to evaluate temporal-state reasoning.

Task: Given a visible prompt describing symbolic state $s$ and a hidden scalar $\tau$ , the model must select an action from a finite set: $\{ \text{REUSE, WAIT, RETRIEVE, REFRESH, WAIT QUOTA, DEADLINE MISSED, ASK CONFIRM} \}$ .
Families: The benchmark covers six families: Cache (TTL), Job (duration), Deadline (slack), Quota (reset), Staleness (session age), and Multi-constraint (priority composition).
Oracle: A deterministic policy $\pi(s, \tau)$ generates the gold label based on strict rules (e.g., if $\tau \ge \text{TTL}$ , then REFRESH).
Splits: The dataset includes standard test sets and held-out splits for templates, durations (interpolation), compositions (multi-constraint), and families (pure quota, which is excluded from training).

2.3 Experimental Controls

To establish causal dependence on the hidden scalar, the study employs several controls:

No-time: $\tau$ is set to zero.
Shuffled-time: $\tau$ is replaced by the scalar from a different example (keeping the original label).
Prompt Timestamp: Time is written as text in the prompt (hidden $\tau=0$ ).
Conflict: Visible text and hidden scalar disagree.
Baselines: Includes LoRA-only (no time channel), Vanilla (no LoRA), and Prompt+LoRA (trained on textual timestamps).

3. Key Results

3.1 Performance on Standard Tasks

Using Qwen2.5-3B-Instruct as the frozen backbone:

Hidden-time CI: Achieved 0.9305 ± 0.0134 accuracy and 0.9410 ± 0.0103 balanced accuracy on the standard test.
Prompt+LoRA Baseline: Outperformed the hidden-time approach with 0.9893 ± 0.0052 accuracy.
No-Time Control: Accuracy dropped to 0.5511, indicating the model relies on the time scalar.
Shuffled-Time Control: Accuracy fell to 0.3323, with high Wrong-State Consistency (WSC) (~0.91). This confirms the model causally recomputes actions based on the injected scalar, even when the scalar is incorrect.

3.2 Generalization and Limitations

Strong Generalization: The model generalized well to held-out templates (0.9357), durations (0.8375), and multi-constraint compositions (0.8652).
Weak Transfer: Performance collapsed on the pure held-out quota family (0.5065). Although quota logic appeared in multi-constraint training examples, the model failed to abstract the pure quota predicate when isolated.
Conflict Handling: In conflict scenarios, the model strongly followed the hidden scalar (scalar-follow ~0.90) rather than the visible text, demonstrating dominance of the hidden channel but a lack of safe disagreement handling.

3.3 Linear Diagnostics

Linear models using engineered state features plus the time encoding ( $\chi(\tau) + s$ ) achieved high performance (e.g., 0.9230 on standard tests), proving the task is solvable with explicit features. The neural model captured much of this structure but failed to match the linear baseline's performance on the pure quota split.

4. Claims and Significance

The paper makes a narrow, intentional claim:

Feasibility: A hidden, non-token elapsed-time scalar can be causally composed with visible symbolic state in a frozen-backbone LM to select temporal actions under direct supervision.
Interface Utility: The Chronometric Injection interface provides a controllable, system-side channel that can be zeroed, shuffled, or put in conflict with visible text, making it a valuable research object for studying system-state interfaces.
No Superiority: The paper explicitly does not claim that hidden-time conditioning is superior to prompt timestamps (the Prompt+LoRA baseline is stronger).
No Autonomous Tracking: The model does not possess autonomous time perception; it relies entirely on the externally supplied scalar. If the scalar is wrong, the model produces wrong actions.
No Broad Abstraction: The failure on the pure held-out quota family indicates that the model does not achieve broad, unseen-family abstraction for all predicate types.

Conclusion: ChronoState validates a specific architectural pattern for time-aware decision support in secure or constrained environments where time must influence routing without entering the visible token stream. It serves as a benchmark and evaluation protocol for hidden-time conditioning, rather than a demonstration of general temporal intelligence or a replacement for deterministic symbolic controllers.