Claurst Review 2026: Rust Terminal Agent, Pricing, GitHub, and Alternatives

Claurst is an open-source terminal coding agent built in Rust. That alone does not make it special; the coding-agent space is already crowded with CLIs, VS Code extensions, hosted builders, and wrappers around larger agent products. The reason Claurst deserves a closer look is narrower: it combines a native terminal workflow, multi-provider routing, headless execution, plugins, memory features, and a public clean-room implementation story in one fast-moving project.

That is also why the evaluation needs discipline. Claurst has strong public curiosity, but it is still young. The official README now marks it as Beta v0.1.7, and several newer features are explicitly described as experimental. Treat it as a serious project to evaluate, not as a proven drop-in replacement for every mature coding-agent workflow.

Short answer: Claurst is worth testing if you want an inspectable, Rust-based, multi-provider terminal agent and you are comfortable with early open-source tooling. It is less compelling if you need a polished managed team product, stable admin controls, or a low-friction editor assistant for non-terminal users.

Quick Verdict

Question	Claurst answer
Best for	Terminal-first developers comparing open-source coding-agent CLIs
Not ideal for	Teams that need a mature managed product with admin, billing, and support controls
Official site	claurst.kuber.studio
GitHub	Kuberwastaken/claurst
Pricing	Free GPL-3.0 open-source project; model/provider usage is separate
Current status checked	Beta v0.1.7, latest release published July 6, 2026
Public signal checked	About 10k GitHub stars, 7.8k forks, and fresh July 2026 repository activity
Main caveat	Experimental features and provider differences need hands-on testing
Closest alternatives	Claude Code, OpenAI Codex, Gemini CLI, Aider, OpenCode

What Is Claurst?

Claurst is a terminal coding agent for working on repositories from the command line. The official README describes it as a multi-provider agent built from the ground up in Rust. It started as a clean-room reimplementation of Claude Code behavior from a specification, then evolved into a broader TUI pair programmer with provider routing, plugins, chat forking, memory consolidation, and other workflow features.

The important distinction is that Claurst is not a model and not a hosted IDE. It is the agent layer that connects your local repository, terminal commands, and model provider into an interactive coding loop.

That puts Claurst in the same evaluation set as Claude Code, OpenAI Codex, Gemini CLI, Aider, and OpenCode. The decision is not simply "which model is smartest?" It is "which agent workflow gives me the right mix of control, speed, provider choice, install friction, and review discipline?"

Current Status and Public Signal

As of July 10, 2026, the Claurst GitHub repository showed roughly 10k stars, 7.8k forks, GPL-3.0 licensing, an active non-archived repo, and recent code activity. The latest GitHub release was v0.1.7, published on July 6, 2026, with release archives for macOS, Linux, and Windows.

The README matters more than the headline numbers. It states that Claurst is officially in Beta at v0.1.7, with the core agent, multi-provider routing, and TUI stable enough for daily driving while experimental features may still have rough edges. That is the right way to read the project: promising enough to evaluate seriously, but not something to adopt blindly because the star count looks high.

The fork-to-star ratio is also worth noticing. A large fork count can mean strong developer interest, but it can also reflect launch dynamics, experimentation, or people saving a fast-moving project. Use it as a signal to investigate, not as proof of maturity.

Install and Setup

The official site presents Claurst as a download-first terminal tool with macOS, Linux, Windows, npm, and Bun paths. The README gives the simplest installer for Linux and macOS:

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

Windows users get a PowerShell installer, while Node.js or Bun users can install the claurst package globally or run it through npx/bunx. The releases page also publishes standalone archives for common desktop platforms.

After installation, the default path is simple:

claurst

For one-shot or automation-style usage, the README documents headless prompting:

claurst -p "explain this codebase"

That headless path is strategically important. A terminal agent that only works as an interactive chat is useful, but harder to reuse in scripts, audits, release-note generation, and background checks. Claurst's -p mode makes it relevant for developers who want both interactive sessions and repeatable command-line workflows.

Provider Support and Pricing Reality

Claurst itself is free open-source software under GPL-3.0. That does not mean your actual usage is free.

The practical cost depends on the provider you connect. Claurst's README describes provider configuration through environment variables or the in-app /connect flow, and the existing tool metadata tracks support for providers such as Anthropic, OpenAI, Google, GitHub Copilot, Ollama, DeepSeek, Groq, Mistral, and other backends. If you use a hosted model, you still pay that provider's bill. If you use a local backend such as Ollama, your cost shifts toward local hardware and maintenance.

This is the same pricing trap that appears across many open-source coding agents. The agent may be free; inference, subscriptions, API keys, and local compute are separate. For individual developers, that flexibility can be a strength. For teams, it means procurement, security review, and spend monitoring are not magically solved by the CLI.

