Context anxiety

Term coined by Craig Brown, 2026-04-13.

Context anxiety (n.) — the fear of closing an AI session because you’ll lose everything it has learned. Like range anxiety with electric cars, but for AI context windows.

Everyone using AI tools feels it. Most people have never named it. This page names it, and explains how CTXone — a self-hosted context engine — makes it go away.

• Keeping four or more sessions open because each has different accumulated context.
• Dreading the “session compacted” notification.
• Spending the first ten minutes of every new session re-explaining your project.
• Copying context between sessions by hand.
• Feeling like an AI “forgot” you.
• Not wanting to start a new session because “this one knows my project.”

If any of those land, you have context anxiety. It isn’t a discipline problem — it’s a missing-infrastructure problem.

You have several sessions open, each with different project context. You can’t close any of them, because the context evaporates on close. The model learned your codebase, your preferences, your project status — and it’s all trapped in a volatile window.

What CTXone does: every session commits what it learns to a durable graph. Close a session, open a new one, and it loads only the relevant context in seconds. Nothing is lost. Close sessions freely — the knowledge lives in the graph, not the window.

Some sessions seem sharp and produce great work; others struggle with the same task. The difference is invisible — you can’t see what context a session holds or why it’s underperforming. Every new session is a lottery.

What CTXone does: every session draws from the same knowledge base, so quality is a function of loaded context, not luck. Because context comes from a structured, ranked graph — not an unstructured memory file — recall is consistent. Pinned facts are always present; primed facts are pulled in when relevant.

Today you have no reliable way to see what an AI session knows. Memory files are black boxes: you can’t tell what the agent remembered, forgot, is confident about, or is guessing at — and when it errs, you can’t trace why.

What CTXone does: open Lens, the web UI, and browse every fact the agent stored, with confidence scores, timestamps, and blame chains. Search across all memory. ctx blame traces a fact to the tool, user, and session that wrote it; ctx why-did-we reconstructs the reasoning behind a decision before anyone reverses it. The agent’s mind is a browsable, auditable graph — not a black box.

You want a large context so a session is “smarter” — more history means better understanding. But it’s self-defeating:

• More context means more tokens per message, and higher cost.
• More context means slower responses.
• Most of that context is irrelevant to the current question.
• The conversation grows until it hits the window limit and compacts.
• Compaction loses the important along with the unimportant.

CTXone breaks the paradox: the agent loads only what’s relevant — often a few hundred tokens instead of thousands — so it’s simultaneously smarter, cheaper, and faster. Every recall reports the live savings ratio, so the win is measurable, not a claim. See Token savings for the math.

Curing context anxiety is the first thing CTXone does, but the same graph that remembers facts also holds plans that survive plan rot, branches for speculative context, taint gates on sensitive paths, and provenance for every write. The anxiety you feel about losing context is the same anxiety you feel about trusting it — and CTXone answers both.

• Vision — the structural problem and the product.
• Use cases — where a context engine earns its keep.
• Features & commands — the full six-primitive tour.