OpenClaw Alternatives in 2026: 10 Self-Hosted AI Assistants

OpenClaw proved you could run a self-hosted AI assistant on your own server. Always on, always reachable through Telegram or Slack, and not dependent on anyone’s SaaS. I’ve been running it myself and wrote a full setup guide if you want to try the original. But it isn’t the only option anymore. These ten OpenClaw alternatives take different swings at the same idea: some are smaller and more focused, some try to do more, and some are built for hardware you wouldn’t expect.

I’ve looked at all ten in depth. This roundup gives you current star counts, security models, setup steps, and project health signals so you can pick where to invest your time.

Quick comparison (October 2026)

Before getting into each project, here’s how these OpenClaw alternatives stack up. Star counts and release dates were verified against the GitHub API on October 27, 2026.

All of these run on a cheap VPS. A $5-6/month box handles any of them. API spend is the real cost.

1. NanoClaw

NanoClaw is a TypeScript-based AI assistant built on Claude’s Agent SDK. The main difference from other bots on this list is real container isolation: agents run inside Docker containers, not behind application-level permission checks. It also has Agent Swarms, where teams of specialized agents collaborate on tasks.

The project moved from qwibitai/nanoclaw to nanocoai/nanoclaw and shipped a v2 rewrite. 31,024 stars as of October 2026. It now has a website at nanoclaw.dev and docs at docs.nanoclaw.dev. We wrote a full NanoClaw deploy guide covering WhatsApp setup, container configuration, skills, and scheduled tasks.

What it does

• Agents execute inside Linux containers with filesystem isolation
• Channels: Slack, Telegram, Discord, WhatsApp, iMessage, CLI
• Agent Swarms for multi-agent collaboration
• Per-group memory and context isolation (each group gets its own CLAUDE.md)
• Skills system where contributors add Claude Code skills instead of features
• Scheduled tasks with per-group context
• Credential gateway: secrets are managed outside the agent container
• Agents in Slack: one Slack app per agent, each with its own bot identity, container, and memory. You can spawn teammates from chat.

Security approach

NanoClaw’s security model is OS-level rather than application-level:

• Container isolation: Every agent runs in its own Docker container with only explicitly mounted directories visible
• No network by default: Containers have no network access unless you enable it
• Process isolation: Container processes can’t access host processes
• Non-root execution: Containers run as non-root user

This puts NanoClaw ahead of projects that rely on allowlists or file path restrictions. The agent would have to escape the container first, and that is a much higher bar.

Getting started

git clone https://github.com/nanocoai/nanoclaw.git nanoclaw-v2
cd nanoclaw-v2
bash nanoclaw.sh

nanoclaw.sh installs Node, pnpm, and Docker if missing, sets up a credential gateway, builds the agent container, and pairs your first channel (Slack, Telegram, Discord, WhatsApp, iMessage, or CLI). Claude Code is only invoked automatically to diagnose failures.

Verify: message the paired channel and confirm the bot responds. Run docker ps and confirm the agent container is up.

Failure mode: if you’re coming from v1, run bash migrate-v2.sh instead of starting from scratch. It handles the config migration.

Who this is for

NanoClaw is the pick if container-level security matters to you, or if you want multi-agent swarms. The Slack teammate feature is genuinely useful: you can spawn specialized agents from chat, each with its own identity and memory. The tradeoff is that it only works with Claude (no multi-model support) and the codebase is customized through Claude Code rather than config files. If you need multi-provider support, look at NullClaw or nanobot instead.

2. nanobot

nanobot comes from HKUDS (Hong Kong University) and has grown fast. 49,436 stars as of October 2026. The pitch is similar to NanoClaw but much more ambitious: a lightweight agent framework (~3,500 lines of code) that connects to basically every chat platform. It’s no longer just a “bot”: nanobot now calls itself a personal AI agent framework with WebUI, a native TUI, and multi-agent delegation. Docs moved to nanobot.wiki. We wrote a full nanobot setup guide covering MiniMax M2.5, GLM-5, and Brave Search if you want to try it.

What it does

