AI Coding Assistants

Executive Summary

Choose a coding assistant around the work you need to supervise: editing in an existing repository, running its tests, reviewing a diff, and controlling the environment and bill. This comparison covers 17 assistants with terminal, IDE, or interactive agent interfaces. It separates a model, the software that operates its tools, and the environment where commands execute. Changing one does not necessarily change the others.

The September 2026 update adds Codex, Gemini CLI, GitHub Copilot, Pi, and Factory's Droid. Copilot belongs here because it now includes terminal, desktop, and IDE agents, not just autocomplete. Continue moves to the departed-project section because its maintainers explicitly archived it. Refact remains a member because its local community engine continues after the hosted service's retirement.^{[1][2][3][4][5]}

Grok Build also joins this edition: its repository coding CLI meets the edit-and-validate criteria, with interactive, scripted, and ACP interfaces. The separately branded web/mobile app builder is not an extra matrix member.^[6][7]

My starting shortlists are:

• Terminal work with provider choice: Aider, OpenCode, Crush, Goose, or Pi; their approval and extension designs differ substantially.
• A commercial agent across local and delegated work: Claude Code, Codex, Copilot, Amp, or Droid.
• Work alongside an existing editor: Cline, Kilo, or Sweep; check the particular editor rather than assuming every interface has identical capabilities.
• An adaptable local control plane: Refact or OpenHands, with additional configuration and operating responsibilities.

These are workflow recommendations, not a measured quality ranking. The product sections below explain their basis. Tembo enters the decision when an assistant becomes shared team infrastructure: it runs existing agents in cloud or self-hosted environments, with integrations and reviewable output. It is discussed separately from the 17 assistant members.^[8]

Scope and Method

An included assistant must provide a usable coding workflow that reads a repository, proposes or makes changes, and supports an edit-and-validate loop. This is a selected market map, not an exhaustive directory. It includes open-source and commercial products, foundation-model vendors and independent developers. A GitHub star threshold or a quiet month of commits does not determine inclusion.

Full editor replacements have their own coverage in Mac Coding Agent Apps. Cloud Coding Agent Platforms compares asynchronous execution and team operations; Foundation Lab Coding Agents covers additional lab offerings. Products can span these categories without every product surface becoming a separate member here.

Evidence checked September 15–16, 2026: current documentation, repositories, licenses, pricing, explicit status announcements, and published experience. No hands-on performance or security benchmark was conducted for this update. Prices below are published USD monthly terms unless stated otherwise. Tool features and hosted entitlements can change independently.

Comparison Matrix

The first column links to a dedicated profile. Local execution means commands run on your machine; it does not imply local model inference or that prompts never leave it.

Terminal Assistants and Extensible Local Tools

Aider

Aider remains a useful candidate when the desired unit of work is an understandable change in a Git repository. It commits its edits, exposes /diff and /undo, and can separate pre-existing dirty changes before making its own. Those defaults are configurable; commit creation alone is not proof of validation, and its default commit path skips pre-commit hooks unless configured otherwise.^[9]

A concrete workflow is to give Aider a bounded bug, configure the repository's actual test command, inspect its patch, and use the failing test output for another iteration. Automatic linting is built in; automatic testing requires the relevant test command and option. That makes it a clear option for developers who want to see the edit/test loop rather than primarily manage a fleet of sessions.^[10]

The release history includes unreleased model-support changes. That is insufficient evidence for the previous article's categorical “maintenance mode” label. Check the installed version against the model and editing behavior you need instead of inferring a shutdown from release cadence.^[49]

OpenCode

OpenCode combines a terminal interface with a beta desktop app and provider choice. Its documented Build agent has editing access; Plan restricts edits and asks before shell actions. General-purpose subagents support additional exploration. The software is MIT-licensed, while the optional Go model subscription is currently $10/month; installing the client and buying hosted inference are different decisions.^[39][40]

Permissions deserve more attention than a simple “human approval” checkmark. The current documentation says most operations default to allow, with specific exceptions. Its auto mode approves actions configured to ask while retaining deny rules. Configure the actions and directories you intend to expose before using it on a sensitive repository; these application rules are not themselves an operating-system sandbox.^[50]

