Personal + coding SuperAgent that grows with you. Powered by the best ideas from Hermes Agent and OpenClaw, delivered as a single native Rust binary with no Python or Node.js runtime requirement.
or: pip install edgecrab-cli · cargo install edgecrab-cli
EdgeCrab synthesises Hermes Agent's ethos of autonomous learning, persistent memory, and user-first alignment with OpenClaw's vision of an always-on assistant living in your channels. Delivered as a native Rust binary: 63 core tools, 15 LLM providers, 17 messaging gateways, and no Python or Node runtime requirement for the agent itself.
Full-screen terminal UI with streaming output, ghost-text completion, fuzzy slash-command search, multi-line input, approval dialogs, and mouse scroll. Built with ratatui — GPU-composited, silky smooth.
Autonomous Reason → Act → Observe loop runs up to 90 iterations. Dispatches 63 registered core tools, including semantic LSP operations, fires learning reflection after ≥5 tool calls, and auto-compresses context at 50% threshold.
GitHub Copilot, OpenAI, Anthropic, Google Gemini, xAI Grok, DeepSeek, Mistral, Groq, HuggingFace, Z.AI, OpenRouter, Ollama, LM Studio, VertexAI, and AWS Bedrock — hot-swappable mid-session via /model.
Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, DingTalk, SMS, Email, Home Assistant, Webhook, API Server, Feishu/Lark, WeCom — streaming delivery with 300ms edit intervals.
Fork up to 3 parallel sub-agents for complex tasks. Each child inherits provider + tool registry but has its own session state, budget, and cancellation token. Max depth: 2 levels.
Run Python, JS, Bash, Ruby, Perl, or Rust in an isolated subprocess. Scripts can call 7 tools via Unix socket RPC. API keys stripped. 5-min timeout. 50 KB output cap.
Run a single prompt through Claude Opus 4.6, Gemini 2.5 Pro, GPT-4.1, and DeepSeek R1 in parallel, then synthesize a consensus answer. Maximum intelligence for hard problems.
7 independent security layers: path jail (SanitizedPath type), SSRF guard (SafeUrl type), command scan, prompt injection detection, code sandbox env stripping, skills threat scanner, output redaction.
Plug in Local (default), Docker container, SSH ControlMaster, Modal cloud sandbox, Daytona cloud dev box, or Singularity/Apptainer HPC overlay. Switch with one config line.
Three-layer memory: MEMORY.md files, SQLite FTS5 session history (instant full-text search), and cross-session Honcho user model. Auto-learning reflection fires after ≥5 tool calls.
Reusable agent procedures as markdown files. Browse the public hub, install in one command, preload per session with -S. The agent creates new skills autonomously during learning reflection.
Built-in Model Context Protocol client — connect any MCP server and its tools appear in the registry automatically. Hot-reload with /reload-mcp. Stdio, SSE, and HTTP transports.
Schedule recurring tasks with standard cron syntax. The agent can schedule its own follow-ups. Deliver proactive summaries to your Telegram at 9am every weekday.
Filesystem snapshots before every destructive operation. Restore any checkpoint with /rollback. Up to 50 snapshots per session. Never lose work from an agent mistake again.
Switch contexts with edgecrab profile use work/homelab/research. Isolate risky experiments in git worktrees with -w. Each profile has its own keys, model, memory, and toolsets.
Built-in JSON-RPC 2.0 stdio adapter for Agent Communication Protocol. Registers as a VS Code Copilot agent, Zed agent, or any ACP-compatible runner. No plugin required.
EdgeCrab doesn't replace hermes-agent or OpenClaw — it distils the best of both into a single Rust binary that removes the Python and Node runtime stack from the deployment story.
hermes-agent is brilliant — autonomous learning, persistent memory, Honcho user model, deep tool chains. It inspired EdgeCrab's entire architecture. The difference: hermes-agent ships through a Python runtime and uv-managed environment. EdgeCrab ships as compiled Rust: same memory system, same Honcho integration, same learning reflection — in one native executable.
OpenClaw nailed the vision: an always-on personal assistant living in your channels. EdgeCrab took that vision and compressed it into a single native executable instead of a Node.js runtime stack.
EdgeCrab is what you get when you take Hermes Agent's soul (autonomous learning, memory, user alignment, Honcho) and pair it with OpenClaw's vision (always-on channels, instant presence) — then forge the result in Rust. You keep 100% of the power, you shed 95% of the weight. No Python venv, no Node.js runtime, no 500 MB node_modules. Just one binary that runs your agent anywhere.
Every number below is source-derived from the current tree, except where explicitly marked as a local measurement.
* Derived from `CORE_TOOLS` in `crates/edgecrab-tools/src/toolsets.rs`.
* Derived from `providers:` in `crates/edgecrab-core/src/model_catalog_default.yaml`.
* Derived from the gateway modules exported in `crates/edgecrab-gateway/src/lib.rs`.
Release note: the current workspace version is v0.9.0. Source-derived counts come directly from the current repository state.
EdgeCrab isn't a demo — it's daily infrastructure. These are the real workflows it enables, from a Telegram DM to a full autonomous coding session.
Every weekday at 9 am, EdgeCrab tails your git log, reads your open PRs, and sends a clean standup summary to your personal Telegram — without you lifting a finger.
Send a WhatsApp voice note describing a bug. EdgeCrab transcribes it with Whisper, locates the relevant files, runs the tests, and replies with a diagnosis and diff — all before you finish your coffee.
Spin up an isolated git worktree for any experimental change. The agent works in a branch-isolated copy — if it goes sideways, just delete the worktree and nothing touches main.
Send the agent a genuinely hard architectural question. Mixture of Agents spawns Claude Opus 4.6, Gemini 2.5 Pro, GPT-4.1, and DeepSeek R1 in parallel — each reasons independently, then Claude aggregates the best answer.
Ask EdgeCrab to "turn off everything that's been on for over 4 hours and set bedtime mode." It queries HA entity states, applies the logic, calls services, and confirms what it changed.
Paste a broken Python data pipeline. The agent runs it in an isolated sandbox, reads the traceback, fixes the bug, re-runs to confirm it passes, then shows you the final working code.
npm, pip, cargo, Docker, and native binaries are verified against the current release. Homebrew support exists, but the external tap can lag until it is synced.
# Install globally via npm — no Rust required
npm install -g edgecrab-cli
# Run setup wizard (detects API keys, writes config)
edgecrab setup
# Verify health (checks keys, provider ping, binary size)
edgecrab doctor
# Start chatting
edgecrab
edgecrab "summarise the git log for today"
edgecrab --model openai/gpt-5 "review this codebase"# Install via pip — no Rust required
# Use pipx for an isolated install (recommended)
pipx install edgecrab-cli
# or: python -m pip install --upgrade edgecrab-cli
# Run setup wizard
edgecrab setup
# Verify health
edgecrab doctor
# Start chatting
edgecrab
edgecrab "count lines in src/**/*.rs"
edgecrab --model ollama/llama3.3 "work completely offline"# Compile and install from crates.io (requires Rust 1.86+)
cargo install edgecrab-cli
# Run setup wizard
edgecrab setup
# Verify health
edgecrab doctor
# Start chatting
edgecrab
edgecrab "review the architecture docs"
edgecrab --model openai/gpt-5 "design a release checklist"# Homebrew support exists, but verify the tap is current
brew tap raphaelmansuy/tap
brew install edgecrab
edgecrab --version
# Run setup wizard
edgecrab setup
# Verify health
edgecrab doctor
# If brew still serves an older release, use npm, pip, cargo,
# Docker, or the native GitHub Release binaries until the tap sync completes.
# Start chatting
edgecrab
edgecrab "explain this codebase" --model openai/gpt-4o
edgecrab -w "explore that risky refactor" # isolated git worktree
edgecrab -S git-workflow "review this PR" # preload a skillpip install edgecrab
from edgecrab import Agent
# Simple chat
agent = Agent(model="openai/gpt-4o")
reply = agent.chat("Explain Rust ownership in 3 sentences")
print(reply)
# Async + streaming
import asyncio
from edgecrab import AsyncAgent
async def main():
agent = AsyncAgent(model="copilot/gpt-5-mini")
async for token in agent.stream("Write a Rust hello-world"):
print(token, end="", flush=True)
asyncio.run(main())npm install edgecrab
import { Agent } from "edgecrab";
// Simple chat
const agent = new Agent({ model: "openai/gpt-4o" });
const reply = await agent.chat("Review this TypeScript code");
console.log(reply);
// Streaming
for await (const token of agent.stream("Write a README")) {
process.stdout.write(token);
}
// npx CLI
// npx edgecrab-sdk chat "Hello!"
// npx edgecrab-sdk models# Pull pre-built multi-arch image (linux/amd64 + linux/arm64)
docker pull ghcr.io/raphaelmansuy/edgecrab:latest
# Run gateway server (15 messaging gateways)
docker run -p 8642:8642 \
-e ANTHROPIC_API_KEY=sk-ant-... \
-e TELEGRAM_BOT_TOKEN=123456:... \
-v "$HOME/.edgecrab:/root/.edgecrab" \
ghcr.io/raphaelmansuy/edgecrab:latest
# Or with docker-compose (full gateway stack)
docker compose up -d
docker compose logs -fEdgeCrab is not a fork of either project. It absorbs what made each great — Hermes Agent's soul of autonomous learning and OpenClaw's messaging vision — then reforges it in Rust as a single binary that runs anywhere.
| Feature | Hermes Agent 🧠 | OpenClaw 🦞 | EdgeCrab 🦀 |
|---|---|---|---|
| What it is | Autonomous agent (Python) — 40+ tools, learns and grows | Personal assistant platform (TypeScript) — 24+ channels | ✓ SuperAgent — 63 core tools + 17 gateways + learns autonomously (Rust) |
| Core soul | ✓ Lives on your server, remembers what it learns, improves over time | ✓ Always-on presence in your channels and tools | ✓ Both: Hermes soul (memory + learning) + OpenClaw presence (17 gateways) |
| User-first alignment | ✓ Hermes LLM — steerable & user-aligned; Honcho cross-session user model | Partial — depends on system prompt | ✓ Compiled-in Honcho user model — deepens with every session |
| Deep reasoning | ✓ Multi-turn + subagent delegation + parallel batch workers | Via LLM API calls only | ✓ ReAct loop (90 iterations) + MoA (4 frontier models in parallel) |
| Coding agent | ✓ Terminal, file, browser + execute_code (Docker / SSH / Modal / Singularity) | Partial — basic shell/git tools | ✓ ReAct + file + terminal + browser + execute_code (6 backends) |
| Memory & learning | ✓ Persistent memory + auto-skills + Honcho cross-session model | Partial — in-session memory only | ✓ MEMORY.md + SQLite FTS5 sessions + Honcho + auto learning reflection |
| Always-on presence | ✓ 7 platforms: Telegram, Discord, Slack, WhatsApp, Signal, Email, CLI | ✓ 24+ channels: WhatsApp, Telegram, Slack, Discord, Matrix, IRC… | ✓ 17 gateways: Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, DingTalk, Email, SMS, HA, Webhook, API, Feishu, WeCom |
| Sub-agents | ✓ Subagent delegation + parallel batch workers | ✗ Not supported | ✓ Up to 3 parallel sub-agents, depth limited to 2 levels |
| Smart home | ✗ Not supported | ✗ Not supported | ✓ Home Assistant — states, call services, trigger automations, history |
| MCP support | ✓ Full MCP client (mcp_tool.py, ~1050 lines) | ✗ Not supported | ✓ Built-in MCP client — JSON-RPC 2.0, stdio + HTTP + SSE transports |
| Install method | curl | bash (Python + uv managed) | npm install (Node.js runtime required) | ✓ npm · pip · cargo · Docker — pick yours |
| Runtime footprint | Python runtime · uv · ~80–150 MB RAM | Node.js runtime · ~80–200 MB RAM | ✓ Single Rust binary · no Python or Node runtime deps |
| Cold startup | ~1–3 s (Python + uv) | > 500 ms on 0.8 GHz edge hardware | ✓ Single Rust binary with no Python or Node runtime dependencies for the agent itself |
| Security | ✓ 5 sandboxing backends (Docker, SSH, Modal, Singularity, local) | Runtime patches | ✓ 7 compiled-in layers (type-level path jail + SSRF + cmd scan + sandbox + more) |
| LLM providers | 11 cloud providers | Via OpenAI-compatible APIs | ✓ 15 built-in: Copilot, OpenAI, Anthropic, Gemini, Vertex AI, Bedrock, xAI, DeepSeek, Mistral, Groq, HuggingFace, Z.AI, OpenRouter, Ollama, LM Studio |
EdgeCrab is open source, Apache 2.0. Your SuperAgent runs on macOS, Linux, Windows, and edge hardware. Use npm, pip, cargo, Docker, or native release binaries today; use Homebrew once the external tap has been synced.
npm install -g edgecrab-cli