• Channels: WebUI, API, Telegram, Feishu, Slack, Discord, Teams, email, Mattermost, Linear, WeChat and others
• Multi-agent delegation: hand off tasks to specialized sub-agents
• Installable via pip: pip install nanobot-ai (or the managed installer)
• Built-in memory system
• Supports local models through vLLM
• Works with OpenRouter, Anthropic, OpenAI, DeepSeek, Groq, Gemini, and others
• Docker deployment available
• Python 3.11+

The channel coverage is what sets nanobot apart. If you need your bot on WhatsApp and Discord and Slack at the same time, most alternatives don’t do that without significant extra work. The WebUI means you can also chat from a browser without any messaging platform at all.

Setup

pip install nanobot-ai   # or the managed installer
nanobot webui            # opens browser setup
# On a VPS / headless: nanobot webui --no-open
# Terminal-only: nanobot onboard --wizard

The WebUI is the recommended first-run path on desktop. On a headless VPS, use nanobot webui --no-open and it prints the URL to access remotely. The onboard --wizard command walks you through picking a chat platform and connecting an LLM provider in the terminal.

Verify: open the WebUI URL printed on first run (or the --no-open output) and send a test message. You should get a response from the configured model.

Local model support

nanobot can connect to a local vLLM server, which means you can run the whole stack without any API costs after the initial hardware investment. If you already have an Ollama or vLLM setup, pointing nanobot at it is straightforward. See the nanobot.wiki providers page for current config flag names.

# Example: using a local vLLM endpoint
nanobot config set llm.base_url http://localhost:8000/v1
nanobot config set llm.model your-local-model

Who this is for

nanobot is the pragmatic choice if you need multi-channel support or want something you can install with pip and have running in five minutes. The university backing and large community mean bugs get fixed and features get added regularly. The multi-agent delegation feature is useful for task-heavy workflows. The tradeoff is that with so many integrations, configuration can get dense.

3. memU

memU is different from the other projects here. It’s not really a chatbot. It’s a memory framework built for 24/7 agents, and it happens to include a bot (at memu.bot) as a reference implementation.

The core idea: most chatbots forget everything between sessions, and even ones with memory just do basic retrieval. memU treats memory like a file system, with categories, items, and cross-references, and it tries to predict what you’re about to need before you ask for it.

14,564 stars as of October 2026. Latest tagged release is v1.5.1 (2026-03-23). No tagged release since March even though the repo is active. The project homepage is now memu.pro.

How memory works

memU organizes everything into three layers:

The “file system” metaphor means your agent’s memory looks like this:

memory/
├── preferences/
│   ├── communication_style.md
│   └── topic_interests.md
├── knowledge/
│   ├── domain_expertise/
│   └── learned_skills/
└── context/
    ├── recent_conversations/
    └── pending_tasks/

New memories get auto-categorized. Related memories link to each other. The system claims 92% accuracy on the Locomo benchmark, which tests how well memory systems retain and retrieve information over long conversations.

Proactive behavior

This is where memU gets interesting. Instead of just answering when asked, it monitors conversations and tries to anticipate what you’ll need next. The agent can:

• Pre-fetch relevant context before you explicitly ask
• Notice patterns in what you’re working on and surface related memories
• Draft action items from conversation flow
• Learn your preferences over time and adjust responses

Whether this is useful or annoying probably depends on your tolerance for unsolicited suggestions. I can see it working well for someone who uses an AI assistant all day, less so for occasional use.

Setup

pip install memu-py

# In-memory test (no database needed)
export OPENAI_API_KEY=your_key
cd tests
python test_inmemory.py

# With PostgreSQL for persistent storage
docker run -d \
  --name memu-postgres \
  -e POSTGRES_USER=postgres \
  -e POSTGRES_PASSWORD=postgres \
  -e POSTGRES_DB=memu \
  -p 5432:5432 \
  pgvector/pgvector:pg16

python test_postgres.py

Verify: run the in-memory test script and confirm it prints a successful recall.

memU also supports OpenRouter, so you can route through whatever model provider you prefer:

from memu import MemoryService

service = MemoryService(
    llm_profiles={
        "default": {
            "provider": "openrouter",
            "base_url": "https://openrouter.ai",
            "api_key": "your_openrouter_api_key",
            "chat_model": "anthropic/claude-3.5-sonnet",
        },
    },
)

Who this is for

