RelayCTX Concept sheet·Confidential·2026-08-12·Not a spec — statuses are honest

Build your own second brain for your agents

Your agents start every session with amnesia. The fix isn't another memory feature — it's a brain you build and own: one corpus of context in three states, one manifest that indexes it, and agents as the librarians who keep it current so you never have to.

The shape

One corpus, three states

Every object in the brain is in exactly one state at a time — and every object entered the same way. The pipe stays the identity; the library and the vault are what a governed pipe deposits.

A9M4FG

PIPE

Context in motion — governed movement with provenance.

  • Transfers, Codes, session handoffs
  • Ephemeral by default — expiry, claim-bounded
  • Custody stamped on every hop
  • "A pipe with a memory of its own routing"
series · v4

LIBRARY

Context at rest, organized — the knowledge base the agents keep.

  • Streams & series — the version lines
  • Shelves in governed Libraries
  • Reference reads that don't spend the object
  • Agent-written change notes at every entry
canon · sealed

VAULT

Context at rest, guarded — canon with proof attached.

  • Promoted to canon — "this is true now"
  • Recorded versions, per-agent acknowledgment
  • Hash-chained history, export-complete
  • Encrypted at the rung the buyer chose (L1→L4)
↩ the return edge — canon re-enters motion by Code; the brain is a circulation, not an archive

"Everything enters through the pipe.
Nothing starts in the vault." This is why the vault can be trusted: everything in it arrived carrying its full custody history — who made it, from which platform, what it superseded, who acknowledged it. Provenance by construction — the one property a data lake cannot retrofit.

The anatomy

Every brain function is an existing primitive

Nothing on this sheet is a new product. The concept is the shape the sequenced programs already add up to — with the status of each part stated honestly.

Brain functionRelay primitiveStatus
CaptureTransfers · session packagingLive
Boot / indexRoot Manifest + relay_context boot skeletonLive · flagged
OrganizeStreams · Series · collections substrate · Library/Shelf layerLive Layer spec'd
RecallUnified search (metadata-first) + receive by Codev1 shipped
ReferenceKB Entries — non-consuming reads, head = current stateSpec'd
DistillAgent change notes at package time · manicureIn flight
VersionContext Version Control — supersession, diff, reflogCVC program
Promote to truthCanon promotion — "which one is true now"Planned
GuardCustody — expiry · max-claims · consent · auditLive
AttestVbR receipts · hash-chained manifest & timelinev2.0 roadmap
Leave with everythingExport, open format — the escape hatchUnshipped · gates campaign
The verbs

The brain already has an API — it's the connector

A second brain is only as good as its verbs. These are shipped MCP tools, installed in every client the user touches — the API isn't a roadmap.

relay_contextOrientBoot holding the index — streams, freshness, what you last held
relay_searchRecallFind by name & envelope across the corpus, metadata-first
relay_receiveLoadPull an object into working memory by Code
relay_sendDepositCapture into the brain — or hand to someone else's
relay_sessionBridgeWorking ↔ long-term memory: package seals the session in, sync keeps the head while you work
relay_sessionsEpisodicThe session chain — what happened, in order, walkable
relay_saveShelveEdges & collections — supersedes, derived-from, the shelving act
relay_manicureGroomThe librarian's toolkit — tidy, retitle, dedupe, retire
relay_nudgesSignalThe brain talks back — freshness, newer version, waiting on you
relay_requestAskInterlibrary loan — request context you don't hold from a brain that does, with consent. No filesystem or memory service has this verb
The spine

Every brain boots from its manifest

The Root Manifest is built and flag-gated today. It is the second brain's index — and the same object plays a different role at each tier.

# an agent's first act, any platform
relay_context →
  streams you hold · what's fresh
  what you last held · what moved since
# wakes up knowing where everything is
The boot sector.An agent's session starts by reading the index, not by being re-briefed. "Never starts from zero," demo-able.
Filters, never grants.The manifest is a projection of what the viewer may hold. Permissions live on nodes; personal objects never leak into org views. One schema serves every tier — same spine, different filter.
A chain worth attesting.Hash-chain the manifest (CVC) and the index becomes the record of what the brain contained, when — verifiable.
SoloThe boot sector — wake up knowing where everything is.
TeamThe shared map, filtered per member — governance shapes the tree; each member sees only what they can hold.
EnterpriseThe attestation surface — "what did our agents know, and when, provably."
The packaging

