Is Crush worth it for a solo developer who lives in the terminal?

Yes. Crush is free and open-source, so the only cost is API usage from providers. For a solo developer who already uses the terminal, it offers multi-model flexibility, LSP integration, and MCP extensibility with no subscription fees. It's a cost-effective alternative to GitHub Copilot if you prefer CLI workflow.

Does Crush integrate with OpenAI and Anthropic?

Yes, Crush supports OpenAI, Anthropic, Groq, OpenRouter, Vercel AI Gateway, Google Gemini, and many more via OpenAI- or Anthropic-compatible APIs. You can also use local models via an API-compatible server.

How does Crush compare to Aider?

Both are terminal-based AI coding assistants. Crush offers LSP integration for code context, MCP extensibility, and supports more providers. Aider is more mature with better Git integration. Crush is younger and may have rougher edges, but it's free and open-source like Aider.

What's the cheapest Crush tier?

Crush has no paid tiers — it is completely free and open-source. You only pay for API usage with your chosen LLM providers. There is no subscription, so your costs are whatever you spend on API credits.

What are Crush's biggest limitations?

The TUI is not ideal for reviewing large diffs or visual designs. The project is younger than Aider or Claude Code, so you may encounter bugs. Shell execution requires setting up approval gates. No team management or admin dashboard exists.

Can Crush replace GitHub Copilot?

For terminal-first developers, Crush can replace Copilot's CLI component. It offers multi-model support and extensibility that Copilot lacks. However, it does not provide IDE inline completions or Copilot's cloud-managed billing, so it's not a like-for-like replacement for Copilot in an IDE context.

How long does Crush take to set up?

Installation via Homebrew takes seconds. Configuring API keys via environment variables takes a few minutes. First useful interaction typically within 10 minutes. NixOS setup via NUR takes about 20 minutes for those familiar with flakes.

How do I migrate from GitHub Copilot CLI to Crush?

Install Crush, set up your API keys in environment variables, and start using it. You may need to adjust to Crush's command set and session-based workflow. Export your Copilot usage patterns via terminal logs and adapt them manually.

Is Crush still active in 2026?

Crush is active in 2026 but worth monitoring — liveness 69/100. Its weakest signal is its revenue model.

Code & Development

Crush

Free, open-source terminal-native AI coding assistant with multi-model support.

69/100MonitorFreeFree

Crush is a capable, free, open-source terminal AI assistant for developers who want multi-model flexibility and deep CLI integration. It requires manual setup and API keys, but offers unmatched extensibility via MCPs and LSPs. Best for power users who prefer terminal workflows over IDEs.

Verified 17d ago · liveness 69/100 · cite: rightaichoice.com/tools/crush

Best for

Terminal-loving developers who want an AI assistant integrated into their CLI workflow
Users who need multi-model flexibility to compare or switch LLMs per task
Developers working on headless servers or via SSH who need AI assistance in the terminal
Power users who want extensibility via MCPs and custom LSP integrations

Not ideal for

Users seeking a graphical, IDE-like AI coding assistant with no terminal use
Non-developers or beginners who want a zero-config, cloud-hosted AI coding tool
Teams requiring centralized billing, usage controls, or admin dashboards

Visit Website

IntermediateInstallation via Homebrew takes under 2 minutes, plus 5 minutes to configure API keys via environment variables. First useful interaction achievable within 10 minutes. NixOS setup via NUR takes longer (flake import), about 20 minutes if familiar with Nix.Desktop · CLINo public API3.2k viewsVerified 17d ago

Pricing

Free

FreeFree tier2 hidden costs

Learning curve

Intermediate

Installation via Homebrew takes under 2 minutes, plus 5 minutes to configure API keys via environment variables. First useful interaction achievable within 10 minutes. NixOS setup via NUR takes longer (flake import), about 20 minutes if familiar with Nix.

Runs on

DesktopCLI

No public API · 14 integrations

Who it's for

Backend developer working on an SSH serverMulti-model power user comparing LLMsNixOS user wanting declarative AI assistant setup

