Stop Managing Multiple Bots! MicroClaw Runs Everywhere

Stop Managing Multiple Bots! MicroClaw Runs Everywhere

What if one AI assistant could replace your entire fleet of chatbots? No more juggling separate Telegram bots, Discord integrations, and Slack apps. No more context lost between platforms. No more $50/month cloud bills for simple automation.

Here's the painful truth: developers today are duct-taping AI assistants together. One Python^{↗ Bright Coding Blog} script for Telegram, another Node.js service for Discord, a third for Slack. Each with its own memory, its own tools, its own failure modes. When your team asks "What did the bot say in the other channel?" — you shrug. The context died with that process.

MicroClaw changes everything.

This isn't another framework. It's a single Rust binary — under 50MB, runs on a $5 VPS — that gives you one persistent agent runtime across Telegram, Discord, Slack, Feishu/Lark, IRC, Web, and Matrix. Same memory. Same tools. Same personality. Everywhere your team actually works.

Built by developers who suffered through the multi-bot nightmare, MicroClaw takes inspiration from nanoclaw's design philosophy and elevates it with enterprise-grade persistence, multi-step agentic execution, and a local web control plane that would make DevOps^{↗ Bright Coding Blog} engineers weep with joy.

Ready to burn your bot zoo to the ground? Let's dive in.

What is MicroClaw?

MicroClaw is an open-source, agentic AI assistant runtime written in Rust 🦀. Created by the team at microclaw.ai, it represents a fundamental rethinking of how AI assistants should integrate with human communication channels.

Unlike traditional chatbots that are channel-native (a Telegram bot only knows Telegram, a Discord bot only knows Discord), MicroClaw is channel-agnostic. It provides a single, persistent agent loop that maintains state, memory, and capabilities across every platform you connect.

The project draws direct inspiration from nanoclaw, incorporating and extending its core design ideas. But where nanoclaw was an experiment, MicroClaw is engineered for production — with persistent SQLite storage, scheduled task execution, MCP (Model Context Protocol) integration, and a architecture that scales from personal hobby projects to team-wide deployments.

Why it's trending now:

• The MCP ecosystem is exploding, and MicroClaw was built protocol-native from day one
• Rust's async runtime (Tokio) delivers the performance Python/Node alternatives can't touch
• Teams are exhausted by SaaS AI pricing — MicroClaw runs on commodity hardware
• The "one agent, many surfaces" model matches how modern teams actually communicate (scattered across 5+ platforms)

The repository has gained serious traction among developers who've outgrown platform-locked solutions and want sovereign AI infrastructure they control completely.

Key Features That Destroy the Competition

🔥 One Runtime, Infinite Channels

The core architectural bet: why should your AI's personality, memory, and capabilities be fragmented? MicroClaw's shared agent loop means the assistant that helped you debug Rust in Telegram remembers your preferences when you Slack it at 2 AM.

🧠 Persistent Memory Architecture

Not "memory" as in "last 10 messages." Real, durable, structured memory:

• AGENTS.md files at global, bot, and per-chat scopes — loaded into every request
• SQLite-backed structured memory with confidence scoring, soft-archiving, and quality gates
• Knowledge graph extraction (subject-predicate-object triples) for relationship queries
• Semantic search via optional sqlite-vec embeddings

⚡ Agentic Execution Engine

Multi-step tool use isn't bolted on — it's the foundation:

• Tool calls with reflection: the agent evaluates results and continues until completion
• Sub-agent delegation: spawn parallel agents with restricted toolsets for isolated tasks
• Plan & execute: todo-list driven task decomposition with progress tracking
• Mid-conversation messaging: progress updates before final responses

🛡️ Defensive by Design

• IP blocking: web_fetch blocks private/loopback/cloud-metadata IPs at every redirect hop
• Bash gating: known-dangerous patterns are intercepted
• PII redaction: automatic before memory writes
• Tool-loop guardrails: warnings on repeated identical results or consecutive failures

💰 Runs on a $5 VPS

Single static binary. Embedded SQLite. No Python interpreter. No separate vector DB. No service mesh. The RAM/CPU footprint fits comfortably on 1 vCPU / 1 GB — the cheapest tier on any cloud provider.

🔌 MCP-Native

Model Context Protocol servers integrate seamlessly. Browser automation via Playwright MCP. Desktop automation via Peekaboo on macOS. Your agent can literally control your computer through secure, protocol-governed interfaces.

Real-World Use Cases Where MicroClaw Dominates

1. The Distributed DevOps Team

Your infrastructure team lives in Slack. Your backend developers prefer Discord. Your Asia-Pacific colleagues use Feishu/Lark. With MicroClaw, one agent monitors all channels, executes runbooks, and maintains operational context across platforms. Schedule a "check error budgets" task at 9 AM in each team's local timezone — same runtime, same memory, appropriate channel.

2. The Solo Founder Who Refuses SaaS Bloat

You're building a startup on nights and weekends. You need AI assistance for coding, customer support, and content creation — but $200/month for multiple AI SaaS tools is absurd. MicroClaw on a $5 VPS gives you:

• Code assistance with persistent project memory
• Customer support bot across Telegram and Discord
• Scheduled social media^{↗ Bright Coding Blog} content generation
• Total cost: VPS + API usage (often under $20/month total)

3. The Privacy-First Organization

Healthcare, finance, legal — industries where data sovereignty isn't negotiable. MicroClaw runs entirely on your infrastructure. No third-party platform holding your conversation history. No opaque SaaS processing your sensitive queries. Self-hosted, auditable, compliant.

4. The AI Power User Building Custom Workflows

You've outgrown ChatGPT's memory limits. You want your assistant to:

• Remember your 47 custom shell aliases across sessions
• Execute multi-step research (search → fetch → analyze → summarize)
• Schedule and manage complex task pipelines
• Integrate with your browser, desktop, and internal tools via MCP

MicroClaw's skill system, sub-agent delegation, and persistent memory make this possible — not as fragile prompt engineering, but as reliable, testable infrastructure.

Step-by-Step Installation & Setup Guide

One-Line Install (Recommended)

# macOS / Linux
curl -fsSL https://microclaw.ai/install.sh | bash

# Full variant with Matrix support
curl -fsSL https://microclaw.ai/install.sh | bash -s -- --full

# Windows PowerShell
iwr https://microclaw.ai/install.ps1 -UseBasicParsing | iex

# Full variant on Windows
& ([scriptblock]::Create((iwr https://microclaw.ai/install.ps1 -UseBasicParsing).Content)) -Full

Verify Installation

# Run comprehensive diagnostics
microclaw doctor

# Machine-readable output for support
microclaw doctor --json

# Sandbox-specific checks
microclaw doctor sandbox

Interactive Configuration

# Launch the setup wizard (auto-runs on first start if config missing)
microclaw setup

The wizard guides you through:

• Provider selection: Anthropic, OpenAI, Ollama, OpenRouter, DeepSeek, and 15+ more
• Channel credentials: Telegram (multi-account), Discord, Slack, Feishu/Lark, IRC
• Model selection with local auto-detection for Ollama
• Safe config persistence with automatic backups

Docker^{↗ Bright Coding Blog} Deployment

# Pull official image
docker pull ghcr.io/microclaw/microclaw:latest

# Quick try (ephemeral)
docker run --rm -it \
  -p 127.0.0.1:10961:10961 \
  ghcr.io/microclaw/microclaw:latest

# Production: persist data and config
mkdir -p data tmp
chmod a+r microclaw.config.yaml
chmod -R a+rwX data tmp

docker run --rm -it \
  -p 127.0.0.1:10961:10961 \
  -v "$(pwd)/microclaw.config.yaml:/app/microclaw.config.yaml:ro" \
  -v "$(pwd)/data:/home/microclaw/.microclaw" \
  -v "$(pwd)/tmp:/app/tmp" \
  ghcr.io/microclaw/microclaw:latest

Source Build (Rust Required)

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

# Optional: full build with Matrix support
cargo build --release --features full

# Optional: semantic memory with embeddings
cargo build --release --features sqlite-vec

Start the Runtime

# Foreground start
microclaw start

# Default web UI
open http://127.0.0.1:10961

# Install as persistent service
microclaw gateway install
microclaw gateway status

REAL Code Examples from the Repository

Example 1: MCP Configuration for Browser Automation

MicroClaw's MCP integration lets your agent control real browsers with your existing sessions. Here's the exact configuration from the repository for Playwright MCP in extension mode (the recommended approach for Chrome 136+):

{
  "mcpServers": {
    "playwright": {
      "transport": "stdio",
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest", "--extension"],
      "env": {
        "PLAYWRIGHT_MCP_EXTENSION_TOKEN": "<your-token-here>"
      }
    }
  }
}

How this works: The Playwright MCP Bridge extension connects via Chrome's chrome.debugger API — no --remote-debugging-port flag needed. This bypasses Chrome 136's security restrictions and preserves your logged-in sessions (X, Google, GitHub, etc.) without CDP setup headaches. Your agent gains full browser automation capabilities: navigate, click, fill forms, extract data — all through natural language requests.

Example 2: HTTP Webhook Trigger for Headless Automation

For CI/CD integration and external automation, MicroClaw exposes webhook endpoints. Here's the exact request/response pattern from the documentation:

Synchronous request:

curl -sS http://127.0.0.1:10961/api/chat \
  -H "Authorization: Bearer $MICROCLAW_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "session_key": "ops-bot",
    "sender_name": "automation",
    "message": "Check error budget and summarize incidents in the last hour."
  }'

Expected response:

{
  "ok": true,
  "session_key": "ops-bot",
  "chat_id": 123,
  "response": "..."
}

Async streaming for long operations:

# Initiate async run
curl -sS http://127.0.0.1:10961/api/send_stream \
  -H "Authorization: Bearer $MICROCLAW_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "session_key": "ops-bot",
    "message": "Analyze all production logs for anomalies"
  }'

# Returns: {"ok": true, "run_id": "6f4c2b1d-...", "session_key": "ops-bot", "chat_id": 123}

# Consume Server-Sent Events
 curl -N "http://127.0.0.1:10961/api/stream?run_id=<RUN_ID>" \
  -H "Authorization: Bearer $MICROCLAW_API_KEY"

This pattern enables fire-and-forget automation: your CI pipeline triggers analysis, MicroClaw processes asynchronously, and you stream results back when ready. The session_key ensures continuity — the same "ops-bot" identity accumulates context across all automated invocations.

Example 3: WebSocket Bridge for Real-Time Control

For building custom UIs or integrating with existing control systems, MicroClaw's WebSocket bridge at ws://127.0.0.1:10961/ provides bi-directional communication:

Connection handshake:

{
  "type": "req",
  "id": "connect-1",
  "method": "connect",
  "params": {
    "minProtocol": 3,
    "maxProtocol": 3,
    "auth": { "token": "mc_..." }
  }
}

Spawn a background task:

{
  "type": "req",
  "id": "spawn-1",
  "method": "sessions.spawn",
  "params": {
    "task": "Summarize the current repo",
    "label": "Ops"
  }
}

Update session metadata:

{
  "type": "req",
  "id": "label-1",
  "method": "sessions.setLabel",
  "params": {
    "sessionKey": "ops-bot",
    "label": "Ops"
  }
}

The bridge exposes 20+ methods including chat.send, sessions.kill, agents.list, models.list, and config.get. This isn't just a chat API — it's a complete runtime control plane that lets you build supervisory dashboards, automated orchestrators, or custom client experiences.

Example 4: Semantic Memory Quick-Start (sqlite-vec)

For projects requiring semantic search across accumulated knowledge:

# Build with vector extension
cargo build --release --features sqlite-vec

# Interactive setup with embedding provider
cargo run --features sqlite-vec -- setup
# Set: embedding_provider = openai or ollama
# Configure credentials, base URL, model as needed

# Start runtime
cargo run --features sqlite-vec -- start

# Verify memory storage
sqlite3 ~/.microclaw/runtime/microclaw.db \
  "SELECT id, chat_id, chat_channel, external_chat_id, category, embedding_model 
   FROM memories 
   ORDER BY id DESC 
   LIMIT 20;"

This enables semantic KNN retrieval for memory deduplication and relevance scoring — critical when your agent has thousands of accumulated facts and needs to surface the truly pertinent ones for each query.

Advanced Usage & Best Practices

🎯 Memory Tuning for Production

The default memory_token_budget: 1500 works for most cases, but tune these for your model:

• memory_l0_identity_pct: 20 — reserve for core identity (who the user is)
• memory_l1_essential_pct: 30 — high-confidence facts always injected
• L2 relevance fills remaining budget with query-matched memories
• Deeper recall stays on-demand via structured_memory_search

🔒 Security Hardening

sandbox:
  mode: "all"                    # Containerize ALL bash execution
  security_profile: "hardened"   # Drop all capabilities
  require_runtime: true          # Fail fast if Docker unavailable
  no_network: true               # Air-gapped where possible

high_risk_tool_user_confirmation_required: true

⚡ Performance Optimization

• Enable Anthropic prompt caching (automatic) — reduces multi-turn costs ~75%
• Use context compaction thresholds (max_session_messages: 40) to prevent ballooning
• Deploy subagents.max_concurrent: 4 to parallelize independent tasks without overwhelming APIs
• Set compact_keep_recent: 20 to preserve immediate context during compaction

🔄 Skill Lifecycle Management

Skills auto-archive after 30 days of disuse. Set skill_review_min_tool_calls: 5 to enable autonomous skill refinement — the reflector patches existing skills, not just creates new ones. This prevents skill sprawl and keeps your agent's "instincts" sharp.

Comparison with Alternatives

The verdict: If you're building one bot for one platform, existing frameworks work. If you want one intelligent agent everywhere, with memory that survives restarts and capabilities that grow organically — MicroClaw is architecturally unmatched.

FAQ

Q: Does MicroClaw require Rust knowledge to use?

No. Prebuilt binaries install via one-line scripts. Configuration is YAML-based. You only need Rust if building from source or developing core features.

Q: Can I run multiple AI providers simultaneously?

Yes. Configure provider_presets with multiple profiles, then switch per-channel or per-account using /provider <profile> or /model <name> commands.

Q: How does memory work across different chat platforms?

Each chat has a unique channel + external_chat_id identity. Memory scopes are: global (all chats), bot/account (specific platform identity), and per-chat. Cross-session recall uses SQLite FTS5 search.

Q: Is my data sent to external services?

Only your configured LLM provider receives prompts. All memory, sessions, and metadata stay in your local SQLite database. Self-hosted = data sovereign.

Q: What's the difference between MicroClaw and nanoclaw?

MicroClaw extends nanoclaw's design with production features: persistent SQLite storage, scheduled tasks, MCP protocol support, multi-account channels, web UI, and comprehensive sandboxing.

Q: Can I restrict which users interact with the bot?

Yes. Per-channel allowed_user_ids, allowed_groups, and allowed_channels configurations. Control chats (control_chat_ids) get elevated cross-chat permissions.

Q: How do I update MicroClaw?

microclaw upgrade  # In-place binary update

Or re-run the install script. Docker users pull new tags. Source builds: git pull && cargo build --release.

Conclusion

MicroClaw isn't just another chatbot framework — it's a fundamental infrastructure bet on how AI assistants should work in fragmented, multi-platform environments. The "one runtime, many channels" architecture eliminates the context fragmentation that plagues every alternative approach. The Rust implementation delivers performance and resource efficiency that Python/Node ecosystems can't match. And the MCP-native design ensures your agent grows with the emerging ecosystem of tool integrations.

For solo developers, it replaces $200/month SaaS stacks with a $5 VPS. For teams, it unifies communication surfaces without forcing migration. For privacy-sensitive organizations, it offers complete data sovereignty.

The installation takes 60 seconds. The configuration wizard holds your hand through provider setup. And within minutes, you'll have an agent that remembers, plans, executes, and persists — across every platform your team actually uses.

Stop building bot zoos. Start with MicroClaw.

👉 Get MicroClaw on GitHub — star the repo, join the Discord, and deploy your first unified agent today.

The future of agentic AI isn't more platforms. It's one agent that transcends them all.