rz

Universal messaging for AI agents — cmux, zellij, NATS, or any terminal.

One binary that works in cmux, zellij, or any plain terminal via PTY wrapping. Spawn agents, send messages, bridge across machines with NATS — rz send peer "hello" works the same way everywhere.

Auto-detects your environment: cmux (CMUX_SURFACE_ID), zellij (ZELLIJ), or use rz agent for any terminal.

Fork of rz by @HodlOg. Zellij support based on meepo/rz.

Install

cargo install rz-agent

From source (macOS requires codesign):

git clone https://github.com/iliasoroka1/rz
cd rz
make install    # builds, signs, copies to ~/.cargo/bin/

Crates

Quick start

Inside a multiplexer (cmux / zellij)

# Spawn agents (auto-detects your multiplexer)
rz run --name lead -p "refactor auth, spawn helpers" claude --dangerously-skip-permissions
rz run --name coder -p "implement session tokens" claude --dangerously-skip-permissions

# Observe and interact
rz list                    # see who's alive
rz log lead                # read lead's messages
rz send lead "wrap up"     # intervene

Any terminal (no multiplexer needed)

# Start a NATS server
nats-server -js
export RZ_HUB=nats://localhost:4222

# Run an agent with PTY wrapping — works in any terminal
rz agent --name worker -- claude --dangerously-skip-permissions

rz agent creates a pseudo-terminal, wraps the command, and subscribes to NATS. Incoming messages are injected directly into the child's input as @@RZ: lines. No cmux or zellij required.

┌──────────────┐       ┌──────────┐       ┌──────────────────────┐
│ rz send      │──pub──│  NATS    │──sub──│ rz agent --name X    │
│ worker "msg" │       │ agent.X  │       │  ├─ NATS subscriber  │
└──────────────┘       └──────────┘       │  ├─ writes @@RZ: to  │
                                          │  │  PTY master fd    │
                                          │  └─ child sees it    │
                                          │     as typed input   │
                                          └──────────────────────┘

Cross-machine / cross-multiplexer (NATS)

Agents in cmux and zellij can talk to each other via NATS:

# Start a NATS server with JetStream (messages survive restarts)
nats-server -js

# Set the hub URL (add to your shell profile)
export RZ_HUB=nats://localhost:4222

# cmux terminal: spawn an agent — NATS listeners auto-start
rz run --name worker claude --dangerously-skip-permissions

# zellij terminal: send to the cmux agent — routes through NATS
rz send worker "process batch 42"

When RZ_HUB is set, rz run automatically starts background NATS listeners for both the new agent and the lead. No manual rz listen needed.

Universal agents (file mailbox, HTTP)

# Register agents with different transports
rz register --name worker --transport file
rz register --name api --transport http --endpoint http://localhost:7070

# Send — rz picks the right transport automatically
rz send worker "process this batch"

# Receive from file mailbox
rz recv worker             # print and consume all pending
rz recv worker --one       # pop oldest message

Backends

rz auto-detects the environment:

Both backends support the same commands. Backend-specific features:

Transports

Message routing

rz send coder "implement auth"
    |
    +-- resolve "coder" -> names.json -> surface titles -> registry -> NATS
    |
    +-- cmux?    -> paste @@RZ: envelope into cmux surface
    +-- zellij?  -> paste into zellij pane
    +-- file?    -> write to ~/.rz/mailboxes/coder/inbox/
    +-- http?    -> POST to registered URL
    +-- nats?    -> publish to agent.coder (via RZ_HUB)

Protocol

Every message is a single line: @@RZ:<json>

{
  "id": "a1b20000",
  "from": "lead",
  "to": "coder",
  "ref": "prev-msg-id",
  "kind": { "kind": "chat", "body": { "text": "implement auth" } },
  "ts": 1774488000000
}

Message kinds

Commands

Agent lifecycle

Messaging

Discovery

File mailbox

NATS

Delivery methods: stdout, file, cmux:<surface_id>, zellij:<pane_id>

Observation

Workspace

Browser (cmux only)

Zellij-specific

Project structure

rz/
├── crates/
│   ├── rz-protocol/        # @@RZ: wire format (transport-agnostic)
│   │   └── lib.rs           # Envelope, MessageKind, encode/decode
│   ├── rz-cli/
│   │   ├── main.rs           # CLI commands + auto-detect backend
│   │   ├── backend.rs        # Backend trait + CmuxBackend + ZellijBackend
│   │   ├── cmux.rs           # cmux socket client
│   │   ├── zellij.rs         # zellij CLI wrapper
│   │   ├── pty.rs            # PTY agent wrapper (no multiplexer)
│   │   ├── nats_hub.rs       # NATS transport (JetStream + core)
│   │   ├── registry.rs       # Agent discovery (~/.rz/registry.json)
│   │   ├── mailbox.rs        # File-based message store
│   │   ├── transport.rs      # Pluggable delivery abstraction
│   │   ├── bootstrap.rs      # Agent bootstrap message
│   │   ├── log.rs            # @@RZ: message extraction
│   │   └── status.rs         # Session status
│   └── rz-hub/               # Zellij WASM plugin (optional)
│       ├── main.rs            # Plugin lifecycle
│       ├── registry.rs        # Agent registry + name index
│       └── router.rs          # Pipe dispatch + message routing
└── Makefile                   # build + codesign + install + publish

Credits

Forked from rz (crates.io/crates/rz-cli) by @HodlOg. Zellij support based on work by @meepo. The @@RZ: protocol, bootstrap design, and core messaging architecture are from the original project.

License

MIT OR Apache-2.0