Live sentiment

Is Crush actually worth it?

We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.

Honest verdict, not marketing
Real pros & cons from real users
Attributed quotes with receipts

Run a free scan

3 free scans · no card needed

Skip it if

Skip Crush if you need a graphical AI coding assistant with a GUI, zero setup, or team management features.

The 30-second take

Biggest gripe

No hidden costs from Crush itself, but you must pay API providers directly — usage costs can add up if you use expensive models like GPT-4o.

Price reality

Crush is completely free and open-source with no subscription tiers. You only pay for API usage with your chosen LLM providers. This makes it ideal for budget-conscious individual developers, but teams may need to manage billing through their provider accounts.

In short

Crush — Free, open-source terminal-native AI coding assistant with multi-model support. Best for Terminal-loving developers who want an AI assistant integrated into their CLI workflow, Users who need multi-model flexibility to compare or switch LLMs per task, Developers working on headless servers or via SSH who need AI assistance in the terminal. Free to use.

Viability Score

69/100

Monitor

How likely is Crush to still be operational in 12 months? Based on 4 signals — momentum (how recently it shipped), wrapper dependency, revenue model, and web presence.

momentum

funding runway

website health

wrapper dependency

100

Last calculated: July 2026

How we score →

Key Features

Multi-model support: OpenAI, Anthropic, Groq, OpenRouter, Vercel AI Gateway
Mid-session LLM switching with preserved context
Session-based workflows for multiple contexts per project
LSP-enhanced code understanding using language servers
Extensible via MCPs: HTTP, stdio, SSE
Cross-platform: macOS, Linux, Windows, Android, FreeBSD, OpenBSD, NetBSD
Built on Charm ecosystem (25k+ applications)
Install via Homebrew, npm, Arch Linux, Nix, Winget, Scoop, Debian, Fedora, Go
Open-source (MIT license) on GitHub
Environment variable configuration for API keys
NixOS and Home Manager module support via NUR
Compact TUI mode and debug options
Supports Anthropic and OpenAI compatible APIs
Experimental: .agents folder for defining custom agents
Command approval gates for shell execution safety

About Crush

FreeIntermediateNo APIDesktop · CLI

Crush is a free, open-source terminal-based AI coding assistant built by Charmbracelet that brings agentic coding capabilities directly into your terminal. It supports multiple LLMs including OpenAI, Anthropic, Groq, OpenRouter, and Vercel AI Gateway, with the ability to add providers via OpenAI- or Anthropic-compatible APIs. Key features include multi-model support with mid-session model switching while preserving context, session-based workflows for multiple contexts per project, LSP-enhanced code understanding using language servers, and extensibility via MCPs (HTTP, stdio, SSE). Crush runs on macOS, Linux, Windows (PowerShell and WSL), Android, FreeBSD, OpenBSD, and NetBSD, and can be installed via Homebrew, npm, Arch Linux, Nix, Winget, Scoop, Debian, Fedora, and Go. It is free and open-source under the MIT license—you only pay for API usage with providers. It offers a compact TUI mode, environment variable configuration for API keys, and NixOS/Home Manager module support via NUR. Developers who want a flexible, terminal-native AI assistant with multi-model flexibility and deep integration into existing tools will find Crush a powerful alternative to cloud-based coding assistants like GitHub Copilot or Aider.

Behind the Verdict

If you live in the terminal, Crush is one of the most flexible AI coding assistants you can run. Multi-model switching mid-session is a standout—you can start with a cheap model for quick edits and swap to a smarter one for debugging, all without losing context. The LSP integration means it understands your codebase similarly to an IDE, and the MCP support lets you plug in custom tools. However, there's a setup cost: you need API keys, and configuration can get complex, especially for NixOS modules or custom providers. Crush isn't for teams needing centralized billing or non-developers who want a GUI. Compared to Aider, Crush is more terminal-native and supports more providers out of the box (including OpenRouter and Vercel AI Gateway). GitHub Copilot offers a richer IDE experience but locks you into OpenAI models. The experimental .agents folder is a promising step toward customizable agentic workflows. In practice, Crush excels for developers working on headless servers, via SSH, or who want to avoid vendor lock-in. The main caveat: the command approval gates are good for safety but can slow down autonomous workflows.

