Relay + Claude Desktop.

Connect Relay to Claude Desktop

Open your Claude Desktop config file. On Mac it's at ~/Library/Application Support/Claude/claude_desktop_config.json. Add the Relay MCP block inside mcpServers:

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

Replace your-api-key-here with your key from the Relay dashboard. Save the file, then fully quit and relaunch Claude Desktop — it needs to restart to pick up MCP config changes.

If you already have other MCP servers configured, add the relay block alongside them — don't replace the whole mcpServers object.

Create a Pulse for each project

A Pulse is persistent context — what's true right now about a given area of work. Unlike a session, it doesn't end when you close Claude. It carries forward and updates as things evolve.

Create one per project, per focus area, or per recurring context you keep re-explaining. In a new Claude Desktop conversation:

You: Create a Relay Pulse for my auth refactor project.
      We're moving from JWT to session tokens.
      Currently in the middleware layer, targeting
      completion by end of sprint.

Claude: Created Pulse "Auth Refactor" — here's your code:
       pc_3a7f...
       I've logged the JWT → session token migration,
       middleware scope, and sprint target as the
       initial state.

Be as specific or as loose as you want. The Pulse is yours — it accumulates context over time and you can update it whenever the situation changes.

Start every session loaded

This is the actual pattern change. Instead of starting a new Claude conversation cold — typing out the context all over again — you load your active Pulse and pick up where you left off.

In practice it looks like this:

You: Load my active Relay Pulse for auth refactor.

Claude: Loaded "Auth Refactor" (pc_3a7f...).
       Current state:
       - JWT → session tokens migration in progress
       - Middleware layer: 60% complete
       - Decision log: refresh token rotation approved,
         sliding window 7 days
       - Sprint ends Friday
       What do you want to work on today?

Package a session as a Code

At any point — end of a working session, before a context switch, before closing a thread — you can package everything into a transferable Code. That's the unit Relay moves. Short, opaque, yours.

You: Package this session with Relay. Title it
      "Auth middleware — session 4".

Claude: Packaged. Your Code:

       QNHC2C

       Included: conversation summary, active decisions,
       middleware state, open questions.
       The Code is ready — send it, save it, or load it
       in a new session to continue.

You don't have to do anything with the Code right now. It holds until you need it. Load it later in a fresh session, send it to a teammate, or pass it to an agent — it works the same way from any of those starting points.

Handoffs — sending and receiving

The Code you packaged is how context crosses sessions, tools, people, and agents. Send it the same way you'd share anything — Slack, email, dropped in a doc. The other side loads it in their agent.

Tools at a glance

The Relay tools Claude Desktop exposes via MCP. These are what you ask Claude to call — by name or by natural language ("load my pulse", "package this session").