memU makes the most sense if you’re building your own agent and want a proper memory layer underneath it. It’s also worth looking at if you’re frustrated with how shallow memory is in other bots. For readers evaluating memory frameworks more broadly, see our comparison of self-hosted agent memory systems like Cognee and Hindsight.

The downside is complexity. This isn’t a “clone and run” bot like NanoClaw. It’s a framework, and you’ll need to integrate it into something.

4. bitdoze-bot

This is my project. I built it because I wanted a Discord bot where multiple specialized agents work together instead of a single model answering everything.

bitdoze-bot uses the Agno framework for multi-agent orchestration. You define agent “teams” in workspace folders, each agent with its own tools and personality, and a coordinator routes incoming messages to the right specialist.

I wrote a detailed build guide for it: Build your own AI Discord bot with Agno teams.

What it does

• Discord-first (responds on mention)
• Multi-agent teams: a coordinator + specialist agents (coding, research, ops, whatever you define)
• Workspace-based config: each agent gets its own folder with instructions, tools, and permissions
• Memory and learning: stores context across conversations and learns from corrections
• Heartbeat + cron: scheduled health checks and recurring tasks
• Tool permissions and audit logging
• Observability: structured logs for every agent run

The team setup

The multi-agent approach is the main difference from everything else on this list. Instead of one model trying to do everything, you split responsibilities:

workspaces/
├── main/
│   └── agent.yaml          # Coordinator - routes to specialists
├── coding/
│   └── agent.yaml          # Coding specialist
├── research/
│   └── agent.yaml          # Web research specialist
└── ops/
    └── agent.yaml          # Server ops specialist

When a message comes in, the coordinator decides which specialist handles it. You can start with just the main agent and add specialists as you need them.

Getting started

You need Python 3.12+, a Discord bot token, and an API key for your model provider.

git clone https://github.com/bitdoze/bitdoze_bot.git
cd bitdoze_bot
cp .env.example .env
# Edit .env with Discord token and API keys

# Install with UV
uv sync
uv run python main.py

Verify: mention the bot on Discord and confirm a specialist responds.

Who this is for

If you want to go beyond a single-agent chatbot and experiment with multi-agent coordination, this is the project to look at. The workspace-based configuration makes it easy to add new specialists without touching the core code. The tradeoff is that it’s Discord-only and the smallest project here by star count. But it’s one I use daily, and the multi-agent approach has been worth the extra setup.

5. PicoClaw

PicoClaw takes the opposite approach from everything else on this list. Instead of adding features, it strips them away. The project is a Go rewrite of nanobot that compiles to a single binary, uses less than 10MB of RAM, and boots in under a second. Sipeed (the RISC-V hardware company) built it to run on their $10 LicheeRV-Nano boards, which says a lot about the resource budget they were working with. We wrote a full PicoClaw setup guide covering MiniMax M2.5, GLM-5, and Discord if you want to try it.

30,081 stars as of October 2026. Latest release v0.3.1 (2026-07-03). The project now has an official site at picoclaw.io and docs at docs.picoclaw.io.

What it does

• Single binary AI assistant, no runtime dependencies
• Channels: Telegram, Discord, WhatsApp (QR or bridge), QQ, Matrix, IRC, WeCom
• 30+ providers via model_list, including LiteLLM proxy (100+ upstream), Azure OpenAI with Entra ID, AWS Bedrock
• Tool access: shell commands, file operations, web search
• Workspace-based file storage for memory and logs
• CLI mode for local use, gateway mode for chat channels
• Voice message transcription through Groq’s Whisper
• MCP protocol support with MCP server management in the Web UI
• WebUI Launcher for browser-based config and chat

Resource comparison

Side by side with the two it most often gets compared to. Figures are from each project’s README:

The $599 Mac mini price in that table is dated at this point. Current configs and prices are in the best Mac mini for OpenClaw guide.

If you have a NanoKVM or MaixCAM sitting around, PicoClaw can turn it into an always-on assistant. That’s a use case none of the other projects here can touch.

Getting started

The WebUI Launcher is the recommended desktop path. It gives you browser-based config and chat without touching the CLI:

# Download prebuilt binary from releases, or build from source:
git clone https://github.com/sipeed/picoclaw.git
cd picoclaw
make build

