A lightweight, extensible AI agent framework with multi-agent support and tool calling capabilities.

• Multi-Agent Support: Create multiple specialized AI agents with independent workspaces and configurations
• Intelligent Conversations: LLM-based natural language interaction with multi-turn dialogue
• Tool Calling: Built-in filesystem, shell, web search tools with parallel execution
• MCP Protocol: Model Context Protocol support for extensible external tools
• Session Management: Auto-compress history messages and generate conversation summaries
• Command System: Built-in commands for agent management and system control
• Event Bus: Lightweight async event system for extensibility
• Tool Policy: Fine-grained tool access control per agent
• Skills System: Pluggable skill modules with custom extensions
• Memory Mechanism: Persistent memory across sessions

• Orchestrator Layer: Smart request routing and command handling
• System Prompt Caching: Smart caching based on file mtime for better performance
• Streaming Response: Real-time streaming output support
• Async Architecture: Built on asyncio for efficient concurrent request handling
• Structured Logging: Using loguru with detailed execution logs
• Systemd Integration: Auto-start on boot, auto-restart, production-ready

• Telegram
• WeChat Work (Bot + App)
• Discord
• Slack
• Webhook
• More coming soon...

┌─────────────────────────────────────────────────────────────────┐
│                     Channel Adapters                            │
│  Telegram, WeChat Work, Discord, Slack, Webhook                 │
└──────────────────────────┬──────────────────────────────────────┘
                           │ Request + Context
                           ▼
┌─────────────────────────────────────────────────────────────────┐
│                   Orchestrator                                  │
│  - Command Router                                               │
│  - Agent Router                                                 │
│  - Event Bus                                                    │
└──────────────────────────┬──────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────────┐
│                   Agent Runtime                                 │
│  - Multi-Agent Support                                          │
│  - Session Manager                                              │
│  - Tool Policy                                                  │
└──────────────────────────┬──────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────────┐
│                   Tools + Providers                             │
│  - Enhanced Tools                                               │
│  - Memory System                                                │
│  - MCP Support                                                  │
└─────────────────────────────────────────────────────────────────┘

cd microclaw
pip install -r requirements.txt

Copy the example config and modify:

cp config.example.yaml config.yaml
vim config.yaml

Configuration example:

core:
  workspace: ~/.microclaw
  log_level: INFO
  default_model: qwen

models:
  - name: qwen
    provider: openai
    base_url: https://dashscope.aliyuncs.com/compatible-mode/v1
    api_key: sk-your-api-key
    model: qwen-plus

channels:
  telegram:
    enabled: true
    settings:
      token: "your-bot-token"
      allowed_users: ["123456789"]

python3 main.py

# Install service
sudo cp microclaw.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable microclaw
sudo systemctl start microclaw

# Check status
sudo systemctl status microclaw

# View logs
sudo journalctl -u microclaw -f

• Quick Start Guide - Get started with multi-agent features
• Roadmap - Development roadmap and planned features
• Phase 1 Complete - Phase 1 implementation report
• Agent Comparison - Detailed comparison with OpenClaw
• Implementation Summary - Overall implementation summary

# Coding assistant - file and shell access only
app.agent_manager.create_agent(
    agent_id="coding",
    description="Coding assistant",
    allowed_tools=["read_file", "write_file", "list_directory", "exec"],
)

# Research assistant - web and memory access only
app.agent_manager.create_agent(
    agent_id="research",
    description="Research assistant",
    allowed_tools=["web_search", "web_fetch", "read_memory", "update_memory"],
)

In any channel:

/status                    # Show session status
/agent list                # List all agents
/agent info coding         # Show agent details
/new                       # Reset session
/help                      # Show help

• Filesystem: read_file, write_file, list_directory
• Shell: exec (with timeout control)
• Web: web_search (DuckDuckGo), web_fetch
• Memory: update_memory, read_memory
• MCP: Extensible external tools via Model Context Protocol

MCP (Model Context Protocol) allows integration with external tool servers.

Configuration example:

mcp:
  servers:
    filesystem:
      command: "npx"
      args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
    
    github:
      command: "npx"
      args: ["-y", "@modelcontextprotocol/server-github"]
      env:
        GITHUB_TOKEN: "your-token"

• Startup Time: ~2s
• Memory Usage: ~100MB
• Response Latency: ~100ms (excluding LLM)
• Concurrency: Supports multi-channel concurrency

# Test all features
python3 test_features.py

# Test multi-agent functionality
python3 test_multi_agent.py

# Test skills integration
python3 test_skills_integration.py

# Test basic functionality
python3 test_basic.py

• Multi-Agent support
• Orchestrator layer
• Event bus
• Tool policy
• Command system

• Tool policy system with groups
• Agent communication tools
• Session management tools
• Semantic memory (optional)

• Lightweight plugin system
• Lifecycle hooks
• Built-in plugins

• Channel plugin system
• Lightweight Gateway (optional)
• Health checks and metrics

• Performance optimization
• Testing and documentation
• Production readiness

Issues and Pull Requests are welcome!

MIT License

• Inspired by OpenClaw
• Implementation: ACE

✅ Production Ready (Phase 1 Complete)

• Multi-agent support: ✅
• Command system: ✅
• Event bus: ✅
• Tool policy: ✅
• Backward compatible: ✅

Last Updated: 2026-03-05

Note: This is a lightweight implementation inspired by OpenClaw, focusing on core functionality with minimal dependencies and codebase (~4,100 lines vs OpenClaw's ~50,000 lines).