Crush

Crush is a terminal-centered option for developers who want provider choice, persistent sessions, MCP connections, and skills in one interface. Its repository documents permission controls as well as a mode that skips confirmation. Compare its interaction style on the actual tasks you perform rather than treating terminal presentation as evidence of model quality.^[23]

The licensing distinction matters: Crush is source available under FSL-1.1-MIT, with a restriction on competing use during the applicable two-year period before that version becomes MIT-licensed. It should not be grouped indiscriminately with permissively licensed clients. Charm's optional Hyper provider has a free credit allowance and a $20/month tier, alongside prepaid credits; these are inference offers, not the license price of the client.^[24][25]

Goose

Goose is a general-purpose local agent, including coding work, with desktop and CLI interfaces. The current repository places it under the Agentic AI Foundation and documents cloud providers, local-model options, MCP, and use of existing Claude, ChatGPT, or Gemini subscriptions through ACP integrations.^[32]

Its practical attraction is keeping a configurable agent close to local tools while retaining provider choice. The corresponding deployment question is what each selected provider and extension receives. “Runs locally” describes the agent process; using a remote model still introduces a remote inference path. An all-local evaluation therefore needs both a suitable model and an inventory of networked integrations, not just the Goose installer.

Pi

Pi takes a smaller-core approach: file reading, writing, editing, and shell execution, with TypeScript extensions and SDK/RPC integration. Sessions persist as a branching JSONL tree, so developers can revisit an earlier point or fork a conversation. Provider access includes API keys, supported subscriptions, and local-model options.^[44]

This flexibility comes with deliberate omissions. Pi does not ship built-in MCP, plan mode, subagents, or per-tool permission popups; extensions can implement additional workflows. Its project-trust mechanism governs loading project resources and code, which is a different boundary from approving every shell command. Choose Pi when owning that configuration is useful, not when you expect a preconfigured enterprise approval system.^[44]

Commercial Agents Across Local and Remote Work

Claude Code

Claude Code is Anthropic's commercial coding agent, available through terminal and editor workflows as well as desktop and web surfaces. A public repository does not make its software open source. Individual Pro pricing is $20/month on monthly billing, with higher-use plans and separately billed API options; allowance and organizational policy still determine what work a session can perform.^[15][51][17]

Its permission system is more specific than “asks before doing anything.” Manual, Plan, accept-edits, Auto, and bypass modes have different behavior. Rules are enforced by the harness rather than by instructions in CLAUDE.md; managed policies can restrict bypass or Auto use. This is useful for teams that want repeatable policy, but a written prompt is not an access-control rule.^[16]

Codex

Codex combines an open-source CLI with a commercial product family. The CLI can inspect and edit code, run commands, resume sessions, use skills and MCP, and delegate work. ChatGPT plans and API-key use have different entitlements; an API key for local CLI work does not automatically provide the hosted cloud product.^[20][21][22]

Codex documents sandboxing and approval policy as separate controls. Its standard local configuration restricts writes and network access, with requests for additional access handled through the selected approval mode. The practical comparison is whether that boundary fits the repository's test servers, dependency downloads, and browser workflow. A sandbox denial is a configuration question to investigate, not a reason to grant every process unrestricted access.^[52]

GitHub Copilot

GitHub Copilot now belongs firmly in an agent comparison. Its IDE feature matrix covers agent mode across several editors, and its CLI supplies interactive and scripted terminal use. The desktop app adds a session-management surface; the Actions-based cloud agent has a different execution environment. Evaluate the client you intend to deploy rather than assuming one “Copilot” capability label covers every surface.^[2][1][53]

The commercial entry is $10/month for Pro; Pro+ is $39 and Max $100. Business and Enterprise seats are $19 and $39/month. Agent usage consumes token-based AI credits, while cloud execution can add compute costs. That makes an existing subscription a useful starting point for an evaluation, but not an unlimited autonomous-work budget.^[30][31]

Amp

Amp is no longer well described as only a terminal assistant with a daily free allowance. Its current interfaces include CLI, apps, and cloud Orbs, with shared threads and tools. An Orb is a remote working environment for a thread; local/cloud synchronization provides a route between interactive local work and delegated execution.^[12][14]

