The problem
Most AI sessions forget the work that made the last answer good.
Every session re-derives context from scratch. The decisions, the reasons, the lessons — gone when the window closes. Beautiful Brain keeps the useful residue.
The idea
Useful intelligence is cumulative. Memory should be inspectable, portable, and yours.
Recall
One vector space, plus a graph that thinks.
Notes, images, audio, video, and documents all land in the same searchable space, so “that diagram from the pricing discussion” is findable by meaning, not filename. When you ask for something, the brain weighs three things at once: the words you used, what you meant, and what’s connected to what. And it shows its work — every result says why it came back. Prefer fully offline? A local model handles text on your machine.
Linking
Typed synapses, and an algorithm that tends them.
Memories don’t just sit near each other — they’re connected with meaning: this supports that, this contradicts that, this was learned from that, use this next time. You can draw links yourself, and a caretaker algorithm quietly finds the ones you missed. It only ever proposes; you approve. It strengthens connections that keep proving useful, and it surfaces contradictions instead of hiding them.
Every applied repair leaves an audit trail — and a precise link is never replaced with a vague one.
Collaborate
Share memory, not access to it.
Send a memory to a colleague as a snapshot — nothing lands in their brain unless they choose to keep it. Hand off tasks the same way. For whole projects, a shared repo becomes the courier: every memory travels sealed end-to-end, so the host in the middle carries your context without ever being able to read it.
The same class of encryption secure messengers use, keyed per member — and tampering is detected, never silently accepted.
Multi-agent
A team of agents, one brain.
Run several agents on the same project and they coordinate through a shared board — started, done, blocked — see what the others are on, and write what they learned into the same brain. Status notes expire on their own after 45 minutes; there’s nothing to clean up.
Connectors
One brain, all your tools.
Your brain can hold the connections to your other tools — GitHub, Notion, mail, anything that speaks MCP — and hand an agent exactly the right one for the job. Finding a tool is instant because the catalog is kept warm, and whatever a third-party tool sends back is treated as information, never as instructions.
Skills
It absorbs what works.
When a piece of work goes unusually well, the brain notices. A background process — the Cognitive Pulse — distills what worked into a reusable pattern and proposes it; nothing changes without sign-off. The next time a similar task shows up, the pattern is already waiting, before planning even starts.
Artifacts & books
Memory becomes work product.
The things you actually make — documents, diagrams, pages, code — live in the brain as artifacts that render beautifully for humans, not just as text for machines. Gather related ones into a book: one shareable thing, laid out as a canvas or read page by page.
What it remembers
A graph, not a pile
Memories carry typed edges — caused_by, contradicts, learned_from, depends_on — so recall follows the shape of how decisions actually happened.
Multimodal recall
Text, images, audio, video, and PDFs share one vector space via gemini-embedding-2. A written cue finds the sketch; spreading activation surfaces the context around it, not just the match.
Lessons that change behavior
A lesson is structured, not sentimental: the trigger to watch for, the wrong default, the better next action, and the evidence. Agents replay them before repeating a mistake.
Cognitive Pulse
A background maintenance runner that notices stale tasks, orphans, and duplicates — then proposes. Review and application stay explicit; your history is never quietly rewritten.
Connect
Point a client at the graph
Works with Claude connectors, ChatGPT developer mode, Claude Code, Cursor, and any client that speaks Streamable HTTP MCP. OAuth and API keys can run side by side.
- MCP endpoint
- https://turbo-brain.com/mcp
- Transport
- Streamable HTTP
- Authorization server
- https://turbo-brain.com
- Scopes
- openid profile email offline_access
- OAuth
- enabled
- API keys
- enabled — Authorization: Bearer or X-API-Key
- Self-host skill
- https://turbo-brain.com/skills/self-host/SKILL.md
- Version
- 1.2.0
Agent first
Install the skill, add the server, and start every relevant task by asking the graph what it already knows.
# 1. Install the agent skill mkdir -p "${CODEX_HOME:-$HOME/.codex}/skills/beautiful-brain" curl -fsSL https://turbo-brain.com/skills/beautiful-brain/SKILL.md \ -o "${CODEX_HOME:-$HOME/.codex}/skills/beautiful-brain/SKILL.md" # 2. Connect the MCP server claude mcp add --transport http beautiful-brain https://turbo-brain.com/mcp # 3. First use Call reflect({ topic: "<project>", goal: "<what you are doing>" }) For repeat work: process_patterns({ action: "find", task: "<task>" })
Self-host with your agent
Want your own instance? Hand the setup to your agent: it fetches the self-host skill and drives the whole install — prerequisites, Docker, config, verification — asking you at most three questions.
Tool surface
memory capture_memory · update_memory · search_memory · recall_memory · get_context · link_memory · reflect artifacts & books get_artifact · show_artifact · book skills & patterns skills · process_patterns collaboration collab · space · board connectors search · fetch · find_connector_tools · call_connector_tool maintenance meta · repair_synapses · backfill_memory_embeddings
Beautiful Brain