- Category
- Developer Tools
- Rank
- No. 316Tools index
- Pricing
- Open Source
- Type
- AGENT
- Use case
- Coding
- Interfaces
- CLI
- Builder
- charmbracelet
- GitHub
- 28.6k stars
- Latest release
- nightly
- Date
About
Crush is a terminal-based AI coding agent that connects to a wide range of LLM providers (Anthropic, OpenAI, Gemini, and more) and integrates with a project's tools, code, and workflows via LSPs and MCP. It supports session-based multi-project workflows and mid-session model switching, and runs across macOS, Linux, Windows, and BSD terminals.
What it does
Crush is a command-line coding assistant written in Go that runs as a background server, so a task keeps running even if the terminal client disconnects and reconnects. It draws on a shared abstraction over many language model backends to plan and carry out edits, and widens what it can see and touch in a project by registering external tool servers and code-intelligence servers alongside its own file, shell, and permission tools. Configuration is not a static file: it is a small script run through a bundled shell engine, so setup behaves the same on every platform.
Why it's ranked here
The provider layer alone spans Anthropic, OpenAI, Google, Amazon Bedrock, Azure, and OpenRouter through one shared interface, and the install surface matches that ambition: package manager builds for the major desktop platforms plus FreeBSD, OpenBSD, NetBSD, and even illumos and Solaris, alongside prebuilt binaries and a plain source install. Configuration runs through an embedded shell interpreter instead of a static file, giving per-project setup real conditional logic rather than flat key-value pairs. Few terminal coding tools match both that provider breadth and that platform reach at once.
What's good
The client and server are separate processes, so closing a terminal window does not end a running session: the server holds a workspace open for a short grace window, and a reconnecting client resumes an in-progress agent turn instead of losing it. Extensibility runs through several independent channels at once, external tool servers, language server hookups for code context, and a discoverable skills system, so a project can add capability without waiting on a new release. Authentication is not limited to pasting a key: some providers connect through OAuth instead.
Tradeoffs
The run loop is intricate: accepting, queuing, and canceling a prompt are tracked through several mutex-guarded counters and sequence numbers layered across the agent orchestration and workspace management code, the kind of machinery that is hard to reason about when a run hangs instead of exiting cleanly. The binary also links an analytics client library, so anyone deploying it in a locked-down environment should check what gets sent by default. Project configuration is executable shell rather than a declarative file, which is more expressive but means a shared configuration script can run arbitrary commands on load.
How to use it well
This fits a developer who works from a terminal across multiple machines or over a flaky connection, since the server survives a dropped session and lets a reconnect pick a task back up mid-turn. It also suits a team standardizing on one coding assistant across many model backends, since switching providers and reusing the same external tool and language-server setup needs no separate integration per provider. It is a poor fit if you want a zero-configuration, single-file setup for a one-off task: the shell-based configuration format rewards someone willing to write a short script up front.
Technical notes+
main.go is a thin entry point that starts an optional pprof listener behind the CRUSH_PROFILE environment variable before calling cmd.Execute; the real wiring lives in internal/app/app.go, whose App.New constructs the session, message, history, permission, LSP manager, and skills services, does best-effort clipboard initialization, and launches a background update check and MCP client initialization as separate goroutines. internal/agent/agent.go defines the SessionAgent interface and its sessionAgent implementation, which tracks in-flight prompts with an accept sequence counter, a per-session cancel mark, and a dispatch mutex map so a queued prompt accepted after a cancel is never dropped by it. internal/agent/coordinator.go builds one SessionAgent per configured role (coder and plan) from provider packages under charm.land/fantasy, including anthropic, bedrock, google, openai, and vercel; its own imports also pull in internal/oauth/copilot and an aliased internal/oauth/openai package, which is what backs OAuth-based sign-in for those providers instead of a pasted key, and it gates non-interactive runs on a bounded wait for MCP server initialization. internal/backend/backend.go and internal/backend/agent.go implement the transport-agnostic Backend and Workspace types that sit between that coordinator and the HTTP or ACP-facing layers, using create-grace, detach-grace, and idle-shutdown timers to keep a workspace alive across a brief client disconnect; internal/backend/session.go exposes session CRUD over the same Workspace. internal/client/client.go is the RPC client half, dialing over a Unix socket, a Windows named pipe, or TCP depending on platform, and its ShutdownServerIfIdle call refuses to tear down a server still hosting a workspace. go.mod lists the shell-interpreter dependency that backs the crushrc format described in README.md, plus a local SQLite driver and a migration library for on-disk storage, and posthog-go linked in as an analytics client.
Observed
- Language
- Go
- Packaging
- Distributed through Homebrew, npm, Arch's AUR, Nix, FreeBSD's pkg, Winget, Scoop, Debian and RPM repositories, prebuilt binaries, and a plain source install via go install
- Platform support
- macOS, Linux, Windows (including WSL), Android, FreeBSD, OpenBSD, and NetBSD by the project's own feature list, with go install additionally working on illumos and Oracle Solaris
- Interfaces
- A CLI plus a transport-agnostic backend consumed by both an HTTP server and an ACP integration layer
- Extensibility
- External tool servers can be registered over HTTP, stdio, or SSE transports
- Structural observation
- Links an analytics client library (PostHog) directly into the binary
- Structural observation
- Project configuration is an executable Bash-like script interpreted by a bundled shell engine, not a static declarative file
Read from README.md, go.mod, main.go, internal/app/app.go, internal/agent/agent.go, internal/agent/coordinator.go, internal/backend/backend.go, internal/backend/agent.go, internal/backend/session.go, internal/client/client.go.
What it can do
Connect to multiple LLM providers such as Anthropic, OpenAI, and Gemini
LLM provider API configuration → LLM-generated responses
Integrate with project tools via Language Server Protocol (LSP)
Project codebase → Code intelligence data
Integrate with external tools via Model Context Protocol (MCP)
MCP server configuration → Tool/data integration
Switch LLM models mid-session
Model selection → Continued session with new model
Tags
Tech Stack
Media
Comments (0)
No comments yet
Editorially curated, with community endorsements as a secondary signal. Corrections welcome.