Claurst: A Rust Terminal Agent That Speaks ACP and Routes Around Your Providers

What Claurst Solves and Who It Targets

Claurst targets developers who want a terminal-based coding agent without being locked to a single vendor. The README describes it as an open-source, multi-provider terminal coding agent built in Rust, starting as a clean-room reimplementation of Claude Code's behavior. It solves the problem of provider lock-in by letting you configure your own API keys and choose among multiple providers. The intended audience is builders who ship, meaning developers who want a fast, memory-efficient tool that runs locally without tracking or telemetry. The project is explicitly in beta as of v0.1.7, so it is not positioned as a polished enterprise product. It is for people who accept rough edges in exchange for control and flexibility.

Architecture and Core Mechanism

The core is a Rust binary that runs either as an interactive TUI or as a headless one-shot query with the -p flag. The TUI is the primary interface, featuring a pair-programming chat with multi-provider routing, a plugin system, a companion called Rustle, chat forking, and memory consolidation. The key architectural point is that the same credentials and providers are shared between the interactive TUI and the ACP agent. Configuration lives in ~/.claurst/settings.json, and the auth flow is handled through claurst auth login or the /connect command inside the TUI. The ACP mode runs in JSON-RPC 2.0 over stdio, implementing initialize, session/new, session/prompt, and session/cancel, and streaming session/update notifications. Tool permissions are routed through session/request_permission, which lets an editor show native approval dialogs. This design separates the agent core from the interface, so the same engine can serve both a terminal user and an editor integration.

Getting It Running: Install and Configuration

Installation is straightforward. On Linux and macOS, a one-liner curl pipe to bash downloads the latest release. Windows users run a PowerShell script. The binary lands in ~/.local/bin or %LOCALAPPDATA%\Programs\claurst, and PATH is updated automatically. Alternatively, npm and bun users can install the global package claurst, which downloads the right prebuilt binary via a postinstall script. Manual downloads are available for Windows x86_64, Linux x86_64 and aarch64, and macOS Intel and Apple Silicon. To build from source, clone the repo, cd into src-rust, and run cargo build --release --package claurst. For systems without ALSA, such as Debian Trixie or headless servers, you must build with --no-default-features to skip voice support. Before the first run, you set ANTHROPIC_API_KEY as an environment variable or use /connect inside the TUI. The one-shot headless query is claurst -p "explain this codebase". Upgrades use claurst upgrade, and you can pin a version with --version 0.1.0.

Editor Integration via ACP

Claurst implements the Agent Client Protocol, an open protocol pioneered by Zed for editor-to-agent communication. This is a significant differentiator because it means any ACP-compatible editor can drive Claurst as a subprocess. The README gives a concrete Zed example: in ~/.config/zed/settings.json, you add an agent_servers entry with command claurst and args ["acp"]. The agent then runs in JSON-RPC 2.0 over stdio, implementing initialize, session/new, session/prompt, and session/cancel. It streams session/update notifications that include text deltas, agent thinking, tool calls with progress and results. Permission requests are sent via session/request_permission, so the editor can show a native approval dialog instead of a terminal prompt. This is a clean separation: the same binary works as a TUI or as a headless agent, and the editor integration does not require a separate daemon. The trade-off is that you must configure credentials before launching, because the ACP agent uses the same settings as the TUI.

Experimental Features and Their Rough Edges

The README flags several features as experimental, which is a honest warning but also a sign of beta maturity. /share lets you share chat sessions via unlisted GitHub Gists, which raises a privacy consideration: the gist is unlisted, not private, so anyone with the link can see the content. Free Mode in /connect offers a free agentic coding experience, but the README's phrasing "as good as free gets you" suggests limitations. /goal <objective> keeps the agent working on an objective across multiple turns instead of stopping after one turn, which is useful for sustained tasks but likely to consume more tokens and time. The most ambitious feature is ultracode, an effort level that sits past max on the "Smarter" end. It runs the model's top reasoning plus a plan, delegate, integrate, verify workflow that fans out to native subagents (Agent), swarms (TeamCreate), and background tasks (TaskCreate). It composes with /goal. These features are marked experimental, so expect instability. The keyword ultracode lights up with a purple gradient, which is a cosmetic touch that does not change the underlying risk.

Licensing and Maintenance Considerations

Claurst is licensed under GPL-3.0. That is a strong copyleft license, which means if you distribute a modified version, you must make the source available under the same license. For individual developers using it locally, this is rarely a concern. But if you plan to embed Claurst in a proprietary product or build a service around it, the GPL may be a deal-breaker. The README does not mention a commercial license or dual licensing, so assume GPL constraints apply. Maintenance appears active: the last push was 2026-07-06, with releases v0.1.7, v0.1.6, and v0.1.5 coming in quick succession. The project is not archived. The presence of a spec directory and a devcontainer suggests a structured development process. However, the beta status means breaking changes are possible between minor versions. The upgrade command exists, and you can pin versions, which is a practical way to manage risk. The build-from-source path is documented, and the no-default-features flag for headless systems shows attention to deployment environments.

Limitations and When It Is the Wrong Tool

The most obvious limitation is that experimental features are rough. If you rely on /goal or ultracode for daily work, you may hit bugs. The README explicitly says to expect rough edges. Another limitation is the dependency on external providers: you must supply your own API key, and the quality of the agent depends on the model you choose. There is no mention of a built-in local model, so it is not a fully offline tool. The ACP integration is solid but only works with editors that support the protocol; if you use an editor without ACP support, you are stuck with the TUI. The build from source requires ALSA on some systems, and the no-default-features build is the only workaround for headless servers. That means you lose voice features, which may or may not matter. The project is also young, so the plugin system and memory consolidation are not yet proven at scale. If you need a stable, production-grade agent with a long track record, this is not the right tool yet.

Alternatives and How They Differ

The most direct alternative is Claude Code itself, which Claurst reimplements from a spec. Claude Code is a commercial, single-provider tool from Anthropic. It is tightly integrated with Anthropic's models and does not support multiple providers. Claurst's multi-provider routing is a clear difference: you can use OpenAI, Anthropic, or others, depending on what you configure. Another alternative is an ACP-based editor integration like Zed's built-in agent, which uses the same protocol but is tied to Zed's own backend. Claurst gives you a standalone binary that you can point at any provider, and the ACP mode is just one interface. The trade-off is that Claude Code may have more polished tooling and support, while Claurst is open source and provider-agnostic. If you want to avoid vendor lock-in and are willing to manage your own API keys, Claurst offers a path that a single-provider tool cannot.

Editorial conclusion

Adopt Claurst if you want a fast, telemetry-free terminal agent that works across multiple providers and integrates with ACP-capable editors like Zed or Neovim, and you are comfortable with beta-level stability and GPL-3.0. Do not adopt it if you need production-grade reliability or strict permissive licensing, or if you rely on features that are still marked experimental. Before committing, verify that your provider's API key works through the settings.json or auth login flow, test the ACP integration with your editor, and inspect the experimental features like /goal and ultracode to see if their rough edges affect your workflow. Also confirm that the no-default-features build works on your headless system if you lack ALSA.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes