NovaKit CLI vs Crush CLI: Battle of the AI Coding Agents
A detailed comparison between NovaKit CLI and Charm's Crush CLI. Explore which AI terminal coding agent suits your development needs.
NovaKit CLI vs Crush CLI: Battle of the AI Coding Agents
The AI coding assistant landscape continues to evolve rapidly, with terminal-based agents becoming increasingly sophisticated. Two powerful contenders in this space are NovaKit CLI and Crush CLI (by Charm). Both tools bring AI-powered coding assistance directly to your terminal, but they take distinctly different approaches. This comprehensive comparison will help you choose the right tool for your workflow.
Overview
NovaKit CLI
NovaKit CLI is a TypeScript-based AI coding agent built with React/Ink, delivering a rich terminal user interface with deep code intelligence capabilities. It emphasizes semantic code search, comprehensive LSP integration, and a flexible multi-provider architecture.
Key Highlights:
- TypeScript + React/Ink architecture
- Vector-indexed semantic code search (LanceDB)
- Full LSP integration (goto definition, references, hover)
- Three operating modes (Agent/Review/Plan)
- 8+ built-in AI provider presets
- Comprehensive memory and checkpoint systems
Crush CLI
Crush CLI is the glamorous AI coding agent from Charm, built in Go using their battle-tested Bubble Tea framework. As the spiritual successor to OpenCode, Crush combines LLM capabilities with Charm's renowned terminal UI expertise and cross-platform excellence.
Key Highlights:
- Go + Bubble Tea architecture (Charm ecosystem)
- 90+ releases with 65+ contributors
- Native cross-platform support (including Windows, BSDs)
- Multi-transport MCP support (stdio/HTTP/SSE)
- Automatic provider model updates via Catwalk
- FSL-1.1-MIT open-source license
Technical Architecture
| Aspect | NovaKit CLI | Crush CLI |
|---|---|---|
| Language | TypeScript | Go (97.9%) |
| UI Framework | React/Ink | Bubble Tea + Bubbles |
| Styling | Custom + Shiki | Lip Gloss |
| Markdown | Marked | Glamour |
| Database | LanceDB (vectors), JSON (sessions) | SQLite |
| Runtime | Node.js 18+ | Native binary |
| Binary Size | Node.js dependency | Standalone (~15MB) |
Analysis: Crush's Go-based architecture offers native binary distribution and superior startup times. NovaKit's TypeScript approach provides easier extensibility for JavaScript developers but requires Node.js runtime.
AI Provider Support
| Feature | NovaKit CLI | Crush CLI |
|---|---|---|
| Anthropic | Yes | Yes |
| OpenAI | Yes | Yes |
| Google Gemini | No (via OpenRouter) | Yes (native) |
| Groq | Yes | Yes |
| OpenRouter | Yes | Yes |
| AWS Bedrock | No | Yes (native) |
| Azure OpenAI | No | Yes (native) |
| Google Vertex AI | No | Yes (native) |
| Cerebras | No | Yes |
| Hugging Face | No | Yes |
| GitHub Copilot | Yes (OAuth) | No |
| Z.ai GLM | Yes | Yes |
| Custom Endpoints | OpenAI-compatible | OpenAI + Anthropic compatible |
| Local Models | Via custom endpoints | Ollama, LM Studio native |
| Model Auto-Update | No | Yes (Catwalk) |
| Mid-Session Switching | Yes | Yes |
Analysis: Crush offers significantly broader native provider support, including enterprise options like AWS Bedrock, Azure OpenAI, and Vertex AI. NovaKit has unique GitHub Copilot OAuth integration. Crush's Catwalk integration automatically fetches the latest models from a community-maintained database.
Terminal User Interface
| Feature | NovaKit CLI | Crush CLI |
|---|---|---|
| Framework | React/Ink | Bubble Tea + Bubbles |
| Markdown Rendering | Marked + Shiki | Glamour |
| Syntax Highlighting | Shiki (VSCode themes) | Glamour built-in |
| Mode Indicators | Color-coded status bar | Integrated display |
| Alternate Screen | Yes | Yes |
| Command Palette | / key | Configurable |
| Model Switching | Ctrl+L | Ctrl+P |
| File Attachment | @ symbol | Supported |
| Input History | Arrow navigation | Arrow navigation |
| Multiline Input | Yes | Yes |
| Spinner Animation | Yes | Yes |
Analysis: Both offer polished terminal experiences. Charm's five years of TUI framework development gives Crush exceptionally refined UI components. NovaKit's Shiki integration provides VSCode-quality syntax highlighting.
Operating Modes
NovaKit CLI Modes
- Agent Mode - Full tool access with write, edit, and bash execution
- Review Mode - Collects changes for batch approval before applying
- Plan Mode - Read-only exploration and planning only
Crush CLI Modes
- Standard Mode - Interactive with permission prompts
- YOLO Mode - Bypasses all confirmation prompts (--yolo flag)
- Non-Interactive - Single-prompt execution for scripting
Analysis: NovaKit's Review Mode offers unique safety features for careful code changes. Crush's YOLO mode is useful for trusted automation but requires careful consideration. Both support planning-oriented workflows.
Code Intelligence
| Feature | NovaKit CLI | Crush CLI |
|---|---|---|
| Semantic Search | Yes (LanceDB + embeddings) | No |
| Vector Indexing | Xenova/transformers | No |
| LSP - Goto Definition | Yes | Yes |
| LSP - Find References | Yes | Via LSP |
| LSP - Hover Info | Yes | Via LSP |
| LSP - Diagnostics | Yes | Yes |
| Code Indexing | Automatic on build | Project analysis |
| Context Files | NOVAKIT.md | CRUSH.md / AGENTS.md |
| Context Scoring | Min relevance threshold | Standard |
Analysis: NovaKit's semantic code search is a significant differentiator, using vector embeddings to find contextually relevant code even without exact keyword matches. Both integrate LSP for code intelligence, but NovaKit exposes more LSP features directly as agent tools.
MCP (Model Context Protocol) Support
| Feature | NovaKit CLI | Crush CLI |
|---|---|---|
| MCP Support | Yes | Yes |
| Transport: Stdio | Yes | Yes |
| Transport: HTTP | No | Yes |
| Transport: SSE | No | Yes |
| Configuration | ~/.novakit/mcp.json | crush.json mcpServers |
| In-App Management | /mcp-status, /mcp-connect | Config-based |
| Environment Variables | Supported | Supported |
| Built-in Servers | Filesystem, GitHub | Configurable |
Analysis: Crush offers more transport options for MCP servers (HTTP and SSE in addition to stdio), providing greater flexibility for different deployment scenarios. NovaKit provides more in-app MCP management commands.
Session and State Management
| Feature | NovaKit CLI | Crush CLI |
|---|---|---|
| Session Storage | JSON files | Project-specific contexts |
| Session Persistence | Full history | Per-project |
| Session Commands | list, resume, rename, compact, export, delete | Standard management |
| Checkpoints | Yes (file snapshots) | No |
| Undo/Redo | Ctrl+Z/Y | Supported |
| Auto-Compaction | Yes (threshold-based) | Yes |
| Session Export | JSON, Markdown | No |
| Context Windows | Token-based tracking | Standard |
| Logging | Session-based | .crush/logs/crush.log |
Analysis: NovaKit provides more sophisticated session management with checkpoints, multiple export formats, and explicit session commands. Crush focuses on project-specific contexts with detailed logging support.
Built-in Tools
NovaKit CLI Tools
File Operations:
- read, write, edit, apply_patch, glob, list_directory
Code Analysis:
- grep, vector_search, vision (image analysis)
System:
- bash, web_search, web_fetch
Persistence:
- save_memory, read_memory
Code Intelligence:
- lsp_goto_definition, lsp_find_references, lsp_hover, lsp_diagnostics
Advanced:
- multi_tool_use.parallel
Crush CLI Tools
File Operations:
- glob, grep, ls, view, write, edit, patch
System:
- bash, shell command execution
- Direct access to git, docker, npm, nix, etc.
Code Intelligence:
- LSP integration for diagnostics
Permission System:
- Configurable auto-approve vs. prompt
- Tool-level permission control
Analysis: NovaKit offers more specialized tools (vector_search, vision, memory system). Crush emphasizes direct CLI tool access with granular permission controls.
Configuration and Customization
| Feature | NovaKit CLI | Crush CLI |
|---|---|---|
| Config Format | JSON | JSON |
| Global Config | ~/.novakit/config.json | ~/.config/crush/crush.json |
| Project Config | .novakit/config.json | .crush.json |
| Custom Commands | ~/.novakit/commands.json | Supported |
| Custom Agents | ~/.novakit/agents.json | No |
| Ignore File | .novakitignore | .crushignore |
| Context Files | NOVAKIT.md | CRUSH.md / AGENTS.md (customizable) |
| Snippets | Yes | No |
| Attribution | No | Customizable (assisted-by, co-authored-by) |
| Debug Mode | Limited | CLI flags + config |
Analysis: NovaKit offers unique custom agents and snippets features. Crush provides flexible commit/PR attribution options and more accessible debug modes.
Platform Support
| Platform | NovaKit CLI | Crush CLI |
|---|---|---|
| macOS | Yes | Yes |
| Linux | Yes | Yes |
| Windows | Via npm | Native (PowerShell, WSL) |
| FreeBSD | No | Yes |
| OpenBSD | No | Yes |
| NetBSD | No | Yes |
| Docker | No | No |
Analysis: Crush's Go-based architecture enables superior cross-platform support, including native Windows and BSD variants. NovaKit requires Node.js on all platforms.
Installation Methods
| Method | NovaKit CLI | Crush CLI |
|---|---|---|
| npm/pnpm/yarn | Yes (@novakit/cli) | Yes (@charmland/crush) |
| Homebrew | Yes (tap) | Yes (charmbracelet/tap) |
| Go Install | No | Yes |
| AUR (Arch) | No | Yes (crush-bin) |
| Nix | No | Yes |
| Winget | No | Yes |
| Scoop | No | Yes |
| Binary Download | Yes | Yes |
| npx (direct run) | Yes | No |
Analysis: Crush offers significantly more installation options, particularly for non-Node.js environments. NovaKit's npx support enables quick trials without installation.
Licensing and Development
| Aspect | NovaKit CLI | Crush CLI |
|---|---|---|
| License | Proprietary | FSL-1.1-MIT |
| Source Code | Private | Open (GitHub) |
| Contributors | Internal team | 65+ |
| Releases | Managed | 90+ |
| Commercial Use | Allowed | Allowed |
| Modification Rights | No | Yes (with restrictions) |
| Organization | NovaKit | Charm (charm.land) |
Analysis: Crush uses FSL-1.1-MIT (Functional Source License), which transitions to MIT after two years. This provides source availability while protecting commercial interests. NovaKit remains fully proprietary.
Privacy and Telemetry
| Aspect | NovaKit CLI | Crush CLI |
|---|---|---|
| Telemetry | Minimal | Pseudonymous metadata |
| Data Collection | Usage stats | Device-hashed metrics |
| Opt-Out | Available | CRUSH_DISABLE_METRICS=1 |
| DO_NOT_TRACK | No | Yes (standard support) |
| Prompt/Response Storage | Local only | Local only |
Analysis: Both respect user privacy. Crush provides more explicit opt-out mechanisms following industry standards (DO_NOT_TRACK).
Performance Characteristics
NovaKit CLI
- Startup: Moderate (Node.js initialization)
- Memory: Higher due to Node.js runtime
- Vector Indexing: Initial build can be resource-intensive
- Response Streaming: React-based rendering
- Session Loading: JSON parsing
Crush CLI
- Startup: Fast (native binary)
- Memory: Lower footprint (Go efficiency)
- Processing: Native performance
- Response Streaming: Bubble Tea optimized
- Session Loading: SQLite efficiency
Analysis: Crush's native Go binary offers tangible performance advantages in startup time and memory usage. NovaKit's vector indexing provides smarter context but requires initial computation.
Unique Features
NovaKit CLI Exclusive
- Semantic Code Search - LanceDB-powered vector search finds contextually relevant code
- Review Mode - Batch file changes for approval before applying
- Custom Agents - Define specialized AI personas with custom instructions
- Persistent Memory - Save and recall memories across sessions
- Snippets System - Store and reuse code snippets
- Checkpoints - Snapshot and restore file states
- IDE JSON-RPC Server - Integration mode for VS Code/JetBrains
- GitHub Copilot OAuth - Native OAuth device flow authentication
Crush CLI Exclusive
- Native Cross-Platform - Windows, BSDs without Node.js
- Multi-Transport MCP - HTTP and SSE in addition to stdio
- Catwalk Integration - Auto-updating model database
- Charm Ecosystem - Leverage mature TUI components
- YOLO Mode - Full automation without prompts
- Enterprise Providers - Native AWS Bedrock, Azure, Vertex AI
- Attribution Control - Customizable commit/PR trailers
- DO_NOT_TRACK Support - Industry-standard privacy compliance
Use Case Recommendations
Choose NovaKit CLI If You:
- Need semantic code search for large, complex codebases
- Want Review Mode for careful, batch-approved changes
- Require custom agent personalities for different tasks
- Use GitHub Copilot and want OAuth integration
- Need persistent memory across coding sessions
- Want checkpoint-based file state management
- Prefer comprehensive session export options
- Work primarily in the JavaScript/TypeScript ecosystem
Choose Crush CLI If You:
- Need native Windows or BSD support
- Want fastest possible startup and response times
- Require enterprise cloud providers (Bedrock, Azure, Vertex)
- Value open-source with commercial-friendly licensing
- Need HTTP/SSE MCP transport options
- Want automatic model updates via Catwalk
- Prefer Go-based tooling and Charm ecosystem
- Need granular tool permission controls
Head-to-Head Comparison
| Category | Winner | Reason |
|---|---|---|
| Code Intelligence | NovaKit | Semantic search + full LSP |
| Platform Support | Crush | Native Windows, BSD |
| Provider Options | Crush | Enterprise providers, auto-updates |
| Session Management | NovaKit | Checkpoints, export, memory |
| Performance | Crush | Native Go binary |
| Customization | NovaKit | Agents, snippets, modes |
| MCP Flexibility | Crush | Multi-transport support |
| Installation Options | Crush | More package managers |
| Safety Features | NovaKit | Review Mode |
| Open Source | Crush | FSL-1.1-MIT license |
Migration Considerations
From Crush to NovaKit
- Export any saved contexts before switching
- Convert crush.json to novakit config format
- Migrate custom commands to JSON format
- Set up equivalent MCP servers
- Build vector index for semantic search capabilities
- Note: Some providers (Bedrock, Azure, Vertex) may need OpenRouter
From NovaKit to Crush
- Export sessions to Markdown format
- Convert novakit config to crush.json
- Create CRUSH.md from NOVAKIT.md content
- Note: Custom agents need manual recreation as prompts
- Note: Semantic search features unavailable
- Note: Memory system needs alternative approach
Future Outlook
NovaKit CLI
- Continued focus on code intelligence features
- Deeper IDE integration capabilities
- Enhanced memory and context systems
- Expanded provider support
Crush CLI
- Active development under Charm stewardship
- Integration with upcoming "Ultraviolet" toolkit
- Growing community contributions (65+ contributors)
- Expanding enterprise provider support
Conclusion
Both NovaKit CLI and Crush CLI represent the cutting edge of terminal-based AI coding assistants, but they serve different priorities:
NovaKit CLI excels in code intelligence and safety. Its semantic search capability is unmatched, finding relevant code context even without exact keyword matches. The Review Mode provides a unique safety layer for developers who want to approve changes in batches. Custom agents and persistent memory make it highly adaptable to different workflows.
Crush CLI excels in performance and accessibility. Built on Charm's proven Bubble Tea framework, it offers native binaries across platforms including Windows and BSDs. Broader provider support (including enterprise options) and open-source licensing make it attractive for diverse team environments.
For developers working on large, complex codebases where understanding context is crucial, NovaKit's semantic search provides clear advantages. For teams prioritizing cross-platform support, enterprise provider integration, and open-source principles, Crush offers compelling benefits.
Both tools continue rapid development. The best choice depends on your specific workflow requirements, platform needs, and whether code intelligence or provider flexibility matters more to your daily development experience.
Experience the power of semantic code search and intelligent context. Get started with NovaKit CLI today and elevate your terminal development workflow.