Kuberwastaken/claurst: Open-Source Agentic Coding in Rust

Kuberwastaken/claurst: Open-Source Agentic Coding in Rust

Terminal coding agents have become essential infrastructure for developers who want to stay in flow. The problem: most are proprietary, phone home with telemetry, or lock you into a single provider. Kuberwastaken/claurst offers a different path—a clean-room Rust reimplementation of Claude Code's behavior that puts control back in the terminal where it belongs.

What is Kuberwastaken/claurst?

Kuberwastaken/claurst is an open-source, multi-provider terminal coding agent built from the ground up in Rust. With 10,086 GitHub stars and 7,783 forks as of July 2026, it has gained substantial traction among developers seeking a privacy-respecting alternative to proprietary coding assistants.

The project originated as a clean-room reimplementation of Claude Code's behavior, derived from behavioral specifications rather than source code. This two-phase approach—specification first, then implementation by a separate agent—establishes clear legal separation from any proprietary codebase. The result is idiomatic Rust that reproduces the functionality without reproducing the expression.

Claurst operates as a TUI pair programmer with several distinguishing characteristics: multi-provider LLM support, no tracking or telemetry, a plugin system, chat forking, memory consolidation, and a companion character named Rustle. It is licensed under GNU General Public License v3.0 and actively maintained with its last commit dated July 16, 2026.

The project is currently in Beta at v0.1.7. The core agent, multi-provider routing, and TUI are stable for daily use; experimental features are clearly flagged in documentation.

Key Features

Multi-provider architecture. Claurst does not lock you into a single LLM vendor. The /connect command configures providers, including an experimental "Free Mode" for cost-conscious users.

Terminal-native TUI. Built with Rust's performance characteristics, Claurst prioritizes speed and memory efficiency. The interface supports rich formatting, animated elements (notably the purple gradient for ultracode mode), and intuitive navigation.

Agentic workflow depth. The ultracode effort level represents the highest reasoning tier—beyond max—triggered by typing ultracode in any prompt. This activates a disciplined plan → delegate → integrate → verify workflow that distributes bounded packets across native subagents (Agent), swarms (TeamCreate), and background tasks (TaskCreate).

Sustained objectives. The /goal <objective> command enables multi-turn persistence, allowing Claurst to work toward objectives across multiple conversational turns rather than terminating after a single exchange.

Session sharing. The experimental /share command exports chat sessions as unlisted GitHub Gists for collaboration or documentation.

ACP editor integration. Claurst implements the Agent Client Protocol, enabling native integration with Zed, Neovim, JetBrains plugins, and other ACP-compatible editors. It communicates via JSON-RPC 2.0 over stdio with proper permission routing for tool approvals.

No telemetry. The codebase contains no tracking mechanisms. Your code, prompts, and session data remain local unless explicitly shared.

Use Cases

Daily development with privacy requirements. Teams in regulated industries or with strict IP policies can run Claurst without vendor data processing agreements or network egress concerns. All inference routing happens through your configured providers; no central service intermediates.

Multi-provider redundancy. Developers who maintain API keys across several LLM services can switch providers contextually—using high-reasoning models for architecture decisions and faster models for routine refactors—without changing tools.

Long-running refactoring tasks. The /goal command combined with ultracode suits substantial codebase transformations: migrating patterns across dozens of files, establishing consistent error handling, or modernizing deprecated APIs. The multi-turn persistence prevents context loss that would otherwise require repetitive prompting.

Editor-agnostic pair programming. Through ACP, Claurst embeds in your existing editor's native chat UI. Zed users see it as a configured agent server; Neovim users access it through plugin integrations. This avoids the context-switching cost of a separate terminal window.

Headless CI/automation. The -p flag enables one-shot queries without interactive TUI initialization, suitable for scripted documentation generation, commit message suggestions, or automated code review comments.

Installation & Setup

Claurst offers four installation paths, from one-liner convenience to full source compilation.

Quick install (one-liner)

Linux / macOS:

curl -fsSL https://github.com/kuberwastaken/claurst/releases/latest/download/install.sh | bash

Windows (PowerShell):

irm https://github.com/kuberwastaken/claurst/releases/latest/download/install.ps1 | iex

This installs to ~/.claurst/bin (or %USERPROFILE%\.claurst\bin on Windows) and updates PATH automatically. Open a new terminal and run claurst.

Via npm / bun

# npm
npm install -g claurst

# bun
bun install -g claurst

# or run without installing
npx claurst
bunx claurst

Upgrade later with:

claurst upgrade

Pin versions with --version 0.1.0 on installers or claurst upgrade --version 0.1.0.

Manual download

Extract the single binary and place it on your PATH.

Build from source

git clone https://github.com/kuberwastaken/claurst.git
cd claurst/src-rust
cargo build --release --package claurst

# Binary at target/release/claurst

Headless systems without ALSA (Raspberry Pi, Debian Trixie, servers):

cargo build --release --package claurst --no-default-features

This disables voice/microphone support, removing the libasound2-dev dependency.

First run

# Set API key (or use /connect inside Claurst)
export ANTHROPIC_API_KEY=sk-ant-...

# Start interactive TUI
claurst

# Or run headless one-shot
claurst -p "explain this codebase"

Real Code Examples

Editor integration via Agent Client Protocol

Claurst speaks ACP for editor embedding. Configure Zed in ~/.config/zed/settings.json:

{
  "agent_servers": {
    "claurst": {
      "command": "claurst",
      "args": ["acp"]
    }
  }
}

Claurst runs in JSON-RPC 2.0 mode over stdio. It implements initialize, session/new, session/prompt, and session/cancel, streaming session/update notifications with text deltas, agent thinking, and tool call progress. Tool permissions route through session/request_permission for native editor approval dialogs.

Credentials configured via ~/.claurst/settings.json, claurst auth login, or claurst /connect are shared between TUI and ACP modes. Enable debug logging to stderr with CLAURST_ACP_LOG=debug—never stdout, which would corrupt the protocol.

Devcontainer configuration

The repository includes a complete devcontainer setup for consistent development:

# After cloning, "Reopen in Container" in VS Code
# Prerequisites: Docker↗ Bright Coding Blog installed

Key configuration elements: base image rust:1-bullseye; preinstalled dependencies gnupg2, libasound2-dev, libxdo-dev, pkg-config; vscode user with uid/gid 1000; persistent Cargo caches via named volumes; local .claurst bind-mounted for settings access; GNUPGHOME=/home/vscode/.gnupg; debug/release targets prepended to PATH.

GPG and SSH forwarding are enabled given host configuration. The post-create script initializes .gnupg and fixes Cargo directory ownership.

Registry listing preparation

To add Claurst to the ACP Registry for automatic editor discovery:

# 1. Fork agentclientprotocol/registry
# 2. Create claurst/ folder, copy from:
#    src-rust/crates/acp/registry-template/agent.json
# 3. Update version and release-archive URLs
# 4. Add claurst/icon.svg (16×16, public/ Rustle logo works)
# 5. Open PR—CI validates against agent.schema.json

After merge, ACP-aware editors refresh automatically.

Advanced Usage & Best Practices

Provider strategy. Configure multiple providers in ~/.claurst/settings.json to route different request types optimally. The experimental Free Mode in /connect offers zero-cost entry, though rate limits and capability boundaries apply.

Effort calibration. The /effort selector spans from minimal to max to ultracode. Reserve ultracode for architectural decisions, complex debugging, or cross-file refactoring where the plan-delegate-integrate-verify overhead pays dividends. Routine tasks at ultracode waste latency and tokens.

Goal decomposition. /goal shines with bounded, verifiable objectives. "Refactor error handling to thiserror" succeeds; "improve code quality" lacks termination criteria. Combine with ultracode for sustained multi-turn execution.

Session hygiene. Chat forking preserves exploration branches without polluting your main working context. Fork before speculative paths, merge insights back, and use /share selectively—unlisted Gists remain discoverable with the URL.

ACP debugging. Protocol corruption usually stems from stdout pollution. Verify CLAURST_ACP_LOG=debug writes to stderr exclusively, and check that editor configurations pass ["acp"] args exactly.

Comparison with Alternatives

Claurst's Rust foundation yields smaller binaries and lower memory overhead than TypeScript alternatives, at the cost of a smaller contributor pool for extensions. The ACP protocol offers deeper editor integration than terminal-only agents, though editor plugin ecosystems remain less mature than purpose-built integrations. Claude Code provides the most polished single-provider experience; Claurst trades that polish for flexibility and verifiable privacy.

FAQ

What providers does Claurst support? Multi-provider via /connect, including Anthropic and experimental Free Mode. Specific model availability depends on API key configuration.

Is this a Claude Code fork? No. Clean-room reimplementation from behavioral specifications, with no proprietary source code included.

Can I run this entirely offline? Requires LLM API access for inference. Local model support depends on provider compatibility; check current /connect options.

What's the stability status? Beta v0.1.7. Core agent, routing, and TUI are daily-driver stable. Flagged experimental features may have rough edges.

How do I disable voice features for headless servers? Build with --no-default-features to exclude ALSA dependencies.

Where are settings stored? ~/.claurst/settings.json for configuration, with session history in the same directory.

How do I contribute? Include AGENTS.md rules in PRs. Open issues for bugs or ideas, or submit PRs for fixes, features, or documentation.

Conclusion

Kuberwastaken/claurst fills a specific niche: developers who want agentic coding assistance without surrendering provider choice, privacy, or terminal-centric workflows. Its Rust implementation, multi-provider architecture, and ACP editor integration distinguish it from both proprietary alternatives and browser-heavy tools.

The project suits privacy-conscious individuals, teams with multi-provider API strategies, and developers who prefer their tools composable and inspectable. The experimental features—/goal, ultracode, Free Mode—signal active evolution with community feedback shaping direction.

If you ship code from the terminal and want an agent that stays there with you, start at https://github.com/Kuberwastaken/claurst. The one-liner install takes under a minute; the source is there to read, modify, and extend under GPL-3.0.

For additional context on terminal-based development workflows, see [INTERNAL_LINK: rust-cli-tools].