# Nexo Rs

> Rust multi-agent LLM framework — OpenClaw alternative. WhatsApp + Telegram + Gmail + browser agents on a single binary. NATS broker, MCP client+server, Claude/Anthropic OAuth, MiniMax, durable TaskFlow workflows.

- **Type:** MCP server
- **Install:** `agentstack add mcp-lordmacu-nexo-rs`
- **Verified:** Pending review
- **Seller:** [lordmacu](https://agentstack.voostack.com/s/lordmacu)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** Apache-2.0
- **Upstream author:** [lordmacu](https://github.com/lordmacu)
- **Source:** https://github.com/lordmacu/nexo-rs
- **Website:** https://lordmacu.github.io/nexo-rs/

## Install

```sh
agentstack add mcp-lordmacu-nexo-rs
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

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

> **The Rust alternative to [OpenClaw](https://github.com/openclaw/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](https://lordmacu.github.io/nexo-rs/docs/getting-started/quickstart.html) ·
[Architecture](https://lordmacu.github.io/nexo-rs/docs/architecture/overview.html) ·
[Recipes](https://lordmacu.github.io/nexo-rs/docs/recipes/index.html) ·
[vs OpenClaw](https://lordmacu.github.io/nexo-rs/docs/architecture/vs-openclaw.html) ·
[Contributing](https://lordmacu.github.io/nexo-rs/docs/contributing.html) ·
[Releases](https://github.com/lordmacu/nexo-rs/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](https://github.com/lordmacu/nexo-rs/releases/latest)),
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](https://github.com/lordmacu/nexo-rs/releases/latest) 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](https://github.com/lordmacu/nexo-rs/releases/latest). Ships a systemd unit; postinst seeds `/etc/nexo-rs/`. |
| **Fedora / RHEL / Rocky** | `sudo dnf install ./nexo-rs--1.x86_64.rpm` | `.rpm` from [Releases](https://github.com/lordmacu/nexo-rs/releases/latest). Same systemd unit. |
| **Termux (Android, aarch64)** | `pkg install ./nexo-rs__aarch64.deb` | aarch64 `.deb` (bionic libc) from [Releases](https://github.com/lordmacu/nexo-rs/releases/latest). 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](https://lordmacu.github.io/nexo-rs/docs/getting-started/platform-support.html).
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](https://github.com/openclaw/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](https://lordmacu.github.io/nexo-rs/docs/architecture/vs-openclaw.html).

## Status

**v0.1.6 — GA.** Stable [release](https://github.com/lordmacu/nexo-rs/releases/latest)
with pre-built binaries for Linux (x86_64 / 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

```bash
# 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:

```bash
# 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 x86_64 + aarch64
> (musl static), macOS Intel + Apple Silicon, Windows x86_64; `.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](https://github.com/lordmacu)
- **Source:** [lordmacu/nexo-rs](https://github.com/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.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** yes
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: flagged — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-lordmacu-nexo-rs
- Seller: https://agentstack.voostack.com/s/lordmacu
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.