How to Use Relay — RelayCTX

Format A — Step by step

Request access

Relay is in early access. Request a spot — you'll get an email with your account and API key when you're in.

Request access →

Already have an account? Skip to step 2.

Add Relay to your agent

Paste one block into your agent's config file. Works with Claude Desktop, Claude Code, Cursor, Devin, and any MCP-compatible client.

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

Restart your client after saving. Your agent will confirm "Relay connected."

Work — Relay tracks as you go

Start a session as usual. Relay runs in the background — logging what's relevant, building a picture of the work. You don't change anything about how you work.

relay_session_log or let your agent log automatically

Package context into a Code

When you want to carry context forward — to a new session, a teammate, or another agent — package it. Relay returns a short Code. That's all that travels.

relay_transfer_create

Your Code looks like QNHC2C — six characters, all yours.

Share the Code — or receive one

Hand the Code to whoever needs it — a person, another agent, your future self in a new session. They load it with one command and pick up exactly where the context left off.

relay_transfer_receive on the receiving end

The Code works once. Context arrives, session continues.

Format B — Start from your situation

Solo

I work across sessions and tools

Sessions end. Work continues. I need context to travel with me — not restart every time.

Start here →

Team

I'm sharing work with other people

Handoffs lose too much. I want to send someone the actual context of what I'm working on, not a summary.

Start here →

Agents

I'm building with AI agents

Multiple agents, multiple runtimes. I need context to flow between them with provenance and control.

Start here →

Set up Relay in your agent

One MCP block in your config. Every session you run after this is relay-aware.

Start a Pulse for your current focus

A Pulse is persistent state — what's true right now about your work. It survives sessions and updates as you go. Think of it as a living brief that travels with you.

relay_pulse_create

Pick up any session with your Pulse

Start a new session in a new tool. Load your active Pulse. Your agent has everything — decisions, state, current focus — without you re-explaining.

relay_pulse_active

Set up Relay — you and your recipient

Both sides need Relay connected. The person receiving a Code doesn't need your account — just their own.

Package what you're handing off

At any point in your session — mid-task, end-of-day, whenever — package the context. Relay creates a Code and holds it. Nothing is sent until someone uses the Code.

relay_transfer_create

Send the Code — they pick up from there

Send the Code however you normally communicate — Slack, email, DM. They load it in their agent. The work continues; the context is on the record.

relay_transfer_receivetheir side

Add Relay to each agent in your pipeline

The same MCP config block works in every compatible runtime. All agents in the chain can create and receive Codes.

Route context between agents with Codes

When Agent A hands off to Agent B, it packages context and passes the Code. Agent B loads it and continues. Every transfer is logged — you always know what moved and when.

You stay root authority

Agents inherit scope — they can't exceed what you've permitted. The governance surface is yours. Every agent action in the chain is traceable back to a human decision.

Get context moving.

One block. You're in.