Workflow: TUI, Headless Mode, Plugins, and Memory

Claurst's core appeal is the terminal loop. You run the agent inside a repository, connect a model provider, ask it to inspect or change code, and keep the workflow close to your normal shell environment.

The README highlights several features that make Claurst broader than a minimal prompt wrapper:

• a rich terminal UI;
• multi-provider routing;
• chat forking;
• memory consolidation;
• plugin support;
• /share for sharing sessions through unlisted GitHub Gists;
• /goal for multi-turn objective work;
• an ultracode mode that routes a higher-effort workflow through planning, delegation, integration, and verification.

The last group should be treated carefully because the project itself labels several of these as experimental. They are interesting because they show where Claurst wants to go: longer-running, more structured agent sessions instead of one prompt at a time. They are also where teams should expect the most uneven behavior.

If your workflow is "open one repo, ask a few questions, make a small patch," Claurst's stable core is the part to test first. If your workflow depends on /goal, subagents, swarms, or shared sessions, budget extra time for edge cases.

Editor Integration Through ACP

Claurst is terminal-first, but it is not terminal-only. The README says Claurst speaks the Agent Client Protocol, which lets ACP-compatible editors run it as a subprocess and show it through the editor's native agent UI.

That matters because it gives Claurst a possible bridge into tools like Zed, Neovim, JetBrains plugins, and other ACP-aware environments without turning Claurst into a VS Code-only product. The documented command shape is:

command: claurst
args:    ["acp"]

This is promising, but it should not be confused with a mature first-party IDE extension ecosystem. If editor integration is the main reason you are evaluating Claurst, test your exact editor path before committing. ACP compatibility is a useful architecture signal; the day-to-day experience depends on the client.

Security and Trust Boundaries

Any coding agent that can read files, edit code, and run terminal commands deserves a security review. Claurst is no exception.

Open-source code helps because you can inspect the implementation, license, release assets, and issue history. It does not remove the need for controls. Before using Claurst on sensitive repositories, check how provider credentials are stored, which tools can execute commands, how MCP or plugin paths are configured, and how your model provider handles code context.

The clean-room implementation story is also worth reading directly from the repository. The README says the project does not contain proprietary Claude Code TypeScript source and describes a specification-to-implementation process. That is a project claim, not a substitute for your own legal or security review. For most individual developers, the more immediate question is practical: do you trust this agent with the repository and credentials in front of it?

Claurst vs Alternatives

Claurst vs Claude Code: Claude Code is the more established product path if you want Anthropic's own coding agent workflow. Claurst is more interesting if you want an open-source Rust implementation, provider flexibility, and a project you can inspect and modify.

Claurst vs OpenAI Codex: Codex is a strong option if you already live in OpenAI's tooling and want first-party Codex CLI behavior. Claurst is more experimental and more provider-flexible, but does not give you the same vendor-backed product surface.

Claurst vs Gemini CLI: Gemini CLI has a clearer Google model path and a large ecosystem around Gemini. Claurst is a better fit if you want to compare providers behind one terminal agent instead of adopting one vendor's default route.

Claurst vs Aider: Aider remains the pragmatic choice for developers who want a proven git-native terminal agent with a long public track record. Claurst is more of an exploratory pick for people interested in Rust, TUI ergonomics, ACP, and newer structured-agent features.

Claurst vs OpenCode: OpenCode is another open-source terminal coding agent to compare closely. Claurst's differentiators are its Rust implementation, explicit clean-room story, and current Beta roadmap. OpenCode may be preferable if its provider model, community, or interface better matches your workflow.

Who Should Try Claurst?

Claurst is a good candidate if:

• you prefer terminal-native tools over browser-first app builders;
• you want a coding agent with multiple provider paths;
• you care about open-source inspectability;
• you are comfortable debugging early software;
• you want to experiment with headless prompts, plugins, memory, or ACP integration.

It is probably the wrong first choice if:

• your team needs formal support, admin controls, and predictable rollout policies;
• your developers avoid terminal workflows;
• your security process cannot tolerate fast-moving experimental agent features;
• you want one bundled subscription that hides all model-provider setup.

Final Verdict

Claurst is one of the more interesting open-source terminal agents to watch in 2026 because it is not just a thin model wrapper. The Rust implementation, multi-provider routing, headless mode, plugin surface, memory features, ACP path, and active release cadence give it enough substance for serious evaluation.

The caveat is maturity. Beta status, experimental features, and provider variance matter more than the GitHub star count. If you are an individual developer or small technical team comfortable with terminal-first tools, Claurst is worth a controlled trial on a non-critical repository. If you need a stable managed product, start with more mature alternatives and keep Claurst on the watchlist.

For the directory summary, open the Claurst profile. For current source details, use the official site, GitHub repository, and latest releases.