Nexo Rs

nexo-rs — Rust multi-agent LLM framework (OpenClaw alternative)

> The Rust alternative to OpenClaw. > Multi-agent LLM gateway for WhatsApp, Telegram, Gmail and the browser — > single static binary, event-driven (NATS or a built-in local broker — > no external infra), fault-tolerant, MCP-native. Boots with zero config.

[](https://lordmacu.github.io/nexo-rs/) [](#license) [](https://www.rust-lang.org/) [](#inspired-by-openclaw-supercharged-by-rust)

📘 Full documentation:

Quick start · Architecture · Recipes · vs OpenClaw · Contributing · Releases · [License](#license)

nexo-rs is a Rust multi-agent LLM framework — an OpenClaw alternative in Rust — for building WhatsApp bots, Telegram bots, Gmail pollers and browser agents behind a single binary. Event-driven over NATS or a built-in local broker (stdio-bridge for subprocess plugins — no NATS server, no external infra), with per-agent tool sandboxes, MCP client + server, Claude / Anthropic / MiniMax / OpenAI-compatible / Gemini / DeepSeek providers, durable workflows (TaskFlow), and drop-in configuration for private vs. public agents.

One process, many agents, many channels. Kate handles your personal Telegram; Ana works the WhatsApp sales line; a cron-style poller sweeps Gmail for leads — all sharing one broker, one tool registry, one memory layer.

Install the pre-built binary (curl … install.sh | bash on Linux/macOS, cargo install nexo-rs on Windows, or a .deb / .rpm / Termux .deb from GitHub Releases), then nexo — the daemon boots against documented defaults with no config dir. Add a channel plugin with nexo plugin install /, a persona with nexo persona install /, or scaffold 19 commented sample YAMLs with nexo init.

Keywords: OpenClaw alternative · Rust agent framework · multi-agent LLM · WhatsApp LLM bot · Telegram AI agent · Gmail agent · MCP server Rust · NATS agent gateway · Claude Code subscription · Anthropic OAuth PKCE · agent framework Termux · self-hosted AI agents.

---

Install

Every channel produces the same nexo binary — the differences are how it lands on your machine. The one-liner needs no Rust toolchain.

| Method | Command | Notes | |--------|---------|-------| | Pre-built binary (Linux / macOS) | curl -fsSL https://lordmacu.github.io/nexo-rs/install.sh \| bash | Linux x86_64 / aarch64 (static musl), macOS Intel / Apple Silicon. Detects OS+arch, verifies sha256, drops nexo on PATH, then installs the bundled plugins + a persona. Falls back to cargo install nexo-rs. Works on Windows too when run from Git Bash. |

| Windows (zip from Releases) | Download nexo-rs-x86_64-pc-windows-msvc.zip from Releases and extract nexo.exe to a folder on PATH. | Verify the bundled *.sha256 manually before extracting. Or just use the cargo install row below. | | crates.io | cargo install nexo-rs | Needs a Rust toolchain (1.80+). Compiles the daemon from the published workspace. Works on every platform Rust supports. | | Debian / Ubuntu | sudo apt install ./nexo-rs__amd64.deb | Download the .deb from Releases. Ships a systemd unit; postinst seeds /etc/nexo-rs/. | | Fedora / RHEL / Rocky | sudo dnf install ./nexo-rs--1.x86_64.rpm | .rpm from Releases. Same systemd unit. | | Termux (Android, aarch64) | pkg install ./nexo-rs__aarch64.deb | aarch64 .deb (bionic libc) from Releases. No root. | | Docker / GHCR | docker pull ghcr.io/lordmacu/nexo-rs:latest | Multi-arch (amd64 + arm64); bundles Chrome, cloudflared, ffmpeg, tesseract, yt-dlp; carries SBOM + SLSA provenance. | | Nix flake | nix run github:lordmacu/nexo-rs | Reproducible dev shell + binary. | | From source | git clone https://github.com/lordmacu/nexo-rs && cd nexo-rs && cargo build --release | Track main. --profile release-fast for ~50 % quicker iterative builds. |

Every release artifact (tarball, .deb, .rpm, .zip) ships a .sha256 sidecar and a cosign signature. Per-OS prerequisites + the optional-feature (STT / voice / browser) matrix: Platform support. After installing, nexo boots with zero config — see [Quick start](#quick-start) below.

---

Why

Most "agent frameworks" assume a single LLM talking to a single user through a single UI. Real deployments aren't that shape:

• Several agents with different personas, models, and skills
• Multiple channels (WA + Telegram + mail) feeding the same agents
• Business logic that isn't LLM-driven (scheduled tasks, regex email

triage, lead notifications) running next to the LLM loop

• Private prompts and pricing tables alongside an open-source core

nexo-rs is opinionated toward that shape.

Inspired by OpenClaw, supercharged by Rust

nexo-rs stands on the shoulders of OpenClaw: its plugin SDK, its multi-channel gateway shape, and its "agents-on-real-messengers" thesis are the seed of this project. OpenClaw proved the model works. nexo-rs takes that blueprint and rebuilds it on a substrate Node simply cannot match — Rust, tokio, NATS — so the runtime can do things the original never could:

• Single static binary, ~90 MB (the release tarball you download

is ~15 MB, xz-compressed; .deb ~18 MB, .rpm ~25 MB). No pnpm install, no node_modules, no runtime VM. Drop the binary on a Termux phone, a Raspberry Pi, a Proxmox container — it runs.

• Memory-safe by construction. Rust's ownership model refuses

whole bug classes at compile time: use-after-free, data races, null deref. The agent loop is unsafe-free.

• True parallelism. tokio + per-agent runtimes + share-nothing

per session. No JS event loop bottleneck — Kate, Ana, the gmail poller, the browser CDP session and 30 LLM turns run on real threads at once.

• Fault-tolerant by default. Every external call sits behind a

circuit breaker. NATS down? In-process mpsc + on-disk queue + DLQ takes over and drains on reconnect. No dropped messages, no duplicates.

• Hot reload without dropping in-flight turns. agent reload

swaps a RuntimeSnapshot via ArcSwap; turns mid-flight finish on the old config, new turns pick up the new one.

• Per-agent capability sandbox. allowed_tools,

outbound_allowlist, skill_overrides, accept_delegates_from and per-binding overrides — the LLM literally never sees tools it isn't entitled to.

• Durable workflows (TaskFlow). wait / finish / fail LLM

tools with Timer / ExternalEvent / Manual resume — flows survive restarts.

• Both sides of MCP. Client (stdio + HTTP) and agent-as-server

(agent mcp-server).

• Claude subscription auth. OAuth PKCE on top of API keys —

reuse your Claude Code subscription quota.

• Observability built in. Prometheus on :9090, health on

:8080, admin console on 127.0.0.1:9091, JSONL transcripts with FTS5 + opt-in regex redactor.

Side-by-side

| Dimension | OpenClaw | nexo-rs | |-----------|----------|---------| | Language / runtime | TypeScript on Node 22+ | Rust, no runtime — single binary; pre-built for Linux / macOS / Windows + .deb / .rpm / Termux | | Install footprint | pnpm install (~42 runtime deps) + Node | one ~90 MB binary; ~15 MB to download (xz tarball), ~18 MB .deb, ~25 MB .rpm | | First boot | wire .env + config before it runs | zero-config — nexo boots against documented defaults; nexo init scaffolds 19 commented YAMLs | | Broker / process model | single Node process, in-memory | NATS (multi-host) or a local stdio bridge (single-host, no external server); subprocess plugins talk to whichever; nexo set-broker flips at runtime | | Fault tolerance | best-effort | broker has disk queue + DLQ + circuit breaker; events survive NATS outages | | Concurrency | JS event loop | tokio async + per-agent runtimes, share-nothing per session | | Hot reload | restart | agent reload swaps RuntimeSnapshot via ArcSwap — in-flight turns keep the old config | | Per-agent capability sandbox | global plugin allowlist | agents. has allowed_tools, outbound_allowlist, skill_overrides, accept_delegates_from, per-binding overrides | | Secret ops | env vars | agents..credentials per-channel + 1Password inject_template + JSONL audit log + agent doctor capabilities inventory | | Transcripts | JSONL (line-grep) | JSONL plus SQLite FTS5 index + opt-in regex redactor (Bearer JWT, sk-…, AKIA…, paths) | | Durable workflows | n/a | TaskFlow: wait/finish/fail LLM tools with Timer/ExternalEvent/Manual resume + taskflow.resume NATS bridge | | Claude auth | API key only | API key and claude_subscription OAuth PKCE flow (uses your Claude Code subscription quota) | | MCP | client only | client (stdio + HTTP) and agent-as-MCP-server (agent mcp-server) | | Mobile-friendly | requires Node + npm runtime | runs on Termux without root (no Docker, no Node) | | Memory safety | runtime errors | Rust ownership model — whole classes of bugs (use-after-free, data races, null deref) refused at compile time | | Bundled skills/extensions | many in extensions/ | 20+ skills + 30+ extensions (browser, gmail-poller, 1password, proxmox, ssh-exec, brave-search, wolfram-alpha, …) | | Plugin SDKs | TypeScript | Rust, Python, TypeScript, PHP — same wire spec; nexo plugin install / |

What we did not improve. OpenClaw has a richer installer flow, a longer track record, and a TypeScript surface that's familiar to a wider audience. If your shop is JS-first, picking it up is faster than learning Rust. nexo-rs trades that approachability for the operational properties above.

Full side-by-side: docs → vs-openclaw.

Status

v0.1.6 — GA. Stable release with pre-built binaries for Linux (x8664 / aarch64, static musl), macOS (Intel / Apple Silicon) and Windows, plus .deb / .rpm / Termux .deb packages, a multi-arch container (ghcr.io/lordmacu/nexo-rs), and crates.io publishing. Used in production for WhatsApp / Telegram sales bots and personal-assistant agents.

Shipped, end-to-end:

• Multi-agent runtime — SessionManager, Heartbeat, CircuitBreaker, agent-to-agent routing + delegation
• Broker — NATS (disk queue + DLQ + backpressure + single-instance lock) or local stdio-bridge; nexo set-broker flips at runtime; zero-config boot, nexo init scaffolds
• LLM stack — MiniMax M2.5 (primary), Anthropic (API + OAuth PKCE / Claude subscription), OpenAI-compatible, Gemini, DeepSeek; per-provider rate limit + retry
• Channels — WhatsApp (Signal Protocol, QR pairing), Telegram (full bot API), Email (IMAP/SMTP, multi-account), Browser (Chrome DevTools Protocol), Google (OAuth + Gmail/Calendar/Drive/Sheets) — extracted to standalone plugin repos, nexo plugin install /
• Tools — Web Search (Brave / Tavily / DuckDuckGo / Perplexity), multi-instance × multi-agent isolation
• Pollers — RSS / Atom feeds, Gmail inbox sweeps, Google Calendar event sync; cron-style, cursor-driven dedupe (Phase 96 poller v2)
• Memory — short-term in-memory, long-term SQLite, vector via sqlite-vec; snapshots
• Extensions — TOML manifest, stdio + NATS runtimes, CLI, 20+ skills, plugin SDKs in Rust / Python / TypeScript / PHP
• MCP — client (stdio + HTTP) and agent-as-server (nexo mcp-server), hot-reload
• TaskFlow — durable multi-step flows with Timer / ExternalEvent / Manual resume
• Soul — identity, MEMORY.md, dreaming, workspace-git forensics, JSONL transcripts (FTS5 + redactor)
• Personas — out-of-tree agent packs (v2 manifest, GitHub Releases), nexo persona install /
• Ops — Prometheus metrics, health endpoint, loopback admin console, hot-reload, secrets audit, cosign-signed release artifacts

Release-by-release notes live in [CHANGELOG.md](CHANGELOG.md).

Architecture

              ┌──────────────────┐
              │  NATS broker     │◄── fault-tolerant event bus
              │  — or local      │      (disk queue + DLQ when
              │  stdio bridge,   │       offline; local mode pipes
              │  no NATS server  │       broker.publish/event over
              └──┬────────────┬──┘       the daemon's stdio JSON-RPC)
 plugin.inbound.*│            │plugin.outbound.*
                 │            │
    ┌────────────┴──┐       ┌─┴─────────────┐
    │  Channel      │       │  Agent        │
    │  plugins      │       │  runtime      │
    │ (WA, TG, mail)│       │ (Kate, Ana…)  │
    └───────────────┘       └───┬───────────┘
                                │
                  ┌─────────────┼─────────────────────┐
                  │             │                     │
            ┌─────┴──┐    ┌─────┴──────┐      ┌───────┴────────┐
            │ Memory │    │ Extensions │      │  LLM providers │
            │(SQLite │    │ (stdio /   │      │ (Anthropic /   │
            │+ vec)  │    │  NATS /    │      │  MiniMax /     │
            └────────┘    │  MCP)      │      │  OpenAI-compat)│
                          └────────────┘      └────────────────┘

Every external call goes through a circuit breaker. NATS offline? The plugin falls back to a local tokio mpsc + disk queue and drains on reconnect. No events lost.

Quick start

# 1. Install — pre-built binary, no Rust toolchain needed:
curl -fsSL https://lordmacu.github.io/nexo-rs/install.sh | bash
#    OR  cargo install nexo-rs            # from crates.io
#    OR  docker pull ghcr.io/lordmacu/nexo-rs:latest
#    OR  download the .deb / .rpm / Termux .deb from
#        https://github.com/lordmacu/nexo-rs/releases/latest

# 2. Run — Phase 92-95: zero config, no NATS server needed
nexo

That's it for a smoke test. The daemon boots with sane defaults (broker=local, sqlite memory, 0 agents) and serves admin RPCs + health. From here, three paths to fill it in:

# A) Scaffold sample YAMLs (heavily commented)
nexo init                       # all 19 templates to ~/.config/nexo/
nexo init --yaml broker,llm     # just the ones you want
vi ~/.config/nexo/llm.yaml      # edit, set ${MINIMAX_API_KEY} env
nexo

# B) Switch broker at runtime (no YAML editing)
sudo systemctl start nats-server
nexo set-broker nats --url nats://localhost:4222

# C) Interactive wizard (classical path)
nexo setup                       # pairs WhatsApp, asks for API key,
                                  # walks Google OAuth for Gmail

nexo setup is interactive — pairs WhatsApp via QR, asks for your LLM API key, walks the Google OAuth consent if you want Gmail. Use it when you want a guided walkthrough; otherwise edit nexo init's scaffolded YAMLs by hand or call admin RPCs from the operator UI.

> Platform support: pre-built binaries for Linux x8664 + aarch64 > (musl static), macOS Intel + Apple Silicon, Windows x8664; .deb > (amd64 / arm64), .rpm (x86_64 / aarch64), Termux .deb (aarch64, > bionic); a multi-arch container (ghcr.io/lordmacu/nexo-rs:latest); > and crates.io (cargo install nexo-rs). Every release artifact is > cosign-signed with a .sha256 sidecar. Some optional features (STT > — voice-note t

…

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: lordmacu
• Source: lordmacu/nexo-rs
• License: Apache-2.0
• Homepage: https://lordmacu.github.io/nexo-rs/

Install and usage instructions live in the source repository linked above.