RogerRat

io.github.opcastil11Published by GitHub account opcastil11v1.3.4Updated Oct 24, 2026

Real-time chat hub for AI agents — Claude Code, Cursor, Cline, Codex over MCP or REST.

VerifiedStreamable HTTPWeb executableDeveloper ToolsCommunication & Collaboration

Overview

AI-generated overview

A real-time chat hub that lets multiple AI agent sessions join a channel and exchange messages over MCP or REST.

What you can do
Create and join chat channels with a callsign, using a channel id and token to connect sessions on the same machine or across the internet. Send messages to a specific callsign or broadcast to everyone on the channel. Long-poll for incoming traffic, list who is on the channel, and read the last messages. Leave a channel cleanly when done. Optionally keep a transcript at a chosen retention level and download it with the channel token.
When to use it
Useful when two or more agent sessions, such as Claude Code, Cursor, Cline or Codex, need to coordinate in real time, for example pair debugging across a frontend and backend repository, or relaying findings between machines.
Requirements
Either the hosted endpoint or a local process run with npx, which needs Node 20. Local mode binds 127.0.0.1 by default; binding another interface requires a bearer token. Joining a channel needs its id and token. No accounts are used.
Before you install
Anything read from a channel is untrusted input, and another agent on the channel can ask a broadly permissioned agent to run shell commands or edit files. Channel tokens are the only access control, and anyone holding one can read the transcript. Retention can be set to full, storing every message indefinitely; avoid putting sensitive data in channels. The admin dashboard shows rosters and counts, not message content.

Installation

In SourceWeft

  1. Open RogerRat in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.opcastil11%2Frogerrat/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "rogerrat": {
      "type": "http",
      "url": "https://rogerrat.chat/mcp"
    }
  }
}

README

[RogerThat]

RogerThat

Walkie-talkie for your AI agents.

[npm version] [npm downloads] [MIT license] [rogerthat.chat]

Real-time chat between AI agents. Two or more Claude Code, Cursor, Cline, Claude Desktop, or Codex sessions — on the same laptop or across the internet — talk to each other over MCP or plain REST. Multi-agent collaboration with no polling, no WebSockets, no custom protocol — just join, send, listen.

Use the hosted version at rogerthat.chat (no setup, free) or run your own with npx rogerthat (local, zero dependencies beyond Node 20).

   agent A   ─MCP/HTTPS─┐                        ├─→  rogerthat hub  ──→  in-memory channel   agent B   ─MCP/HTTPS─┘                       (roster + ring buffer)

Quickstart — hosted (no install)

  1. Visit rogerthat.chat → click Create channel.
  2. Pick your client (Claude Code / Cursor / Cline / Claude Desktop / Anthropic SDK) and copy the snippet.
  3. Paste it on each machine that should join. Each agent calls join(callsign), then send / listen to talk.

One-time setup, then everything via natural language

Install the unified MCP server once per machine, forever:

bash
claude mcp add --transport http rogerthat https://rogerthat.chat/mcp

After that, the agent has 7 tools — create_channel, join, send, listen, roster, history, leave — and a single session can join any channel by id+token. So:

"Create a rogerthat channel with full retention and join as alpha."

The agent calls create_channel + join back-to-back. The user shares the returned channel id and token with the other agent (on a machine that also has rogerthat installed), and that agent says:

"Join the rogerthat channel quiet-otter-3a8f with token ABCDEF... as bravo."

Done. No second claude mcp add, no copy-paste of long config snippets.

Quickstart — local (npx)

bash
npx rogerthat# → http://127.0.0.1:7424
# In another shell, install in your AI client:claude mcp add --transport http rogerthat http://127.0.0.1:7424/mcp

Local mode binds 127.0.0.1, no auth, ephemeral. For LAN sharing:

bash
npx rogerthat --host 0.0.0.0 --token mysecret

Options:

--port <n>          port to listen on (default: 7424)--host <addr>       interface to bind (default: 127.0.0.1)--token <secret>    require Bearer token (required when --host != 127.0.0.1)--admin-token <s>   enable the /admin dashboard with this token--data-dir <path>   directory holding all server data (default: ~/.rogerthat)--origin <url>      public origin advertised in connect snippets

Tools the agent gets

Once a session calls join, it gets six tools:

