# Beyond the Big Three: OpenCode, Pi, Copilot CLI, Cline, Goose and Other Coding Agents

URL: https://developertoolkit.ai/en/ecosystem/agent-tools/other-coding-agents/
Description: Install lines, status and licences for ten widely used coding agents beyond Claude Code, Codex and Cursor, and a mixed-agent team on one rules file.

Ten maintained coding agents outside Claude Code, Codex and Cursor are worth a look in September 2026: OpenCode, Pi, GitHub Copilot CLI, Cline, Kilo Code, Goose, Qwen Code, Crush, Amp and Factory Droid. Most read `AGENTS.md`, so one rules file, one multiplexer and one CI gate can run a mixed team once licences are cleared.

Your team standardised on Claude Code, but one engineer works mostly in OpenCode, the platform group already pays for GitHub Copilot, and a contractor sends pull requests written with Cline. Each agent reads a different instructions file, so the same repo gets four versions of "how we run tests". The drift only shows up when a pull request ignores a rule nobody knew was missing. This page is for the developer choosing a second agent and the tech lead who has to keep a mixed team consistent.

## What you get from this catalogue of other coding agents

- A status table for ten live agents and four you should stop recommending, with dated popularity figures
- A verified install line and one headless command for each agent
- The licence facts that decide whether legal has to sign off (Copilot CLI is proprietary, Crush is source-available)
- A mixed-agent workflow: one `AGENTS.md`, one herdr session, one CI gate, and a reviewer that is never the builder
- Two copy-paste prompts: a read-only audit and a cross-agent review

## Which coding agents are worth a look in September 2026?

Every agent in this catalogue does [agentic coding](/en/glossary/agentic-coding/): it plans a change, writes the code, runs it and iterates. GitHub stars below were read through the GitHub API on 2026-09-26 and recorded in the site's agent-tools research dossier. Stars measure attention, not daily use; download counts are omitted because the npm and PyPI statistics hosts were unreachable.

| Agent | Shape | Licence | Stars (2026-09-26) | Status | Reach for it when… |
| --- | --- | --- | --- | --- | --- |
| **OpenCode** (`anomalyco/opencode`) | Terminal agent, desktop app | MIT | 210,085 | Alive | you want an open-source terminal agent that works with any model provider |
| **Pi** (`earendil-works/pi`) | Terminal agent | MIT (npm licence field) | 109,402 | Alive | you want a minimal, hackable terminal agent that herdr, Orca, Sculptor and CC Switch support |
| **GitHub Copilot CLI** (`github/copilot-cli`) | Terminal agent | Proprietary GitHub licence | 11,211 (repository holds docs and issues only) | Alive, frequent releases | your org already pays for Copilot and wants existing Copilot policies to apply |
| **Cline** (`cline/cline`) | VS Code and JetBrains extension, CLI, desktop, SDK | Apache-2.0 | 69,340 | Alive | you want approvals in the IDE and the same config in CI |
| **Kilo Code** (`Kilo-Org/kilocode`) | VS Code and JetBrains extension, `kilo` CLI (an OpenCode fork) | MIT | 27,419 | Alive | you want built-in Code, Plan, Ask and Debug agents and a marketplace |
| **Goose** (`aaif-goose/goose`) | Desktop app, CLI, API | Apache-2.0, Linux Foundation AAIF project | 54,661 | Alive | you want a foundation-governed, vendor-neutral agent that also handles non-code tasks |
| **Qwen Code** (`QwenLM/qwen-code`) | Terminal agent, desktop, web UI, IDE plugins, SDKs | Apache-2.0 | 28,137 | Alive | you run Qwen models, hosted or local, in a Claude-Code-shaped harness |
| **Crush** (`charmbracelet/crush`) | Terminal agent | FSL-1.1-MIT (source-available) | 28,307 | Alive | you want an LSP-aware terminal agent with mid-session model switching |
| **Amp** (`@ampcode/cli`) | Terminal agent with subagents and an "Oracle" | Proprietary vendor product | no public metric | Alive | you want a second-opinion reasoning model built into the loop |
| **Factory Droid** (`@factory/cli`) | Terminal agent with a headless `droid exec` | Proprietary vendor product (npm licence field `UNLICENSED`) | no public metric | Alive | you want a vendor multi-agent "mission" mode in CI |

