RelayCTX
Platform

One rule, all the way down.

Some context accumulates, and it's yours. Some context travels, and it goes out as a relay. Everything on the platform is one of the two — and the boundary between them is where the governance lives.

One config block · any MCP client · no SDK.
The stack

Where Relay fits.

It sits beneath the tools you already use. Each is useful, and none carries the work from one session, tool or person to the next. Relay replaces none of them.

The toolsClaude, Cursor, custom agents
Memory toolsstore and retrieve, for one person
Orchestratorscoordinate inside one runtime
Integrationsmove data, not working context
Agent messaginga name, an address, a sentence
Relaycarries the work between all of them
Accumulates

Your side of the line.

Streams
A working surface, not a group chat.
A Stream is your own surface for a focus area — it gathers state, items, and decisions as work happens, so the context stays current instead of rotting in a doc. It's private by design; when something in it needs to reach someone, that piece goes out as a relay.
Sessions
Work in flight, with a lifecycle.
A session can be packaged and resumed — but also logged, synced while live, updated, and closed. It's a thing that keeps going, not just a thing you pass.
Versions
Nothing is overwritten.
Entries append. What you believed two weeks ago is still there, still loadable, with who-wrote-what attached.
Travels

The other side, relayed.

Relays
The sharing mechanism. The only one.
Context leaves your hands as a relay, sealed with a Code for the next holder. Single-use by default; multi-use by deliberate choice.
Series
A relay that recurs.
Name it — like weekly-sync — and whoever relays it in always gets the latest drop. One Code that keeps giving, instead of a fresh paste each week.
Connections
Consent, then a durable pipe.
Cross-user sharing runs request → approve → relay, and an approved connection can skip the gate next time — with a record either way. Org policy can restrict a relay; it can never auto-approve one.
Provenance
The trail is the object.
Who sent, who took it in, every hop, every timestamp. An agent pipeline built on relays is auditable end to end because the audit rides the context itself.
Inside your agent

The MCP toolset.

Relay isn't a website you visit. Once it's connected, every primitive above is an MCP tool inside Claude or any MCP client, so the context moves from the session you're already in, with no copy-paste.

relay_searchrelay_sendrelay_receiverelay_requestrelay_saverelay_session
claude_desktop_config.json
{
  "mcpServers": {
    "relay": {
      "command": "npx",
      "args": ["-y", "@relayctx/mcp-server"],
      "env": { "RELAY_API_KEY": "your-key-here" }
    }
  }
}
The unit

The session is the unit.

A Code moves a moment. The platform holds the thing that keeps going — the session that logs, syncs, and resumes; the Stream that accumulates around it; the trail that makes all of it attributable. Handing off is the special case. Picking your own work back up is the every-day one.

Context in.
Context out.

Join the Loop and your first 12 months are on us. A direct line to the founding team included.

Join Relay
Registration is open — access by activation code as Early Access expands.