Time in Environments

What it is

How an environment decides what time it is, what moves the clock, and how the agent and its harness find out. Survey of 2026-09-10 (web plus the itsmbench-core repo), prompted by the V2 design question: ITSM work is time-shaped (SLA clocks, business calendars, wait-user aging, change windows), but V1 pins one instant per task and never moves it.

Where V1 stands. The world carries a FrozenClock resolved from the seed’s _now (override ITSM_CLOCK), every handler stamps from it, and no code path reads the wall clock. SLA timers are computed against that instant at write time, so an SLA can only breach if it was already past due when the world was seeded, and a paused clock is the only SLA state that changes during an episode. The agent is told the date nowhere: not in instruction.md, not in ENVIRONMENT.md, not in an env var. The only signals are the frozen HTTP Date header on every response, timestamps inside records, and a token-gated /health endpoint. Two tasks (iam-16, sn-ops-5) need “now” and assume the agent infers it from that header. Multi-turn journal rows all share one author and one timestamp, so a conversation has no temporal order in world state. The seed-gen and policy-gen worktrees do better: seed-gen builds an as-of-T world with a leak audit (nothing after _now, business hours 08:00 to 18:00 Mon to Fri), and policy-gen tells the policy author “The current time is X” because “a corpus with no anchored now cannot state a decidable rule about elapsed time”. The agent gets no such sentence.

Six designs in the literature.

Pattern	Who	How “now” reaches the agent	What advances it	What it lets you test
Frozen clock	Tau-Bench, Tau2-Bench, AppWorld, AgentDojo, CRMArena-Pro, ITSMBench V1	a policy line (“The current time is 2024-05-15 15:00:00 EST”), a get_current_day tool (AgentDojo: “the assistant should not assume what the current date is”), process-level freezegun so datetime.now() lies (AppWorld, per-task datetime), or a [TODAY] placeholder in the query (CRMArena)	nothing	date arithmetic against static records; deterministic verifiers
Real clock over frozen data	WebArena, OSWorld, WorkArena, TheAgentCompany, EnterpriseOps-Gym	the OS or live instance	wall time	nothing temporal; WorkArena disables every relative-time dashboard filter as “not stable” and pins an install-time cutoff
Real clock with dynamic verifiers	MCP-Universe, Toolathlon	live tools	wall time	live tasks; the verifier re-derives ground truth by reference execution instead of a static key
Action-cost clock	TimeArena, Vending-Bench, Robotouille	narrated duration (“it will take 9 minutes”), morning digest	each tool call costs a duration (5 min to 5 h in Vending-Bench); delayed effects via timers	multitasking, efficiency per simulated minute, long horizons (a 365-day business in an afternoon)
Explicit-advance clock	Vending-Bench (wait_for_next_day), ARE/Gaia2 (wait, wait_for_next_notification)	get_current_time tool	the agent chooses to wait; the sim then jumps event to event	patience, scheduling, deadline compliance
Tick clock	Generative Agents (10 s per step), OASIS (3 min per step, probabilistic per-agent activation), Concordia (multi-interval gearbox: hours for days, minutes for conversations)	formatted time in the prompt and in memories	the engine, every round	population dynamics, multi-agent simulation
Event-driven clock	ARE/Gaia2, SentinelBench, discrete-event simulation (AgentSimulator, Prosimos, SimPy)	events arrive when their scheduled time passes; agent queries or waits	next-event time advance; resource calendars; duration distributions fitted from logs	reacting to a world that moves without you; SLA-style deadlines

Two hybrids worth knowing. ARE runs the clock in real time while the agent thinks and switches to event-to-event when it waits, so latency becomes a capability: Claude 4 Sonnet’s Time score goes from 8.2% to 26.7% when actions are made instant. ITBench and AIOpsLab run real Kubernetes and score mean time to diagnose and repair, which is faithful and slow and non-reproducible.

Lessons that transfer.

• Frozen clocks win wherever a deterministic verifier matters, and every one of them still states “now” to the agent in prose or through a tool. V1 is the outlier that does neither.
• Time becomes a capability under test only when something moves it. For ITSM the natural mover is event-driven: the operator replies at a simulated time, an SLA breaches at a simulated time, a colleague reassigns at a simulated time. AgentSimulator already discovers arrival distributions, per-resource calendars, and activity durations from a BPI-style log, so the clock model can be fitted, not invented.
• Do not charge inference latency to the clock in an RL environment; it conflates model speed with competence (the ARE ablation). Turn-based advance with per-action costs keeps training reproducible.
• Verifiers that touch time need tolerance: LOGIGEN excludes timestamps from the state diff; Gaia2 scores actions inside a window around the oracle’s time.
• Models do not reliably believe a stated date. “Can Prompts Rewind Time” finds prompted dates work for direct queries and fail for causally related knowledge; forcing the model to state the date before reasoning helps. AgentDojo’s tool and the cluster of get_current_time MCP servers exist for this reason.

How the harness sees world time (Claude Code case). Claude Code writes today’s date into the uncached tail of its system prompt from the host clock in UTC, and a second copy sits inside the WebSearch tool description. No setting overrides it (issue 8316 closed as not planned). Bash runs a real shell, so date, file mtimes and any script read the container clock. Levers, from weakest to strongest:

