Every morning, your AI meets you for the first time.
The pipeline you debugged for a week. The client's odd constraint. The reason you did it that way. Gone, every new session. brainbox is a memory that never resets — one graph of what you know, shared by every AI tool you use.
Free during early access.
Two steps. Then it compounds.
brainbox is a private memory graph with an API. You connect it to the AI tools you already use; they read it before answering and write back what matters. The value shows up in your conversations, not on a dashboard.
Point your AI at your brain — Claude Code's CLAUDE.md, a Claude project's instructions, Cursor Rules, or your own scripts through the API. One key, one paste.
Your AI recalls what's relevant before it answers, and records decisions, gotchas and context as you go. No filing, no tagging, no "remember this" rituals.
Every session starts where the last one ended. The tenth week is sharper than the first, because nothing you learned together has been thrown away.
One brain. Every tool you already use.
brainbox speaks MCP — the open protocol AI tools use to reach external memory — plus a plain HTTP API for everything else. No plugin marketplace, no gatekeeper: if your tool can call an API, it can carry your memory.
Prefer to browse? brainbox is listed on the official
MCP Registry
as dev.thexi/brainbox and on
Smithery.
New MCP-capable tools ship every week — most work out of the box. Using something we haven't listed? Tell us and we'll verify it with you.
On OpenClaw, brainbox isn't a tool on the side — it's the memory backend. Our plugin takes
OpenClaw's exclusive memory slot: the built-in memory_search and memory_get
answer from your graph, a wake brief opens every session with where you left off, and a digest is
filed when it ends — deterministically, in the runtime, no model judgement involved. One command:
openclaw plugins install openclaw-memory-brainbox
On Hermes, brainbox is the external memory provider (memory.provider: brainbox):
relevant context is prefetched from your graph before every turn, a wake brief opens each
session, and the session digest is filed at close and distilled server-side into lessons
overnight. Recall keeps its honesty on the way in — confidence grades, evidence tags,
and abstention when nothing confidently matches, instead of confident noise. One command:
hermes plugins install CIF-AI/hermes-brainbox
— then pick brainbox in hermes memory setup. Prefer it manual?
git clone https://github.com/CIF-AI/hermes-brainbox ~/.hermes/plugins/brainbox
does the same.
On opencode, brainbox is the memory backend: brainbox_recall/brainbox_store
tools your agent can call, a wake brief injected into the system prompt at session start, and a
session digest filed when it ends — deterministically, in the runtime, no model judgement.
opencode installs the plugin from npm automatically; add one line to
~/.config/opencode/opencode.jsonc:
"plugin": ["opencode-brainbox"]
On goose, brainbox is the memory backend: brainbox_recall/brainbox_store
tools your agent can call, a wake brief injected into the system prompt at session start (through the
extension's MCP instructions), and a session digest filed when it ends —
deterministically, in the runtime, no model judgement. Clone it, then add a stdio extension to
~/.config/goose/config.yaml:
git clone https://github.com/CIF-AI/goose-brainbox
On Amp, brainbox is a native plugin: brainbox_recall/brainbox_store tools,
a wake brief injected at the start of each turn, and a digest filed as the thread runs. Today the
plugin loads and every lifecycle hook fires in Amp; the final hop — the wake brief reaching the
model — is being finalized. Amp runs on Bun and loads .ts plugins from
~/.config/amp/plugins/:
git clone https://github.com/CIF-AI/amp-brainbox
One box. Two doors. Your own brain.
Every tool you connect walks through one of two doors — you sign in once, your machines carry a key. Behind them, one box routes every request to a graph that belongs to you alone. Nothing decides who you are except your credential.
Drawn from the engineering source of truth — the code-verified architecture doc this system ships against. Every arrow in this picture exists in production.
Yours should live with you.
Built-in chatbot memory is real — and locked to one vendor. Switch tools and you start from zero. brainbox is one memory across all of them: the model you use today, the one you'll switch to next year, the script you write yourself. And it's yours to export — the whole graph, any time, no ransom.
Get early accessFree during early access — pricing arrives with launch.
Built by someone who needed it first.
brainbox is built by Barak Achillah Asidi, founder of CIF AI — a Kenyan studio shipping AI products for real work, including Tarjumi (machine translation for African languages) and Ishara (a Kenyan Sign Language interpreter). He's a data engineer by trade.
brainbox didn't start as a product. It started as the memory behind his own AI — 2,400+ working sessions and counting — and became a product because working without it stopped making sense. What you connect to is the system he trusts with his own work, every day.