Researching Crush? Get your full AI stack in 60 seconds.

Free, no signup — tell us your goal and get tools matched to your budget & existing stack.

Real-world workflow fit

Concrete scenarios for the personas Crush actually fits — and what changes day-one when you adopt it.

Backend developer working on an SSH server

You SSH into a headless Linux server and need AI assistance without an IDE. You install Crush via Homebrew, configure your API keys via environment variables, and start a session. You ask Crush to review a Go function; it uses the Go LSP to provide contextual suggestions.

Outcome: You get AI-powered code analysis and fixes directly in your terminal, with no need for a graphical environment.

Multi-model power user comparing LLMs

You have a code generation task and want to compare responses from GPT-4o, Claude Sonnet, and a local Llama model. With Crush, you start a session, generate code with one model, then switch to another mid-session without losing conversation history.

Outcome: You select the best output by comparing multiple LLMs in a single terminal session, improving code quality.

NixOS user wanting declarative AI assistant setup

You use NixOS and want to integrate Crush into your flake-based configuration. You import the NUR module and enable Crush with your API keys defined in your Nix config. Crush is available system-wide.

Outcome: Your AI assistant is declared as part of your NixOS configuration, ensuring reproducibility and easy setup on new machines.

Use Cases

Run an AI coding assistant over SSH on a remote dev server without an IDE.
Work inside tmux panes alongside your editor and shell, all in the terminal.
Swap between GPT-4o, Claude Sonnet, and a local Llama model in the same session.
Use LSP integration to get code diagnostics and inline completions in the terminal.
Execute shell commands via the assistant with approval gates for safety.
Define custom agents for specialized tasks using .agents folder.

Models Under the Hood

GPT-4oGPT-4Claude Sonnet 4.7Claude Opus 4.7Gemini 2.5 ProLlama 3.3 70BMixtral 8x22BGroq-provided modelsOpenRouter-provided modelsproprietary via API

as of 2026-07-14

Limitations

TUI has inherent UI limits — reviewing a 500-line diff or a visual design spec is awkward compared to an IDE.
Younger project than Aider or Claude Code — expect rough edges on the long tail of commands.
Shell execution requires careful approval-gate setup for safety.
No centralized team management or usage dashboards.

as of 2026-07-02

Hidden costs & gotchas

What the public pricing page doesn't put in bold. Captured from pricing-page footnotes, contract terms, and recurring complaints.

No hidden costs from Crush itself, but you must pay API providers directly — usage costs can add up if you use expensive models like GPT-4o.
Some providers may charge overage fees for high-volume usage beyond included credits.

Where the pricing makes sense

The company stage and team size where Crush's pricing actually pencils out — and where peers do it cheaper.

Setup time & first value

How long it actually takes to get something useful out of Crush — broken out by persona, not the marketing-page minute.

Switching to or from Crush

How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.

Migrating in

→From GitHub Copilot CLI: Install Crush, configure the same API keys you already use for other tools, and you'll get multi-model flexibility that Copilot CLI does not offer.
→From Aider: Crush offers a similar terminal experience but adds LSP integration and MCP extensibility; you can export Aider sessions by replaying commands manually.

Migrating out

↗To Aider: Export your Crush session history (logged in terminal), then adapt your workflows to Aider's command set.
↗To Claude Code: Copy your project context and API usage patterns; Claude Code provides a similar terminal-based assistant with Anthropic focus.

Integrations

OpenAIAnthropicGroqOpenRouterVercel AI GatewayGoogle GeminiHyper (Charm)SyntheticZ.ai MiniMaxHugging Face InferenceCerebrasLSP (Language Server Protocol) for Go, Nix, and any LSP serverMCP (Model Context Protocol) over HTTP, stdio, SSE