RsClaw

RsClaw: AI Automation Manager with One-Click OpenClaw Migration & Native Long-Term Memory

• 
• 
• []()

1. Overview

• RsClaw is an AI automation manager rebuilt from the ground up in Rust, designed to deliver a high-performance, cross-platform desktop experience with one-click installation.
• Core capabilities include native long-term memory, self-evolution, and seamless migration from OpenClaw, ensuring that existing configurations transfer without friction.
• The project emphasizes a compact binary footprint (approximately 12MB), fast startup (a fraction of a second), and modest idle memory usage, contrasting with heavier Node.js-based rivals.
• It brings together a comprehensive feature set: broad channel support, dozens of built-in tools, a rich model ecosystem, and a robust security model for safe automation in diverse environments.
• The design prioritizes forward compatibility, with a configurable resolution order for settings and an approach that silently ignores unknown fields to preserve upgrade safety.

1. Migration from OpenClaw

• Quick-start flow: Stop the OpenClaw gateway, initialize RsClaw, and allow automatic data detection with an import option.
• Migration commands (conceptual flow):
• Stop OpenClaw gateway.
• Run the setup process in RsClaw, which detects existing OpenClaw data.
• Choose Import (recommended) to copy config, workspace, and session history into ~/.rsclaw/. OpenClaw data remains read-only.
• Alternatively, choose Fresh to start anew, ignoring OpenClaw data.
• Configuration resolution priority for migrated setups: 1) A --config-path CLI flag (highest priority) 2) RSCLAWBASEDIR/rsclaw.json5 3) ~/.rsclaw/rsclaw.json5 4) .rsclaw.json5 in the current directory (lowest)
• All OpenClaw config fields are supported by RsClaw; unknown fields are silently ignored to ensure forward compatibility.

1. RsClaw vs OpenClaw

• Language and runtime:
• RsClaw uses Rust for a lean, fast, memory-safe runtime.
• OpenClaw uses TypeScript/Node.js.
• Binary size and startup:
• RsClaw: ~12MB binary size; startup time around ~26ms.
• OpenClaw: ~300MB+ binary with Node.js dependencies; slower startup (2–5 seconds).
• Memory and dependencies:
• RsClaw idle memory around ~20MB; fewer runtime dependencies (Rust crates in the low hundreds).
• OpenClaw typically requires many Node modules (1,000+).
• Protocol and compatibility:
• RsClaw maintains OpenClaw WS v3 compatibility for the WebUI and provides OpenAI-compatible endpoints.
• OpenClaw uses native/TypeScript-based protocol stacks.
• Channels, tools, and capabilities:
• RsClaw ships with 13+ channels plus custom webhooks; OpenClaw has fewer built-in channels.
• RsClaw includes 15 pre-configured LLM providers and a larger set of built-in tools (32) versus OpenClaw’s smaller toolset.
• RsClaw features pre-parsed commands with sub-millisecond response, a broad exec/shell integration, and advanced safety and audit capabilities.
• Security and safety:
• RsClaw enforces write sandboxing, file system path isolation, and content scanning as standard safeguards.
• It includes a concrete exec safety model with 40+ deny/confirm/allow patterns and memory protections for sensitive data.

1. RsClaw-Exclusive Features

• Pre-parsed Commands (40+)
• Local, ultra-fast commands that bypass the LLM entirely to deliver sub-millisecond responses at zero token cost.
• Shell/Exec category includes robust pipes, redirection, and chained commands such as /run, /sh, /exec, /ls, /cat, /read, /write, /find, /grep.
• Web & Search commands enable on-demand browsing and content extraction, with /search, /google, /fetch, and /screenshot.
• System & Session commands provide fast access to help, status, health checks, model switching, memory, and session history.
• Context & Side Query commands (ctx, btw) enable persistent background context and lightweight side-channel queries.
• Memory and upload commands (remember/recall; get/set upload size and chars) facilitate long-term memory usage and runtime tuning.
• Skill and tool management through /skill install and /skill list.
• Exec Safety Rules
• A configurable deny/confirm/allow model with 50+ built-in patterns to prevent dangerous operations (sudo, rm -rf /, dd, mkfs, shutdown, etc.).
• Read protection blocks access to SSH keys, cloud credentials, and sensitive config files, with an opt-in mode to enable safety via tools.exec.safety = true.
• Two-Layer File Upload Confirmation
• Layer 1 (Size Gate): large files trigger a confirmation step with actions such as analyze, save to workspace, or discard.
• Layer 2 (Token Gate): extracted text beyond a threshold prompts a token-cost confirmation.
• Runtime-adjustable limits via set/upload size and set/upload chars commands; persistent in config when saved via config commands.
• Vision Auto-Detection
• Detects whether the current model supports image input (e.g., GPT-4V, Claude 3, Gemini, Qwen-VL) and uses image-aware handling.
• Non-vision models receive an [image] placeholder to avoid silent token waste.
• Native Voice Recognition (STT)
• Multi-provider, fallback-capable voice-to-text pipeline, including Candle Whisper (local), whisper.cpp (local binary), macOS SFSpeechRecognizer (offline), Tencent/Alibaba Cloud ASR, and OpenAI Whisper API.
• Supports common audio formats (WeChat SILK, Opus, MP3, WAV, OGG, M4A, AAC, FLAC) via a Rust-based decoder with optional FFmpeg fallback.
• Includes Chinese character conversion (Traditional-Simplified).
• Video & Audio Processing
• Automatic transcription of video audio tracks (via FFmpeg) and direct transcription of audio files.
• Injects transcriptions into context with markers like [Audio transcription from {ext} file].
• Document Extraction
• Native, tool-free extraction for PDF, DOCX, XLSX, PPTX, and plain text/codes.
• PDF via pdf_extraction crate with a pdftotext fallback; Office formats parsed from ZIP structures.
• Image Compression
• Automatic resizing to a 1024px max dimension and conversion to JPEG to reduce token payloads.
• Write Sandbox
• Workspace isolation for writes; content scanning to block dangerous patterns.
• Per-Agent Command Permissions
• The main agent has access to all commands; other agents can be constrained by configuration.
• Tool Loop Detection
• Sliding-window detector (12-call window with an 8-call threshold) prevents infinite tool call loops; resets after productive activity.
• Configure Section Menu
• Interactive rsclaw configure with sections for Gateway, Model Provider, Channels, Web Search, Upload Limits, and Exec Safety; supports direct access via --section flag.
• CDP Browser Automation
• Built-in headless Chrome control via Chrome DevTools Protocol (no ChromeDriver or Node.js dependency); 20 actions including text extraction, screenshots, and page interaction.
• Accessibility tree snapshots for LLM-friendly interactions; memory-adaptive lifecycle with idle timeout and crash recovery.
• Customizable Defaults
• Place defaults.toml under base_dir to override built-ins at runtime; supports provider definitions, channel definitions, exec safety rules, and web/search URLs.
• Dual Skill Registry
• ClawHub + SkillHub with automatic fallback to ensure broader skill availability.
• ACP Extended Commands
• Additional commands for OpenClaw compatibility, such as advanced spawn/connect/run/send/kill operations.
• Pairing Revoke
• Pairing management for OpenClaw compatibility, with an 8-character code format and 1-hour TTL.
• Base Directory Flexibility
• Global flags --base-dir and --config-path support flexible config paths for multi-instance use.
• Date-Based Versioning
• Automatic versioning using a YYYY.M.D date prefix coupled with a git hash.

1. Quick Install and First Run

• Pre-built binaries (recommended)
• macOS/Linux: curl -fsSL https://app.rsclaw.ai/scripts/install.sh | bash
• Windows: PowerShell - irm https://app.rsclaw.ai/scripts/install.ps1 | iex
• Supported platforms include macOS x8664 and ARM64, Linux x8664 and ARM64, Windows x86_64 and ARM64.
• Desktop App
• Downloads from Releases: .dmg (macOS), .msi (Windows), .deb (Linux).
• macOS security note: disallow quarantine and bypass gatekeeper if necessary for initial run.
• From Source
• Git clone, cargo build --release to produce a ~12MB binary at target/release/rsclaw.
• Local Cross-Compilation
• Build scripts support macOS, Linux, and Windows targets for multi-arch releases.
• First Run
• Run rsclaw setup to detect OpenClaw data, then rsclaw start to launch the gateway.

1. Quick Start

• Interactive onboarding with rsclaw onboard.
• Start gateway with rsclaw start, verify with rsclaw status, and perform health checks with rsclaw doctor --fix.
• Configure via rsclaw configure, including targeted sections like channels.

1. Update / Upgrade

• Auto-update from GitHub: rsclaw update.
• Manual update from source: git pull origin main; cargo build --release.
• Check current version with rsclaw --version.
• The update process replaces the binary in-place and restarts the gateway when run as a service.

1. Supported Channels (13 + Custom)

• WeChat Personal: ilink long-poll; QR login; supports voice STT, image/file/video sharing, and SILK decoding.
• Feishu / Lark: WebSocket; OAuth-based login; event dedup; rich text support.
• WeCom: AI Bot WebSocket; uses botId/secret; auto-reconnect; markdown replies.
• QQ Bot: WebSocket Gateway; appId/appSecret; multi-channel support with sandbox mode.
• DingTalk: Stream WebSocket; DM and group messaging; voice transcription.
• Telegram: HTTP long-poll; botToken; DM/group with inline image support.
• Matrix: HTTP / sync long-poll; homeserver/accessToken/userId; optional E2EE.
• Discord: Gateway WebSocket; bot token; guild/DM support with streaming edits.
• Slack: Socket Mode WebSocket; botToken + appToken; no public URL needed.
• WhatsApp: Webhook (Cloud API); environment variables for phone and access token; meta webhook verification.
• Signal: signal-cli JSON-RPC; supports encrypted messaging.
• LINE: Webhook; channelAccessToken + channelSecret; push/reply API.
• Zalo: Webhook; accessToken + oaSecret; official account API.
• Custom Webhook: Webhook POST to /hooks/{name}; generic inbound handler.
• Channel features include per-channel DM/group policies, pairing, health monitoring, text chunking, retry logic, pairing codes, streaming modes, and file upload confirmations.
• Each channel supports independent policies and agent routing to fit enterprise or personal workflows.

1. LLM Providers (15 Pre-configured)

• Qwen (Alibaba DashScope): dashscope.aliyuncs.com; qwen-turbo / qwen-plus / qwen-max.
• DeepSeek: api.deepseek.com; streaming tool call accumulation.
• Kimi (Moonshot): api.moonshot.cn.
• Zhipu (GLM): open.bigmodel.cn.
• MiniMax: api.minimax.chat.
• GateRouter: api.gaterouter.com; multi-model routing.
• OpenRouter: openrouter.ai/api.
• Anthropic: api.anthropic.com; Claude 3/4 family.
• OpenAI: api.openai.com; GPT-4o / o1 / o3.
• Google Gemini: generativelanguage.googleapis.com.
• xAI (Grok): api.x.ai.
• Groq: api.groq.com; Llama / Mixtral.
• SiliconFlow: api.siliconflow.cn.
• Ollama: localhost:11434; local models.
• Custom: user-defined; any OpenAI-compatible API.
• Features across providers include failover with exponential backoff, model fallback chains, image fallback models, token usage tracking, and automatic provider registration from config and environment variables.

1. Built-in Tools (32)

• Category coverage includes:
• File: read, write
• Shell: exec (with safety rules)
• Memory: memorysearch, memoryget, memoryput, memorydelete
• Web: websearch, webfetch, webbrowser, computeruse
• Media: image, pdf, tts
• Messaging: a broad set of integrations (message, telegramactions, discordactions, slackactions, whatsappactions, feishuactions, weixinactions, qqactions, dingtalkactions)
• Session: sessionssend, sessionslist, sessionshistory, sessionstatus
• System: cron, gateway, subagents, agentspawn, agentlist
• Web search engines configurable via rsclaw configure --section web_search (DuckDuckGo default, with Brave, Google, Bing options).

1. Storage Architecture

• Hot KV: redb 2 for fast session data, messages, pairing state, and config cache.
• Full-Text Search: tantivy 0.22 for memory-based search and document indexing.
• Vector Search: hnsw_rs 0.3 for semantic similarity and auto-recall.
• Data locations: $base_dir/var/ (var/data for redb/search/memory, var/run, var/logs, var/cache) and other runtime storage.

1. Configuration Example (rsclaw.json5)

• Gateway: defines port and bind address.
• Models/providers: e.g., qwen with API key and base URL.
• Agents/defaults: model primary, thinking level, etc.
• Channels: telegram, feishu, and others with their credentials.
• Tools: exec safety toggle and upload limits (max file size, max text chars).
• Importantly, environment variable substitution is supported (e.g., ${TELEGRAMBOTTOKEN}).

1. Integrations and Protocols

• MCP (Model Context Protocol): spawn MCP servers and auto-register tools as mcp_.
• Plugins: hook-based architecture with lifecycle events (preturn, postturn, pretoolcall, etc.), loading from plugins/.
• Skills: external packages from ClawHub and SkillHub; install via rsclaw skills install or /skill install.
• A2A Protocol: Google A2A v0.3 for cross-network agent communication, including:
• Agent Card auto-discovery via /.well-known/agent.json
• JSON-RPC 2.0 task dispatch with tasks/send
• Cross-machine collaboration with Bearer token authentication
• Collaboration modes: sequential, parallel, orchestrated
• Streaming support for capable agents
• Endpoints for discovery and task submission
• DM pairing and health monitoring across channels to support reliable, multi-agent workflows.

1. Roadmap (Phases)

• Phase 1: CLI Parity + Stability
• Maintain existing commands with new options, add completion/dashboard/daemon/qr/docs/uninstall, and enhance doctor/logs/sessions/status options.
• Phase 2: Large Commands + Ecosystem
• Expand the command tree, support distributed computing and a broader flag set, and launch a plugin marketplace.
• Phase 3: Advanced Features
• Add browser commands, containerization support, video frame extraction for non-Gemini models, and multimedia messaging integration.
• Phase 4: Public Release
• Achieve full CLI and control UI compatibility, publish Homebrew / cargo install distributions, and deliver complete documentation.

1. FAQ (Selected Answers)

• Can I run RsClaw and OpenClaw simultaneously?
• Yes. RsClaw defaults to port 18888, OpenClaw to 18789, with separate data directories (~/.rsclaw/ vs ~ / .openclaw/).
• Will RsClaw modify my OpenClaw data?
• No. Import mode reads OpenClaw data but never writes to ~/.openclaw; all RsClaw data goes to ~/.rsclaw/.
• How do I switch back to OpenClaw?
• Stop RsClaw and start OpenClaw gateway; your OpenClaw data remains untouched.
• Does RsClaw support all OpenClaw WebSocket methods?
• 33+ methods are implemented; wire-compatible with the OpenClaw WebUI.
• How do I enable exec safety?
• Set tools.exec.safety = true in the config or use rsclaw configure --section exec_safety. There are 40+ deny patterns in built-in rules.
• How do I update RsClaw?
• Use rsclaw update; for source, pull and build again.
• Where does RsClaw store data?
• In ~/.rsclaw/. Import mode copies data from OpenClaw here during setup.
• How do I configure file upload limits?
• Use rsclaw configure --section uploadlimits or set tools.upload.maxfilesize and tools.upload.maxtextchars; runtime changes via /setuploadsize and /setupload_chars.

1. Development and Requirements

• Core architecture spans multiple modules: src/agent, config, gateway, mcp, plugin, provider, skill, store, ws, cmd, acp, a2a.
• Requirements:
• Rust 1.91+ (Edition 2024)
• Cross-platform: macOS, Linux, Windows
• Optional: ffmpeg (for image compression and transcription), whisper-cpp (local STT)
• Optional: Matrix E2EE support via feature flag --features channel-matrix
• Cross-compilation:
• On macOS hosts, use musl-cross to build Linux targets and cargo-xwin for Windows MSVC targets.
• Targets include x8664-unknown-linux-gnu, aarch64-unknown-linux-gnu, x8664-pc-windows-msvc, aarch64-pc-windows-msvc, and macOS variants.
• Matrix E2EE:
• Build with --release --features channel-matrix for encrypted Matrix rooms; without the flag, a lighter, unencrypted mode is used.

1. License

• RsClaw is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0).
• You are free to use, modify, and distribute, but any modified network service must be open-sourced under the same license.

Notes

• The description above preserves the core ideas and phrasing from the input while reorganizing content into a detailed, readable description composed of sections and bullets.
• All major features, configurations, integrations, and workflows described in the original input are included, with emphasis on how RsClaw differentiates itself from OpenClaw and what users can expect in practical terms.