LaunchedEditorial Listing

Crush

Charm · Crush: Charm's Terminal Coding Agent for Any LLM Provider

Open Crush

Crush is Charm's AI coding agent for the terminal. It reads and edits your code, runs commands, and uses language servers (LSP), MCP servers, and Agent Skills, with the model provider of your choice. It suits developers who live in the terminal, switch between models, or work on less common platforms such as Windows PowerShell, Android, or the BSDs. The tool is free to use and source-available under FSL-1.1-MIT; you pay for model usage, either to your provider or to Charm's optional Hyper service.

PricingFree
Setupmedium
Runs onDesktop · API
APIYes
Open sourceNo
DocsYes
CategoryCoding
Coding AgentAgentic CodingTerminalCLIModel-AgnosticBYOKLocal ModelsMCPAgent SkillsSubagentsSource-AvailableGo

Best for

Terminal-first developers who want one agent across many model providers and local models, with language-server context, MCP, and skills, on macOS, Linux, Windows, Android, or the BSDs

Not ideal for

Developers who want an IDE-native agent with inline suggestions, teams that need hosted cloud agents running in parallel, organizations that require an OSI-approved license, and users who mainly want to code on a Claude Pro/Max subscription

Who it's for

Developers who work in the terminal and want a model-agnostic coding agent with LSP, MCP, and skills support

Capabilities

  • Terminal coding agent that reads and edits files, runs shell commands, searches code and the web, and fetches pages, with per-tool permission prompts by default
  • Pick from Catwalk's provider and model registry or add any OpenAI- or Anthropic-compatible API, and switch models mid-session while keeping context
  • Automatic model discovery for local Ollama, LM Studio, llama.cpp, LiteLLM, and oMLX servers
  • Sign in with a ChatGPT subscription, GitHub Copilot, or xAI Grok OAuth, or use API keys for Anthropic, OpenAI, Gemini, Vertex AI, Bedrock, Azure OpenAI, OpenRouter, Groq, and more
  • Language server (LSP) integration: the agent sees diagnostics, references, and symbols the way your editor does, and can rename symbols or replace whole functions through the language server
  • MCP servers over stdio, HTTP, and SSE, with built-in OAuth, per-server tool allow and deny lists, and toggles in the UI
  • Agent Skills (agentskills.io standard) discovered from Crush, .agents, .claude, and .cursor skill folders, with user-invocable skills in the command palette
  • Background subagents (v0.100.0) that you can check on, send follow-ups to, stop, or move to a different model while they run
  • Plan mode for agreeing on an approach first, a question tool for structured clarifying questions, and Sysadmin mode for unrestricted system commands
  • Configurable safety lists: allow or deny tools, mark commands safe for yolo mode, or block commands such as kubectl or terraform entirely
  • Hooks on tool calls, turns, sessions, and permission events, which can redact tool output or stop a turn
  • crushrc configuration in Bash, run by a built-in interpreter so it behaves the same on Windows, with project and global levels
  • Multiple sessions per project, AGENTS.md project initialization, .crushignore, and Git commit attribution trailers
  • Headless runs with crush run (including --reasoning-effort), and a local client/server mode (Unix socket by default, or HTTP/TCP) where several clients or a host app share one workspace
  • Runs on macOS, Linux, Windows (PowerShell and WSL), Android (Termux), FreeBSD, OpenBSD, and NetBSD

