openbrainstore.
Shared memory for Claude, Codex and your agents

One memory for every AI you use.

OpenBrainStore gives your AI apps and agents one long-term memory they all share. Tell one about a decision and the others already know it. It's stored as plain Markdown files you own, and setup is one URL.

Start free with GitHub See what it does
Works with Claude and CodexAny MCP appOne URL to connectSign in with GitHubPlain Markdown you ownSkills you approveExport any timeSelf-hostable Works with Claude and CodexAny MCP appOne URL to connectSign in with GitHubPlain Markdown you ownSkills you approveExport any timeSelf-hostable
What it does

Remember. Share. Teach.

OpenBrainStore isn't a chatbot or a notes app. It's a memory service your AI apps connect to, so what you work out with one of them is there for all of them.

01 / remembers

It remembers

Your AI apps save what matters as you work: decisions, preferences, project facts, open questions. Next session they still know it, so you stop re-explaining.

02 / shares

Every app shares it

Claude, Codex and any app that speaks MCP read the same memory. Switch tools, or hit a usage cap, and your context comes with you.

03 / teaches New

It teaches your agents

What worked becomes a reusable skill your agents load before they start. You approve every skill, and each agent gets only the skills and permissions you give it.

Getting started

Three steps. One memory.

Nothing to install and nothing to import. You add a URL to the AI apps you already use.

Sign in with GitHub

That's your account. The free tier starts right away: no card, no invite.

Just work

Your apps save what matters as you go and look it up when it helps. Ask one app what another learned.

See it work

Teach one. Ask another.

Two different apps, one account. A decision saved in one is an answer in the other.

memory handoff / project obssame identity
App 01 / saves
Remember that our retrieval strategy uses vectors only as a fallback.
Stored as a project decision, tagged retrieval and architecture.
remember accepted
tenant: gh_35787482
id: mem_01KXVZ...
App 02 / recalls
What retrieval strategy did we choose?
Structured filters and full text first, graph context next — and when those aren't enough, a deep semantic traversal across everything.
same tenant recalled
lanes: fts + graph
vector_fired: false
Skills New

Teach once. Every agent follows.

Memory is what your agents know. Skills are how you want things done: checklists, procedures and guardrails built from work that went well. Every skill is versioned, and none reaches an agent until you approve it.

An agent proposes

After a task goes well, an agent drafts a skill from it: your deploy checklist, how you review a pull request, a rule it should never break.

You approve

Drafts wait in the Catalog tab of the app. Edit, approve or reject them. Agents can never approve their own.

Every agent loads it

At the start of a session, each agent gets the skills that fit its task and fetches the ones it needs.

Each agent gets a role

Agent profiles give an agent its own role, skills and key, with only the permissions you pick. Change or revoke a key from the app; nothing new needs pasting into the agent.

Skills are opt-in: turn them on in the app's Catalog tab. Memory works the same either way.

Why it matters

Every app remembers a different you.

Memory is becoming the moat. The more an AI app learns about you, the harder it becomes to leave. Your accumulated context turns into someone else's switching cost.

Today / isolated memory

Switch tools and the story restarts. Decisions disappear. Preferences vanish. The briefing begins again.

OpenBrainStore / one account

Every app becomes a window onto the same memory. Your account decides what it can reach, not the app.

Subscriptionmaxxing

Hit the cap. Keep the plot.

Max out one subscription, switch to another AI app, and keep going with the same project history. Your usage resets. Your context doesn't.

app_01limit reached
100%
usage exhausted
app_02active
64%
context restored
app_03standby
08%
ready next
decisions + architecture + preferences + open questionscarried forward

Use the best app for the moment. A coding agent, a browser chat, a desktop app, or whatever arrives next.

Stop rebuilding context from zero. OpenBrainStore makes continuity independent from the subscription meter.

Files + retrieval

Just files? Exactly. That's the trick.

Point a coding agent at a Markdown vault and it can write notes all day. Ask it to find them again and it's grepping. The trick was never the files — it's the retrieval on top.

An agent + a vault / retrieval is grep
  1. Your coding agent drops a note in the vault — its own phrasing, its own tags.
  2. Next session, a different agent invents different tags for the same things.
  3. Retrieval is keyword match: ask about "auth decisions," and the note that says "OAuth + PKCE" never comes back.
  4. The note linked right next to it — the reasoning — is invisible.
  5. The agent answers confidently from the two notes it grepped.

The files are fine. The misses are silent.

OpenBrainStore / the algorithm does all of it
  1. Writes normalize on the way in — types, tags, and entities converge instead of drifting, whichever agent is talking.
  2. The graph wires itself as memories land — mentions and explicit links.
  3. Recall runs four lanes: exact filters and full-text first, then graph context…
  4. …then deep semantic traversal when nothing shares the words.
  5. Fused, ranked, and logged — the telemetry names what found the answer.

Same plain files underneath. The algorithm does the librarian's job — writing and finding.

Inspectable retrieval

A cascade. Not a black box.

The fastest, most explainable signals run first. And when they come up short — or the agent simply asks — recall traverses deeper: full semantic search across everything you've stored.

01

Structured filters

Type, tags, entities, dates, and normalized key-values.

02

Full-text search

Fast lexical matches over the actual memory body.

03

Graph context

Related entities and linked memories, one or two hops away.

04 / deep traversal

Vector search

The deep option: semantic retrieval across everything — automatic on low confidence, on demand with deep recall.

lanes_run: fts, graphvector_fired: falseduration_ms: 18.6fusion: RRF
▶  Watch a recall think
Yours to keep

Your memory. Your files.

Your memories are plain Markdown files in an open format, the Open Knowledge Format, not rows locked inside one vendor's app. Read them, export them, or run the same server yourself.

