The freshness problem
Why static context goes stale
Static context — a rules file, a skill, a pinned doc — is read once at the top of the session and then it’s frozen. That’s exactly right for the things that don’t change, and exactly wrong for the things that do.
Staleness isn’t a bug in any particular file; it’s what “static” means. A frozen copy can’t know anything you settle after it’s read, and it gives no sign which of its lines are still true. Unl holds the moving half differently: a decision is current until you supersede it, and the superseded one retires rather than lingering — so currency is a property of the store, not a chore.
What “static” actually means
A static file is loaded at the start of the session and then it’s scenery. Whatever you decide afterwards happens outside its knowledge; it keeps serving the version it held at read-time, with no way to notice the world moved. That property is the whole point for some things and the whole problem for others.
The half that survives freezing
Conventions, mechanics, voice, stack — these rarely move, so a frozen copy stays accurate all session. This is why a file is the right home for them, and why nobody should feel bad leaning on one. A snapshot of something that isn’t moving is simply a good record.
The half that doesn’t
Anything with a present-tense truth-value is the opposite case: which decision is current, where the work stands, what you ruled out an hour ago. The instant you settle something new and don’t stop to edit, the file is wrong — and, worse, it’s read with the same confidence as the parts that are still true. Nothing in a frozen file separates the fresh lines from the expired ones.
Why editing doesn’t rescue it
The fix everyone reaches for is discipline: keep the file updated. But the edit lands after the decision, if it lands at all, and in the gap between the call and the edit the model reads a stale line as gospel. You’re also doing this by hand, mid-flow, for every change — the upkeep grows with exactly the thing it’s trying to track.
What freshness by construction looks like
Unl holds the moving half as structure. A decision stands until you supersede it; superseding retires the old call and installs the new one; the current version is the one served when it bears. Nothing goes stale, because staleness is the absence of a gesture that here is built in. Tuned for Claude, Claude Code, ChatGPT & Cursor at launch, extending across the AI ecosystem. Connects anywhere MCP does.
Static context is frozen at the moment it’s read, so conventions stay true and decisions go stale; a layer that supersedes on your word keeps the moving half current — so the answer comes back measured against what you already decided, and why.
Reads through Unl arrive with measured context — in the presence of the decisions you’ve already settled. The reach lane is live: one box, paste anything. If it speaks MCP, Unl can reach it. Readings arrive unprompted, the data beside the criterion; Unl is a courier, not a warehouse, and keeps only your keys and the frame.
Read further
Questions people ask
Why does my AI context file keep going out of date?
Because it's static: read once at the start of the session and frozen. It holds what you last wrote, so any decision you settle afterwards isn't in it — and the file gives no sign which lines are current and which have quietly expired.
Do conventions go stale too?
Rarely — that's why a file is the right home for them. Conventions, commands and style change slowly, so a frozen copy stays accurate. It's the present-tense things — current decisions, live state — that decay between edits.
Can't I just keep the file updated?
You can try, but the edit always trails the decision, and often never happens mid-flow. A layer that supersedes on your word removes the discipline problem: the current call is current by construction, not by remembering to overwrite a line.
Isn't this the same as AI memory?
No — memory recalls what was said; this is about which decision stands now. Freshness here means the superseded call retires and the current one is served when it bears, not that more of your history is stored.
What this is
Think inside your AI world — you stay in command
Unlimitless (Unl to friends) holds what you've settled, reads what your tools are showing, and catches what's changed out in the world — and hands your AI whatever bears on the work, the moment it's needed, without you asking. The right thing, in front of the model, unprompted, with you in command of the call. So you keep moving toward what you set out to build, on top of everything you've already decided.
It plugs into Claude, Claude Code, ChatGPT and Cursor as an MCP connector. Quick to connect, in a couple of steps.
Unlimitless is open now to invited Alpha. Apply for the Beta waitlist to come in ahead of the full launch:
Alpha is invite-only · free at launch.