Hobby access has pay-as-you-go or own-runner options; paid individual tiers start at $20 and include defined usage. Model and active environment consumption still matter. An especially consequential workflow detail: the default Orb Ship action rebases, validates, and pushes to the base branch. Teams requiring a pull request should configure the branch/PR workflow instead of assuming Ship means “open a draft PR.”^[13][54]

Factory / Droid

Factory's Droid supplies the same Factory runtime through a terminal interface with project context, approvals, MCP, and structured headless execution. It can delegate scoped work to Custom Droids, package procedures as skills, or use Missions for broader work. droid exec is the useful transition point when an interactive procedure becomes something to run from a script or CI job.^[26]

Individual paid plans start at $20/month, with larger tiers and usage windows. Missions require Extra Usage to be enabled while sharing the regular rolling rate limits. Budget for extended usage rather than assuming the entry subscription covers every orchestration workload. My reason to shortlist Droid is that continuity from supervised work to repeatable automation, provided the team's evaluation includes its additional usage costs.^[27]

Gemini CLI

Gemini CLI is Google's Apache-2.0 terminal agent. It supports repository instructions, tools, MCP, and noninteractive output, making it a relevant direct comparison with other lab-provided CLIs. Authentication is part of the product choice: the official quota guide lists 1,000 daily requests for the free Google-account route, with different limits and billing for paid plans and API/Vertex access.^[28][29]

Sandboxing is configurable rather than a universal property of every run. Documentation describes platform-specific controls, Docker/Podman, and optional Linux mechanisms. The default macOS Seatbelt profile allows broad reads and network access while restricting writes. Select and verify the intended profile; “sandbox enabled” alone does not answer which files or services an agent can access.^[55]

Grok Build

Grok Build is SpaceXAI's coding CLI, with a terminal interface, scripted output, and ACP integration for other clients. It defaults to Grok 4.6, but supports custom model endpoints. The Apache-2.0 source can be inspected and built locally; the repository does not accept external contributions. This is a configurable client, not evidence that its default hosted inference keeps repository context on the developer's machine.^[6][33]

Worktrees make it useful to evaluate for parallel repository tasks: sessions can start from the current checkout, including uncommitted changes, or an explicit clean Git ref. Subagents can request separate worktrees. These are real checkouts that persist after sessions end, and changes return through ordinary Git operations. Budget for reconciliation and cleanup; separate branches do not establish process isolation.^[34]

Two defaults change the evaluation. Plan mode gates editing tools, but shell commands can still write, and subagents do not inherit that edit gate. Separately, the OS sandbox is off by default. Its strict/read-only child-network restrictions apply on Linux but are a no-op on macOS; in-process model and web-tool traffic is outside those restrictions. Test the exact permissions, operating system, and profile you intend to use.^[35][36]

For API-funded Grok 4.6 work, published global rates are $2 input, $0.50 cached input, and $6 output per million tokens below 200,000 prompt tokens. At 200,000 or more, those rates double for the request. That token bill differs from subscription entitlements and the web/mobile builder, whose August release announced availability on every plan with varying limits. Count the CLI once here; evaluate the app builder's publishing workflow separately.^[56][7]

Editor Integrations and Local Control Planes

Cline

Cline now spans VS Code, CLI, native macOS/Windows desktop, and JetBrains. The core repository is Apache-2.0, while the JetBrains plugin is explicitly not open source. Plan/Act workflows, rules, skills, MCP, and provider choice are useful reasons to evaluate it alongside a developer's current editor; configurable auto-approval means it should not be described as requiring a person to approve every action in all modes.^[18]

The individual client is free to use with inference paid separately. The optional Cline Pass is $9.99/month, with five-hour, weekly, and monthly limits; it is distinct from general BYOK access. Enterprise offerings add commercial controls. Check which features are actually shipped: the pricing page still marks some finer-grained administrative capabilities as coming soon.^[19][57]

Kilo

Kilo provides VS Code and JetBrains integrations, a CLI derived from OpenCode, and cloud-agent products. Its modes cover planning, implementation, debugging, and review, with additional customization and MCP. Anaconda's acquisition announcement supersedes the old article's speculation about a time-limited GitLab right of first refusal.^[37][58]

