What Stays When the Session Ends
Every AI session starts from scratch. fai remembers.
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, surfaces it every session. That's context.
Three vaults. Three layers of what you've built and who you are:
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.
Every sixty seconds, a cascade runs: 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 three markdown files in ~/.fai/.
"Files are truth. Index is derived. History is Git. The whole thing zips and emails." - Michael Gearhardt
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.
"When you fire me, you know what leaves your studio too? My workbench. But you know what didn't leave? All the things that my workbench evolved." - Mike Gearhardt
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(orfai --mcp --shareif you're working remotely)- AI reads FAI-SESSION.md: already knows active decisions, project vocabulary, environment
- You start working. It starts contributing.
- Three seconds, not twenty minutes.
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.
Session 50: 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.
The Invitation
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.
Read more: You Hired Me. You Also Hired My Workbench. →