openbrainstore.
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. Keep the context when the interface changes.

Connect a client See how it works
Open Knowledge FormatHarness agnosticIdentity scopedMCP nativeOAuth 2.1Plain MarkdownSelf-hostable Open Knowledge FormatHarness agnosticIdentity scopedMCP nativeOAuth 2.1Plain MarkdownSelf-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

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

OpenBrainStore / one identity

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 vector search only on fallthrough or explicit deep recall.
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. Ownership you can inspect.

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.

Inspectable retrieval

A cascade. Not a black box.

The cheapest, most explainable signal runs first. Semantic search is an escape hatch, not the default answer to every question.

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 / fallback

Vector search

Semantic retrieval on low confidence or explicit deep recall.

lanes_run: fts, graphvector_fired: falseduration_ms: 18.6fusion: RRF
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 / private beta

Let us run the same server.

The identical service, managed for you and authenticated against your identity. Access is allowlisted while the hosted service is hardened.

Connect a client

One endpoint. Then GitHub.

The production service is currently an invite-only beta. These are the real connection steps for an approved GitHub identity.

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

Is OpenBrainStore just a vector database?

No. Structured filters and full-text search run first, graph expansion adds related context, and vectors fire only on fallthrough or explicit deep recall.

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.

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 clientView the project