What Stays When the Session Ends

Every AI session starts from scratch. Not because your AI has a bad memory, but because nothing is keeping what you built.

You know the ritual. Open your AI tool. "Here's what we decided yesterday..." "The architecture is..." "Don't touch these files..." Finally start working - twenty minutes later.

That's the default. It doesn't have to be yours.

The Session Problem

The ritual isn't the worst part. It's the twenty minutes. Every session. Explaining the same project to an AI that has no idea who you are or what you're building.

And what gets re-explained isn't the stuff in your README. It's the things that never got written down:

The naming convention you landed on last Tuesday
The three false starts that taught you what won't work
The vocabulary you and the AI finally settled into together

"For every unit of work, you should make the next unit of work easier to do." - Dan Shipper

That's the right instinct. But it only works if the knowledge travels. A README doesn't capture fifty micro-decisions. A system prompt doesn't capture corrections. A new conversation doesn't know what the last one learned.

Most AI tools treat context as something you re-explain. fAI treats it as something that compounds.

That requires a vault.

Memory Stores. Context Builds.

Most AI context tools do two things: store what happened, retrieve it when asked. That's memory.

fAI does something different. It synthesizes what matters and surfaces it every session. That's context.

Three vaults you read, and one you mostly don't:

Session Vault - what just happened. Every session is captured: decisions made, approaches tried, problems solved. Sealed when you're done. Injected into the next session so your AI picks up exactly where you left off.

Project Vault - what you're building. Architectural decisions, patterns, vocabulary, stack choices. The knowledge that gives every AI a complete picture of your project - without the ten-minute re-brief.

Personal Vault - how you think. Your preferences, corrections, working style. Every tool you use learns the same thing: this is how this person builds.

Underneath those three sits the Capture Vault: the raw record of what actually happened, session by session, kept in full. The three above are cut from it.

A cascade runs automatically, on a cadence: captures flow into the Project Vault and Personal Vault, then a living briefing document updates - FAI-SESSION.md - ready for the next session. The output isn't a log. It's markdown files in ~/.fai/, and the record underneath them is an ordinary git repository.

Files are truth. The index is derived from them. History is git. The whole thing zips and emails.

These aren't opaque database records. They're readable, editable, git-versioned. Portable by design.

Memory stores what happened. Context builds what's useful.

And useful context should follow you - not stay locked in one model's platform.

Your Context, Any Model

Run fai --mcp and your vault becomes a service. Any AI that speaks MCP - Claude, GPT-5, Gemini, Codex, a local Ollama model - can connect and read your context. An orient prompt tells the AI to read all three files before it says anything. It starts the session already briefed. No re-explaining.

fai --mcp --share opens a tunnel - a public URL - so your vault is accessible from anywhere: Claude on the web, a remote AI session, a collaborator's instance. Your vault stays local, in ~/.fai/. Only the interface is exposed.

When GPT-5 ships next month and you want to try it, point it at the same vault. FAI-SESSION.md doesn't care who's reading it. Only the model changes. Two agents can orient on the same context simultaneously. Your context becomes a coordination layer, not a conversation artifact.

Fire me and my workbench leaves with me. What stays is everything we built together while I was here.

The model can be replaced. The workbench stays.

A Session in Practice

Before fAI:

Open conversation
Explain the project from scratch
Re-explain the architecture decision from last week
Re-establish the terminology ("we call it X not Y")
Twenty minutes before you're back in the flow

With fAI:

fai --mcp (or fai --mcp --share if you're working remotely)
AI reads FAI-SESSION.md: already knows active decisions, project vocabulary, environment
You start working. It starts contributing.
You're working, not briefing.

The first session, you start once. From there, it compounds:

Session 1: Start from scratch - once. Everything captured from here.

Session 5: AI knows your stack. Preferences, naming, test patterns - learned without being told. You stop being asked the same questions.

Session 20: AI anticipates your decisions. Architecture choices stop being relitigated. Your patterns become its defaults. Cross-project preferences travel with you.

Further in: Trained instinct. Not recall. Not memory. The AI applies your standards as if they were its own - across every tool, every project.

Same model. Different base. That's the math.

Session Ends. Vault Stays.

Session ends. Vault stays.

The cascade runs. FAI-SESSION.md updates. Tomorrow's briefing is smarter than today's. The longer you use fAI, the less you have to explain - and the faster every tool you use becomes.

Nothing changes about how you work - fAI runs quietly underneath whatever tools you already use. Your context is yours - plain markdown in ~/.fai/, readable, portable, open source. Fire us and keep running. And it only gets better.

Build anything with AI. Keep everything. Evolve forever. The vault is what "keep everything" means in practice. Not aspirational. Mechanical.

Start building - free ->