# OpenCrabs: A Single-Binary Terminal Agent That Keeps Everything Local

> OpenCrabs is a Rust-based AI agent that runs as a single binary, offering TUI, CLI, and daemon modes with local storage and zero telemetry. It targets developers who want autonomy without a server, but its claims of self-improvement need scrutiny.

**adolfousier/opencrabs** — The all-in-one AI agent living in your terminal. Build landing, mobile apps, backends, manages files, deep research, schedule tasks and events. Self-improving, self-healing, fully autonomous. TUI, CLI and Daemon. Connect to your favorite channels.

- Repository: https://github.com/adolfousier/opencrabs
- Website: https://opencrabs.com
- Stars: 1,003 · Forks: 104
- Language: Rust
- License: MIT
- Published: 2026-08-26 · Updated: 2026-08-26 · Language: en
- Canonical page: https://hysenlabs.com/projects/adolfousier-opencrabs

## What OpenCrabs Solves and Who It Is For

The README's comparison table is the core of its argument. It contrasts OpenCrabs with Node.js frameworks on binary size, runtime, attack surface, API key security, data residency, supply chain, memory safety, concurrency, native TTS/STT, and telemetry. For each point, OpenCrabs claims superiority: zero network listeners, keys cleared from RAM via zeroize, SQLite storage in ~/.opencrabs/, and compile-time memory safety from Rust. The table is a marketing document, not a benchmark, but it does reflect real architectural choices. The 'zero telemetry' claim is absolute: no analytics, no opt-in flag, no telemetry code to disable. That is a concrete design decision, not a vague promise. However, the table does not mention performance, reliability, or the quality of the agent's outputs, which are more relevant to daily use than the binary size. The README also lists what stays local: chat sessions, tool executions, memory embeddings, voice transcription in local STT mode, and brain files. What goes out is limited to LLM API calls, optional web searches, GitHub CLI usage, browser automation via CDP, and HTTP tools defined in tools.toml. This clarity is useful for privacy-conscious users, but it also means that any tool that requires network access, like web search or browser automation, is an explicit opt-in per use.

## How OpenCrabs Works: Architecture and Data Flow

The repository includes an architecture document at src/docs/reference/ARCHITECTURE_2026_04_14.md, which we do not have access to, but the README gives enough hints about the data flow. OpenCrabs runs as a single binary with three modes: TUI, CLI, and daemon. It connects to various channels, meaning you can interact with it through a terminal UI, command line, or as a background daemon that integrates with messaging platforms. The core is a 'brain' defined by multiple markdown files: SOUL.md for personality, AGENTS.md for workspace rules, TOOLS.md for tool usage, MEMORY.md for long-term memory, and others like BOOT.md for startup config. These brain files act as configuration and context for the agent, shaping its behavior. The agent uses a local SQLite database for chat sessions and messages, and local vector embeddings for memory search. It calls LLM providers directly over HTTPS, with no intermediate server. The 'self-improving' and 'self-healing' claims likely refer to the agent's ability to modify its own brain files or tools based on feedback, but the README does not explain the mechanism. The presence of a BRAIN_CONSTITUTION.md suggests a set of rules that govern self-modification, which is a novel approach to control. The 'Dynamic Workflows' guide mentions orchestrating agents with scripts, including fan-out, pipelines, structured outputs, and checkpointing, which implies a workflow engine for multi-step tasks. This is a concrete feature that goes beyond simple chat.

## Getting OpenCrabs Running: Commands and Configuration

The README directs users to a getting started guide at src/docs/start/GETTING_STARTED.md and an onboarding wizard at src/docs/start/ONBOARDING.md. Since we do not have those files, the exact installation command is not available from the material. However, the README implies that installation is a matter of downloading a single binary, given the emphasis on 'single binary' and 'zero dependencies.' The onboarding wizard likely guides users through setting up API keys and creating brain files. The configuration is file-based, with templates for SOUL.md, AGENTS.md, TOOLS.md, MEMORY.md, and others. These templates are in the repository, so a user can copy them to ~/.opencrabs/ and edit them. The TOOLS.md template likely defines which tools are available, and the README mentions tools.toml for defining HTTP tools. For example, you can add a custom HTTP tool by editing tools.toml, and the agent will be able to make requests to that endpoint when you explicitly allow it. The 'browser' feature is optional and auto-detects Chromium-based browsers via CDP, not Firefox. To enable it, you would need to build with that feature flag, but the README does not give the exact cargo command. The daemon mode allows the agent to run in the background, likely for scheduled tasks via cron templates. The cron jobs guide is referenced, so scheduling is a documented feature. Without the getting started file, we cannot provide exact commands, but the pattern is clear: download the binary, run the onboarding wizard, and edit markdown files to shape the agent.

## Limitations and Failure Modes

OpenCrabs has several limitations that are evident from the README. First, the 'self-improving' and 'self-healing' claims are vague and not backed by detailed documentation in the provided material. Self-modification of brain files could lead to unpredictable behavior if the agent changes its own constraints. The BRAIN_CONSTITUTION.md is meant to prevent this, but the README does not explain how it is enforced. Second, browser automation only works with Chromium-based browsers via CDP, not Firefox. If your workflow depends on Firefox, OpenCrabs is not suitable. Third, the project is in a nightly release as of August 2026, with version v0.3.83, which suggests rapid development but also potential instability. The README does not mention any stability guarantees or production readiness. Fourth, the zero telemetry stance means no crash reports, so if the agent fails, you have no way to send diagnostics to the developers, which could slow down bug fixes. Fifth, the agent relies on external LLM providers, so if you are offline, the agent cannot function unless you use local models, which are not mentioned. The README mentions local STT with whisper.cpp, but not local LLM inference. So the 'fully autonomous' claim is limited by network access to APIs. Finally, the README's comparison table may overstate the security benefits; while Rust prevents memory errors, it does not prevent logical errors or prompt injection attacks, which are a real risk with any LLM agent.

## Comparing OpenCrabs to Node.js Agent Frameworks

The primary alternative is Open Claw, the project that inspired OpenCrabs, which runs on Node.js. The difference is architectural: OpenCrabs compiles to a single native binary with no runtime dependencies, while Open Claw requires Node.js and an npm install, resulting in a node_modules directory that can exceed 1 GB. This affects deployment, startup time, and supply chain risk. OpenCrabs also claims zero network listeners, meaning it does not expose any ports, whereas Node.js frameworks often include a server component for webhooks or APIs. For a developer who wants to run an agent on a laptop or a minimal VPS, the single binary is a clear advantage. However, the Node.js ecosystem offers a richer set of libraries and integrations, and Open Claw may have a larger community and more documentation. The trade-off is between a lean, local-first tool and a heavier but potentially more feature-complete framework. The README does not mention any performance benchmarks, so we cannot say which is faster for actual tasks. The choice depends on whether you prioritize resource footprint and privacy over ecosystem maturity. OpenCrabs is a Rust bet that pays off in binary size and memory safety, but it is a younger project with fewer contributors.

## Maintenance, Upgrade Cost, and License

The project is under the MIT license, which is permissive and allows commercial use, modification, and distribution with attribution. That is a low-license-friction choice for internal tools. The maintenance cost is not documented in the README, but the release cadence is high: v0.3.82 and v0.3.83 were released within three days, and there is a nightly pre-release. This suggests active development, but also that the project may change rapidly, which could break configurations or brain files. Upgrading likely involves replacing the binary and possibly migrating the SQLite database, but the README does not mention any migration process. The documentation includes a 'Dynamic Workflows Guide' and 'Plan JSON Specification', which are advanced features that may evolve. Users should expect to track release notes for breaking changes. The zero telemetry stance means no remote update checks, so you must manually check for new versions. The dependency on external LLM providers means that changes in their APIs can affect OpenCrabs, and the project must adapt. The cost of maintenance is therefore not zero: you need to monitor releases and test updates, especially given the nightly builds. The MIT license also means you can fork and maintain your own version if needed, which is a safety net.

## Conclusion

Adopt OpenCrabs if you want a local-first, single-binary AI agent that avoids Node.js dependencies and server infrastructure, and if you value zero telemetry and data residency. Avoid it if you need mature ecosystem support, extensive documentation, or if you rely on Firefox for browser automation. Before adopting, verify that the nightly release is stable enough for your workflow, check the exact feature flags for voice and browser support, and confirm that the 'self-improving' and 'self-healing' claims match your expectations by reading the Brain Constitution and BOOT.md templates. Also, review the MIT license to ensure compliance with your distribution needs.

## FAQ

### Is OpenCrabs the same project as OpenClaw?

No. OpenCrabs is a Rust project by Adolfo Usier that describes itself as inspired by Open Claw, and its own comparison table sets it against Node.js agent frameworks with Open Claw named as the example. It ships from its own repository as a single Rust binary under its own release tags.

### How large is the OpenCrabs binary?

The project quotes two figures for the same artifact. The comparison table gives 34 to 36 MB for a single binary with zero dependencies, while the package description in `Cargo.toml` recommends the 40MB prebuilt binary for macOS, Linux and Windows. Neither number is tied to a build configuration or platform.

### Does OpenCrabs need a server or a gateway?

No. It runs as a single binary on your terminal with no server, no gateway and no infrastructure, and it makes direct HTTPS calls to LLM providers from your own machine. It ships in three shapes, as a TUI, a CLI and a daemon.

### Which configuration files does OpenCrabs read?

Six example files sit at the repository root: `config.toml.example`, `keys.toml.example`, `commands.toml.example`, `tools.toml.example`, `usage_pricing.toml.example` and `rtk_filters.toml.example`. Named sections include `[decisions]` for the decision cache and `[features]` for audit recording, and safety gates live under `~/.opencrabs/safety/`.

### What are the brain file templates in OpenCrabs?

Nine are documented: SOUL.md, AGENTS.md, TOOLS.md, MEMORY.md, CODE.md, SECURITY.md, BOOT.md, USER.md and HEARTBEAT.md. The SECURITY.md template holds the policies the agent follows and is not the repository's vulnerability disclosure policy, which is a separate file at the root under the same name.

## Sources

- [Official documentation](https://opencrabs.com)
- [Official README](https://github.com/adolfousier/opencrabs#readme)
- [Project repository](https://github.com/adolfousier/opencrabs)
- [Release notes](https://github.com/adolfousier/opencrabs/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/adolfousier-opencrabs