ZeroClaw is a free, open-source AI agent from ZeroClaw Labs. It runs as a Rust binary on your own device and connects to cloud-hosted models, local Ollama models, messaging channels, browser and shell tools, hardware, and custom MCP servers.
You can use ZeroClaw as an interactive terminal agent, an always-on service, a multi-agent host, or the runtime behind a chat channel and web dashboard. It currently supports about 20 AI model providers and 30+ channel adapters. Each agent can have its own workspace, memory, model provider, security policy, and identity.
Messages can enter through a channel, the web gateway, the terminal, or an ACP-compatible editor. ZeroClaw routes each request to the selected agent, applies its security policy, calls the configured model and tools, and stores memories within that agent’s scope. This architecture supports a private personal assistant on one computer as well as several agents with different jobs, permissions, and model budgets.
Features
- Multi-agent runtime: One daemon can run multiple named agents with separate workspaces, memories, providers, identities, and risk profiles.
- Model choice: Connect Anthropic, OpenAI, Ollama, and about 20 other providers. OpenAI-compatible endpoints and fallback routing cover additional services.
- Messaging and clients: Connect agents to Discord, Telegram, Matrix, email, voice, webhooks, a CLI, the web dashboard, and other channel adapters.
- Security controls: The default supervised mode requires approval for medium-risk actions and blocks high-risk actions. Workspace boundaries, command policies, OS sandboxes, and cryptographic tool receipts provide additional controls.
- Tools and MCP: Agents can work with the shell, browser, HTTP requests, hardware interfaces, and custom MCP servers.
- Skills and plugins: Install reusable skills and extend tools, channels, or memory through the WebAssembly plugin host.
- SOP engine: Standard Operating Procedures can start from cron schedules, webhooks, MQTT events, Git forge events, or hardware input. Approval gates and resumable runs support longer procedures.
- Developer integration: Agent Client Protocol support connects ZeroClaw to compatible editors and IDE clients.
- Hardware access: The runtime supports GPIO, I2C, SPI, and USB through its peripheral interface for Raspberry Pi, Arduino, ESP32, STM32, and related devices.
How ZeroClaw Works
ZeroClaw separates the agent runtime into components that you can configure independently. A channel or client receives the request. The runtime identifies the target agent, loads its workspace and memory, applies the selected risk profile, and sends the conversation to its model provider. The agent can then call permitted tools, save useful context, and return the result through the same channel.
| Component | Role |
|---|---|
| Agent | Owns the identity, workspace, model, memory, skills, channels, and policies for one assistant |
| Provider | Connects the agent to a hosted model, local model, or compatible API |
| Channel | Receives and sends messages through chat services, email, voice, webhooks, or the CLI |
| Tool | Lets the agent work with files, shell commands, browsers, HTTP services, hardware, and other systems |
| Memory | Stores and retrieves information within the correct agent scope |
| Risk profile | Defines which actions can run, require approval, or remain blocked |
| SOP | Runs a defined procedure from an event, schedule, webhook, or hardware trigger |
| Gateway | Provides HTTP, WebSocket, dashboard, and remote client access |
Table Of Contents
- Multi-Agent Runtime
- Models, Providers, and Routing
- Channels and User Interfaces
- Memory and Context
- Skills, Plugins, and MCP Servers
- Standard Operating Procedures
- Security and Permissions
- Hardware and Edge Use
- Install ZeroClaw
- Create the First Agent
- Run ZeroClaw in the Background
- Connect Channels and the Dashboard
- Migrate from OpenClaw
- Quick Command Reference
Multi-Agent Runtime
One ZeroClaw daemon can run many named agents. A coding agent can use a powerful model and shell access in one workspace, while a Telegram assistant uses a cheaper model and a stricter policy in another. Each agent has separate memory, skills, identity files, channel bindings, provider settings, and runtime controls.
Channels, cron jobs, webhooks, SOP runs, and ACP sessions can target a specific agent. Per-agent isolation also applies to SQLite, PostgreSQL, Qdrant, and Markdown memory backends. This prevents one assistant from automatically reading another agent’s stored context or workspace files.
Models, Providers, and Routing
ZeroClaw can connect to Anthropic, OpenAI, Ollama, GitHub Models, OpenRouter, llama.cpp, and about 20 other model providers. OpenAI-compatible endpoints cover services that use the same request format. Local model support lets you keep inference on your own hardware when the selected model fits your machine.
A model provider is assigned by alias, so different agents can use different models from the same installation. Fallback chains can move a request to another provider when the first service fails. ZeroClaw also records token and cost data by provider, model, and agent when the selected provider reports the required usage fields.
Channels and User Interfaces
The project supports more than 30 channel adapters, including Discord, Telegram, Matrix, Slack, WhatsApp, email, voice, webhooks, Twitch, WeCom, AMQP, and the built-in CLI.
The web dashboard provides chat, agent status, memory browsing, configuration editing, cron management, logs, cost views, workspace inspection, and tool controls. ZeroCode is the terminal interface. It has Chat, Code, Dashboard, Config, Quickstart, and Logs views, and its sessions can reconnect after the daemon restarts.
ACP support connects ZeroClaw to compatible editors through JSON-RPC. The ZeroCode Code view uses the same protocol for coding sessions. Multiple-choice prompts, tool approvals, cancellation, and persistent sessions can travel through the ACP connection when the client supports them.
Memory and Context
ZeroClaw handles memory within the runtime and does not require a separate hosted memory service. It can store memory in SQLite, Markdown, PostgreSQL, or Qdrant, depending on the compiled features and configuration. The runtime can combine recent context, keyword search, and embeddings, then inject relevant material into a later turn.
Each memory operation carries the agent scope. The current runtime also tracks memory identity when embeddings change, supports migration of stored vectors, and applies deduplication, superseding, budgets, and policy gates to durable memories. You can inspect memories in the dashboard and keep separate stores for agents with unrelated tasks.
Skills, Plugins, and MCP Servers
Skills provide reusable instructions and task workflows for an agent. ZeroClaw can install, list, and remove skill bundles, discover additional registries, and expose selected skills as slash commands on supported channels. Each agent can receive its own skill bundle.
The WebAssembly plugin host extends tools, channels, and memory through the Wasmtime component model. Plugin calls can have execution limits, signature requirements, and restricted configuration access. The registry supports search and installation by name, while the security audit status remains visible during skill and plugin management.
Custom MCP servers add external resources, prompts, and callable tools. MCP access can be scoped per agent, and deny rules apply wherever the runtime connects to a server. Current releases can pin resources as context, render named prompts, reconnect dropped sessions, and keep the MCP resource and prompt surface behind policy checks.
Standard Operating Procedures
The SOP engine runs repeatable, multi-step procedures. An SOP can start from cron, a webhook, MQTT, a filesystem event, a calendar event, a Git forge event, or a connected peripheral. Each step has defined inputs, outputs, routing, scope, and execution rules.
Approval gates can pause a procedure before a sensitive step. Run state is durable, so the daemon can resume work after an interruption. ZeroClaw records run history and metrics, and its experimental visual authoring interface can help you assemble procedures from the web dashboard.
The Git forge channel connects SOPs to GitHub and Gitea or Forgejo events. This makes repository activity a possible trigger for triage, maintenance, or another defined procedure. The unified Git forge tool gives the assigned agent a consistent interface across supported forge providers.
Security and Permissions
ZeroClaw starts in supervised autonomy mode. Medium-risk actions require approval and high-risk actions remain blocked. You can assign a different risk profile to each agent, restrict filesystem access to its workspace, define command rules, limit tools, and isolate execution with Landlock, Bubblewrap, Seatbelt, or Docker where supported.
Channel messages and SOP trigger payloads are treated as untrusted input. The ingress layer can sanitize and frame incoming content before the model reads it. Agent-scoped tool allowlists, MCP deny rules, HTTP protections, secret-leak checks, rate limits, and signed tool receipts add controls around actions that reach outside the conversation.
These controls reduce risk, but they do not remove the need to review permissions. Keep the gateway private during setup, pair approved senders, restrict public channels, inspect skills and plugins, and test an agent with limited access before it receives shell, browser, network, or hardware permissions.
Hardware and Edge Use
The peripheral layer supports GPIO, I2C, SPI, and USB connections. It can work with Raspberry Pi boards and supported Arduino, ESP32, STM32, and related devices. Hardware events can reach an agent directly or start an SOP, while the risk profile controls which operations the agent may perform.
A minimal source preset reduces the compiled surface for small devices, while a full build includes more channels and runtime features. The AI model still determines the largest hardware requirement. A small ZeroClaw binary can connect to a hosted model from modest hardware, but a local Ollama model needs enough memory and compute for that model.
Use Cases
- Private local assistant: Run an agent on your own computer and keep its workspace, configuration, and memory under your control.
- Always-on chat agent: Connect a named agent to Telegram, Discord, Matrix, email, or another supported channel and run it as an operating-system service.
- Multi-agent workflows: Give separate agents different models, workspaces, memories, permissions, and channel bindings from one installation.
- Automated procedures: Use the SOP engine for scheduled maintenance, webhook-driven work, GitHub or Gitea activity, and hardware events that need approval and recovery.
- Local model setup: Connect Ollama or another OpenAI-compatible local endpoint when you want to avoid per-request API charges.
- Edge and hardware projects: Build agents that interact with sensors and boards through GPIO, I2C, SPI, or USB.
ZeroClaw vs OpenClaw
ZeroClaw and OpenClaw both let you run an AI agent on your own hardware, connect models and chat channels, and give the agent access to tools. ZeroClaw is a separate Rust project from ZeroClaw Labs. Its current design centers on one binary, a multi-agent daemon, configurable security policies, and replaceable providers, channels, memory backends, and plugins.
| ZeroClaw | OpenClaw |
|---|---|
| Rust agent runtime | Node.js agent platform |
| MIT or Apache 2.0 | MIT license |
| One daemon can host named agents | Supports agents through its own runtime |
| Installs from a prebuilt binary or source | Installs through npm or Docker |
| Imports an OpenClaw workspace | Uses its native workspace format |
| ZeroClaw Labs project | OpenClaw project |
How To Use It
Install ZeroClaw
The official installer can download a prebuilt binary or build ZeroClaw from source. Run it on Linux, macOS, or another Unix-like shell:
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/master/install.sh | bashYou can inspect the installer before running it, or clone the official repository and start the same script locally:
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
./install.shSelect the prebuilt option for the shortest setup. A source build needs the Rust toolchain and takes longer. The installer supports separate presets and feature flags if you want a smaller build or a specific set of channels.
Windows users can download a release installer or follow the Windows instructions in the official documentation. Current releases publish self-contained desktop installers for Windows, macOS, and Linux.
Create the First Agent
The installer normally starts Quickstart after installation. Run it manually if you skipped that step:
zeroclaw quickstartStart an interactive session with the alias created during setup:
zeroclaw agent -a <alias>Run ZeroClaw in the Background
Install the service after your agent works in the terminal:
zeroclaw service install
zeroclaw service start
zeroclaw service statusConnect Channels and the Dashboard
Configure a supported channel in ~/.zeroclaw/config.toml, bind it to a named agent, and start the service. Unknown direct-message senders must complete pairing under the default security policy. Keep public access disabled until you have reviewed channel allowlists, tool permissions, and the agent’s workspace boundary.
The gateway provides HTTP and WebSocket access for clients. The web dashboard supports chat, memory browsing, configuration editing, cron management, and tool inspection. A standard prebuilt installation includes the supported default channel bundle; a source build can include additional channel features.
Migrate from OpenClaw
Preview the import before ZeroClaw writes any changes:
zeroclaw migrate openclaw --dry-runRun the migration after you review the preview:
zeroclaw migrate openclawThe migration imports supported workspace files, memory, and configuration from ~/.openclaw/ into the ZeroClaw layout. Keep a backup of the original workspace before the full import.
Quick Command Reference
| Command | Purpose |
|---|---|
zeroclaw quickstart | Creates a provider and working agent configuration |
zeroclaw agent -a <alias> | Starts an interactive agent session |
zeroclaw status | Shows runtime status |
zeroclaw doctor | Checks configuration and runtime health |
zeroclaw service install | Registers the operating-system service |
zeroclaw service start | Starts the background service |
zeroclaw gateway | Starts the HTTP and WebSocket gateway |
zeroclaw auth status | Checks stored provider authentication |
zeroclaw config schema | Prints the current configuration schema |
zeroclaw migrate openclaw --dry-run | Previews an OpenClaw import |
Pros
- Free and open-source
- Runs on your own machine
- Supports hosted and local models
- Hosts multiple isolated agents
- Includes supervised security controls
- Imports OpenClaw workspaces
Cons
- Requires technical setup
- Channel availability depends on build features
- Self-hosting requires security maintenance
Alternatives & Related Resources
- 7 Best OpenClaw Alternatives for Safe & Local AI Agents
- Openclaw: Your 24/7 Personal AI Employee
- NanoClaw: Lightweight OpenClaw Alternative for Safer Local AI Agents
FAQs
Q: Is ZeroClaw free and open-source?
A: Yes. ZeroClaw’s code is available from the official ZeroClaw Labs repository. You may use it under the MIT license or the Apache 2.0 license. A hosted model provider can still charge for API usage.
Q: Who publishes ZeroClaw?
A: ZeroClaw Labs publishes the official project at github.com/zeroclaw-labs/zeroclaw. The project credits its original creator, current project lead, maintainers, and community contributors in the repository.
Q: Is openagen/zeroclaw the official ZeroClaw repository?
A: No. ZeroClaw Labs states that it is not affiliated with openagen/zeroclaw, zeroclaw.org, or zeroclaw.net. Use the ZeroClaw Labs website, documentation, and zeroclaw-labs/zeroclaw GitHub repository for downloads and project information.
Q: Is ZeroClaw an OpenClaw fork?
A: ZeroClaw is a separate Rust agent runtime and an alternative to OpenClaw. It can import supported OpenClaw workspace data, memory, and configuration through its migration command.
Q: Can ZeroClaw use an OpenAI-compatible provider?
A: Yes. ZeroClaw supports OpenAI and compatible endpoints through its model-provider configuration. Quickstart handles common providers, while the current configuration reference documents custom endpoints and authentication.
Q: Can I run ZeroClaw without paying for an AI API?
A: Yes. Connect ZeroClaw to Ollama or another compatible local model endpoint. You still need hardware that can run the selected model, and online channels or web tools still need network access.
Q: Can ZeroClaw run on Windows?
A: Yes. The official documentation includes Windows setup instructions, and current releases include self-contained desktop installers. You can also build from source with the supported Rust toolchain.
Q: Does ZeroClaw support multiple agents?
A: Yes. One daemon can run multiple named agents. Each agent can have a separate workspace, memory scope, model provider, identity, channels, runtime profile, and risk profile.
Q: Is ZeroClaw ready for unattended production work?
A: ZeroClaw is still below version 1.0, and its commands or configuration can change. Pin the release, keep supervised mode during evaluation, restrict tool and channel permissions, test upgrades separately, and monitor the service before you rely on it for unattended work.
Last Updated: July 15, 2026
