v3.5 · CONCEPT
Platform

One primitive.
A platform of tooling.

The Code is the atom: a unit of context you send and receive. Everything else is built on it. Living context that stays current, whole sessions you can resume, handoffs that carry continuity to whoever comes next, recurring streams, full provenance, and a connection graph. All of it native inside your agent.

Capabilities

Built on the Code.

Six capabilities and one toolset, each a different shape of the same primitive. A Code is a moment; the platform makes it a heartbeat, a session, a handoff, a stream, a record, a relationship.

Living context01

Pulses

A Code is a moment; a Pulse is a heartbeat. Pulses are focus areas that stay current. They accumulate state, items, and contributions over time, so a project's context is always live, never a stale paste from last week.

relay_pulse_* · create, update, get, list, archive
Resume anything02

Sessions

Package an entire working session, goals, decisions, and state, then resume it later, on another machine, or hand it to the next agent. The "show up ready every time" promise, made literal. Continuity, not re-briefing.

relay_session_* · package, log, browse, aftercare
Standing streams03

Series

A named, recurring relay, like weekly-sync. Drop context into the series; everyone subscribed receives the latest. One Code that keeps giving, instead of a fresh paste every time.

relay_series_* · claim, update, expire, get, list
Continuity04

Handoffs

A Handoff is a special transfer: a continuity package. The full working state of a session, wrapped to carry forward. Hand it to a teammate, the next agent, or future-you, and whoever receives it resumes mid-stride instead of starting cold. This is the heart of Relay: continuity that survives the gap between sessions, people, and tools.

relay_session_package · relay_transfer_create · resume
The graph05

Connections

Sharing across people and orgs isn't a free-for-all. Cross-user claims go through request, approve, receive, so context lands with the right person, with consent. Durable connections skip the gate next time.

relay_request_* · approve, deny, list, cancel
Trust & control06

Provenance

Every relay carries a timeline: who sent it, who received it, every forward, every timestamp. Org visibility controls, claim approvals for cross-user shares, encryption, and retention. Context you can audit and govern, end to end.

chain of custody · timeline · approvals · org policy · encryption
The differentiator07

The MCP toolset

Relay isn't a website you visit, it's tooling your agent already has. Around 24 MCP tools expose every capability above directly inside Claude or any MCP client. No app-switching, no copy-paste. Context operations where the work actually happens.

~24 tools · one config block · any MCP client
No commands to learn

Speak your own language.
Your agent knows the rest.

You never type a tool name. Say what you want in plain English; your agent picks the right Relay tool and calls it. The toolset is for the agent, not for you.

“Give me a handoff.”
relay_session_package
“Send this to Ben.”
relay_transfer_create
“Pick up where I left off.”
relay_transfer_claim
“What’s the latest on the project?”
relay_pulse_get
“Save this for tomorrow.”
relay_pulse_update
Integration

It lives where you work.

One block, any client
A single MCP config entry in Claude Desktop, Claude Code, or any MCP-compatible tool. No SDK, no build step.
The whole platform, in-agent
Pulses, Sessions, Handoffs, Series, transfers, provenance, all callable as tools. Your agent operates on context without leaving the conversation.
Governed by default
Encryption, approvals, and org controls apply to every tool call, the same trust model whether a human or an agent is driving.
claude_desktop_config.json
{
  "mcpServers": {
    "relay": {
      "command": "npx",
      "args": ["-y", "@relayctx/mcp-server"],
      "env": {
        "RELAY_API_KEY": "your-key-here"
      }
    }
  }
}
Tooling your agent already has, not a website you visit.

Context in.
Context out.

One primitive, a whole platform of tooling, native inside your agent. Join the Loop and get a direct line to the founding team.

Join the Loop →
Registration is open — access by activation code as Early Access expands.