Your agent can read every line of your code. It still can't tell you what you decided not to build, or why.
None of it lives in your repo. Or your chat history.
Brain OS holds the part that was never written down.
Local-first by default. No setup. Your data stays on your machine.
Works natively with
One memory across every AI
Tell ChatGPT a decision on your phone; Claude knows it at your desk. Brain OS is the shared memory across your AI tools. Start in a chat, or in your editor.
Brain OS is coming to ChatGPT, Claude, and Grok. One memory across AI tools. Access your projects, decisions, and ideas from any device. Start something in Claude at your desk, pick it up in ChatGPT on your phone.
Early access, onboarding in small batches.
Claude Code, Cursor, Zed, and any MCP client. Local-first, your data stays on your machine. Install in seconds, no account needed.
Your agent knows your code.
Brain OS makes it know your project.
Same question. Same code. One agent buries you in technical detail and aims at the wrong thing. The other tells you plainly what matters.Example: Sendly, a made-up app for sending money to family abroad.
Investor demo is Friday. What should I build next?
Scanning the repo. src/payments/ is scaffolded but the charge flow is unimplemented, the payout_state_machine test is skipped, and there's no webhook handler for transfer.completed. Three TODOs left in ledger.ts. That's the biggest area of unfinished code, so I'd build the payments module next: wire the transfer intent, finish the state machine, add the webhook, then un-skip the test.
✕ Sounds competent. Hard to follow, and aimed at the wrong target. You decided weeks ago to leave payments for later. It just pointed you at the one thing you'd agreed not to do, two days before the demo.
Investor demo is Friday. What should I build next?
Don't build payments. You decided three weeks ago to leave that for later, and your plan still says so.
The real problem is the demo itself: it shows someone splitting a $12 dinner bill, but Sendly is for people sending money home to family. Investors will see a toy, not your pitch.
Your code is basically ready. Fix that one example and you're set for Friday.
✓ Plain and clear. It knew the decision you'd made, skipped the busywork, and caught what would have sunk the demo.
AI agents are becoming operators.
Operators need memory.
Not chat memory.
Operational memory.
Get started in 30 seconds
Initialize
npx brain-os initCreates a .brain/ directory in your project. Brain OS auto-discovers it from any subdirectory, no path config needed.
Connect to Claude Code
claude mcp add brain-os -- npx brain-os serveOr any MCP client
{
"brain-os": {
"command": "npx",
"args": ["brain-os"]
}
}Brain OS doesn't store conversations.
It tracks what actually matters.
Know what to do next
Not a to-do list. Operational judgment. What matters today based on urgency, blockers, and what's already in motion.
Decisions, with pushback
Every decision logged with reasoning and rejected alternatives. Your agent surfaces conflicts before you commit.
Public work keeps deferring.
See what keeps slipping
Compare what you planned against what shipped. Spot the work that appears every session but never moves.
exactly where you left off.
End clean, restart instantly
One command captures everything that changed across every project, a restart-ready handoff for the next session.
Just ask.
Your agent already has the context. No re-explaining.
Your project state, preserved
This is what your agent sees when it connects. Not chat history, operational state.
Same .brain/ folder. Different day, different tool, full context.
- ✓ Claude Code
- ✓ Cursor
- ✓ Zed
- ✓ Windsurf
- ✓ GitHub Copilot
What your agent can finally do
entity_read
Know what you're working on
Projects, blockers, momentum. Your agent understands the state of your work without you explaining it again.
decision_log + decision_check
Decisions, with conflict checking
Log what you decided, why, and what you rejected. When the next decision conflicts, decision_check surfaces it with the original reasoning, so your agent pushes back instead of yes-anding.
pattern_detect
See patterns over time
Recurring blockers, loops, avoidance. Your agent notices what you don't.
focus_get
Know what to do next
Not a to-do list. A judgment. What actually matters based on urgency and momentum.
semantic_recall
Recall by meaning
Ask "what did we decide?" and get the answer. Not a list of messages to read.
brain://status
Start with context already loaded
When your agent connects, it already knows what's going on. No setup. No re-prompting.
This is what changes
Instead of searching old messages,
your agent understands your work.
Instead of asking "what's next?",
it already knows.
Instead of starting over,
you continue.
Three commands. One operational layer.
End a session. Open the next one tomorrow. Your agent already knows what changed, what matters next, and what's drifting from the plan.
Capture what changed across every project. Decisions logged, patterns observed, plan steps advanced, restart-ready handoff for the next agent.
Agent reads operational state and surfaces what matters today, by urgency, momentum, what's blocked, and what's already in motion.
Compare what you said you'd do against what actually shipped. Surface the work that keeps reappearing in every session but never moves.
SHIPPED payments-api Stripe migration complete, webhooks verified marketing-site pricing page rewrite live, contact form connected DECIDED Postgres over DynamoDB for the new billing schema Defer mobile app to Q3, API stability comes first REPEATED BUT NOT SHIPPED Launch blog post appeared as next_move in 4 wraps running Demo video stayed in open_questions across 3 retros Onboarding email drafted twice, never sent HIDDEN PATTERN Polish keeps expanding. Public-facing work keeps deferring. RECOMMENDATION Send the onboarding email. Record the demo this week. More internal iteration is now avoidance.
Most agent-memory tools help an AI remember.
Brain OS helps an AI keep work coherent over time.
Built for the Claude Code + MCP ecosystem.
One .brain/ folder, every MCP client reads from it: Claude Code, Cursor, Zed, Windsurf, GitHub Copilot.
Structured operational state, not transcripts.
Most "AI memory" tools capture conversations. Brain OS captures the work itself.
These are different categories, not better or worse. If you want chat-history recall, use a transcript tool. If you want your agent to operate from what's actually true about your project, that's Brain OS.
High-intent guides: Persistent memory · Claude Code memory · MCP memory server
Detailed comparisons: vs claude-mem · vs Mem0 · vs Hindsight · vs AMP
FAQ
What is Brain OS?
An MCP server that gives your AI agent persistent memory of decisions, blockers, and project state. It runs locally, plugs into Claude Code or any MCP client, and lets your agent pick up where it left off.
How is it different from a notebook like Obsidian or Notion?
Notebooks are for you to read and write. Brain OS is for your agent to read and write. It doesn't store notes you author, it tracks the state of your work: what you decided, what's blocked, what matters next. You can use both: a notebook for your thinking, Brain OS for your agent's operational memory.
How is it different from a vector database or chat history?
Brain OS doesn't store conversations. It stores structured operational state: decisions with reasons and rejected alternatives, plans, blockers, momentum, focus. Recall is by meaning, not by searching old messages.
How is Brain OS different from claude-mem, Mem0, or Hindsight?
Different category. claude-mem, Mem0, Hindsight, and AMP capture conversations and use semantic search over past messages. Brain OS captures structured operational state (decisions, plans, blockers, focus, momentum) and exposes it through typed MCP tools. If you want recall over what was said in earlier sessions, use a transcript tool. If you want your agent to operate from what's true about your project right now, that's Brain OS.
Does state carry across different AI tools?
Yes, this is by design. Brain OS stores state locally in your project's .brain/ folder, and any MCP-compatible client reads from and writes to the same files. A decision logged in Claude Code on Monday shows up in Cursor or GitHub Copilot on Tuesday, same brain, every agent. Validated across Claude Code, Cursor, Zed, and GitHub Copilot with autonomous cross-tool calls. Big-vendor memory products won't build this because lock-in cuts the other way.
Can my team share a Brain OS?
Yes, today, with no product changes. Because .brain/ is just local JSON files, any synced filesystem works: commit it to your git repo, share via Dropbox or Drive, or mount NFS. Every Brain OS tool call reads fresh from disk, there's no in-memory cache, so the next call sees whatever your filesystem syncs. Log a decision from Claude Code on one machine, open Cursor on another, same brain, both agents.
Native encrypted team sync with proper merge semantics is on the roadmap. The local-first foundation makes that additive, not a retrofit.
Does Brain OS push back, or just remember things?
It pushes back. When your agent is about to log a new decision through decision_check, Brain OS scans prior decisions and returns conflict, caution, or clear, with the original reasoning surfaced. Instead of yes-anding a new direction, the agent gets to flag "we considered this in March and rejected it because X." The structured-state model makes agent disagreement possible; transcript tools can't do this because they don't know what a decision is.
Which AI tools does it work with?
Anything MCP-compatible. Validated across Claude Code, Cursor, Zed, and GitHub Copilot with autonomous tool calls from each client without prompting. Also runs in Windsurf and any other MCP-compatible client. Install with npx brain-os init, then connect via claude mcp add brain-os or your client's MCP config.
What do I get when I install it?
One command, three things:
npx brain-os init creates a .brain/ folder for state, installs 8 slash commands into .claude/commands/, and gives you the MCP config to paste into Claude Code or Cursor.
The commands: /brain (project scanner), /focus (today's priorities), /decide (capture a decision, with conflict check), /strategy (think a decision through), /wrap (session close), /patterns, /retro, /graph. If any of those names already exist in your project, Brain OS installs everything under the /brain: namespace instead so nothing collides.
Where does my data live? Is it private?
Locally, in a .brain/ directory inside your project. No cloud, no database, no telemetry, no API key required by default.
Semantic recall is opt-in: set BRAIN_EMBEDDINGS=local for an on-device model (~100MB, runs on your CPU, no data leaves your machine) or =openai if you want the API. If unset, the other tools work normally and semantic_recall returns a clear error with the config snippet, no silent downloads, no surprise API calls.
Is it free?
Yes. Open source under the MIT license. Free to install and run locally.
What's on the roadmap?
Near term: entity version history, decision revisit triggers, blocker as a first-class object. Phase 2 (12 to 18 months out, opt-in only): end-to-end encrypted cloud sync for multi-device continuity. Local-first is the default today and remains the priority. Full roadmap on GitHub.
How do I give Claude Code persistent memory across sessions?
Install Brain OS with npx brain-os init in your project directory, then connect it to Claude Code: claude mcp add brain-os -- npx brain-os serve. Brain OS creates a .brain/ folder that persists decisions, plans, blockers, and project state across every Claude Code session. When you start a new session, your agent already knows what was decided, what's blocked, and what matters next.
What is the best MCP server for AI agent memory?
Depends on what kind of memory. For conversation recall (searching past messages), use a transcript tool like claude-mem, Mem0, Hindsight, or AMP. For operational memory, decisions made, plans active, blockers in the way, momentum across sessions, Brain OS is purpose-built. It exposes typed MCP tools (decision_log, decision_check, plan_set, focus_get, pattern_detect) that store structured state, not chat history.
Why does my AI assistant keep forgetting context between sessions?
Most AI assistants have only conversation memory, they remember what was said in this chat, sometimes across recent chats. They don't have operational memory: what was decided, what's blocked, what plan is active. When a session ends, the operational state is gone. Brain OS solves this by giving agents a persistent .brain/ folder of structured state that survives across sessions and across AI tools.
Stop re-explaining.
Start remembering.
If you're building with AI, you already feel this problem.
One install. Your agent stops forgetting.
If it helped, star it on GitHub →