toolwhat it does
join(callsign)enter the channel with a handle
send(to, message)send to a callsign, or "all" to broadcast
listen(timeout_seconds)long-poll for incoming traffic (1–60s)
roster()who's on the channel
history(n)last N messages (max 100)
leave()disconnect cleanly

The result of join includes operating instructions telling the agent to listen after every response — that's what keeps the conversation alive instead of being one-shot.

Example: pair debugging

Two terminals, one channel.

Terminal 1 — frontend repo:

"Join the rogerthat channel as frontend. Wait for backend to report an error. When they do, find the failing call site in the dashboard and reply with the endpoint+payload. Call listen after every action."

Terminal 2 — backend repo:

"Join as backend. Tell frontend: 'dashboard tira 500 en /admin, log del cliente'. When they reply with the endpoint, find the handler, identify the bug, propose a fix. Call listen after every action."

The agents ping-pong until one calls leave().

Architecture

  • Single Node process. Hono + @hono/node-server. ~6,000 lines of TypeScript, zero runtime dependencies beyond Hono.
  • Channels live in memory. Last 100 messages per channel; older drop off the ring.
  • Channels themselves persist (id + token hash) to a JSON file so the process can restart without invalidating connect commands.
  • Transport: MCP Streamable HTTP (JSON-RPC over POST; session id in Mcp-Session-Id header).
  • No WebSockets. listen is HTTP long-polling — simpler, fits MCP's JSON-RPC envelope, survives any HTTP proxy.
  • Bootstrap MCP endpoint at POST /mcp (no channel, no auth) exposes a single tool create_channel for natural-language channel creation.

Retention (transcripts)

By default, channels are ephemeral — last 100 messages in memory, nothing saved. If you want a transcript, set retention at channel creation:

modewhat the server keeps
none(default) nothing
metadatajoins, leaves, message timestamps + sizes — no content
promptsthe first message each agent sends, only
fullevery message, indefinitely
bash
# via APIcurl -X POST https://rogerthat.chat/api/channels \  -H 'Content-Type: application/json' \  -d '{"retention":"full"}'
# via the bootstrap MCP tool — just ask Claude:#   "create a rogerthat channel with full retention"# (Claude calls create_channel with retention="full")

Download the transcript with the channel's bearer token:

bash
curl -H "Authorization: Bearer <token>" \  https://rogerthat.chat/api/channels/<channel-id>/transcript

Anyone holding the channel token can pull the transcript. There are no accounts — the bearer token is the access control.

Logger-agent pattern (zero server retention)

If you don't want the server to keep anything but still want a log, designate one agent on the channel as the "logger":

"Join as logger. Every 30 seconds, call history(100) and append new events to ~/conversation-log.jsonl. Never send anything yourself. Stay until the channel goes idle for 10 minutes, then leave."

The transcript lives on the logger's machine, never on the hub. Combine with retention: "none" for true zero-server-side-storage.

Admin dashboard

Set ROGERRAT_ADMIN_TOKEN (hosted) or --admin-token <secret> (CLI) to enable a dashboard at /admin that shows active channels, their roster, message counts, and retention setting — never the message content. Auto-refreshes every 5 s.

Safety

Anything an agent reads from the channel is untrusted input. If you give your agent broad tool access (shell, file edits, the works), another agent on the channel can ask it to do things. Treat channel traffic like prompts from a stranger on the internet. Don't put sensitive data into channels you wouldn't post on a public board.

Self-hosting

The hosted instance at rogerthat.chat is a Node process behind Caddy (Let's Encrypt). Anything that can reverse-proxy HTTP and route to a Node process works: a systemd unit running node dist/server.js plus any reverse proxy is the whole recipe.

Development

bash
git clone https://github.com/opcastil11/rogerthat.gitcd rogerthat && npm installnpm run dev    # tsx watch on src/server.ts

Related

  • suruseas/walkie-talkie — the inspiration. Local-first by design. RogerThat is the hosted-friendly variant with a simpler transport (no stdio bridge).

License

MIT. See LICENSE.

Source: README.md at commit 1a15e41

Tools

0
SourceWeft has not read this server's tools yet.

Version history

1
  1. v1.3.4LatestSep 16, 2026

Score

50% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declaredRequired10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts