Edgecrab
EdgeCrab 🦀 A Super Powerful Personal Assistant inspired by NousHermes and OpenClaw — Rust-native, blazing-fast terminal UI, ReAct tool loop, multi-provider LLM support, ACP protocol, gateway adapters, and built-in security hardening.
Last verified:
What is Edgecrab?
EdgeCrab is a SuperAgent for personal assistance and coding, built as a single native Rust binary with no Python or Node.js runtime requirement. It synthesizes the autonomous learning and persistent memory from Hermes Agent with the always-on channel presence from OpenClaw, delivering 63 core tools, 15 LLM providers, and 17 messaging gateways in one Compiled executable.
The tool features a full-screen ratatui TUI running at 60 fps with streaming output, ghost-text completion, fuzzy slash-command search, and mouse scroll support. Its ReAct tool loop runs up to 90 autonomous iterations, dispatching tools for file I/O, web scraping, code execution, semantic LSP operations, and Home Assistant control. EdgeCrab supports sub-agent delegation (up to 3 parallel children at 2 levels deep) and Mixture of Agents that runs 4 frontier models in parallel for complex problems.
EdgeCrab is designed for developers, engineers, and power users who need a production-ready AI agent for coding tasks, personal assistance, smart home automation, and automated workflows. It integrates with GitHub Copilot, VS Code (via ACP protocol), Telegram, Discord, Slack, WhatsApp, and MCP servers. The agent has persistent memory across sessions with SQLite FTS5 full-text search, auto-learning reflection after 5+ tool calls, and a reusable skills library in markdown format.
Key capabilities include sandboxed code execution for Python/JS/Bash/Ruby/Perl/Rust with 5-minute timeouts, 7 compiled-in security layers (path jail, SSRF guard, prompt injection detection), 6 terminal backends (local, Docker, SSH, Modal, Daytona, Singularity), cron scheduling for recurring tasks, checkpoint/rollback for filesystem snapshots, and profile isolation for different work contexts. The agent is open source under Apache 2.0 and runs on macOS, Linux, Windows, and edge hardware.
Edgecrab pricing
Pricing model: Freemium
EdgeCrab is completely free and open source under the Apache 2.0 license. There is no paid tier or subscription model. The tool itself is free to install via npm, pip, cargo, Docker, or native binaries. Users only pay for the LLM provider API calls they use (OpenAI, Anthropic, Google Gemini, etc.) - EdgeCrab does not charge any additional fees. Docker images are hosted on ghcr.io at no cost. All 63 core tools, 15 LLM providers, 17 gateways, and features are included in the free open-source release.
Edgecrab pros
- Built entirely in Rust for memory safety and blazing-fast performance
- Single native binary with no Python or Node.js runtime dependencies
- 63 core tools including file I/O, web scraping, code execution, and browser control
- 15 LLM providers hot-swappable mid-session via /model command
- 17 messaging gateways including Telegram, Discord, Slack, WhatsApp, Signal
- Full-screen ratatui TUI capable of 60 fps with streaming output
- ReAct autonomous loop runs up to 90 iterations without user intervention
- Sub-agent delegation forks up to 3 parallel children at 2 levels deep
- Mixture of Agents runs 4 frontier models in parallel for consensus answers
- Sandboxed code execution with API key stripping and 5-minute timeout
- 7 compiled-in security layers including path jail and SSRF guard at type level
- Persistent memory with MEMORY.md files and SQLite FTS5 full-text search
- Auto-learning reflection fires after 5+ tool calls to create new skills
- Built-in MCP client supports stdio, SSE, and HTTP transports
- Cron scheduling for recurring tasks like daily standup summaries
- Checkpoint and rollback restores filesystem snapshots before destructive operations
- Profiles and git worktrees isolate risky experiments from main branch
- ACP/VS Code Copilot integration registers as native agent without plugins
- 6 terminal backends: local, Docker, SSH, Modal, Daytona, Singularity
- Cross-session Honcho user model deepens alignment with every session
- Open source under Apache 2.0 license
- Cold startup under 50 ms on edge hardware
- 42 slash commands for session, model, config, tools, skills, memory control
- YAML theming for TUI colors, spinners, and agent personality customization
Edgecrab cons
- Newer project with less battle-testing than mature alternatives like hermes-agent
- Fewer channel adapters than OpenClaw (17 vs 24+ adapters)
- No native IRC bot support out of the box
- No SMS shortcode support like OpenClaw offers
- Homebrew tap can lag behind official releases until synced
- Requires Rust 1.86+ if compiling from source via cargo
- Python ecosystem less rich than hermes-agent for data-science workflows
- No pandas/NumPy native interop for agent tools like hermes-agent provides
Frequently asked questions about Edgecrab
What is EdgeCrab and how is it different from hermes-agent?
EdgeCrab is a SuperAgent for personal assistance and coding built as a single native Rust binary. It distills the best of hermes-agent (autonomous learning, persistent memory, Honcho user model, deep tool chains) into compiled Rust. The key difference: hermes-agent ships through a Python runtime with uv-managed environment (~80-150 MB RAM), while EdgeCrab ships as one native executable with no Python runtime dependency, resulting in 50× lighter footprint and sub-50ms cold startup. EdgeCrab has 7 compiled-in security layers vs hermes-agent's runtime patches. However, hermes-agent has a richer Python ecosystem for data-science workflows needing pandas/NumPy interop.
What is the ReAct tool loop and how does it work?
The ReAct (Reason → Act → Observe) loop is EdgeCrab's autonomous reasoning engine that runs up to 90 iterations without user intervention. The agent reasons about the task, dispatches registered tools (file I/O, web scraping, code execution, semantic LSP operations), observes the results, and loops back to reason again. After 5+ tool calls, it fires a learning reflection to autonomously create new skills. The loop also auto-compresses context at 50% threshold using the CompressionEngine to prevent context-window overflow. Tool calls go through security checks (path jail, SSRF guard, command scan) before dispatch and injection scans after results return.
How do I install EdgeCrab?
Five installation methods are available: (1) npm: npm install -g edgecrab-cli (no Rust required), (2) pip: pipx install edgecrab-cli or python -m pip install --upgrade edgecrab-cli (no Rust required), (3) cargo: cargo install edgecrab-cli (requires Rust 1.86+), (4) Docker: docker pull ghcr.io/raphaelmansuy/edgecrab:latest, (5) Homebrew: brew tap raphaelmansuy/tap && brew install edgecrab (tap may lag). After install, run edgecrab setup for the guided setup wizard that detects API keys and writes config, then edgecrab doctor to verify health, then edgecrab to start chatting.
What LLM providers does EdgeCrab support?
EdgeCrab supports 15 built-in LLM providers: GitHub Copilot, OpenAI, Anthropic, Google Gemini, xAI Grok, DeepSeek, Mistral, Groq, HuggingFace, Z.AI, OpenRouter, Ollama, LM Studio, VertexAI, and AWS Bedrock. Providers are hot-swappable mid-session using the /model slash command. The unified LlmClient uses OpenAI-compatible HTTP with streaming, prompt caching, and retry logic. Local models via Ollama and LM Studio enable completely offline work. Model routing can automatically select providers based on task type via the model router with smart routing configuration.
What are the messaging gateways and how do they work?
EdgeCrab has 17 messaging gateways: Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, DingTalk, SMS, Email, Home Assistant, Webhook, API Server, Feishu/Lark, and WeCom. Gateways provide streaming delivery with 300ms edit intervals. The HTTP API server (Axum) plus platform adapters handle approval workflows (inline buttons on Telegram/Discord), proactive home-channel messaging, per-platform allowlists, and delivery confirmation with retry. Gateways are exported in crates/edgecrab-gateway/src/lib.rs. Docker can run the gateway server on port 8642 with environment variables for API keys.
How does EdgeCrab's persistent memory work?
EdgeCrab uses a three-layer memory system: (1) MEMORY.md files for persistent user memories, (2) SQLite FTS5 session history database at ~/.edgecrab/state.db with WAL-mode for concurrent reads and instant full-text search across thousands of messages, and (3) cross-session Honcho user model that deepens alignment with every session. Auto-learning reflection fires after 5+ tool calls to autonomously create new skills. Session CRUD, message storage/retrieval, checkpoint metadata, and FTS5 index are managed by edgecrab-state crate with schema migrations via edgecrab-migrate. Use /memory slash command to view memory.
How does sandboxed code execution work?
EdgeCrab runs Python, JS, Bash, Ruby, Perl, or Rust code in an isolated subprocess sandbox. Scripts can call 7 tools via Unix socket RPC. The sandbox strips API keys from the environment, enforces a 5-minute timeout, and caps output at 50 KB. The execute_code tool runs failing scripts in isolation, reads stderr tracebacks (without API keys visible to sandbox), patches bugs with write_file, re-runs to confirm fixes, and returns clean tested code. Six terminal backends are available: Local (default), Docker container, SSH ControlMaster, Modal cloud sandbox, Daytona cloud dev box, and Singularity/Apptainer HPC overlay. Switch backends with one config line.
What is Mixture of Agents (MoA) and when should I use it?
Mixture of Agents runs a single prompt through multiple frontier models in parallel (Claude Opus 4.6, Gemini 2.5 Pro, GPT-4.1, and DeepSeek R1), then synthesizes a consensus answer. Each model reasons independently, then Claude Opus 4.6 aggregates the reasoning into a synthesis with dissenting notes. Use MoA for genuinely hard architectural questions or complex problems requiring maximum intelligence. Spawn MoA by simply asking EdgeCrab a difficult question - it automatically spawns the 4 parallel model calls. Maximum depth is 2 levels for sub-agent delegation.