Context needs an explicit time-to-live

What it is

In the kitchen, “the usual” is taken as the oat latte from three minutes ago; the next morning the same words are, on some products, yesterday’s order, and on others a sentence never heard. Nothing in the signal tells the user which rule is in force. An explicit context TTL requires that objects and slots in common ground have a learnable lifetime: how long “that one again” is legal, and which pointers die past that line. The lifetime is a contract, not a side effect of an internal cache. It governs whether an object still counts as present, not how long to wait before nudging — nudging is a different policy.

Why it happens

People treat the most recent task as the default topic until a perceptible boundary closes it: leaving the room, starting another conversation, overnight. Systems that approximate those boundaries with process lifetime, a wake session, or a fixed thirty seconds let the two clocks drift. TTL too short, and a legal anaphor is treated as a new intent — the system feels forgetful. TTL too long, and yesterday’s address is written onto today’s delivery — the system feels presumptuous. Lifetime should also layer by object type: an order being filled is short; a home address the user set on purpose is long; a one-time code is almost this-turn only. Cramming every slot into one session clock dirties the short ones and drops the long ones. The contract has to be explicit because lifetime is invisible — unlike a form on a screen, which is gone when the window closes.

Studying it

Use delayed probes: after an object is introduced, at 10 seconds, 2 minutes, after a session break, and the next day in the same scene, have people say “that one again / the same.” Independents: kind of interval (time inside continuous talk, session boundary, calendar day) and object type (this-turn order versus long-run preference). Dependents: rate of acting on the old object, rate of treating it as a new task, and whether people can afterwards describe “did you think it would still remember.”

On logs, bin anaphoric turns by time since last mention. A bin where successful binds collapse, with no matching expiry behaviour in the product, is TTL breaking in the dark. Labs that never split a session only ever measure “still in the same stretch,” and overestimate how long context can be held.

Where it stops holding

Medical and payment objects have legal and safety lifetimes; the product clock must be shorter than or equal to that hard limit, and must not extend it because “the user might still be talking.” On a shared device, the previous person’s context has zero life for the next person; TTL is cut at identity switch. Experts at a fixed workstation form very long defaults (“yesterday’s line still”); a short TTL injures those, which means promoting such objects into named, inspectable preferences, not stretching the clock on this-turn orders. Even a clear TTL will have disputed edges — those belong in settings or first-use explanation, not in a wrong execution.

Applying it

• Write separate TTLs for this-turn task objects, session-level objects, and long-run preferences, with different expiry actions in state (drop, demote to a recoverable draft, keep).
• Make the lifetime learnable in one hearable move: at session close, “I won’t keep this order for next time,” rather than letting people probe with “the same.”
• After expiry, neither silently reuse nor pretend there never was an object; once the clock has run out the loss still has to be spoken, but that is a further move — here the job is that the clock is written down.
• How to check: the same “that one again” just after the task, two minutes later, after a wake, and overnight. If the four outcomes do not match the written TTL, there is no contract.

Related

• Same group: M1.04.1 Anaphora has to bind to a prior discourse object · M1.04.3 Lost context must be announced, not silently reset
• Nearby: M1.09 Context Retention and Reference Resolution · M1.12 Opening and Closing a Dialogue · M2.07 Dialogue Flow and State Design
• Search terms: explicit context TTL · discourse recency · session context lifetime