Limitations

  • The tool is free, but model usage is not: you pay your provider, a subscription you sign in with, or Charm's Hyper service unless you run local models
  • Source-available under FSL-1.1-MIT, not an OSI open-source license: you cannot offer it in a competing commercial product or service until a release converts to MIT two years after it ships
  • Terminal-only: no IDE extension, ACP editor mode, desktop app, or hosted cloud agents are documented
  • Pseudonymous usage metrics are collected by default (prompts and responses are not); opt out with CRUSH_DISABLE_METRICS=1 or DO_NOT_TRACK=1
  • crushrc and crush.json are executed as trusted code, so opening Crush in a repository with an unreviewed project config can run commands
  • Sysadmin mode can run any command on your system and yolo mode skips approval prompts; both need care on machines with production access
  • Amazon Bedrock support covers Anthropic models only, with prompt caching disabled
  • No Claude Pro/Max subscription sign-in is documented; Claude models need an Anthropic API key, Bedrock, Vertex AI, or another compatible provider
  • Hooks are described in the README as preliminary support, and the JSON config format is deprecated in favor of crushrc
  • Output quality depends on the model you connect

Use cases

  • Fixing a failing build or test suite from the terminal while the agent reads compiler and language-server diagnostics
  • Comparing models on the same task by switching providers mid-session without losing the conversation
  • Running a coding agent on local models through Ollama, LM Studio, or llama.cpp for code that should not leave the machine
  • Splitting a larger change across background subagents, then checking on or redirecting each one
  • Running scripted agent tasks in CI or shell pipelines with crush run
  • Coding over SSH on a remote server, a BSD machine, or an Android phone in Termux

Our take

Crush is a good pick if you want one terminal agent that is not tied to a model vendor and that understands your project the way your editor does. Language-server context, MCP, Agent Skills, and hooks are all built in, the provider list is long and updates itself through Catwalk, and it runs on more platforms than most rivals, including native Windows, Android, and the BSDs. Charm ships releases about weekly, and v0.100.0 added background subagents and finer command controls. Know three things before adopting it. The license is FSL-1.1-MIT: fine for internal and professional use, but source-available rather than open source until each release turns MIT after two years. The power features need discipline: project config files run as code, and Sysadmin and yolo modes remove guardrails. And it stays in the terminal, with no IDE extension or cloud agents, so teams that want those should look at Claude Code, Codex, or OpenCode's desktop and editor front ends.

Who should use it

Developers who spend their day in a terminal, want to choose or switch between hosted and local models, and value language-server context, MCP, skills, and scriptable configuration; also people coding on Windows without WSL, on Android, or on BSD systems.

Who should skip it

Developers who want IDE-native assistance or inline completions, teams that want managed cloud agents and admin controls, organizations whose policy requires an OSI-approved license, and anyone who wants to run their agent on a Claude Pro/Max subscription.

Strengths

  • Works with a long list of providers, compatible APIs, subscriptions, and auto-discovered local models, with model switching mid-session
  • Native LSP, MCP (stdio, HTTP, SSE with OAuth), Agent Skills, and hooks
  • Background subagents you can monitor, redirect, or move to another model
  • Permission prompts by default, plus allow, deny, safe, and block lists for tools and commands
  • Unusually broad platform support, including native Windows, Android, and BSDs, with many package managers
  • Free to use, with frequent releases

Weaknesses

  • Source-available (FSL-1.1-MIT) rather than OSI open source for the first two years of each release
  • Terminal-only, with no documented IDE extension, desktop app, or cloud agents
  • Model costs are separate, and quality depends on the model you pick
  • Usage metrics are on by default and must be opted out of
  • Project config runs as code, and Sysadmin and yolo modes remove guardrails

Crush pricing

Crush

Free

  • Free to install and use under FSL-1.1-MIT
  • Bring your own API key, sign in with a ChatGPT subscription, GitHub Copilot, or xAI Grok OAuth, or use local models
  • No Charm account needed unless you use Hyper

Charm Hyper (optional)

$20/month or prepaid

  • Charm's own inference service on open-weight models, tuned for Crush
  • $20/month subscription per Charm's August 2026 release notes, plus prepaid options; zero data retention (ZDR) available
  • Described by Charm as GDPR compliant