Four names still appear in older articles and should not be recommended to a team today:

| Agent | What happened | Evidence |
| --- | --- | --- |
| **Roo Code** | Shut down on 15 May 2026 and archived; its README points to Cline and the ZooCode fork | `RooCodeInc/Roo-Code` README, GitHub API `archived: true` |
| **Continue** (`cn` CLI) | README: "no longer actively maintained and is read-only for all users"; last npm release 2026-06-18. GitHub still shows it as not archived, with 36,030 stars | `continuedev/continue` README, npm |
| **Aider** | Slowing: last push 2026-05-22, last PyPI release (`aider-chat` 0.86.2) 2026-02-12, README still recommends models from early 2025. Usable, not a default | GitHub API, PyPI |
| **Gemini CLI on a personal Google account** | Since 2026-06-18, Gemini CLI no longer serves free, Google AI Pro or Ultra users; those tiers moved to the closed-source **Antigravity CLI** (`agy`). Gemini CLI itself is alive (npm `@google/gemini-cli` 0.63.0, 2026-10-06; read 2026-10-12) for Gemini Code Assist Standard or Enterprise, Google Cloud and paid API keys | `google-gemini/gemini-cli` Discussion #27274 (2026-05-19); npm |

**The Gemini CLI README is out of date**

The Gemini CLI README still advertises a free tier for personal Google accounts. The maintainers' own announcement (Discussion #27274) contradicts it. Write "Antigravity CLI (personal accounts) / Gemini CLI (enterprise, Google Cloud, paid API key)" when you document Google's agents for your team. Third-party READMEs and search snippets of Google's migration page quote this Antigravity CLI install line: `curl -fsSL https://antigravity.google/cli/install.sh | bash` (binary `agy`). Treat it as a secondary source. `antigravity.google` could not be reached from the research environment on 2026-09-26. On 2026-10-12 its site navigation lists a CLI next to Antigravity 2.0, the IDE, extensions and an SDK, which confirms that the CLI exists but not this install line, so confirm the line on Google's page before you put it in a team runbook. herdr accepts `agy` as a `--kind`, so it fits the multiplexer workflow below. See [Gemini CLI, Jules and Antigravity](/en/comparison/gemini-cli/) for the full picture.

## How do you install each agent?

Every install line below was read from the project's README or docs on 2026-09-26 (Droid: from search results, see its tab); versions come from `npm view` the same day, except those of OpenCode, Copilot CLI, Cline, Kilo Code, Qwen Code and Droid, which were re-read from the package registries and GitHub releases on 2026-10-12. Pick one install route per machine, not all of them.

**OpenCode**

    ```bash
    curl -fsSL https://opencode.ai/install | bash
    # or
    npm i -g opencode-ai@latest              # 1.19.0
    brew install anomalyco/tap/opencode
    ```

    `Tab` switches between the **build** agent (full access) and the read-only **plan** agent; `@general` calls the general subagent. Headless: `opencode run "Explain how the auth middleware works"`. The original Go project `opencode-ai/opencode` is archived; the live one is `anomalyco/opencode`. See [OpenCode compared with the big three](/en/comparison/opencode/).

**Pi**

    ```bash
    npm install -g --ignore-scripts @earendil-works/pi-coding-agent  # 0.87.1, binary `pi`, Node 22.19+
    ```

    `pi` in the project starts a session. Pi is a small terminal agent in its own right and a supported harness in herdr (`--kind pi`), Orca, Sculptor and CC Switch. `--ignore-scripts` is part of the README's install line: it stops npm from running the package's lifecycle scripts.

