Every decision remembered. Every judgment learned. Every mistake caught — before it ships. Xpansion isn't a tool Claude Code reaches for. It's the platform Claude Code runs on. Install it once. It gets smarter every session, for as long as you build.
Connect with GitHub — it's free See how it works →7-day free trial — full Pro · Founding Pro: $15/mo (first 250) · Pro: $29/mo · Team: $34/seat/mo
It's not a skill problem. It's a structural one. The model is powerful — but it doesn't remember what you decided, doesn't learn your judgment, and doesn't catch its own drift. It has to.
Claude reports success. The output looks right. Three steps later, something is broken — or missing — and tracing it back costs more time than the original task. There was no checkpoint. There was no verification. There was just trust.
Nothing in the model knows what depends on what. A change lands. Something else breaks. Fix that — break another. Fix that — break yet another. This is whack-a-mole with your own codebase, and there's no natural exit unless something outside the model is tracking the connections.
The decision you landed on. The tradeoff you reasoned through. Why you chose this approach. Gone. Tomorrow you start from the beginning — not from where you were. Every session starts at zero, for as long as you use the tool.
Xpansion was built by someone who lived this — not an observer diagnosing from the outside, but a builder inside the loop. The frustration isn't unique to developers. It belongs to anyone building real things with AI: products, content, systems, decisions. Powerful tools. No accountability layer. Until now.
This is built for them.
XFFI defines your intent as a finite, verifiable spec before work begins. XFXA checks every terminal before you ship. You stop guessing and start knowing.
XFFI's discovery phase asks the questions about your brief that you didn't know to ask. Boundaries surface before work begins — not after something breaks.
XFMT builds a memory tree that compounds across every session. Every decision, every context, every tradeoff — searchable, permanent, always carried forward.
XF started in code. It didn't stay there. The thesis — code enforces what the LLM can't be counted on to do alone — applies anywhere AI is doing structured work. The four session modes map to any domain.
Implementation, debugging, refactoring. Contract violations caught before they land. Blast radius mapped before you commit.
Writing, product definition, design. Intent defined as deliverables. Verified against what was actually produced.
Research, architecture, strategic analysis. Design decisions formally specified. Grounded in verified data, not inference.
Deployment, configuration, incident response. System state verified. Changes tracked against intended configuration.
The only limitation is the scope of what you're trying to accomplish.
Intent defined. Execution enforced. Delivery verified. Memory compounded. Six categorizations feed the platform — every module lives inside one.
Four gates: three on every code edit (contract violations, cascade impact, security exposure) and one on every response (plain language, actionable, recommendation-first).
See the gates →An organic memory tree that compounds across every session, retrievable semantically, self-reconciling, learning your judgment over time.
Explore the tree →Finite MECE specs before work begins. Binary terminal verification before work ships. No more "I think it's done."
See how it works →Dispatch scans 16,500+ MCPs, plugins, and skills in real time, routing by AI intent detection so you never default to the wrong tool.
See routing →Real-time context hygiene: 60% compact nudges, 85% enforcement, token-hog detection. No silent compaction. No lost work.
See XFTC →Stated purpose in, ranked shortlist out — weighted by quality, cost, latency, and capability against eight independent evaluators. Hosted MCP endpoint, one-line install.
See XFMS →Other Claude Code frameworks give Claude more skills. More things it can reach for. XF is the layer between you and the mistake — the enforcement, the routing intelligence, and the memory that compounds.
Other frameworks surface a fixed skill catalog. XF routes across 16,500+ MCPs, plugins, and skills using AI intent detection — matched to your task and your stack, on every shift, without you asking.
XFBA catches code contract violations at edit time. XSIA maps what else breaks before you commit. Other tools help you ship faster. XF ensures what you ship doesn't take down something else on the way out.
XFMT builds an organic memory tree — each concept finds its branch, decisions surface with temporal precision, contradictions flagged automatically. Every session makes the tree smarter. Nothing is ever lost.
Most AI tools add capabilities. Xpansion Framework adds structure — the missing layer between AI-generated output and verified execution.
Every session begins with a defined boundary — what this task is, what it touches, and what it must not break. XFBA and XSIA enforce the edges. The AI doesn't guess where the walls are. They're defined.
From every change, XF maps every branch — every caller, every dependency, every downstream effect. Not a static checklist. A live graph that updates as Claude Code works, surfacing what you didn't know to ask about.
Nothing ships without a terminal — a binary, verifiable outcome that defines what done actually means. Not a feeling. Not a test that passed once. A finite result, enforced by XFXA before every commit.
This is the structure that makes Human-to-AI communication reliable at scale. Boundaries contain the blast radius. Recursive discovery surfaces what's hidden. Terminals replace assumption with verification. Together, they make Claude Code something you can deliver with confidence — not just speed.
XF enforces intent. It doesn't care what domain that intent lives in.
"I finally shipped without second-guessing it. XFXA said 9 of 9 terminals met. That was my sign-off."
A founder building their first product. XFFI defined every deliverable before a line was written. XFBA caught violations at edit time. XFXA confirmed everything before push. No more "I think it's done."
"I briefed Claude on a 12-piece campaign. Two weeks later, every deliverable traced back to the original brief — not what felt right in the moment."
A marketer running a product launch. XFFI scoped the campaign before Claude wrote a word. XFMT carried the brief across every session. Nothing drifted.
"Every claim in the report was traceable to data we actually had. XFFI wouldn't let a terminal reference anything we hadn't confirmed."
A researcher synthesizing a complex analysis. Roots grounded the spec in real data sources. No hallucinated citations. No drifting into inference. Grounded work from the first terminal.
"Nothing advanced until the previous phase was confirmed. We ran a zero-downtime migration across three environments with no surprises."
An ops team running a critical production deployment. XFFI defined the phase gates. XSIA mapped what would break if sequence was violated. Every step earned the next one.
These are four worlds. The enforcement is the same in all of them. XF doesn't know what you're building — it only knows how to make sure you delivered what you intended. The scope of what it can enforce is bounded by exactly one thing: your vision.
Every module is both a service and a sensor. What the platform catches, what you approve, what you override — all of it becomes training signal for the next release. Not a snapshot. A living system.
Every approval and override trains a per-rule confidence score. Once a pattern earns trust, it auto-applies. The guardrails fade where they don't need to fire — without losing the enforcement where they do.
Anonymized signals from every install — which prompts converge, which rules false-positive, which resolutions earn approval — feed back into the next platform release. You benefit from everyone else's sessions, even the ones you'll never see.
The platform you installed last week is quantitatively better today. Module thresholds retune. Prompts sharpen. Heuristics learn. Static AI tools ship once and rot. XF closes the loop between what happens in your session and what ships in the next release.
Full Pro access for 7 days. After that, subscribe or we stop — no reduced free tier, no ads, no surprises. Clean uninstall available anytime.
/dispatch-uninstall in Claude Code for a clean removal. Your project .xf/ folders and XFMT snapshot history stay on disk — your data, your call.git clone https://github.com/XpansionFramework/Dispatch && cd Dispatch && ./install.sh
Takes about two minutes. Start a new Claude Code session after install.
Code, content, research, deployment — XF enforces the full contract, whatever you're building. One install. Every session. Automatically. The ceiling is yours.
Connect with GitHub — it's free