Open Knowledge Format / Portable memory for the AI era

Your AI changes. Your memory shouldn't.

OpenBrainStore is one identity-owned memory layer built on the Open Knowledge Format (OKF), for every compatible AI client. Teach one harness. Recall from another. Underneath, plain Markdown you own. On top, a retrieval engine your agents actually use.

Start free with GitHub See how it works

Open Knowledge FormatHarness agnosticIdentity scopedMCP nativeOAuth 2.1Plain MarkdownRetrieval engine includedSelf-hostable Open Knowledge FormatHarness agnosticIdentity scopedMCP nativeOAuth 2.1Plain MarkdownRetrieval engine includedSelf-hostable

Subscriptionmaxxing

Hit the cap. Keep the plot.

Max out one subscription, switch harnesses, and continue with the same project history. Your usage resets. Your context does not.

harness_01limit reached

100%

usage exhausted

harness_02active

64%

context restored

harness_03standby

08%

ready next

decisions + architecture + preferences + open questionscarried forward

Use the best interface for the moment. Coding client, browser chat, desktop app, or whatever arrives next.

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

Act I / The fracture

Every client remembers a different you.

Memory is becoming the moat. The more a client learns, the harder it becomes to leave. Your accumulated context turns into someone else's switching cost.

Today / isolated memory

client 01client 02client 03client 04 no shared
context

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

OpenBrainStore / one identity

client 01client 02client 03client 04 your
memory

The harness becomes an interface. Your authenticated identity determines which durable memory it can reach.

Act II / Continuity

Three moves. One continuous mind.

No proprietary SDK and no import ritual. OpenBrainStore uses the identity and tool protocols modern AI clients already understand.

Add the MCP endpoint

Point a compatible client at your hosted or self-managed OpenBrainStore URL.

Sign in with GitHub

OAuth 2.1, dynamic client registration, and PKCE bind requests to your stable identity.

Remember and recall

Every authorized client reaches the same tenant and the same portable memories.

Cross-client proof

Teach one. Ask another.

The client name does not determine the tenant. Identity does.

memory handoff / project obssame identity

Client 01 / write

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...

Client 02 / recall

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

The layer beneath

Not a feature. Infrastructure.

A model is not a harness. A harness is not your memory. OpenBrainStore separates the third layer so it can remain yours — stored in the Open Knowledge Format: plain, portable, identity-owned files no single vendor controls.

01 / format

Plain Markdown

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

02 / transport

MCP native

A common protocol instead of a proprietary client SDK.

03 / identity

Scoped to you

OAuth tokens resolve the person, never merely the session or client.

04 / exit

Portable by design

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

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

Your coding agent drops a note in the vault — its own phrasing, its own tags.
Next session, a different agent invents different tags for the same things.
Retrieval is keyword match: ask about "auth decisions," and the note that says "OAuth + PKCE" never comes back.
The note linked right next to it — the reasoning — is invisible.
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

Writes normalize on the way in — types, tags, and entities converge instead of drifting, whichever agent is talking.
The graph wires itself as memories land — mentions and explicit links.
Recall runs four lanes: exact filters and full-text first, then graph context…
…then deep semantic traversal when nothing shares the words.
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.

Structured filters

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

Full-text search

Fast lexical matches over the actual memory body.

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

Identity and trust

The client never becomes the tenant.

The server resolves the acting identity and carries it explicitly through every operation. Switch clients without switching who you are.

ID / stable subject

Identity that survives a rename

GitHub's numeric user ID becomes the tenant subject, so a username change does not sever your memory.

PK / authorization

OAuth 2.1 plus PKCE

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

RT / control

Revocable sessions

Opaque access tokens, rotating refresh tokens, and persisted authorization state keep access controllable.

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

forever

1,000 memories
The full retrieval cascade — filters, full-text, graph, semantic
Sign in with GitHub, connect any MCP client
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.

GitHub username

What best describes you

What you'd build with it (optional)

I understand this is a beta. It may occasionally forget which decade it's in, restart mid-thought, or grow suspiciously strong opinions about my architecture. I won't trust it as the only home for anything I'd cry about losing.

Connect a client

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 client'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

Codex

Add the endpoint to your Codex configuration, then begin OAuth login. A browser completes GitHub authorization.

Your GitHub identity is the account — no separate signup step.

[mcp_servers.openbrainstore]
url = "https://openbrainstore.com/mcp"

codex mcp login openbrainstore

Claude.ai

Open Settings, then Connectors, then Add custom connector. Leave Client ID and Secret empty.

GitHub completes identity verification in the browser.

Name: openbrainstore
Remote MCP server URL:
https://openbrainstore.com/mcp

OAuth Client ID / Secret: leave empty

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 clients: 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 client see memories written by another?

Yes, when both clients are authorized as the same identity. The OAuth token subject determines the tenant; the client name and session do not.

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 clients are verified?

The production OAuth and MCP flow has been verified end to end with Codex and Claude.ai. Other clients need compatible Streamable HTTP MCP and OAuth behavior.

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 client 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 client View the project