Product

Context version control, working.

The mental model is Git, for the context your work runs on — versioned, owned, portable between the tools you already use. Here is the whole loop.

How it works

Connect → Package → Share → Relay it in.

01 · Connect

One block, any client.

One config block in Claude, Cursor, or any MCP-compatible client. Takes under a minute. No SDK, no build step — Relay becomes tooling your agent already has.

02 · Package

What travels, exactly.

Not a summary. Decisions, state, intent. The transfer captures the substance of where you are; what comes out is a working brief, not a recap.

03 · Share

You get a Code.

Drop it in a task, a message, a note — anywhere the next person or agent will look. A Code is single-use by default: relayed in once, then it's spent. Multi-use is a deliberate choice, not the default.

04 · Relay it in

The word is the action.

"Relay QNHC2C7WRD." That's the whole instruction — to an agent, or typed into the app. The context loads and work resumes mid-thought.

A Code is the whole handoff.

Single-use

One clean pass.

Spent the moment it's relayed in. For handing a session to exactly one next holder — usually future-you.

Multi-use

Deliberately open.

Raise the use count and everyone with the Code gets the same context — a team, or a Series that keeps giving.

Received status

You see it land.

Shared turns to received. Every hop and timestamp is on the record, end to end.

Code

Team plan · single-use

The mental model

If you know Git, you know Relay.

Git	Relay
Repository	Stream — the named context container
Commit	An append-only entry — nothing is overwritten
Tag / ref	Code — the short share token
Branch	Series — a named line of relays within a Stream
Push	Send / forward
Pull	Relay it in — the Code, used
Reflog	The audit trail, coupled to every write
Working tree	Whatever tool you're in — Claude, Cursor, anything MCP
Clone	Relaying a Code in on a new machine

Owned like your repo: your context is versioned, attributable, and leaves with you.

Integration

One block. Any client.

MCP interface

Relay exposes a standard MCP server. Confirmed working in Claude (web, desktop, mobile), Claude Code, Cursor, Windsurf, VS Code + Copilot, and ChatGPT — and any client that takes a custom connector.

The agent does the filing

Packaging, logging, and updating happen in the session, by the session. You read and decide; the librarian is software.

What the connection doesn't do

No watching. No indexing. No trail retained after receipt on the free tier. The connection moves what you package, when you package it — nothing else.

claude_desktop_config.json

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

Ownership

It leaves with you.

Relaying in is always free. Export is always free. Stop paying and your context downgrades gracefully — it is never held hostage. Those are published commitments, not fine print.

Context in.
Context out.

See the platform primitives, compare plans, or join the Loop — your first 12 months are on us.

Join Relay

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