Note: Crush itself has no price. Model usage is billed by whatever you connect: your provider's API rates, an existing ChatGPT, GitHub Copilot, or xAI subscription, OpenCode Zen or Go, or Charm's Hyper service. Local models have no per-request cost. Charm's release notes of August 26, 2026 describe Hyper as a $20/month subscription; the Hyper web app at hyper.charm.land loads current plans client-side, so check it for today's plans and prepaid credit prices.

Technical specs

Modalities

Text, Code, Images (for models that support image input)

Available models

Anthropic Claude (API key, Amazon Bedrock, or Vertex AI)OpenAI GPT models (API key, Azure OpenAI, ChatGPT subscription sign-in, or GitHub Copilot)Google Gemini (API key or Vertex AI)xAI Grok (API key or OAuth)Charm Hyper open-weight modelsOpenRouter, Vercel AI Gateway, Groq, Cerebras, Moonshot, MiniMax, Z.ai, Hugging Face, io.net, Alibaba, Synthetic, Avian, and OpenCode Zen and GoLocal models via Ollama, LM Studio, llama.cpp, LiteLLM, or oMLXAny OpenAI- or Anthropic-compatible API as a custom provider

Where Crush excels

Model-agnostic daily coding in the terminal

Crush keeps sessions, language-server context, MCP tools, and skills the same while you switch between a frontier API, a subscription sign-in, and a local model, so you can match the model to the task without changing tools.

Parallel investigation with subagents

Since v0.100.0 the main agent can send named subagents off in the background, and you can check on them, send follow-ups, stop them, or move one to a cheaper or stronger model mid-run.

Guarded automation

Allow and deny lists control which tools run without a prompt or at all, safe and block lists decide which shell commands yolo mode treats as dangerous (for example, marking go build safe while blocking kubectl or terraform entirely), and hooks can deny a tool call, redact its output, or stop a turn.

Coding on uncommon platforms

Crush ships binaries and packages for Windows (without WSL), Android via Termux, FreeBSD, OpenBSD, and NetBSD, and its Bash-based crushrc works the same on each.

Crush vs. competitors

Crush vs. OpenCode

OpenCode (Anomaly) is also a model-agnostic terminal coding agent, but it adds a desktop app, a browser UI, and an ACP mode for editors such as Zed, and it is MIT-licensed. Crush is terminal-only and source-available under FSL-1.1-MIT, but it ships language-server integration (which OpenCode V2 lists as not yet supported) and background subagents you can message, stop, or move to another model mid-run. Choose OpenCode for more front ends and a permissive license; choose Crush for LSP context, subagent control, and its platform reach.

Crush vs. Claude Code

Claude Code is Anthropic's coding agent, built around Claude models and usable with a Claude subscription, across the terminal, IDEs, desktop, and web. Crush works with many providers and local models but documents no Claude Pro/Max sign-in, so Claude in Crush needs an API key, Bedrock, or Vertex AI. Choose Claude Code if you are standardizing on Claude; choose Crush for provider choice.

Crush vs. goose

goose is an Apache-2.0 agent under the Linux Foundation's AAIF with a desktop app and a CLI, built for coding and general workflow automation through MCP extensions and recipes. Crush is a coding-focused terminal app with language-server context and coding-specific controls such as Plan mode. Choose goose for a desktop app or non-coding automations; choose Crush for a terminal-native coding workflow.

Crush vs. Qwen Code

Qwen Code is the Qwen team's Apache-2.0 coding agent, with a terminal CLI, desktop app, IDE integrations, and SDKs; its recommended path is Alibaba Cloud's Coding Plan, though it also connects to OpenAI-, Anthropic-, and Gemini-compatible providers. Crush is terminal-only and source-available, but its built-in provider catalog (Catwalk), ChatGPT, GitHub Copilot, and xAI sign-ins, and local model discovery make switching providers easy, and it runs on Android and the BSDs. Choose Qwen Code for Qwen models, IDE plugins, a desktop app, or an open-source license; choose Crush for a provider-neutral terminal agent.

Frequently asked questions

Is Crush open source?

Not in the OSI sense. Crush's source code is public on GitHub, but it is licensed under the Functional Source License (FSL-1.1-MIT), a source-available license. You may use, copy, modify, and redistribute it for any purpose except a Competing Use, which the license defines as offering it in a commercial product or service that substitutes for Crush or another Charm product built on it, or that offers substantially similar functionality. Internal use, non-commercial education and research, and professional services for licensees are explicitly permitted. Each version also becomes available under the MIT license on the second anniversary of its release.

How much does Crush cost?

Crush is free to use. You pay for the models you connect: your provider's API rates, an existing ChatGPT or xAI subscription you sign in with, or Charm's optional Hyper service, which Charm's August 2026 release notes put at $20/month, with prepaid options as well. Local models through Ollama, LM Studio, or llama.cpp have no per-request cost.

Which models and providers does Crush support?

Crush's built-in list comes from Catwalk, Charm's open provider registry, and includes Anthropic, OpenAI, Google Gemini and Vertex AI, Amazon Bedrock (Anthropic models), Azure OpenAI, xAI, OpenRouter, Vercel AI Gateway, Groq, Cerebras, Moonshot, MiniMax, Z.ai, Hugging Face, OpenCode Zen and Go, and Charm Hyper, plus sign-in with GitHub Copilot, a ChatGPT subscription, or xAI. Any OpenAI- or Anthropic-compatible API can be added as a custom provider, and local Ollama, LM Studio, llama.cpp, LiteLLM, and oMLX models are discovered automatically.

How do I install Crush?

Use Homebrew (brew install charmbracelet/tap/crush), npm (npm install -g @charmland/crush), winget or Scoop on Windows, the AUR on Arch, Nix or NUR, FreeBSD pkg, or Charm's apt and yum repositories. Binaries are published for Linux, macOS, Windows, FreeBSD, OpenBSD, and NetBSD, and go install works as well. Then run crush in a project and pick a model with ctrl+l.

Do I need a Charm account to use Crush?

No. You can paste an API key for a supported provider, sign in with a ChatGPT subscription, GitHub Copilot, or xAI OAuth, or point Crush at a local model. A Charm account is only needed for Hyper, Charm's optional model service.

What are Crush's subagents and Sysadmin mode?

Both arrived in v0.100.0 on November 5, 2026. Subagents are named background agents the main agent can dispatch; you can check on them, send follow-ups mid-run, stop them, or move one to a different model. Sysadmin mode lets Crush run any command on your system. It is found in the command palette or the shift+tab mode cycle and should be used with care.

Does Crush collect data?

Crush records pseudonymous usage metrics tied to a device hash, and Charm says prompts and responses are never collected. If you use Hyper, usage metrics may be linked to your Hyper account. You can opt out with CRUSH_DISABLE_METRICS=1 or DO_NOT_TRACK=1. Automatic provider list updates from Catwalk can also be turned off for air-gapped environments.

Crush vs OpenCode: what is the difference?

They are separate products from different companies. Crush is Charm's Go terminal agent, source-available under FSL-1.1-MIT, with LSP integration, Agent Skills, and background subagents. OpenCode is Anomaly's MIT-licensed agent with a terminal UI, desktop app, browser UI, and ACP editor mode. Both let you bring your own model provider.

Integrations & fit

AnthropicOpenAIChatGPTGoogle GeminiGoogle Vertex AIAmazon BedrockAzure OpenAIOpenRouterVercel AI GatewayGroqCerebrasxAIMoonshotMiniMaxZ.aiHugging FaceOpenCode ZenGitHub CopilotCharm HyperOllamaLM Studiollama.cppLiteLLMMCP serversLanguage servers (LSP)Agent SkillsGit
Good fit forSolo / individual, Startup / small team
Pricing modelFree· No cost to start
See pricing on Crush →

Alternatives to consider

About Crush