# Option 1: WebUI launcher (recommended for desktop)
picoclaw

# Option 2: CLI onboarding
picoclaw onboard
# Edit ~/.picoclaw/config.json with your API keys

# Chat directly
picoclaw agent -m "What is 2+2?"

# Or start as gateway for Telegram/Discord
picoclaw gateway

Verify: picoclaw agent -m "What is 2+2?" returns an answer. Gateway logs show channel connected.

Failure mode: sensitive keys now live in .security.yml, not config.json. If you’re restoring from an old backup, the secrets won’t transfer. Re-enter them through the onboard wizard or WebUI.

Who this is for

PicoClaw is the pick if you care about resource efficiency above all else, or if you want to run a bot on hardware that would choke on Python. The Go codebase is small and readable, and the single-binary deployment means there’s nothing to install. The 30+ provider support via model_list (including LiteLLM proxy) means you can route through nearly any model API. The tradeoff is that the feature set is narrower than nanobot or ZeroClaw, and the community is still forming.

6. IronClaw

IronClaw comes from NEAR AI and takes a security-first approach that goes well beyond what the other projects attempt. It’s a full Rust rewrite of the OpenClaw concept, and the main selling point is the WASM sandbox. Every untrusted tool runs inside an isolated WebAssembly container with explicit capability-based permissions. Your API keys never get exposed to tool code. HTTP requests only go to hosts you’ve approved.

12,677 stars as of October 2026. Latest release v1.4.1 (2026-09-29). The repo description now reads “Agent OS focused on privacy, security and extensibility”, the same positioning space as OpenFang. IronClaw hit the v1.x stable line in 2026 and is no longer a REPL-only tool: there’s a WebUI at ironclaw.com, a durable notification inbox, and background subagents.

If you’ve ever felt nervous about giving an AI agent shell access on a box with real data on it, IronClaw was built for that anxiety.

What it does

• Rust-native AI assistant with WebUI, REPL, HTTP webhook, and WASM-based channels (Telegram, Slack)
• WASM sandbox for all tool execution with capability-based permissions
• Credential protection: secrets get injected at the host boundary, tool code never sees them
• Prompt injection defense with pattern detection and content sanitization
• Endpoint allowlisting so the agent can only reach hosts you approve
• PostgreSQL with pgvector for memory (full-text + vector hybrid search)
• Background subagents: a parent turn spawns children that run and deliver results on their own
• Durable notification inbox for async task results
• Persistent per-user sandbox containers on the local-Docker profile
• Self-expanding: describe a tool you need, and IronClaw builds it as a WASM module
• MCP protocol support for connecting external tool servers

The security model

This is where IronClaw stands apart. The security pipeline for tool execution looks like this:

1. Tool request hits the endpoint allowlist validator
2. Request gets scanned for credential leaks
3. Credentials get injected at the host boundary (tool code never holds them)
4. Request executes inside the WASM sandbox
5. Response gets scanned again for credential leaks
6. Result returns to the agent

There are also per-tool rate limits and resource caps (memory, CPU time, execution duration). Policy rules let you set severity levels for different situations: block, warn, review, or sanitize.

No other project on this list has anything close to this level of isolation. NanoClaw has container isolation, but IronClaw’s WASM containers take a different approach, with capability-based permissions built in.

Getting started

IronClaw v1.4 is WebUI-first. The old build-from-source REPL flow is no longer the primary path. Check ironclaw.com/docs for the current install method. The v1.4 line introduced managed sandbox profiles, a Railway preview profile, and Google OAuth activation for extensions.

If you’d rather build from source:

git clone https://github.com/nearai/ironclaw.git
cd ironclaw
cargo build --release

# Set up PostgreSQL with pgvector
createdb ironclaw
psql ironclaw -c "CREATE EXTENSION IF NOT EXISTS vector;"

# Run the setup wizard
ironclaw onboard

You’ll need Rust 1.85+, PostgreSQL 15+ with pgvector, and an auth account (the setup wizard handles the OAuth flow through your browser).

Verify: the WebUI loads after setup, or ironclaw daemon status shows running.

Failure mode: IronClaw requires PostgreSQL. If you don’t have it running, the onboard wizard will fail at the DB connection step. On a VPS, install postgresql-15 and pgvector first.