Same organism, three doors

What changes by tier is never the brain — it is who shapes it, how far it reaches, and how hard the vault is. Individual limits stay soft; the real gates are reach and governance.

Personal plane

Solo brain

Free · Pro $15/mo

Structure
Streams + series + personal collections; person-scope manifest
Management
You. Agents ride your seat via MCP — any platform, one brain
Reach
Personal — every session, every tool, your context follows you
Vault hardness
L1 hardened SaaS; custody semantics in full
Ships Today Export pending
Team plane · the reach wedge

Team brain

$15/seat/mo · 3-seat min

Structure
+ governed Libraries & Shelves; Teams containers; org-scope manifest
Management
Governance ≠ content — admins shape the tree; org membership grants no reads. The property E2E products structurally can't offer
Reach
+ org broadcast — push a stream to the whole org
Agents
Workspace accounts — the librarians get their own named, org-scoped identities
Ships with G4 · self-serve orgs Org broadcast Library layer
Governed plane

Enterprise brain

Custom · sales-led

Structure
+ cross-org shelves by bilateral consent; residency-pinned
Management
+ SSO/SCIM · retention policy · audit & provenance export · SLA
Compliance
Pinned versions + per-agent acknowledgment — "who knew what, when, provably"
Vault hardness
L2 → L3 customer-held keys, in-tenancy — the vault becomes literal; L4 narrow opt-in
Ships with Governance kit CVC-3 attest Sovereign program
The lifecycle

How context earns its state

Defaults, not features. Forgetting is a feature — most working context should die in the pipe. Persistence is earned, and the agent does the earning.

Motionpipe

Context arrives as a transfer: claim-bounded, expiring, provenance-stamped. The daily verb. Nothing asks to be filed.

Settlinglibrary

What recurs earns persistence — a series becomes a version line, a KB entry gets non-consuming reads, a shelf collects it, the manifest indexes it. The agent does the settling: change notes, supersession judgments, manicure. Things aren't filed; they settle where the rules put them.

Hardeningvault

What bears load is promoted: canon status, recorded versions, acknowledgment, hash-chained history, export-complete, encrypted at the chosen rung. Earned state, not a separate product — reversible downward, never silently.

Returnvault → pipe

Canon re-enters motion by Code — old versions stay claimable forever; a boot Code is literally the vault feeding the pipe. The brain is a circulation.

The bear

Standing next to Obsidian

1.5M users, free, and a plugin ecosystem we can't outbuild — we don't fight for the solo note-taker's vault. The in: their premise caps them exactly where brains are going.

Agent-readable ≠ agent-accountable Their MCP turn lets agents write vaults — but a file carries no author, no provenance, no supersession, no acknowledgment. When agents write the brain, trust in its contents becomes the binding constraint. No accounts, by principle, forecloses the answer.
Shared ≠ governed They can share a vault — 20 collaborators, every one an owner. They structurally cannot govern one: sub-vault ACLs are impossible under their own E2E. The team brain is ours by foreclosure, not by race.
Files can't forget Expiry, claim-bounded delivery, deliberate ephemerality — no filesystem analogue. A brain that can't forget on purpose fills with stale certainty.

And for the vault-holder, the move isn't convert — it's connect: "Keep the vault. Relay is the remote." The vault stays the working tree; Relay adds what files can't carry — history, multiplayer, custody, proof. The bear becomes a channel (their plugin surface), gated only on R9.

Cede the solo vault; own the accountable brain — multiplayer, agent-gardened, provable. And hold the robustness register: R1 export R2 non-consuming reads R3 reflog invariant R4 touch-up surface R5 offline answer — open R6 extension surface — unowned R7 free solo door R8 boot as SLO R9 relay.md collision — R5 stays the honest concession: on "my brain with no network," they win; the answer is a complete export in hand, never a claim that cloud equals local.