Cost has three parts: platform access, inference, and cloud compute. Individual software access is free; Teams is $15/user/month. The gateway advertises provider-price inference without markup, but credit purchases incur a 5% processing fee. Cloud environments are metered separately. This is a concrete reason to compare an expected task's full bill rather than repeating “pass-through pricing” as equivalent to no additional charges.^[38]

OpenHands

OpenHands now presents Agent Canvas, in beta, as a self-hosted control center. Its current repository documents OpenHands, Claude, Codex, Gemini, and ACP-connected agents, with local, remote, and cloud backends. The architecture separates the GUI, Agent Server, and Automation Server, and the project maintains separate SDK components.^[41]

That makes it more adaptable than the old description of one fixed Dockerized agent. It also makes configuration consequential: the documented no-sandbox launch has full filesystem access, while the Docker route introduces a container boundary and explicit project mounts. The MIT repository and free local software are distinct from OpenHands Cloud, whose current individual offering separates platform access from provider inference. Treat the beta control center as something to evaluate and operate, not evidence of production reliability by itself.^[41][42][43]

Refact

Refact has a material identity change. The former hosted project's repository directs users to the community continuation and states that Refact Cloud is retired. The April 30 shutdown announcement described the withdrawal of managed accounts, billing, and cloud features while retaining local/BYOK use; it did not mean every Refact component disappeared.^[5][59]

The current BSD-3-Clause engine uses a resident daemon and project workers, with terminal, browser, and editor clients. It documents project-scoped memory, MCP, configurable modes, and task agents in Git worktrees. This fits developers willing to own a local control plane and model configuration. Do not carry forward the old hosted enterprise buying recommendation: current community availability is not a replacement commercial support contract.^[4][46]

Sweep

Sweep is a JetBrains-focused combination of completion and coding-agent interaction. Its current pricing page lists a free allowance and Basic, Pro, and Ultra plans at $10, $20, and $60/month. Completion allowances and agent credits are separate, so “unlimited autocomplete” should not become “unlimited agent work.”^[47][48]

There is a specific maintenance signal worth checking: the JetBrains Marketplace updates API returned version 1.29.3, dated February 5, 2026, as the latest release when reviewed September 16. That is relevant to IDE compatibility and support evaluation. It does not, by itself, establish that the company has closed or that the existing plugin is unusable.^[60]

Permissions, Context, and Deployment: The Differences That Matter

A feature matrix full of “yes” cells hides the consequential details. Use these questions during a trial:

MCP connectivity is useful, but the important procurement questions are which tools are exposed, with whose credentials, and whether the intended client enforces the team's policy. For example, Copilot CLI documents policy differences from other Copilot surfaces. “Our vendor supports MCP governance” is not enough detail to approve an unexamined client configuration.^[1]

Where Tembo Fits

Choosing an assistant and choosing where a team operates it are related decisions. Tembo runs agents including Claude Code, Codex, OpenCode, Pi, and Amp in shared cloud environments, with a self-hosted platform option. Its current product describes live sessions that can pause, resume, be shared, or hand work to background execution, while retaining existing agent configuration and repository instructions.^[8][61]

A concrete use case is a dependency migration that starts as an interactive investigation and then becomes a series of repository tasks. The team can use its selected assistant, carry the instructions into the hosted environment, inspect execution, and review resulting PRs. Tembo also documents triggers through tools such as Slack, Linear, GitHub, schedules, and webhooks. That makes it worth evaluating when local sessions become recurring team operations.^[61]

Tembo's current product page also lists Grok Build as a harness. The detailed agent-configuration page does not yet provide a corresponding Grok Build entry, so verify authentication, model billing, and feature support for the intended deployment before assuming every local CLI capability carries over.^[8][62]

Compare that platform choice against each assistant's own cloud option using the same repository setup, allowed credentials, reviewer workflow, and accepted-change cost. An agent dropdown is not proof of identical model access, performance, or policy enforcement across harnesses. The cloud-platform comparison handles those purchasing and deployment questions in more detail.

