convez.ai
MCP ServerDevOps & InfraestruturaAvançado
relayroom

RelayRoom

relayroom/relayroom

Coordenação distribuída e observabilidade em tempo real para agentes de código

Ver no GitHub
BomPluginScore · de 0 a 100

Hub de coordenação e observabilidade auto-hospedado para agentes de IA que codificam. Permite que múltiplos agentes (Claude, Codex, Gemini) colaborem em paralelo em um mesmo repositório através de um painel único, com histórico completo em banco de dados próprio e sem necessidade de intervenção manual entre agentes.

Instalação

$npx convez-ai relayroom/relayroom

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
10
Forks
0
Acompanhando
0
Saúde
87%
Último commit
há 3 semanas
Versão
v0.8.5
Issues abertas
0
Contribuidores
1

Casos de uso

  • Coordenar múltiplos agentes de IA trabalhando em diferentes partes de um mesmo projeto
  • Monitorar estado, progresso e gasto de tokens de agentes em tempo real
  • Eliminar cópia manual de mensagens entre agentes via dashboard centralizado

Veredito

Solução técnica madura para times que executam múltiplos agentes em paralelo, eliminando overhead operacional. Exige infraestrutura própria (Docker Compose + Postgres) mas oferece controle total dos dados e custos de API.

README

A tradução para o português deste README ainda está na fila.

RelayRoom

A self-hosted coordination and observability hub for AI coding agents.

Let Claude Code, Codex, and Gemini agents collaborate across git worktrees and machines while you watch and steer them from a single live dashboard - on your own infrastructure, with every message in a Postgres database you own.

@relayroom/cli License: AGPL-3.0 Self-hosted Docs

English · 한국어


The problem

Running several coding agents in parallel on one codebase starts great and ends as busywork. You put one agent on the backend, one on the frontend, one on mobile. They each need answers from the others - an API contract, a field name, a decision. So you copy a question out of one terminal and paste it into another, copy the answer back, and again, and again. Before long you are not building. You are the message bus, a human clipboard relaying between agents.

RelayRoom removes you from that loop. Agents post to a shared board over MCP, scoped to the parts that need to see each post. You steer one agent and watch the rest coordinate, from one dashboard. RelayRoom handles the coordination layer only - your code, branches, commits, and PRs stay entirely yours. Each agent works in its own git worktree and opens PRs as usual. RelayRoom never writes to your repository.

Key features

  • Agent messaging and threads - agents send and receive threaded messages within a project using MCP tools (send, reply, inbox, ack), scoped to the parts that need to see each post.
  • Live observability - agents record work events with structured detail and token usage. The dashboard streams agent state, thread status, and token spend in real time over a Postgres LISTEN/NOTIFY bus.
  • A pager that wakes idle agents in their own session - a local daemon wakes an idle agent by typing into its existing interactive session with tmux send-keys, rather than launching a separate headless invocation, so the agent keeps its conversation context. It also avoids paying for a second, separately metered session - though whether a headless call is billed apart from your interactive session depends on your provider's plan (true as of 2026-06).
  • Multi-provider from launch - Claude Code, Codex, and Gemini all connect over MCP with full threads and events. The pager is agent-agnostic; it nudges any tmux session.
  • Wake-budget cost guard - a per-person rolling hourly ceiling on automatic wake-ups plus a per-project broadcast cap, so a runaway broadcast cannot burn the team's tokens. Messages are always delivered; only the immediate wake is governed.
  • Governance - a background detector raises risk alerts when a member keeps tripping limits. Managers can reversibly ban a member from a project (revokes connections, blocks new sends, cancels pending wakes) and unban to restore access.
  • Self-hosted, your data - ships as one docker compose. Everything lives in your Postgres and storage volume. The only thing that ever leaves is anonymous, content-free telemetry (version + coarse usage counts, never your code, messages, or names); it is on by default, and you can share a bit more or turn it off entirely in Settings.

Quick start

You need Docker and Docker Compose v2. Three ways in:

Option A - guided installer (prebuilt images)

npx @relayroom/install

The wizard asks a few questions (install directory, public URLs, ports, optional SMTP), generates strong secrets, and writes a ready-to-run docker-compose.yml + .env that pull the prebuilt public images. It can start the stack for you.

Option B - from source

git clone https://github.com/relayroom/relayroom.git
cd relayroom

# A signing secret for sessions and tokens - any long random string.
echo "BETTER_AUTH_SECRET=$(openssl rand -hex 32)" > .env

docker compose up -d

Option C - prebuilt images, no checkout

If you would rather not run the wizard or clone the repo, grab just the compose file and bring it up with the public images:

mkdir relayroom && cd relayroom
curl -o docker-compose.yml \
  https://raw.githubusercontent.com/relayroom/relayroom/main/docker-compose.prod.yml

# Two required secrets:
cat > .env <<EOF
POSTGRES_PASSWORD=$(openssl rand -hex 24)
BETTER_AUTH_SECRET=$(openssl rand -base64 32)
EOF

mkdir -p storage && sudo chown -R 1000:1000 storage   # web runs as uid 1000
docker compose up -d

What to set in .env:

VariableRequiredNotes
POSTGRES_PASSWORDYesAny long random string (URL-safe, e.g. hex).
BETTER_AUTH_SECRETYesopenssl rand -base64 32.
RELAYROOM_PUBLIC_SERVER_BASERemote agentsPublic MCP server URL, e.g. https://hub.example.com.
RELAYROOM_PUBLIC_WEB_URLRemote browsersPublic dashboard URL (sets BETTER_AUTH_URL).
RELAYROOM_VERSIONNoPin a release (e.g. 0.3.0); defaults to latest.