**Copilot CLI**

    ```bash
    npm install -g @github/copilot           # 1.0.96, binary `copilot`
    # or
    brew install copilot-cli
    winget install GitHub.Copilot            # Windows
    ```

    Run `copilot` in a repository and use `/login` on first start, or set a fine-grained token with the "Copilot Requests" permission in `GH_TOKEN`. It ships GitHub's MCP server by default. Headless: `copilot -p "Fix the failing test in tests/auth.spec.ts" --allow-tool 'shell(npm run test:*)'` (glob patterns in `--allow-tool` are documented in the Copilot CLI changelog). `/delegate` hands the task to the Copilot cloud agent as a pull request. Every Copilot plan includes the CLI; billing is usage-based since 2026-06-01. From CLI 1.0.94-0, `/model` also discovers models from a running local Ollama instance (the models need tool calling and streaming; this is not an offline mode), and local sandboxing became generally available in the CLI on 2026-10-07 (GitHub changelog, read 2026-10-12). See [GitHub Copilot for agentic teams](/en/comparison/github-copilot/).

**Cline**

    ```bash
    npm install -g cline                     # 3.0.70
    cline auth                               # interactive sign-in or API key setup
    cline --auto-approve false "Audit this package and propose fixes"
    ```

    The one-shot form `cline "…"` runs a single turn and exits, and it **auto-approves every tool call by default** (Cline CLI README, 3.0.65), so add `--auto-approve false` whenever the run must not edit files. `cline` alone opens the TUI with a plan/act toggle. `cline --json "…"` streams NDJSON events, and `git diff origin/main | cline --auto-approve false "Review these changes for issues"` reviews piped input. Rules live in `.clinerules/`; Cline also picks up `AGENTS.md`, `.cursorrules` and `.windsurfrules` (Cline rules docs). In a mixed team keep rules in `AGENTS.md` only; the CI check in step 4 below rejects `.clinerules/`.

**Kilo Code**

    ```bash
    npm install -g @kilocode/cli             # 7.8.8, binaries `kilo` and `kilocode`
    # or
    brew install Kilo-Org/tap/kilo
    ```

    `kilo` starts an interactive session. The README's CI form is `kilo run --auto "run tests and fix any failures"`; `--auto` approves every permission prompt that no rule explicitly denies, so run that form only inside a disposable, network-restricted sandbox (see the caution below). Kilo's AGENTS.md docs page (`packages/kilo-docs/pages/customize/agents-md.md` in the Kilo repository, checked 2026-09-26) marks the memory bank as deprecated in favour of `AGENTS.md`; existing memory-bank rules keep working.

**Goose**

    ```bash
    curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash
    goose configure                          # pick provider and model
    goose session -n payments-refactor       # interactive, named session
    goose run -t "List the modules without tests"   # headless
    ```

    The repository moved from `block/goose` to `aaif-goose/goose` under the Linux Foundation's Agentic AI Foundation. Goose reads `AGENTS.md` and then `.goosehints` by default.

**Qwen Code**

    ```bash
    npm install -g @qwen-code/qwen-code@latest   # 0.25.1, binary `qwen`, Node 22+
    # or
    brew install qwen-code
    ```

    `qwen` in the project, then `/auth` to choose a provider. Headless: `qwen -p "Summarize the repository layout."`. Its native file is `QWEN.md`, but it reads an existing `AGENTS.md` too. Qwen Code forked Gemini CLI v0.8.2 and stopped syncing with upstream from Qwen Code v0.1: it is a diverged fork, not Gemini CLI's successor.

**Crush**

    ```bash
    brew install charmbracelet/tap/crush
    # or
    npm install -g @charmland/crush          # 0.96.1
    go install github.com/charmbracelet/crush@latest
    ```

    `crush` starts a session and `ctrl+l` opens the model picker. Project initialization writes `AGENTS.md` by default. Crush records pseudonymous usage metrics by default; set `CRUSH_DISABLE_METRICS=1` or `DO_NOT_TRACK=1` to opt out.

**Amp**

    ```bash
    npm install -g @ampcode/cli              # binary `amp`
    amp -x "Find every place we parse dates without a timezone"
    ```

    `amp -x` is execute mode; `amp threads continue -x "…"` continues a thread. Prompts can ask Amp to "Spawn subagents to: …" or to "Use Amp Oracle to …". `@sourcegraph/amp` still publishes the same versions, but `@ampcode/cli` is the current name. Amp's pricing page lists a free Hobby tier (pay as you go, or your own runners with your own subscriptions or keys: "No Amp token fees or limits") and a Megawatt tier at $20 a month for individuals (ampcode.com/pricing, checked 2026-10-12). Since 2026-10-10, Amp's news post says you can use a Claude Pro or Max subscription in Amp through **Mode > Claude Code**, which uses the Claude Agent SDK (ampcode.com/news/use-your-claude-plan, checked 2026-10-12).