01 / format

Plain Markdown

Readable, diffable canonical files with YAML frontmatter — indexed four ways, so owning your files never means grepping them.

02 / protocol

Works over MCP

The open protocol AI apps already use to connect tools. No special SDK.

03 / account

Tied to you

Access belongs to your account, not to an app or a session, so every app reaches the same memory.

04 / exit

Portable by design

Export the files or run the same server on infrastructure you control.

Identity and trust

Your account holds the keys.

Every request is tied to your GitHub account, and that identity travels with it through every step. Apps and agents only get access you can see and revoke.

ID / stable subject

Identity that survives a rename

GitHub's numeric user ID becomes your account ID, so changing your username doesn't cut you off from your memory.

PK / authorization

OAuth 2.1 plus PKCE

Dynamic registration lets compatible clients connect without distributing pre-issued client secrets.

RT / control

Access you can revoke

Apps get rotating tokens. Agents get their own keys: limited to the permissions you pick, set to expire, and changeable or revocable any time.

EX / portability

An exit you can actually use

Export canonical Markdown or run the same service yourself. The format does not depend on the hosted service.

Two ways in

Own the box, or don't. Own the format.

Both paths share one open format and one open protocol, so there is no lock-in even into OpenBrainStore itself.

Self-hosted

Run your own instance.

Full inspection and control, with no recurring cost beyond the infrastructure you choose.

Hosted / free to start

Let us run the same server.

The identical service, managed for you and authenticated against your identity. Sign in with GitHub and the free tier starts immediately — no invite, no card.

Pricing

Simple. Like the format.

Two plans, no seats, no meters on recall. Export everything, either way, any time.

Free
$0
forever
  • 1,000 memories
  • The full retrieval cascade — filters, full-text, graph, semantic
  • Sign in with GitHub, connect any MCP app
  • OKF export any time — your files, portable by design
  • Open right now — no invite, no card, no queue
Start free with GitHub
Pro
$6/month
or $60/year — two months free · opening soon
  • 50,000 memories — room for years of context
  • Everything in Free, same cascade, same export rights
  • Cancel anytime; downgrade never deletes your data
  • Directly funds one indie project staying independent
Tell me when Pro opens
Pro, when it's ready

Want the bigger store?

Free is open now — no waiting, no approval. Leave your details and we'll tell you the day Pro opens, with 50,000 memories and no ceiling worth thinking about.

Connect an app

One endpoint. Then GitHub.

These are the real connection steps — and they work right now. Signing in with GitHub creates your free account on the spot.

Streamable HTTP MCP

Add the endpoint in your app's MCP settings. OAuth discovery advertises registration, authorization, token, and protected-resource metadata.

Leave credentials empty when your client supports dynamic registration.
Remote MCP URL:
https://openbrainstore.com/mcp

OAuth: automatic discovery
Scope: memory
FAQ

Answers without the fog.

What is the Open Knowledge Format (OKF)?

OKF is the open, portable format underneath OpenBrainStore: every memory is a plain Markdown file with YAML frontmatter — typed, tagged, entity-linked, and scoped to your identity rather than to any AI vendor. Because the canonical data is just files in an open format, you can read it, diff it, export it, and run it anywhere. OpenBrainStore is the first OKF service: the memory layer.

How is this different from Obsidian or a Markdown second brain?

Same canonical layer — plain Markdown you own — different job. A vault is a tool for humans: you garden it, you search it, you ferry context into your AI by hand. OpenBrainStore is a memory service for your AI apps: they write memories mid-conversation, structure normalizes automatically, and recall runs a ranked cascade — filters, full-text, graph, and deep semantic traversal when the agent needs it — over MCP. You can still open every file. Nobody has to garden them.

Is OpenBrainStore just a vector database?

No — it's a retrieval cascade with vectors as its deepest lane. Structured filters and full-text search run first, graph expansion adds related context, and when those come up short — or the agent asks for deep recall — a full semantic traversal runs across everything you've stored.

Does the write path use an LLM?

No. Key normalization, entity and tag slugification, type validation, and value coercion are deterministic. The memory body remains plain prose supplied by the calling client.

Can one app see memories written by another?

Yes, when both are signed in as you. Your account decides what they can reach; the app and the session don't.

What are skills?

Reusable instructions for your agents: a checklist, a procedure, a guardrail. Agents propose them from work that went well, you approve them in the app, and agents load the ones that fit their task at the start of a session. Assign skills to an agent profile and only that agent sees them. Skills are opt-in and versioned, and agents can never approve their own.

Do my agents need a key?

Apps like Claude and Codex sign in with GitHub and don't need one. Agents that run on their own, such as scheduled jobs, CI or your own code, use an agent key from the app's Agents tab. Each key is limited to the permissions you choose, can be bound to an agent profile, expires, and can be changed or revoked at any time.

What happens if I leave the hosted service?

Export the canonical Markdown files and run the same server yourself. Filesystem and S3-compatible storage preserve the same portable structure.

What happens when I delete a memory?

Its projections are removed immediately. The canonical file is tombstoned for a grace period before final purge, allowing safer operational recovery.

Which apps work?

The production OAuth and MCP flow has been verified end to end with Codex and Claude.ai. Other apps work if they support remote MCP servers with OAuth (Streamable HTTP).

Get in touch

Licensing, or just hello.

OpenBrainStore is free to self-host for individuals and companies under $1M in yearly revenue (PolyForm Small Business license). Bigger, or want to offer it as a hosted service? Let's talk about a commercial license.

The next AI app is already coming

Take your memory with you.

The model will change. The interface will change. The context you built should remain yours.

Connect your first appView the project