Who this is for

IronClaw is for people who want the strongest security guarantees available in this space. The WASM sandbox, credential isolation, and background subagents make it the safest option for running an AI agent with real tool access on a production machine. The Rust codebase gives native performance and memory safety. The downsides: it requires PostgreSQL infrastructure, and the NEAR AI auth requirement may not sit well with everyone who wants a fully independent self-hosted setup. If you want autonomous background work without the security tradeoffs, IronClaw’s background subagents (v1.4+) are worth a look.

7. ZeroClaw

ZeroClaw started as a Rust-based assistant that pushed resource efficiency further than PicoClaw. It’s grown into something bigger: 33,050 stars as of October 2026, v0.8.6 (2026-10-18), and it now calls itself “an agent runtime.” The release binary ships a WebAssembly plugin host, a plugin registry for channel and tool packages, and authenticated principals with OIDC.

We wrote a full ZeroClaw setup guide covering MiniMax M2.5, GLM-5, and Discord if you want to try it.

What it does

• Single Rust binary with 30+ channels (Discord, Telegram, Matrix, email, voice, webhooks, CLI, and more)
• ~20 LLM providers built in (OpenRouter, Anthropic, OpenAI, Ollama, Gemini, Groq, Mistral, xAI, DeepSeek, and more)
• SQLite hybrid memory: FTS5 keyword search + vector embeddings with cosine similarity
• SOP (Standard Operating Procedure) engine: typed steps, cron/filesystem/calendar triggers, approval plane for scheduled and autonomous behavior
• WASM plugin host with plugin registry for channels and tools
• Gateway pairing with 6-digit one-time codes and bearer token auth
• Workspace sandboxing, command allowlists, and forbidden path protection
• Encrypted secrets storage (ChaCha20-Poly1305)
• Docker support with distroless production images
• Built-in zeroclaw migrate openclaw command for switching from OpenClaw
• TOML configuration instead of JSON

Security approach

ZeroClaw’s security defaults are stricter than most projects on this list. The gateway binds to 127.0.0.1 and refuses to go public without a tunnel. Empty channel allowlists deny all messages by default (opposite of most bots). There’s a 6-digit pairing code flow before the gateway accepts webhook requests.

[autonomy]
workspace_only = true
allowed_commands = ["git", "npm", "cargo", "ls", "cat", "grep"]
forbidden_paths = ["/etc", "/root", "/proc", "/sys", "~/.ssh", "~/.gnupg", "~/.aws"]

[secrets]
encrypt = true

14 system directories and 4 sensitive dotfiles are blocked by default. Symlink escape attempts get caught through path canonicalization.

Getting started

The curl installer is the fastest path:

curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/master/install.sh | sh
"${CARGO_HOME:-$HOME/.cargo}/bin/zeroclaw" quickstart

Building from source (still supported, and needed on some platforms):

git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
cargo build --release --locked
cargo install --path . --force --locked

# Interactive setup
zeroclaw onboard --interactive

# Chat
zeroclaw agent -m "Hello!"

# Start all channels
zeroclaw daemon

On a Raspberry Pi with 1GB RAM, use CARGO_BUILD_JOBS=1 cargo build --release to avoid the kernel killing rustc.

Verify: zeroclaw agent -m "Hello!" responds. The daemon shows channels online.

Who this is for

ZeroClaw is the pick if you want low resource usage with serious security defaults and a wide range of built-in providers. The SOP engine now covers scheduled and autonomous behavior, which was previously OpenFang’s niche. The plugin system means you can extend it without patching the core. If you’re migrating from OpenClaw, the built-in migration command makes the switch straightforward. The tradeoff is compile time if you’re building from source (the curl installer avoids this).

8. NullClaw

NullClaw pushes resource efficiency to the absolute limit. It’s a static Zig binary: 678 KB, ~1 MB RAM at runtime, boots in under 2 milliseconds on Apple Silicon. The project ships with 50+ LLM providers, 19 chat channels, hybrid memory (FTS5 + vector), and multi-layer sandboxing. We wrote a full NullClaw deploy guide covering provider setup, channels, memory, sandboxing, and edge hardware deployment.