Disclosure: Ry Walker is Tembo's co-founder and CEO. Tembo is adjacent execution infrastructure in this assistant comparison, not a separately counted assistant.

What Published Experience Actually Shows

Evidence does not support one universal productivity multiplier. METR's February 24, 2026 update explains why its follow-up to the early-2025 developer study became difficult to interpret: developers and tasks selected into participation differently, and parallel work complicated time measurement. Its earlier slowdown result should not be presented as the measured effect of every September 2026 assistant; the follow-up also does not establish a clean new category-wide speedup.^[63]

METR's May 11 survey offers a different kind of evidence. Across 349 technical-worker respondents, median self-reported value gains were 1.4–2× and speed gains 3×. These are perceptions from a convenience sample, including only 87 software engineers, with low email response rates and acknowledged selection bias. They are useful evidence of how respondents experience AI, not a controlled ranking of these 17 products.^[64]

For an operational example, Microsoft's Stephen Toub described 878 Copilot agent PRs in dotnet/runtime, of which 535 were merged, over May 2025–March 2026. His account stresses environment setup and describes tests that overfit changes or encode existing bugs. This is first-hand experience from an affiliated engineer on selected tasks, not an independent success-rate benchmark for Copilot's current local clients.^[65]

The actionable lesson is to measure useful accepted changes and review effort on your own repository. Model-written tests, a confident completion message, and a large generated diff are all things to inspect rather than substitutes for acceptance criteria.

A Practical Evaluation and Buying Guide

Use a small set of representative tasks with the same starting revision and requirements:

1. A bounded regression: provide a reproducible input and expected output; require a test that fails on the original behavior and passes after the fix.
2. A cross-file change: choose a real API or dependency migration; inspect missed callers, compatibility, and unnecessary edits.
3. An investigation: ask for an explanation of a repository behavior with file references before authorizing changes. Check whether the answer points to the relevant code.
4. An unattended task, if needed: provide the real setup command, test services, network policy, and review destination. Measure setup failures and interventions separately from coding failures.

Record model and client versions, configuration, elapsed time, human review time, failed attempts, provider usage, compute, and whether the result was accepted. Include follow-up corrections: a fast first draft can still be expensive to finish. This is a proposed evaluation procedure, not a test performed for this article.

For an individual developer, begin with the interface and allowance already available, then compare an alternative on the same task. For a team, add administrative policy, integration credentials, repeatable environments, and ownership of unattended jobs. For a customizable internal tool, inspect the software license and extension boundary before assuming an open repository grants the rights or controls you require.

The cost model is subscription or seats + model usage + remote compute + integration costs + operating and review time. Kilo's gateway fee, Amp's environment consumption, Copilot's credits, and Factory's extra Mission usage illustrate why matching monthly sticker prices is not enough.^{[38][13][31][27]}

Departed Projects and Adjacent Options

Continue is now explicitly archived and no longer actively maintained. Its final 2.0.0 releases cover VS Code, CLI, and JetBrains and remove anonymous telemetry. Existing software remains available under Apache-2.0, but it should not be recommended as an actively developed commercial CI-agent platform on the strength of an older profile.^[3]

Roo Code states that its extension shut down on May 15. The current repository directs users to the community ZooCode continuation or Cline. Preserve the historical profile and migration context; don't count the discontinued original alongside currently offered assistants.^[66]

Background Agents belongs to the adjacent question of operating agents asynchronously. Likewise, agentic skills frameworks package procedures and local agent sandboxes address execution containment. These layers can complement an assistant without being interchangeable with it.

Outlook

The observable change is convergence across interfaces: commercial assistants increasingly offer local and remote work, while configurable local projects add planning, memory, and orchestration. Amp's Orbs, Droid's headless workflow, and OpenHands' multi-harness Canvas are concrete examples, with different maturity and operating models.^[14][26][41]

I expect environment reproducibility, human review, and shared operating policy to matter increasingly as teams delegate more work. That is an editorial expectation, not a dated market-share forecast. Choose the assistant that produces reviewable, accepted changes in your workflow—and evaluate the execution platform separately when the work needs to outlive one developer's local session.