Git remembers what changed. Relay remembers why.

When a PR merges, the reasoning behind it evaporates — what was tried and rejected, what gotcha the diff quietly works around, which approach the team chose and why. The next developer (or the next AI agent) starts blind and re-makes the same mistakes. That's the handoff problem.

Relay turns the events already in your workflow into durable, trustworthy memory:

• Captures automatically — on every PR merge (GitHub webhook), it pulls the diff, commits, and review threads (where the real decisions live).
• Synthesizes the why / what-was-rejected / watch-outs with Cerebras.
• Builds a conflict-aware knowledge graph on Backboard — when two PRs make contradictory architectural decisions, it flags the conflict for a human instead of letting it merge silently; when PRs agree, it raises a confidence score.
• Serves it to humans and agents — a web UI for developers, and a sync into Backboard's R-CLI so a coding agent inherits the full decision history before it writes a line of code.

Live demo: https://relay-8090.fly.dev · Built at the 8090 × Highline Beta Hackathon (June 2026). See PLAN.md for full architecture, API notes, and roadmap.

Two engineers solve "keep users logged in" two incompatible ways — server-side sessions vs stateless JWTs. Without Relay, both merge and the codebase has a split-brain auth system nobody flagged. With Relay, the moment the second PR merges:

⚠️  PR #7 (JWT) conflicts with PR #6 (server-side sessions)
    reason: mutually-exclusive auth mechanisms — adopting both is contradictory
    → flagged for human review, not silently overwritten

Ask the system "sessions or JWT for auth?" and it surfaces both approaches and the unresolved conflict — to a developer in the UI, or to a coding agent in R-CLI.

                          ┌──────────────── CAPTURE (on PR merge) ────────────────┐
GitHub PR merged ─webhook─▶ pull diff + commits + REVIEW THREADS   (github.py)
                          │   → Cerebras synthesizes a memory entry  (cerebras_client.py)
                          │   → store in Backboard                   (backboard_client.py)
                          │   → reconcile(): classify vs related memories  (graph.py)
                          │        conflict   → flag BOTH, cross-link, record why  (never auto-resolve)
                          │        corroborate→ bump confidence, record agreeing PRs
                          │   → sync into the active R-CLI session
                          └────────────────────────────────────────────────────────┘

question ─▶ Backboard RAG search ─▶ Cerebras streams a CITED answer that surfaces
            each memory's epistemic state ("⚠️ conflicts with #6", "corroborated by 3 PRs")

The knowledge graph = memory entries (nodes) + relationships stored in their Backboard metadata (conflicts_with, corroborated_by, confidence, status). Retrieval is vector RAG; the graph layer annotates every result with whether it's contested or corroborated — memory you can trust, not just recall.

python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env     # fill in CEREBRAS_API_KEY + BACKBOARD_API_KEY (multiple CEREBRAS_API_KEY_* keys round-robin)
# RELAY_ASSISTANT_ID is preset for the shared store; to make your own:
python -m relay.backboard_client bootstrap

python scripts/smoke_test.py                              # verify both sponsor APIs are live
python -m relay.server                                    # web UI → http://localhost:8000

python -m relay.cli capture "owner/repo#123"             # capture one PR (quote the # for the shell)
python -m relay.cli seed owner/repo --count 5            # backfill a repo's recent merged PRs
python -m relay.cli ask "why was X changed, and is there a conflict?"
python -m relay.cli sync-rcli --watch                    # keep R-CLI sessions auto-synced with memory
python -m relay.cli reset                                 # wipe the store clean

Auto-capture on merge: point a GitHub webhook (pull_request events) at https://<host>/webhook — every merge then captures itself in the background and animates the UI live.

docker compose up --build       # the whole engine in a container (UI + webhook + memory)

The live demo is this same image deployed on Fly.io.

Python · FastAPI · Cerebras (gpt-oss-120b) · Backboard (memory/RAG + R-CLI) · GitHub Webhooks · Server-Sent Events · Docker · Fly.io

• Cerebras rate limits are per-org — Relay round-robins across multiple CEREBRAS_API_KEY_* keys to spread load. seed/backfill is throttled by default.
• .env is git-ignored — never commit keys.
• Conflict detection is an LLM judgment that flags for a human — it reduces silent contradictions, it doesn't claim to be infallible. Roadmap: atomic-claim graph, graph-aware retrieval, and Relay as an MCP server so any agent loads it natively. See PLAN.md.