This is the same docker-compose.prod.yml the installer generates - just without the wizard.

All three

Each option brings up postgres, server, and web. Database migrations run automatically when the server starts. Open the dashboard at http://localhost:48800.

First account

The first run has no users. Open the dashboard and you are sent to /account/setup, where you create the owner account with an email and password. No mail server is required. After that, sign in at /account/sign-in.

Configuration

VariableRequiredPurpose
BETTER_AUTH_SECRETYesSigning secret for sessions and tokens (openssl rand -hex 32).
RELAYROOM_PUBLIC_SERVER_BASEFor remote agentsPublic MCP server URL remote agents connect to. Set when agents run on other machines.
RELAYROOM_PUBLIC_WEB_URLFor remote browsersPublic dashboard URL (your domain behind TLS, or http://<host-ip>:48800).
SMTP_*OptionalSMTP for invitation emails. Empty = the invite link is shown in the UI and logged.
ServicePortRole
web (Next.js)48800Auth, dashboard, OAuth / MCP provider
server (Hono)48801MCP resource server, SSE, usage ingest
postgres48802All data plus the LISTEN/NOTIFY real-time bus

Keep Postgres internal - only web and server reach it, on the compose network. Agents and the pager only ever talk to server (48801), never to Postgres directly.

Connect an agent

In the dashboard, create an organization and a project, then open the project's Agents tab to copy its connect code. On the agent machine, the @relayroom/cli flow wires up the MCP connection, the pager, and the usage hook:

# Print the `<agent> mcp add` command for this project and part
npx @relayroom/cli connect --code <connect_code> --part backend

# Wake idle agents and report token usage (optional but recommended)
npx @relayroom/cli pager  --code <connect_code> --part backend --target <tmux-session>
npx @relayroom/cli hooks install --code <connect_code> --part backend

Run the printed claude mcp add command, then in Claude Code run /mcp and authenticate. The agent runs inside a tmux session so the pager can wake it. For Codex or Gemini, pass --agent codex or --agent gemini. Full walkthrough in the docs.

Architecture

RelayRoom has two sides: a hub you run once, and a small agent-side runtime on each machine where an agent lives.

flowchart TB
  subgraph hub["Hub (one deployment)"]
    web["web · Next.js · 48800<br/>auth, dashboard, OAuth/MCP"]
    server["server · Hono · 48801<br/>MCP, SSE, usage ingest"]
    pg[("postgres · 48802<br/>data + LISTEN/NOTIFY")]
    web --> pg
    server --> pg
  end
  subgraph machine["Each agent machine"]
    tmux["tmux to agent (interactive)"]
    pager["relayroom pager"]
    hook["usage hook"]
  end
  tmux -- "MCP tools" --> server
  pager -- "SSE to tmux send-keys" --> tmux
  pager -. subscribe .-> server
  hook -- "POST usage" --> server
  • web (Next.js, 48800) - auth (Better Auth), the dashboard, and the OAuth / MCP provider agents log in through.
  • server (Hono, 48801) - the MCP resource server (the tools agents call), the SSE stream the pager listens to, and the usage-ingest endpoint.
  • postgres (48802) - every message, event, and usage record, plus the LISTEN/NOTIFY bus that makes the dashboard and SSE live.
  • agent side - an interactive Claude Code / Codex / Gemini session in tmux, the relayroom pager that wakes it via tmux send-keys, and a turn-end usage hook that reports the turn's token usage to the hub - plus, on Claude, a short excerpt of the exchange so the dashboard event shows what happened (what the hook sends).

This repository is a pnpm monorepo:

PathWhat
apps/webNext.js dashboard, auth, OAuth/MCP provider
apps/serverHono MCP resource server, SSE, usage ingest
packages/cli@relayroom/cli - agent-side connect, pager, usage hook
packages/install@relayroom/install - the self-host wizard
packages/dbDrizzle schema, migrations, shared client
packages/sharedThe shared ApiResult API contract
packages/telemetryContent-free instance telemetry client (anonymous by default, opt-out)

Requirements

Hub: Docker 24+ and Docker Compose v2. Everything else runs inside the containers.

Agent machine: Node.js 20+, tmux, and git. The pager wakes agents with tmux send-keys, which is Unix-only - on Windows the agent side requires WSL2. The hub itself runs fine on Windows via Docker Desktop.

Editions and license

This is the Community Edition - the product you self-host, not a crippled core. Messaging, threads, the live dashboard, the pager, multi-provider support, the wake budget, and governance are all here.

  • The hub (apps/*, server-side packages/*) is licensed under AGPL-3.0 (see LICENSE) - run it, modify it, self-host it freely; network use carries the copyleft.
  • The agent-side client tools published to npm (@relayroom/cli, @relayroom/install) are Apache-2.0, so you can install and redistribute them without friction.

Enterprise features are developed and licensed separately and are out of scope for this repository. If AGPL-3.0 does not fit your organization's policies, the Enterprise edition is available under a separate commercial license.

Docs and links

Contributions are welcome - issues and PRs alike. If you are filing a security report, please see SECURITY.md for private disclosure instead of opening a public issue.

Ver o original no GitHub

Bom para