Crush is a terminal user interface (TUI) built in Go on Charm's own Bubble Tea stack. You start it in a project, pick a model with ctrl+l, and work in sessions: each project can keep several sessions with their own context, and you can switch models mid-session without losing the conversation. Models come from Catwalk, Charm's open, community-maintained provider and model registry, which Crush refreshes automatically (this can be turned off or pointed at a fork for air-gapped setups). Built-in providers include Anthropic, OpenAI, Google Gemini and Vertex AI, Amazon Bedrock (Anthropic models), Azure OpenAI, OpenRouter, Vercel AI Gateway, Groq, Cerebras, xAI, Moonshot, MiniMax, Z.ai, Hugging Face, and OpenCode Zen and Go; any OpenAI- or Anthropic-compatible API can be added as a custom provider, and Ollama, LM Studio, llama.cpp, LiteLLM, and oMLX models are discovered automatically. Instead of pasting a key, you can also sign in with GitHub Copilot, a ChatGPT subscription (added in v0.94.1), or xAI Grok OAuth (v0.98.0). Charm also runs Hyper, its own paid inference service on open-weight models (described in Charm's August 2026 release notes as a $20/month subscription, with prepaid options), which the README presents as the quickest way to start but which is optional. What sets Crush apart is how much of the developer environment it brings into the agent: language servers feed it diagnostics, references, and symbols and back rename and symbol-replace refactoring tools, MCP servers connect over stdio, HTTP, or SSE (with OAuth), Agent Skills load from Crush, Claude, Cursor, and shared .agents folders, and hooks can run on tool calls, turns, sessions, and permission events. Configuration moved in July 2026 to a crushrc file written in Bash and run by a built-in interpreter, so the same config works on Windows. Tools ask for permission by default, apart from provably read-only shell commands such as git status; you can allow, deny, or block specific tools and commands. Plan mode (v0.95.0) is for working out an approach before any code changes. v0.100.0 (November 5, 2026) added background subagents you can check on, message mid-run, stop, or move to another model, plus a Sysadmin mode that can run any command on your system, and prompts for SSH and GPG passwords inside Crush. Crush also runs headless with crush run, and a client/server mode, served locally over a Unix socket by default (or HTTP/TCP) with an OpenAPI-described API, lets several terminals or an app that embeds Crush share one workspace; this is a local API, not a hosted Charm service. The tradeoffs: it is terminal-only, with no IDE extension, desktop app, or cloud agents documented; the license is source-available rather than OSI open source (each release becomes MIT two years after it ships); pseudonymous usage metrics are on until you opt out; and output quality depends on the model you connect.

Updates from Crush

New Featurev0.100.0: subagents, Sysadmin mode, and SSH/GPG prompts

Crush can now dispatch named subagents in the background, check on them, send them follow-ups mid-run, stop them, or move them to a different model. A new Sysadmin mode lets the agent run any command on the system. Yolo mode still blocks dangerous commands, and the dangerous list is now configurable with permissions safe, block, and unblock. SSH passwords, GPG passphrases, and Yubikey prompts can be answered inside Crush.

New Featurev0.99.0: hooks across the whole run and Catwalk v3

Hooks can now follow sessions, turns, and permissions, and can act after a tool runs, for example to redact secrets from output or stop a turn. Client/server mode gained host theming, host context, piped permission prompts, and config reload on SIGHUP. Provider types now describe the API format (completions, responses, messages), and existing configs migrate automatically.

Integrationv0.98.0: xAI Grok OAuth sign-in

Crush added OAuth sign-in for xAI's Grok models and support for the OSC 7501 Program Status Protocol.

New Featurev0.95.0: Plan mode

Plan mode lets you talk through a task, answer the agent's questions, and agree on a plan before it starts work. Toggle it with shift+tab.

Integrationv0.94.1: use a ChatGPT subscription

Crush can sign in with a ChatGPT subscription, and crush run gained a --reasoning-effort flag for headless use.

Are you the founder? Claim this listing →