The “null overhead, null compromise” philosophy means zero runtime dependencies beyond libc. Drop the binary on any hardware with a CPU and it runs. That includes $5 ARM boards and RISC-V SBCs.

8,133 stars as of October 2026. Latest release v2026.5.29 (2026-05-29). Calendar versioning. Slower release cadence than peers, but the repo was pushed as recently as October 2026.

What it does

• 678 KB static binary with no runtime dependencies
• 19 channels: CLI, Telegram, Signal, Discord, Slack, iMessage, Matrix, WhatsApp, Nostr, Mattermost, IRC, Line, Lark, QQ, OneBot, Email, DingTalk, MaixCam, Webhook
• 50+ LLM providers via OpenAI-compatible interface (OpenRouter, Anthropic, OpenAI, Ollama, Groq, Mistral, xAI, DeepSeek, and more)
• SQLite hybrid memory: FTS5 keyword search + vector embeddings with cosine similarity
• Multi-layer sandboxing: Landlock, Firejail, Bubblewrap, Docker (auto-detected)
• Gateway pairing with 6-digit codes and bearer token auth
• Encrypted secrets (ChaCha20-Poly1305)
• Subagents, streaming, voice, tunnels, hardware peripherals, MCP server support
• Built-in nullclaw migrate openclaw for switching from OpenClaw
• Cross-compilation for ARM, x86, and RISC-V from any platform
• Config is OpenClaw-compatible (snake_case): providers under models.providers, model under agents.defaults.model.primary

Resource footprint

Same comparison, with ZeroClaw and NullClaw added in. All figures come from each project’s own README, so treat them as claims rather than measurements:

Getting started

# Install Zig 0.15.2
curl -L https://ziglang.org/download/0.15.2/zig-linux-x86_64-0.15.2.tar.xz | tar -xJ
sudo mv zig-linux-x86_64-0.15.2 /usr/local/zig
sudo ln -s /usr/local/zig/zig /usr/local/bin/zig

# Clone and build
git clone https://github.com/nullclaw/nullclaw.git
cd nullclaw
zig build -Doptimize=ReleaseSmall

# Setup (non-interactive)
nullclaw onboard --api-key sk-... --provider openrouter

# Check channel health
nullclaw channel status
nullclaw channel start telegram

# Start
nullclaw daemon

For model recommendations, MiniMax M2.5 and GLM-5 work well with NullClaw through OpenRouter or direct API endpoints.

If you want a UI instead of editing JSON, try NullHub (beta). It provides setup/config UI, orchestration, observability, and task tracking for the Null ecosystem.

Verify: nullclaw channel status shows your channels. nullclaw channel start telegram brings the Telegram channel online.

Who this is for

NullClaw is for anyone who wants the smallest possible footprint with the widest feature set. If you have a Raspberry Pi Zero, a cheap ARM SBC, or any edge device sitting around, NullClaw turns it into a full AI assistant. The 19-channel support and 50+ providers mean you’re unlikely to hit a wall with what it connects to. The OpenClaw-compatible config format makes migration easier than most. The tradeoff is that Zig is less familiar than Rust or Python, and the community is newer. But the 5,300+ test suite and active development suggest the project is solid.

9. OpenFang

OpenFang calls itself an “Agent Operating System.” Built in Rust (137K lines of code, 14 crates, 1,767+ tests), it compiles to a single ~32MB binary. The interesting part is Hands: autonomous agents that run on schedules, build knowledge graphs, and report to your dashboard without you prompting them. We wrote a full OpenFang setup guide covering GLM-5, MiniMax M2.5, Discord, the Hands system, and security configuration.

18,229 stars as of October 2026. Not archived, but dormant.

What it does

• Single ~32MB Rust binary with 40 channel adapters (Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Teams, LINE, IRC, and 31 more)
• 7 autonomous Hands: Clip (video), Lead (sales), Collector (OSINT), Predictor (forecasting), Researcher (deep research), Twitter (social), Browser (web automation)
• 27 LLM providers including MiniMax, Zhipu, Anthropic, OpenAI, Ollama, vLLM, and OpenRouter
• 16 discrete security systems: WASM dual-metered sandbox, Merkle audit trail, taint tracking, Ed25519 signed manifests, SSRF protection
• 53 built-in tools + MCP + Agent-to-Agent (A2A) protocol support
• SQLite + vector embedding memory with canonical sessions and compaction
• Built-in dashboard at localhost:4200 (Tauri 2.0 desktop app also available)
• Migration from OpenClaw: openfang migrate --from openclaw