**Droid**

    ```bash
    npm install -g @factory/cli              # 0.239.0, binary `droid`
    droid
    ```

    According to Factory's documentation (`docs.factory.ai` redirects to docs.factory.com; read 2026-10-13), `droid exec` runs headless and is read-only by default; `--auto low`, `--auto medium` and `--auto high` enable edits and commands at rising risk tiers, and `--skip-permissions-unsafe` skips every permission prompt (it cannot be combined with `--auto`, and command blocks still apply). `droid exec --mission` runs Mission Mode, a multi-agent orchestration with worker and validator agents, and Factory says it "requires `--auto high` or `--skip-permissions-unsafe` because the orchestrator needs high autonomy to manage workers". Run `--auto high` and `--skip-permissions-unsafe` only inside a disposable, network-restricted sandbox (see the caution below), and check `droid exec --help` before you script it. Factory's site has since moved to factory.com (`factory.ai/pricing` redirects there, checked 2026-10-12). Factory's pricing page lists Pro at $20, Plus at $100 and Max at $200 a month, and Teams at $60 a month per team plus $40 a month per seat (factory.com/pricing, checked 2026-10-12).

**Every skip-approvals flag belongs in a disposable sandbox**

`cline --yolo`, `kilo run --auto`, `copilot --allow-all-tools`, `crush --yolo` and Droid's `--skip-permissions-unsafe` all remove the human from tool approval. Use them only in a throwaway, network-restricted container or VM with no production credentials, never on your laptop against a real checkout. See [permissions and sandboxing](/en/workflows/harness/permissions-and-sandboxing/) and [agent sandboxes compared](/en/ecosystem/agent-tools/sandboxes/).

## Try one agent on a real task without letting it write

The fastest honest evaluation is a read-only audit of a package you know well: you can judge the findings without reading a diff, because you already know where its real defects are. Cline's CLI makes this a one-liner.

```bash
cd packages/billing
cline --auto-approve false "Audit this package and propose fixes"
```

Without `--auto-approve false`, the one-shot turn approves every tool call. For a stricter start, `cline --plan --auto-approve false "…"` opens the run in plan mode (Cline CLI README, 3.0.65). `--auto-approve false` makes the CLI prompt you in the terminal before each tool call: approve the reads, decline any edit or command that writes. Expect a list of findings with file references and suggested changes. Score it against what you already know: which real problems did it find, which did it miss, and which findings are false.

**Copy-paste prompt: read-only package audit for a new agent**

```text
Audit this package without modifying any file. Read the source, the tests and
AGENTS.md first. Report, in this order:
1. Bugs you can point to with a file and line, each with the input that triggers it.
2. Code paths with no test that exercises them, with the test you would add.
3. Places that contradict a rule in AGENTS.md.
For every finding give a confidence (high/medium/low) and the command I can run
to confirm it (a test invocation, a grep, a type check). Do not propose style
changes. End with the three findings you would fix first and why.
```

Run the same prompt in your current agent and compare. The same pattern works headless in each tool: `opencode run "…"`, `qwen -p "…"`, `goose run -t "…"`, `amp -x "…"`, or `copilot -p "…"` without `--allow-all-tools`.

## How do you run a mixed-agent team under one rules source and one multiplexer?

The failure you are preventing is drift: five instruction files that each say something slightly different about how to test, which directories are off limits, and what "done" means. The fix is one source of truth that every agent reads, one place where you watch all of them, and one gate that treats their output identically.

1. **Write one `AGENTS.md` at the repository root.** Put build, test and lint commands, the directories agents must not touch, and your definition of done in it. Keep it short: every agent loads it at the start of every session, so every line costs context in every run.

   ```markdown
   # AGENTS.md
   ## Commands
   - Install: pnpm install --frozen-lockfile
   - Test: pnpm test (must pass before you say you are done)
   - Types: pnpm typecheck
   ## Boundaries
   - Never edit migrations/ or .github/workflows/
   - Never add a dependency without saying why in the PR description
   ## Done means
   - Tests and typecheck pass, and the PR description lists the commands you ran
   ```

2. **Point every agent at it, and delete the duplicates.** OpenCode, Kilo Code, Cline, Goose, Qwen Code and Crush read `AGENTS.md` (checked in each project's docs on 2026-09-26; for Kilo, its AGENTS.md docs page), and the Copilot CLI changelog documents `@`-import expansion in `AGENTS.md`. For Amp and Droid, confirm which file they read in the vendor's docs; this page has not verified it. The big three differ:

     **Claude Code**

       Claude Code reads `CLAUDE.md`. From v2.1.277 (both release channels on 2026-10-12), it falls back to `AGENTS.md` only when the project has no `CLAUDE.md`. Bedrock, Google Cloud, Foundry, gateway and telemetry-off sessions get that fallback from v2.1.281, and you can toggle it under "Project instructions" in `/config`. A repo with both files gets only `CLAUDE.md`. The version-proof setup is a `CLAUDE.md` whose first line imports the shared file:

       ```markdown
       @AGENTS.md

       <!-- Claude-Code-only notes go below this line, and nothing else. -->
       ```

     **Codex**

       `AGENTS.md` is Codex's native file, so no extra step is needed. One gotcha: since Codex 0.150.0, an untrusted project does not supply its project-level `AGENTS.md`, so trust the repository when Codex first asks. In CI there is no trust prompt, so the reviewer prompt in step 5 names `AGENTS.md` explicitly and Codex reads it as a file.

     **Cursor**

       Cursor reads its own Rules. To keep one source, let rulesync generate all three files. After that, `.rulesync/rules/overview.md` is the only file you edit. Run the import before you shorten `CLAUDE.md` to an `@AGENTS.md` line: it copies today's rules into `.rulesync/rules/`, and it needs the real rules to copy (observed with rulesync 20.0.0):

       ```bash
       npx rulesync@20.0.0 import --targets claudecode        # run while CLAUDE.md still holds the real rules
       npx rulesync@20.0.0 generate --targets claudecode,codexcli,cursor --features rules
       # writes CLAUDE.md, AGENTS.md and .cursor/rules/overview.mdc
       ```

       On this path, `CLAUDE.md` is a generated file, not an `@AGENTS.md` stub, so skip the Claude Code tab's import line. The other six agents then read the generated `AGENTS.md`. If you use the `@AGENTS.md` stub path instead, Cursor reads `AGENTS.md` in the project root and in subdirectories, and reads `CLAUDE.md` the same way (Cursor docs, checked 2026-10-12); use rulesync when you also want scoped Cursor Rules (`.cursor/rules/*.mdc`). See [rules sync with Ruler and rulesync](/en/ecosystem/frameworks/rules-sync/).

3. **Put the whole team in one multiplexer.** herdr's `--kind` accepts `claude`, `codex`, `cursor`, `pi`, `opencode`, `copilot`, `cline`, `kilo`, `qwen`, `amp` and `droid` among its 24 values (docs for herdr 0.9.1); Goose and Crush run as plain panes. From inside a running `herdr` session:

   ```bash
   split=$(herdr pane split --current --direction right --no-focus)
   pane=$(printf '%s\n' "$split" | jq -r '.result.pane.pane_id')
   herdr agent start reviewer --kind codex --pane "$pane"
   herdr agent prompt reviewer "Review the current diff against AGENTS.md" --wait --timeout 120000
   herdr agent read reviewer --source recent-unwrapped --lines 120
   ```

   The sidebar marks each pane `working`, `blocked` or `idle`, whichever vendor runs in it. The [herdr guide](/en/ecosystem/agent-tools/herdr-agent-multiplexer/) covers the full orchestrator script.

4. **Gate every agent's output the same way.** Add one job that fails the pull request when a second instructions file reappears, next to your usual tests, types and lint:

   ```bash
   # ci/check-agent-rules.sh — one rules source, no shadow copies
   set -euo pipefail
   [ -f CLAUDE.md ] || { echo "CLAUDE.md missing: create it with @AGENTS.md as line 1"; exit 1; }
   head -n 1 CLAUDE.md | grep -qx '@AGENTS.md' || { echo "CLAUDE.md must start with @AGENTS.md"; exit 1; }
   for f in QWEN.md CRUSH.md .goosehints .clinerules .cursorrules .windsurfrules; do
     if [ -e "$f" ]; then echo "$f duplicates AGENTS.md; move its rules there"; exit 1; fi
   done
   ```

   If you chose rulesync in step 2, replace the whole script with `npx rulesync@20.0.0 generate --targets claudecode,codexcli,cursor --features rules && git diff --exit-code`. That drift check is this site's suggestion, not a documented rulesync feature. On `pull_request` GitHub runs the workflow, and this script, from the pull request's merge ref, so an agent's pull request could edit the check itself: put `ci/` and `.github/` under `CODEOWNERS` with required review, or the job only reports.

5. **Never let the builder review its own work.** Route each branch to a reviewer from a different vendor: a Claude Code branch goes to Codex, a Cline or OpenCode branch goes to Claude Code. A different model does not share the builder's blind spots. Run the reviewer read-only and let it judge the test and typecheck results CI already produced: plan mode and a read-only sandbox are not meant to run your test suite, and a reviewer that cannot write cannot "fix" a test to make it pass.

   ```bash
   # Codex reviews a branch another agent built, without write access
   codex exec -s read-only "Review the diff between origin/main and HEAD against AGENTS.md. List blocking issues first."
   # Claude Code as the reviewer, in plan mode (no edits)
   git diff origin/main...HEAD | claude -p --permission-mode plan "Review the diff between origin/main and HEAD against AGENTS.md. List blocking issues first."
   ```

**Copy-paste prompt: cross-agent review with evidence**

```text
You are reviewing a branch that a different coding agent wrote. Do not edit files.
1. Read the diff (git diff origin/main...HEAD, or the diff piped in below), then
   read every changed file in full.
2. Check the change against AGENTS.md: commands, boundaries, definition of done.
3. Read the CI test and typecheck results for this branch (or the output pasted
   below) and quote the failing lines. Do not run them yourself.
4. List blocking issues (wrong behaviour, missing test for a changed path, a
   boundary violation) before non-blocking ones. For each, give file:line and the
   input or command that demonstrates it.
5. Finish with APPROVE or REQUEST CHANGES and one sentence of reasoning.
Never approve a change whose CI results are missing or red.
```

## How do you prove a second agent is good enough for your repo?

Stars and vendor-reported benchmarks, such as the SWE-bench table in Qwen Code's README, do not show how an agent behaves on your codebase. Run a small bake-off and let the gate decide, not your impression of the transcript.

1. **Pick five closed tickets** with merged fixes and tests. Revert the fix on a branch per ticket, keeping the tests.
2. **Give each agent the same ticket text** and the same `AGENTS.md`, one worktree per agent per ticket.
3. **Score only what a machine can check:** did the original tests pass, did typecheck and lint pass, did the cross-agent reviewer flag a blocking issue, and how many files changed beyond the ones the real fix touched.
4. **Record the cost** each agent reports, or use a usage tracker (see [tracking agent cost](/en/ecosystem/observability/agent-cost-tracking/)).
5. **Decide with the tech lead.** A new agent joins the team's approved list only if it matches the incumbent on passes and stays inside the boundaries. The tech lead signs off, and the result goes in the repo's `docs/` so the next evaluation starts from data.

## Licences to clear before an agent joins the team

| Agent | What the licence means for you |
| --- | --- |
| Copilot CLI | Proprietary GitHub licence that allows redistributing unmodified copies only. The public repository holds the README, changelog and issues, not the source. Usage runs under your Copilot plan and org policies |
| Crush | FSL-1.1-MIT: source-available today, converts to MIT later. Not OSI open source, so check whether your policy accepts it |
| Amp, Factory Droid | Proprietary vendor products with no public source: review data handling and terms like any SaaS |
| Antigravity CLI | Closed-source, Google-operated. Antigravity has a $0 Individual plan with unlimited Tab completions and Command requests and basic weekly rate limits; Google AI Pro ($20 a month) and Ultra ($100 or $200 a month) add quota (Antigravity pricing page and plans post, checked 2026-10-12) |
| OpenCode, Kilo Code | MIT |
| Cline, Goose, Qwen Code | Apache-2.0 |

Licence is not the only question. Every agent that talks to a hosted model sends your code to that provider, so the provider you configure matters as much as the agent. For local models, see [gateways and local models](/en/ecosystem/agent-tools/gateways-local-models/).

## Where mixed-agent teams go wrong

**Traps**

- **Qwen Code is not Gemini CLI's successor.** It is a diverged fork, and Gemini CLI is alive (npm `@google/gemini-cli` 0.63.0, read 2026-10-12).
- **The Copilot CLI README's default model is stale.** The changelog records later default-model migrations, so do not quote a default model from the README; check `/model`.
- **Bundled MCP servers cost context in every session.** Copilot CLI ships GitHub's MCP server by default, and each enabled server puts its tool schemas into every session's context. Disable the servers you do not use; see [reducing MCP token cost](/en/ecosystem/mcp/reducing-mcp-token-cost/).

**Two agents follow two different rules.** Someone ran `/init` in Qwen Code, or used a Crush setup with `option initialize-as CRUSH.md` in its config (Crush README), and a new `QWEN.md` or `CRUSH.md` appeared with its own test command. Recovery: merge its content into `AGENTS.md`, delete the copy, and let the CI check from step 4 stop it from coming back.

**Claude Code ignores `AGENTS.md`.** The repo has both files, or developers run a Claude Code build older than v2.1.277, which predates the fallback. Recovery: make `@AGENTS.md` the first line of `CLAUDE.md`, which works on every version.

**A tutorial installs the wrong package.** `opencode-ai/opencode` is archived, `@sourcegraph/amp` is the old Amp name (now `@ampcode/cli`), `block/goose` moved to `aaif-goose/goose`, and `npm i -g aider-chat` does not exist because Aider is Python (`python -m pip install aider-install && aider-install`). Recovery: use this page's install commands, read from each README or docs page on 2026-09-26.

**The team adopted a dead project.** Roo Code is archived and Continue is read-only, yet both still rank high on stars. Recovery: before adding an agent, check its last push date and README status, not its stars. Move Roo Code users to Cline or Kilo Code, which cover the same VS Code niche.

**A personal Gemini CLI setup stopped working in June.** That is the 2026-06-18 cut-off, not a bug. Recovery: personal accounts move to Antigravity CLI; teams on Code Assist Standard or Enterprise, Google Cloud or a paid API key can stay on Gemini CLI.

**A skip-approvals run changed something it should not have.** Recovery: restore from the branch, rerun inside a disposable sandbox, and add the violated path to the Boundaries section of `AGENTS.md` so the next agent reads it too.

**The multiplexer says `idle` while an agent waits for you.** herdr reads Claude Code, Codex and Cursor from the screen, not lifecycle hooks (herdr 0.9.1 docs), and only marks `blocked` on prompt shapes it knows. Recovery: use `herdr agent wait … --until blocked --timeout …` in scripts and treat long silences as suspicious.

## Where to go next with other coding agents

- [The coding-agent landscape](/en/comparison/agent-landscape/) — Where every agent sits and how to run a bake-off across them
- [Rules sync with Ruler and rulesync](/en/ecosystem/frameworks/rules-sync/) — Generate every agent's instructions file from one source
- [herdr: the agent multiplexer](/en/ecosystem/agent-tools/herdr-agent-multiplexer/) — State detection and a scriptable API for a mixed fleet
- [Headless agents in CI](/en/ecosystem/agent-tools/headless-agents-ci/) — claude -p, codex exec and the SDKs as a pull-request gate
- [Reviewing agent pull requests](/en/workflows/ship/agent-pr-review/) — The review standard every agent's output has to pass
- [Agent tools overview](/en/ecosystem/agent-tools/) — Shells, multiplexers, orchestrators, sandboxes and bots
