A situation we handle
Claude Code forgets my decisions
You settled it last session — the approach, the constraint, the thing you ruled out. Today it's gone, and you're explaining it again. That's not a weak model. It's a missing inheritance.
You’ve started, and you’re stuck re-explaining yourself. Unlimitless (Unl) holds each decision you make with its reasoning and serves the relevant one back the moment it bears on the work — so Claude Code works from the call you already made, unprompted. It’s just-in-time context; you stay in command. Free at launch.
Memory isn’t the fix
It isn’t a memory problem to solve — it’s a missing inheritance.
A memory of your chats would recall that a decision came up. That’s useful, and it isn’t the gap here. What Claude Code is missing is narrower and more important: the decision you settled, the reasoning that carried it, and it being in front of the model at the step where it matters.
So the honest frame isn’t “stop it forgetting” — it’s give it something to inherit. A settled decision with its why, carried into the next session, is a different unit from a remembered conversation.
What changes when the decision is inherited
The model builds from your call instead of re-deriving its own.
Hand a reasoning model a bare conclusion and it re-derives — a no without a why is a yes, and it re-opens what you closed. Hand it the decision with the reasoning and it holds the line: it inherits how you got there and builds forward, at full speed on the mechanical work.
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 forget my decisions between sessions?
Each session starts without your settled decisions in front of it — not because the model is weak, but because nothing is carrying that context forward. A rules file holds conventions; it doesn't hold the decisions you made and why. Unl does: it serves the relevant settled call, with its reasoning, unprompted when it bears on the work.
Isn't this just a memory feature?
It's a different unit. Memory recalls what was said across your chats; Unl carries what you settled — the decision with its reasoning, superseded when your thinking moves. The model inherits your call rather than being reminded a topic came up.
How do I set it up on Claude Code?
Add the Unl MCP connector — about five minutes. From then on your settled decisions are served into Claude Code's context unprompted, at the step where they bear. It also works across Claude, ChatGPT and Cursor over MCP.
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.