1. Belief layer: put the world time in instruction.md and ENVIRONMENT.md, restate it with --append-system-prompt or a SessionStart hook, and expose a get_current_time operation on the world API. Instruct: “world time differs from wall time; trust the API”.
2. OS layer: libfaketime preloaded in the agent container with start-at format (FAKETIME="@2026-07-18 09:00:00", FAKETIME_DONT_RESET=1, FAKETIME_DONT_FAKE_MONOTONIC=1 for Node). Then Claude Code’s own date line, date, and Python all agree with the world. Caveats: bypassed by static Go binaries and vDSO paths; Linux time namespaces do not help because they never virtualise CLOCK_REALTIME; Docker cannot set a per-container date; only gVisor or a QEMU guest with -rtc base= owns a real clock.
3. World layer: keep the injectable clock the world already has, add a control endpoint to advance it, and drive both the API and the container’s FAKETIME from one value. No major harness (Terminal-Bench, SWE-bench, OpenHands, Inspect, METR) pins the clock; they pin image digests. This is infrastructure V2 would own.

Proposed V2 design (not yet decided). Keep the frozen clock for single-shot tasks but tell the agent the time (instruction plus get_current_time). For the multi-turn and team tracks, make the clock event-driven: each operation costs a duration drawn from BPI activity timings, simulated actors respond at scheduled simulated times, SLA timers are re-evaluated against the moving clock, business hours come from the log, and the agent gets wait_for_next_event. Verifiers compare timestamps with tolerance. Run the agent container under libfaketime seeded from the same _now so Claude Code’s date, the shell, and the API agree.

(agent-drafted from a web and repo survey, not yet reviewed)

Key sources

• Tau-Bench — “The current time is 2024-05-15 15:00:00 EST” as the first line of the airline policy; retail carries time only in order timestamps
• Tau2-Bench — telecom pins 2025-02-25 12:08:00 EST; contract, suspension and extension dates make policy checks into date arithmetic
• AppWorld — per-task datetime, freezegun at the API server so datetime.now() returns the task date; latency timers must bypass the freeze
• AgentDojo — current_day as environment state surfaced by a get_current_day tool with the rationale in its docstring
• CRMArena-Pro — “Today is [TODAY]” in the query plus explicit definitions of quarter, season and “past 2 quarters”
• AgentSimulator — discrete-event clock with arrival distributions, per-resource calendars and durations discovered from the log; the fitted clock model for V2
• WorkArena — relative-time reports disabled as unstable; install-time cutoff stored as a sys_property
• TheAgentCompany — dates hard-coded per task; notes agents’ “lack of temporal grounding”
• EnterpriseOps-Gym — no clock design found in code or README; seeded fixed timestamps under a real container clock (weak evidence)
• ITBench — real clock, mean time to diagnose and repair as scores
• LOGIGEN — timestamps excluded from the state diff

Related

• ITSMBench — the design question this page answers
• User Simulators — simulated actors are what make an event-driven clock necessary
• Enterprise Environments, Benchmark Validity, WorldSmith
• Code: environment/src/core/clock.ts, services/servicenow/lifecycle.ts (SLA), world-gen/seed-gen/mappings.py (as-of-T window), world-gen/policy-gen/stages/org_model.py (world_window)

To ingest

• Vending-Bench https://arxiv.org/abs/2502.15840 — per-tool time costs plus wait_for_next_day, 222 simulated days
• TimeArena https://arxiv.org/abs/2402.05733 — action durations, occupying vs. non-occupying actions, efficiency scoring
• ARE and Gaia2 https://arxiv.org/abs/2509.17158 — event-driven async simulation, wait tools, Time capability scored with tolerance windows, instant-mode ablation
• SentinelBench https://arxiv.org/abs/2606.05342 — scripted event playback, reaction time and resource use
• Robotouille https://arxiv.org/abs/2502.05227 — delayed effects via timers
• AsyncTool https://arxiv.org/abs/2605.27995 — delayed tool feedback and concurrent tasks
• OASIS https://arxiv.org/abs/2411.11581 — 3-minute ticks with hourly activation probabilities from real users
• Concordia https://arxiv.org/abs/2312.03664 — GameClock and MultiIntervalClock gearbox
• Generative Agents https://arxiv.org/abs/2304.03442 — uniform tick, hour-by-hour plans against curr_time
• MCP-Universe https://arxiv.org/abs/2508.14704 — dynamic evaluators for temporally sensitive tasks
• Toolathlon https://arxiv.org/abs/2510.25726 — snapshot-or-reference-execution verification
• DynaSchedBench https://arxiv.org/abs/2605.27566 — LLM policies inside a discrete-event engine with immutable snapshots per decision epoch
• Can Prompts Rewind Time for LLMs https://arxiv.org/abs/2510.02340 — prompted cutoffs fail on causally related knowledge
• Can LLMs Be Constrained to the Past https://arxiv.org/abs/2606.05804 — self-recall of the date before answering improves adherence
• Non-arxiv: Prosimos (resource calendars in BPS), libfaketime README https://github.com/wolfcw/libfaketime, Claude Code issues 4514, 5443, 8316