The Hands system

Hands are what separates OpenFang from chatbots. Each Hand is a pre-built autonomous agent that bundles a HAND.toml manifest, a multi-phase system prompt, domain expertise (SKILL.md), and guardrails. You activate one and it runs on a schedule. The Researcher Hand cross-references sources and generates cited reports. The Lead Hand discovers and scores prospects daily. The Collector Hand monitors targets with change detection and sentiment analysis.

openfang hand activate researcher
openfang hand status researcher

You can also build your own Hands and publish them to FangHub.

Security approach

OpenFang shipped the deepest security model of any project on this list. The 16 systems include WASM sandboxing (tool code physically cannot escape), Merkle hash-chain audit trails (tamper with one entry and the chain breaks), information flow taint tracking, Ed25519 signed agent manifests, SSRF protection, and automatic secret zeroization. Every layer operates independently.

Getting started

# Install
curl -fsSL https://openfang.sh/install | sh

# Initialize
openfang init

# Start the daemon
openfang start

# Dashboard is live at http://localhost:4200

For model recommendations, GLM-5 and MiniMax M2.5 both work well. GLM-5 pairs nicely with the Researcher Hand given its BrowseComp scores.

Production advice: treat OpenFang as unmaintained until activity resumes. If you run it anyway, pin to a specific commit and don’t expose it to untrusted input without reviewing the security config yourself.

Who this is for

OpenFang is worth reading if you want to see what an Agent OS architecture looks like: Hands, 40 adapters, 16 security layers. But the dormancy is a real problem. Unmaintained means unpatched vulnerabilities and no bug fixes. If you want autonomous scheduled work, ZeroClaw’s SOP engine or IronClaw’s background subagents are the actively maintained alternatives. Only run OpenFang if you accept the maintenance risk and are comfortable reviewing security patches yourself.

10. Hermes Agent

Hermes Agent is a self-improving AI assistant from Nous Research. The headline feature is a learning loop: the agent creates skills from complex tasks, improves those skills on subsequent runs, and remembers who you are across sessions through MEMORY.md, USER.md, and FTS5 session search. It ships with a built-in OpenClaw migration tool that imports your persona, memories, skills, and API keys. We wrote a full Hermes Agent setup guide covering OpenRouter free tier configuration, messaging platforms, voice mode, and terminal backend isolation.

257,465 stars as of October 2026. Latest release v0.22.5 (2026-10-23). Hermes is no longer “a single Python process”: it’s a product line.

What it does

Hermes ships as a CLI/installer, a Microsoft Store app, a Docker image, a hosted option (Hermes Cloud), a desktop app, native Windows (no WSL), and Android/Termux via a signed APT repo (stable + canary channels). It runs a gateway for messaging platforms (Telegram, Discord, Slack, WhatsApp, Signal, Home Assistant, and more), 40+ built-in tools, six terminal backends (local, Docker, SSH, Daytona, Singularity, Modal), voice mode across CLI and messaging, a natural-language cron scheduler, and a SOUL.md personality system with 14 built-in presets.

Why it’s different

The learning loop is what sets it apart. After a complex task, Hermes extracts the workflow into a reusable skill and refines it on later runs. FTS5 session search lets it recall details from past conversations. Voice mode in Discord voice channels (join, listen, speak) is something none of the other projects on this list offer.

The plugins system landed in 2026 (hermes plugins install agent-importers, hermes plugins update, dependency consent flow) and MCP integration is first-class. The Nous Portal subscription bundles web search, image gen (FAL), TTS (OpenAI), and cloud browser (Browser Use), billed as “one sub instead of five API keys.” For cost-conscious setups, see our guide to the cheapest AI models for Hermes Agent.

Subagent delegation and background sessions let Hermes handle multi-step work. If you’re using those heavily, Hermes Kanban task boards for multi-agent workflows are worth setting up.

And the hermes claw migrate command makes switching from OpenClaw a one-line operation (now delivered via the agent-importers plugin):

