Momentum, Verified build, Docs and Privacy are not measured yet; their weight goes to the signals shown. A dash means the signal is not scored for that kind of project. Hover a number for its rating in words.
Runs an AI coding agent in the terminal with two built-in agents: build (full access) and plan (read-only, asks before running bash), plus a general subagent for multi-step searches. Installs via a curl script, npm, Homebrew, Scoop, Chocolatey, pacman, mise or Nix, and ships a beta desktop app for macOS, Windows and Linux. For developers who want an open, configurable coding agent.
Strengths
MIT license; installable from npm, Homebrew, Scoop, Chocolatey, pacman, mise and Nix
Plan agent denies file edits and asks before bash, for safe codebase exploration
Desktop app (beta) for macOS, Windows and Linux alongside the terminal UI
Weaknesses
README covers install only; providers, config and server mode are in external docs
Desktop app that runs CLI coding agents in parallel git worktrees
89.5k stars, MIT, last commit Oct 2026
Orca is a cross-platform desktop app (macOS, Windows, Linux) that runs several CLI coding agents side by side, each in its own isolated git worktree. It bundles terminals with splits, an editor, an embedded Chromium browser, GitHub and Linear task views, and diff annotation. A mobile companion app and an `orca` CLI let you monitor and script agent workflows.
Strengths
Works with any agent that runs in a terminal, including Claude Code, Codex, OpenCode, Pi
Each agent gets its own git worktree; fan one prompt across several and compare
Agents can run on a remote machine over SSH with port forwarding
MIT license; desktop builds for macOS, Windows, Linux plus Homebrew and AUR packages
Weaknesses
No Docker or self-hosted server install; it is a desktop app
Mobile pairing relay lives in a separate pnpm workspace under cloud/
Collects anonymous usage telemetry; opt-out is documented but not the default
Ships daily and the README says its feature list lags behind
YAML workflow engine that runs coding agents in isolated worktrees
23.7k stars, MIT, last commit Oct 2026
Defines development processes (plan, implement, validate, review, PR) as YAML workflows and runs them through Claude Code, Codex or Pi, each run in its own git worktree. Deterministic nodes mix with AI nodes and human approval gates; runs start from the CLI, a web console, Slack, Telegram, Discord or GitHub webhooks, with state in SQLite or PostgreSQL. For teams standardizing how agents ship code.
Strengths
Every run isolated in a git worktree; parallel fixes without conflicts
Codex CLI is a coding agent from OpenAI that runs in the terminal on your machine. It installs through a shell script, npm, Homebrew, or prebuilt release binaries for macOS and Linux, and it signs in with a ChatGPT plan or an API key. The same project also covers IDE extensions and a desktop app.
Strengths
Prebuilt binaries for macOS and Linux on x86_64 and arm64
Multiple install paths: script, npm, Homebrew, or release archive
Sign-in with an existing ChatGPT Plus, Pro, Business, Edu, or Enterprise plan
Apache-2.0 license, written in Rust
Weaknesses
README documents only OpenAI sign-in or API key; other model providers are not mentioned
API key use requires extra setup beyond the quickstart
RAM and disk requirements are unknown
Install scripts fetch from OpenAI-hosted release URLs by default
Terminal coding agent that runs parallel sub-agents and keeps git-based memory
70k stars, custom license, last commit Oct 2026
OmO ships a single `omo` command, a native binary built on senpi, the project's fork of pi. It takes a prompt and plans, runs and checks the work. Adding `ultrawork` or `mass ulw` makes it fan the job out to many agents, each on a model chosen for that step. Memory is stored as markdown files in a git repository, and `/login` supports Claude, ChatGPT, Kimi and GLM subscriptions.
Strengths
Native binary installs via curl script, bun or npm; no Docker needed
Logs in with Claude, ChatGPT, Kimi and GLM subscriptions
Memory is plain markdown in a git repo, so it can be inspected
`omo setup` migrates keys, MCP servers and skills from the OpenCode edition
Weaknesses
License is SUL-1.0, not a standard OSI license; check terms before commercial use
Install is a curl-pipe-to-bash script
Computer use is documented as experimental
Hardware needs and supported model list are not stated in the README
Coding agent for terminal, desktop, browser and VS Code, written in Go
35.8k stars, MIT, last commit Oct 2026
Reasonix is a local coding agent that reads a project folder, edits files and runs commands and tests, asking for approval at a permission level you choose. DeepSeek is a built-in preset and any OpenAI-compatible endpoint is a config entry in reasonix.toml. The same engine backs the Studio desktop app, a terminal UI, a browser UI via `reasonix web`, and editors through ACP.
Strengths
Models are config entries in reasonix.toml; any OpenAI-compatible endpoint works
Static single binary built with CGO_ENABLED=0, cross-compiled to six targets
Per-turn rewind of files changed by its edit tools, independent of git
Same engine behind desktop, CLI, browser and ACP editor clients
Weaknesses
Rewind does not cover changes made by shell commands
Two release lines: 2.x is still changing quickly, 1.x is maintenance only
VS Code extension needs the separately installed 1.x CLI
Prompts and file contents go to whichever model provider you configure
no GPU
Needs Model provider API key, Go 1.25+ (build from source), Node 24+ and pnpm 10 (Studio build)
Terminal coding agent that runs Gemini models with file, shell and MCP tools
107.3k stars, Apache-2.0, last commit Oct 2026
Gemini CLI is a TypeScript terminal agent, installed from npm, Homebrew, MacPorts or conda, that sends prompts to Gemini models and can edit files, run shell commands, fetch web pages and ground answers with Google Search. It supports MCP servers, GEMINI.md context files, conversation checkpointing, a headless mode with JSON and stream-JSON output, and a GitHub Action for PR review and issue triage.
Strengths
Free tier with Google login: 60 requests/min, 1,000 requests/day
1M token context window with Gemini 3 models
Headless mode emits plain text, JSON or newline-delimited stream-JSON
Auth via Google login, Gemini API key or Vertex AI
Weaknesses
Only talks to Gemini models; no other providers listed in the README
Needs a Google account, API key or Vertex AI credentials; no local models
Preview and nightly channels may contain regressions
Free-tier quotas and terms are governed by Google, not the project
no GPU
Docker
Needs Node.js, Gemini API, Google account login or Vertex AI
Web control center for running coding agents and scheduled automations
90.6k stars, MIT, last commit Oct 2026
Agent Canvas is a web frontend that starts and manages conversations with coding agents. It runs the OpenHands agent by default and can drive Claude Code, Codex, Gemini CLI, Pi, OpenCode, or any ACP-compatible agent. It connects to one or more Agent Server backends (local, Docker, VM, or OpenHands Cloud) and pairs with an Automation Server for scheduled and webhook-triggered runs.
Strengths
Switches between local, remote and cloud Agent Server backends from one UI
Works with third-party agents through ACP, not only OpenHands
Option to run each conversation in its own Docker container
Automations can run on a schedule or on webhook events
Weaknesses
Marked beta in the README
Non-sandboxed install gives the agent full filesystem access
Needs Node.js 24+ and uv for non-Docker installs
Automation and agent server live in separate repositories
Workspace for running and reviewing OpenCode coding agents across devices
11.4k stars, MIT, last commit Oct 2026
OpenChamber is a front end for OpenCode coding agents, shipped as a desktop app, web/PWA, VS Code extension, and iOS/Android clients. It adds session goals, multi-run comparison across up to five models, guided diff walkthroughs, GitHub issue and PR integration, and scheduled prompts. A CLI server runs on a workstation and can be reached through an encrypted relay, LAN, tunnels, or SSH.
Strengths
Multi-run sends one task to up to five models, each in its own worktree
Session Goals keep the agent working after a turn until the goal is met or blocked
Same sessions reachable from desktop, browser, VS Code, iOS and Android
Remote access via end-to-end encrypted relay needs no open ports
Weaknesses
Depends on OpenCode for agents; web and VS Code need a separate OpenCode install
CLI/Web requires Node.js 24.14 or newer
Docker deployment is not documented in the README
RAM, GPU needs and supported model providers are unknown
LangChain coding agent that plans, implements and reviews pull requests
11k stars, MIT, last commit Oct 2026
LangGraph-based agent that investigates a repository, implements changes in a per-thread Linux sandbox, validates them and opens a pull request, then reviews PRs and watches CI with /baby-sit. Work starts from a dashboard, GitHub issues or PR comments, Slack or Linear. Deploys into your infrastructure with a backend, dashboard, GitHub and Slack apps, for teams building an internal coding-agent service.
Strengths
Covers build, review, investigate and operate flows, with subagents for parallel work
Durable execution and thread state via LangGraph; sandboxes persist per thread
Configurable models, reasoning effort, skills, MCP integrations and sandbox providers
Coding agent for VS Code, JetBrains, terminal and desktop
70.2k stars, Apache-2.0, last commit Oct 2026
Cline is a coding agent that reads a project, edits files across it, and runs shell commands while watching the output. It ships as a VS Code extension, JetBrains plugin, CLI with headless mode, macOS/Windows desktop app, and a Node.js SDK. Edits and commands need approval by default, with Plan and Act modes, checkpoints, and optional auto-approve.
Strengths
Same agent engine across VS Code, JetBrains, CLI, desktop app and SDK
Works with Anthropic, OpenAI, Gemini, Bedrock, Vertex, OpenRouter, Ollama and LM Studio
Headless CLI accepts piped input and emits JSON for CI/CD scripts
Supports MCP servers, SDK plugins, cron-scheduled agents and multi-agent teams
Weaknesses
JetBrains plugin source is not open-sourced
VS Code extension code is still migrating to the new layout
Hosted model providers need your own API keys; local models via Ollama or LM Studio
Diff review and checkpoints are described only for VS Code and JetBrains
Needs Node.js, VS Code or JetBrains IDE (for extensions), LLM provider API key or local model server
Models: Anthropic, OpenAI, Google Gemini, OpenRouter, Vercel AI Gateway
Terminal coding agent, a Codex fork tuned for low-cost models
68.5k stars, Apache-2.0, last commit Oct 2026
Open Interpreter is a Rust fork of OpenAI's Codex that runs as a terminal coding agent. It can emulate other agent harnesses (claude-code, kimi-code, qwen-code, swe-agent and others) via /harness, so cheaper models are driven the way their providers recommend. It also runs as an ACP agent for editors and accepts the Codex exec protocol.
Strengths
Switchable harness emulation: native, claude-code, kimi-code, qwen-code, swe-agent, minimal and more
Runs under native sandboxing on macOS, Linux and Windows
Works as an ACP agent via `interpreter acp`; Codex SDK users can swap the binary
Reads shared AGENTS.md and .agents/skills; supports MCP, hooks and permissions
Weaknesses
Rewrite of the original Python project, which is now only a community fork
Built-in computer use relies on external tools: agent-browser and trycua
README gives no RAM, GPU or supported-model minimums
Install is a curl or PowerShell pipe-to-shell script; no Docker image
Needs agent-browser, trycua
Models: OpenAI-compatible Chat Completions providers, Kimi K3, DeepSeek, Z.AI GLM
Terminal multiplexer that keeps coding agents running and shows which are blocked
43.3k stars, Apache-2.0, last commit Oct 2026
herdr is a Rust terminal multiplexer for running several coding agents such as Claude Code, Codex, Cursor and opencode. A background server keeps panes alive when the client detaches or SSH drops, and each pane is marked working, blocked or idle. Agents can also drive it through a CLI and socket API, and saved SSH machines appear in the same window.
Strengths
Panes keep running in a background server after detach or SSH disconnect
Per-pane working, blocked or idle status across local and saved SSH machines
Agents can spawn panes and prompt each other via CLI and socket API
Single Rust binary; installs via curl script, Homebrew, mise or PowerShell
Weaknesses
After a server or machine restart, processes are lost; only layout and supported agent sessions resume
Resume works only for supported agents; the README does not list which
Windows support is described as beta in the docs link
Claw Code is a Rust implementation of the `claw` CLI agent harness, with the workspace in `rust/` and commands such as `claw prompt`, an interactive session, and `claw doctor` as a health check. It authenticates with API keys (Anthropic, OpenAI, others), and the docs cover local OpenAI-compatible providers such as Ollama, llama.cpp and vLLM. The README describes the repo as an agent-managed exhibit and points users who want to run work to LazyCodex or Gajae-Code.
Strengths
Rust workspace builds to a single `claw` binary with a `doctor` check
Supports local OpenAI-compatible backends: Ollama, llama.cpp, vLLM
MIT license; PowerShell-first Windows install docs alongside Linux and macOS
Mock parity harness and workspace test suite via `cargo test --workspace`
Weaknesses
Build from source only; `cargo install claw-code` installs a deprecated stub
README says it is not the serious production project
Claude subscription login unsupported; API key required
No ACP/Zed daemon yet; `claw acp serve` only returns status
Docker + Compose
Needs Rust toolchain (cargo), API key (Anthropic, OpenAI or compatible provider)
Terminal coding agent that works with hosted or local models
41.1k stars, MIT, last commit Oct 2026
Codewhale is a Rust coding agent that reads a project, edits files, runs commands, and checks its own work from the terminal. It supports over 40 provider routes, any OpenAI-compatible endpoint, and local models via Ollama, vLLM, or SGLang. The same local engine backs the TUI, headless exec, a local web client, PR review, and an HTTP runtime API.
Strengths
Over 40 built-in provider routes plus any OpenAI-compatible endpoint and local runtimes
Plan, Work and Operate modes with approval postures, /undo and /restore
Headless `codewhale exec` and local HTTP runtime API fit scripts and CI
Supports MCP servers, skills, plugins, hooks and Claude Code plugins
Weaknesses
Usage telemetry is on by default and must be disabled in config
Linux bubblewrap sandbox is opt-in; Seatbelt is the macOS sandbox
Native desktop app is still in development; VS Code extension is community-maintained
Account-based key sync adds an optional dependency on a hosted Codewhale service
GPU optional
Docker
Needs Ollama, vLLM or SGLang for local models, hosted provider API key
Terminal coding agent with built-in LSP, debugger, subagents and hash-anchored edits
35k stars, MIT, last commit Oct 2026
A fork of Pi that runs as a terminal coding agent with a Rust core, shipping 31 built-in tools and support for 60+ model providers. It wires in LSP operations and a DAP debugger, runs persistent Python and Bun cells, and fans work out to subagents in isolated worktrees. Edits use content-hash anchors instead of string replacement, and grep, glob and many shell utilities run in-process.
Strengths
Drives LSP (14 ops) and DAP debuggers (28 ops) from the agent
Hashline edits reject patches against stale files before writing
Runs on macOS, Linux and Windows natively, no WSL needed
Reads Cursor, Cline, Codex and Copilot rule files in native format
Weaknesses
Requires bun 1.3.14 or newer for the recommended install
Memory, GitHub, image and TTS tools are off by default
Pull request vouch policy is a trial and may return
Benchmark claims come from the author's own blog post
Background coding agents on cloud sandboxes with Slack, GitHub and Linear triggers
3.3k stars, MIT, last commit Oct 2026
Runs coding sessions in cloud sandboxes coordinated by a Cloudflare Workers control plane, driven from a web UI, Slack, GitHub PR comments, Linear issues or webhooks. Sessions use OpenCode or the Claude Agent harness with Anthropic, OpenAI, xAI, DeepSeek or Z.AI models, with multiplayer editing, commit attribution, child sessions and cron or event automations. For single-tenant engineering orgs.
Strengths
Snapshot restore, prebuilt images and proactive warming for fast session starts
Automations from cron, Sentry alerts, GitHub workflow runs and inbound webhooks
Secrets encrypted with AES-256-GCM and scoped globally, per repo or per environment
Browser automation, code-server and a web terminal inside each sandbox
Weaknesses
Single-tenant only; all users must be trusted members of one organization
Control plane requires Cloudflare Workers, Durable Objects and D1
Sandboxes run on third-party providers (Modal, Daytona, E2B, OpenComputer, Vercel)
Cached credentials can persist in snapshots; grant removal does not revoke tokens
no GPU
Compose
Needs Cloudflare Workers, Durable Objects and D1, Sandbox provider (Modal, Daytona, E2B, OpenComputer or Vercel Sandbox), GitHub App, Slack and Linear apps (optional)
Models: Anthropic Claude (API key or subscription), OpenAI Codex via ChatGPT subscription, xAI Grok via SuperGrok, OpenCode Zen and Go, Z.AI Coding Plan
Warp is a Rust client that started as a terminal and now includes a built-in coding agent. It can also run third-party CLI agents such as Claude Code, Codex and Gemini CLI. The client source is public, and the repository is itself maintained partly by automated agents (Warp Factories).
Strengths
Runs its own agent or external CLI agents (Claude Code, Codex, Gemini CLI)
Client source is public; build with ./script/bootstrap and ./script/run
UI framework crates (warpui_core, warpui) are MIT-licensed
Written in Rust; contribution flow and AGENTS.md engineering guide documented
Weaknesses
Most code is AGPL-3.0, which constrains proprietary forks
README does not state supported models, RAM or GPU requirements
Factories automation is early access with a demo booking flow
README covers only the client; server-side components are not described
Docker
Models: GPT models, Claude Code, Codex, Gemini CLI
Coding agent as a CLI, VS Code extension and JetBrains plugin
36.2k stars, Apache-2.0, last commit Jul 2026
Continue is a coding agent distributed as an npm CLI, a VS Code extension (Marketplace and OpenVSX) and a JetBrains plugin. The repository is read-only and no longer actively maintained; the final 2.0.0 release removed anonymous telemetry and authentication. The README does not list supported models or providers and points to docs.continue.dev for configuration.
Strengths
Ships as CLI, VS Code extension and JetBrains plugin from one codebase
Final 2.0.0 release removed anonymous telemetry and authentication
Apache-2.0 license; extension available on OpenVSX as well as Marketplace
Source for each extension lives in its own directory (vscode, cli, intellij)
Weaknesses
Repository is read-only and no longer actively maintained
README recommends the CLI over the JetBrains plugin
README does not list supported models or providers; docs needed
Terminal pair-programming tool that edits your git repo with LLMs
49.5k stars, Apache-2.0, last commit May 2026
Aider runs in the terminal and edits files in an existing codebase through chat with a cloud or local LLM. It builds a map of the repository to give the model context, commits each change to git with a generated message, and can run linters and tests after edits and try to fix failures. It also accepts images, web pages and voice input, and can be triggered by comments in an editor.
Strengths
Auto-commits every change to git, so diffs and undo use ordinary git tools
Connects to almost any LLM, including local models
Runs linters and tests after edits and attempts to fix reported failures
Repo map gives the model context across larger codebases
Weaknesses
Terminal-first; no standalone GUI, IDE use relies on comment watching
Last tagged release is 2025-08-09, older than recent commits
Needs an LLM API key or a separately hosted local model
Installed via pip and aider-install; no Docker setup in the repo
no GPU
Docker
Needs LLM provider API key or local model server
Models: Claude 3.7 Sonnet, DeepSeek R1 and V3, OpenAI o1, o3-mini, GPT-4o, local models
Serves code completion and chat to VS Code, Vim and JetBrains extensions from one self-contained binary with no external database. Runs local models such as StarCoder-1B and Qwen2-1.5B-Instruct on CUDA or Apple Metal, exposes an OpenAPI interface on port 8080, and adds an Answer Engine, repository and GitLab merge-request indexing and LDAP auth. For teams that want an on-premises Copilot alternative.
Strengths
Single binary with embedded storage; no DBMS or cloud service required
One docker run command starts a server with completion and chat models