Documentation

Every agent in your pipeline has a token budget. When Agent A produces a large output — a code review, a research report, a database dump — and Agent B needs it, you have two options: paste the full text into B's prompt (expensive) or truncate it (lossy).

ContextRelay gives you a third option. Agent A pushes the payload to the edge and gets back an 80-character URL. Agent B receives the URL, then pulls the full payload directly — it never appears in A's conversation again. For sensitive payloads, add encrypted=True and the data is encrypted in your process before it leaves your machine — Cloudflare only ever sees ciphertext.

Claude does a thorough code review. The review is too large to fit alongside the follow-up instructions in Mistral's context. ContextRelay bridges them.

import os, anthropic
from mistralai import Mistral
from contextrelay import ContextRelay

relay   = ContextRelay(api_key=os.environ["CONTEXTRELAY_API_KEY"])
claude  = anthropic.Anthropic()
mistral = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

# ── Agent A: Claude reviews the PR ──────────────────────────────
diff = open("pr_diff.txt").read()   # ~20 KB of git diff

review = claude.messages.create(
    model="claude-opus-4-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": f"Code review:\n\n{diff}"}],
).content[0].text

# Store the review — hand off only the URL
review_url = relay.push(review, metadata={"pr": "PR-441", "type": "review"})

# ── Agent B: Mistral turns the review into Jira tickets ─────────
full_review = relay.pull(review_url)   # fetched directly by Mistral

tickets = mistral.chat.complete(
    model="mistral-large-latest",
    messages=[{
        "role": "user",
        "content": f"Convert this review into Jira tickets:\n\n{full_review}"
    }],
).choices[0].message.content

Three researcher agents write different sections simultaneously. A synthesis agent subscribes to a channel and assembles the report the moment all three push their findings — no polling.

import os, threading
from contextrelay import ContextRelay

relay = ContextRelay(api_key=os.environ["CONTEXTRELAY_API_KEY"])
collected = {}

def on_section_ready(url):
    meta    = relay.peek(url)           # read tag without downloading
    section = relay.pull(url)
    collected[meta["section"]] = section
    if len(collected) == 3:
        report = "\n\n".join(
            collected[k] for k in ["intro", "analysis", "conclusion"]
        )
        print("Report ready:", len(report), "chars")

# Synthesis agent subscribes before any pushes arrive
threading.Thread(
    target=relay.subscribe,
    args=("report-ch", on_section_ready),
    daemon=True,
).start()

# Three researcher agents push independently, in any order
def researcher(name, prompt):
    result = call_llm(prompt)           # your LLM call here
    relay.push(result, channel="report-ch", metadata={"section": name})

for name, prompt in [
    ("intro",      "Write an intro to quantum computing"),
    ("analysis",   "Analyse current quantum hardware"),
    ("conclusion", "5-year outlook for quantum computing"),
]:
    threading.Thread(target=researcher, args=(name, prompt)).start()

An orchestrator script sends a coding task to a Claude Code instance running in a tmux window. push_and_wait blocks until Claude finishes and the result is relayed back — no polling, no SSH, no copy-paste.

# terminal in your tmux session named "vibe", window 0
pip install contextrelay
contextrelay-bridge start --tmux vibe --task-channel vibe-tasks --done-channel vibe-done

import os
from contextrelay import ContextRelay, AgentBridge

relay  = ContextRelay(api_key=os.environ["CONTEXTRELAY_API_KEY"])
bridge = AgentBridge(relay, task_channel="vibe-tasks", done_channel="vibe-done")

result = bridge.push_and_wait(
    "Refactor the auth module to use Firebase. "
    "Run the type checker. Return a summary of all changed files."
)

print(result)   # full Claude Code output, stripped of UI chrome

A pipeline stage produces output too large for the next step's context window. Checkpoint it to ContextRelay and reload only when you actually need it.

import os, json
from contextrelay import ContextRelay

relay = ContextRelay(api_key=os.environ["CONTEXTRELAY_API_KEY"])

# Step 1 — SQL extraction produces 80 KB JSON
raw_data = run_sql_query()
url = relay.push(
    json.dumps(raw_data),
    metadata={"step": "sql_extraction", "rows": len(raw_data)},
)

# Step 2 — peek first: is this worth the analysis cost?
meta = relay.peek(url)
if meta["rows"] < 100:
    print("Too few rows — skip analysis")
else:
    # Step 3 — pull only when needed, in the agent that needs it
    data = json.loads(relay.pull(url))
    run_analysis_agent(data)

Encryption is opt-in per push. Use it for any payload containing PII, credentials, or proprietary data.

relay = ContextRelay(api_key=os.environ["CONTEXTRELAY_API_KEY"])

# Encrypt on push — a fresh AES key is generated locally
url = relay.push(sensitive_payload, encrypted=True)
# url → "https://.../pull/<uuid>#key=<base64-fernet-key>"

# Anyone with the full URL can decrypt; anyone without #key= cannot
result = relay.pull(url)   # decrypted locally, never on the server

pip install contextrelay[crypto]   # or: pip install cryptography

Every SDK method maps to a Worker endpoint. Authenticate with Authorization: Bearer cr_live_....

curl -X POST https://contextrelay.hashim-cmd.workers.dev/push \
  -H "Authorization: Bearer $CONTEXTRELAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"data": "hello from curl"}'

Register ContextRelay as a native MCP server so Claude can push and pull context without leaving the conversation.

// ~/.claude/mcp.json  or  .mcp.json in project root
{
  "mcpServers": {
    "contextrelay": {
      "command": "contextrelay-mcp",
      "env": {
        "CONTEXTRELAY_URL": "https://contextrelay.hashim-cmd.workers.dev",
        "CONTEXTRELAY_API_KEY": "cr_live_..."
      }
    }
  }
}

Available tools: push_context, peek_context, pull_context.

Max payload: 25 MB · TTL: 24 hours.