hermes plugins install agent-importers
hermes claw migrate            # add --migrate-secrets for API keys

Getting started

# Install
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
source ~/.bashrc

# Configure
hermes setup

# Start chatting
hermes

Hermes also runs as Docker, Desktop app, Microsoft Store app, or on Android/Termux via a signed APT repo. For model provider options, Hermes supports OpenRouter (200+ models including free tier), Nous Portal, OpenAI, Anthropic, Ollama, and any OpenAI-compatible endpoint. The Nous Portal bundles free models. See our guide to free models on the Nous Portal.

Verify: after hermes setup, message a channel and confirm the gateway responds.

Failure mode: v0.22.2 fixed a real VPS issue where supervised gateways refused to start after reboot due to early-PID confusion. If your gateway doesn’t come back after a reboot, update to v0.22.2+ and make sure the service is supervised (systemd, supervisor, etc.).

Who this is for

Hermes Agent is the pick if you want an assistant that gets better over time through skill creation and session search. Voice mode and terminal backend isolation (Docker, SSH, Modal) are bonuses you won’t find elsewhere. The Android/Termux support makes it the pocket option. For UI options, see Hermes Agent dashboards and mobile apps. The tradeoff is that it’s Python-based with a larger footprint than the Rust/Go/Zig options, and the community is newer than OpenClaw’s.

New OpenClaw alternatives to watch (late 2026)

These are early days for all four: small teams, fast-moving, evaluate accordingly.

AstrBot (AstrBotDevs/AstrBot, 43.9k stars) is a mature Python AI agent assistant and development framework integrating many IM platforms, LLMs, and plugins. It’s an older project that got re-discovered as an OpenClaw alternative. If you want breadth of platform support out of the box, it’s worth a look.

Poco (poco-ai/poco-claw, 1.4k stars, MIT) is a “pocket coworker” built on Python 3.12 + FastAPI + Next.js. Docker-enabled, long-lived servers with channels, DMs, and threads. It turns messages into trackable tasks with shared file outputs. The nicest UI of the new entrants. Docs at docs.poco-ai.com.

Kai (SimonSchubert/Kai, 1.3k stars) is a Kotlin-based “OpenClaw alternative in your pocket.” Mobile angle.

thClaws (thClaws/thClaws, 1.2k stars) is a Rust agent harness with GUI, CLI, headless, and webapp from one binary. Multi-provider.

Star counts as of October 27, 2026.

Which one should you pick?

The best OpenClaw alternative depends on what you need:

All of them run on a basic VPS. A Hetzner CX22 VPS (around $5-6/month) is enough for any of them, or a budget Hostinger VPS if you want US locations or NVMe storage. Before committing to a provider, here’s how to benchmark a VPS before committing. API costs depend on which model you pick and how much you chat, but $15-50/month covers most people. Models like MiniMax M2.5 via MiniMax’s API or GLM-5 via Z.ai keep costs at the low end. For model recommendations, see our best open source models for OpenClaw guide.

If you haven’t tried any self-hosted AI bot yet, I’d recommend starting with OpenClaw itself. It’s the most documented, has the largest community (393k stars), and the setup wizard makes the first run pretty painless. Once you know what you want to change about it, these alternatives start making more sense.

If you’re settled on OpenClaw and want a proper UI for it, our best OpenClaw dashboards guide covers nine community-built options, from full multi-agent orchestration platforms like Mission Control down to lightweight single-file monitors. For getting started with OpenClaw itself, the setup guide has the full installation walkthrough. And before installing skills from ClawHub, read the OpenClaw security guide. 12% of skills were infected in a supply chain attack (CVE-2026-25253). For hardening any of these bots, the official openclaw/agent-skills repo and denoland/clawpatrol (“security firewall for agents”) are worth adding to your stack. For OpenClaw, Hermes, coding agents, and the rest of the stack in one place, see top AI GitHub repos. And if what you want is xAI’s Grok Bot setup (a roster of bots in a chat app, each with a computer to work on) without the lock-in, our open source Grok Bot alternatives roundup compares Rakazo, OpenMausBot, OpenBot, and five more. Note that the per-project setup guides linked in this article get refreshed on their own schedules.