A situation we handle
Claude Code keeps losing context between sessions
Close the session and the context is gone — the thread, the decisions, the reasons. Next time you rebuild it by hand. But the part worth keeping was never the transcript. It was the decisions.
You’re re-establishing the same ground every session. Unl keeps the decisions that ground the work — each with its reasoning — and serves the relevant one into Claude Code’s context unprompted, the moment it bears. No transcript to reload, no re-explaining. You stay in command; free at launch.
The transcript isn’t the context worth keeping
It isn’t a memory problem to solve — it’s a missing inheritance.
It’s tempting to want the whole conversation carried over. But you don’t think in transcripts, and neither should the model start there. What actually governs the next session is a short list: the calls you settled and why.
So the answer to losing context isn’t a bigger window holding more of what was said — it’s carrying the decisions forward, so the model inherits what stands rather than replays what was typed.
Inherited, at the step it matters
Served when relevant — not reloaded up front.
Unl doesn’t dump last session back into the window. It serves the decision that bears on this step, unprompted, when it bears — so Claude Code builds from what you settled without carrying the weight of the whole history.
How it works
Connect once. From then on, what you settled arrives on its own.
1 · Connect. Add the MCP connector in a couple of steps, about five minutes. It plugs into Claude, Claude Code, ChatGPT & Cursor as an MCP connector.
2 · Settle a decision. When you make a call, it’s held with its reasoning — on your word, never scraped. Change your mind and it’s superseded, the old one retired.
3 · It arrives unprompted. Next session, the decision that bears on the work is served into the model’s context the moment it’s relevant — you don’t fetch it, and you don’t re-explain it. The model inherits what you decided and builds from it.
Questions people ask
Why does Claude Code lose context between sessions?
The session's working context isn't persisted, and a fresh one starts empty. But the fix isn't hoarding the transcript — it's carrying the decisions the work runs on. Unl holds those with their reasoning and serves the relevant one unprompted, so the next session inherits what stands.
Won't a bigger context window solve this?
A bigger window holds more of what was said; it still can't tell a settled decision from a passing mention. Inheriting the decision itself — with its why, served when it bears — is a different and more reliable unit than replaying more transcript.
How does Unl fit into Claude Code?
It's an MCP connector — about five minutes to add. Your settled decisions are then served into Claude Code's context unprompted, at the step where they matter, and the same set carries across Claude, ChatGPT and Cursor.
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.