MicroClaw

English · 简体中文 · हिन्दी · Español · العربية · Français · বাংলা · Português · Bahasa Indonesia · اردو

One embeddable Rust agent core: Server, Code, and an SDK.
Run MicroClaw Server, code in your repository with MicroClaw Code, or embed the same Agent Engine in your own Rust application.

Quick start · Rust SDK · Why MicroClaw · Capabilities · Documentation

MicroClaw is a self-hosted Rust agent platform with three products that share one Agent Engine. MicroClaw Server (microclaw) runs continuously for chat channels, Web, APIs, scheduling, and automation. MicroClaw Code (mccode) is a coding agent for Zed and the terminal that works directly in your repository and verifies its edits with your project's own checks. microclaw-sdk lets other Rust applications run the same channel-independent Agent Engine, tools, policy, memory, skills, and runtime events.

It is designed for work that lasts longer than one request: multi-step tool use, resumable sessions, durable delivery, persistent memory, scheduled tasks, and governed extensions all run in the same runtime.

Read the MicroClaw Code guide for the coding workflow, permission modes, project trust and verification. The current stable delivery baseline is MicroClaw v0.11.0.

Choose the path that matches what you are building:

Install MicroClaw Code (preview) and configure a model once:

curl -fsSL https://microclaw.org/install-mccode.sh | bash   # macOS, Linux
# Windows: iwr https://microclaw.org/install-mccode.ps1 -UseBasicParsing | iex
mccode setup

Then use it in Zed, the recommended editor. Zed is free for macOS, Linux, and Windows: download it or run brew install --cask zed (macOS), curl -f https://zed.dev/install.sh | sh (Linux), or winget install -e --id ZedIndustries.Zed (Windows). Add MicroClaw Code as an agent in Zed's settings (which mccode gives the path) and pick MicroClaw Code in the Agent Panel. The Zed guide has the details; it needs mccode 0.27.0 or later.

"agent_servers": {
  "MicroClaw Code": { "type": "custom", "command": "/path/to/mccode", "args": ["acp"] }
}

Or run it in the terminal: cd path/to/your/repo && mccode.

To run MicroClaw Server, install on macOS or Linux:

curl -fsSL https://microclaw.org/install.sh | bash

On Windows PowerShell:

iwr https://microclaw.org/install.ps1 -UseBasicParsing | iex

Configure and start:

microclaw doctor
microclaw setup
microclaw start

Then open http://127.0.0.1:10961.

The latest release is v0.27.0: MicroClaw Code is at home in Zed. In Zed's Agent Panel it has mode and model pickers, real diffs of every edit, approval cards, project checks as their own cards, / commands, a context meter and thread history that imports terminal sessions. The terminal UI masks API keys in /config, and the docs now recommend Zed first. See the release notes and downloads.

For Homebrew, Docker, source builds, Linux compatibility, upgrades, and service installation, see the getting-started guide.

• One core, three products. Server, Code, and SDK applications share the same Agent Engine, provider layer, tools, memory, policy, and recovery model.
• An embeddable Rust SDK. Applications can use stable Agent, Run, event, control, and Worker contracts without depending on Server, Web, channel, or desktop UI code.
• A coding agent that checks its work. MicroClaw Code edits your repository with reviewable diffs and approvals, then runs your project's build and lint checks and hands failures back to the agent.
• Execution that can continue. Sessions, safe tool boundaries, scheduled work, and outbound delivery survive process restarts.
• Provider freedom. Use native Anthropic or a broad set of OpenAI-compatible and local providers through one internal message model.
• Extensible by design. Add skills, MCP servers, plugins, hooks, tools, or channel adapters without replacing the core runtime.
• Operable on modest infrastructure. A Rust service and embedded SQLite keep deployment straightforward; no separate vector database or service mesh is required.
• Safety is part of execution. Tool risk gates, scoped grants, egress controls, sandboxing, redaction, and audit trails use shared enforcement points.

Read the durable coworker guide and reliability proof report for the concrete recovery model. Every release publishes a machine-readable reliability scorecard as a release asset — reproduce it locally with scripts/ci/reliability_scorecard.sh.

Every message follows the same flow:

1. Resume session state and load relevant memory, skills, and runtime context.
2. Call the selected model using provider-neutral messages and tool definitions.
3. Execute tools through shared guardrails, hooks, and authorization checks.
4. Continue until completion, then persist the turn and deliver the result durably.

Server channel adapters translate ingress and delivery events only. MicroClaw Code consumes the same runtime events through microclaw-sdk and renders them in Zed (over ACP) or its terminal UI. Neither product carries a separate agent loop or provider implementation.

microclaw-sdk exposes the shared run lifecycle to other Rust applications. Its full preset includes the configured Agent Engine, Skills, tools, MCP, memory, hooks, Subagents, and Local Worker support without pulling in the Server, Web console, or concrete channel adapters.

[dependencies]
microclaw-sdk = { version = "0.27.0", features = ["full"] }

use microclaw_sdk::{FullRuntimeConfig, MicroClaw};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = FullRuntimeConfig::new("openai", "gpt-5", std::env::var("OPENAI_API_KEY")?);
    let microclaw = MicroClaw::configure(config).build().await?;
    let result = microclaw.agent("assistant").build()?.run("Plan this task").result().await?;
    println!("{}", result.final_text);
    Ok(())
}

Use MicroClaw::builder for YAML configuration or MicroClaw::configure for an entirely programmatic setup, inspect the Skill catalog, build an Agent with selected Skills, and consume ordered runtime events plus the terminal RunResult. See the compiling configured_skilled_agent example and the SDK quickstart, concept guide, Skills guide, and Worker guide. The public Rust packages are available on crates.io as microclaw-core, microclaw-engine, and microclaw-sdk.

The runtime includes adapters for Telegram, Discord, Slack, Feishu/Lark, WeChat, DingTalk, QQ, WhatsApp, Signal, Matrix, IRC, Nostr, iMessage, email, and Web. Matrix is enabled by the full feature; availability and setup requirements vary by platform.

Anthropic has a native provider path. OpenAI, OpenAI Codex, OpenRouter, Ollama, Google, DeepSeek, local servers, and many other services use the shared OpenAI-compatible path. The generated provider matrix is the source of truth for current IDs, protocols, defaults, and models.

The prebuilt Linux binary has glibc and OpenSSL requirements. Read Getting started before installing on an older distribution.

MicroClaw Server is supported on macOS, Linux, and Windows. MicroClaw Code is a preview with installers for the same three platforms.

Start with the documentation map. It separates everyday use, extension, operations, security, architecture, and contributor material so this page can remain a focused project entry point.

Localized README files cover the project overview and quick start. The English technical documentation remains the canonical source so commands and configuration facts have one maintainable home. See the translation policy.

Questions and ideas are welcome on Discord and Reddit. For bugs and code changes, read CONTRIBUTING.md before opening an issue or pull request. Security reports should follow SECURITY.md.

Thanks to everyone who has contributed to MicroClaw.

MIT