Split View: AI CLI 코딩 도구 정면 비교 2026 — Claude Code · Junie · Cline · Aider · Codex CLI · Cursor CLI · Continue 슛아웃

AI CLI Coding Tools Shootout 2026 — Claude Code, Junie, Cline, Aider, Codex CLI, Cursor CLI, Continue.dev

• Prologue — Why "CLI" again
• 1. The comparison axes — what to actually look at
• 2. Claude Code — the terminal-agent baseline
• 3. OpenAI Codex CLI — Rust rewrite and GPT-5.5
• 4. JetBrains Junie CLI — the late arrival from the IDE world
• 5. Cline — from VS Code to CLI, the OSS champion
• 6. Aider — the original git-native
• 7. Cursor CLI / Background Agents — the IDE company's non-IDE surface
• 8. Continue.dev — the OSS that pivoted to "Continuous AI"
• 9. The head-to-head comparison matrix
  • What the edit model really costs — a closer look
• 10. Real workflows — which tool fits which job
  • Workflow 1 · Fix a flaky test
  • Workflow 2 · Add a new endpoint
  • Workflow 3 · Refactor a module
• 11. The decision tree — an honest guide
• Epilogue — checklist, anti-patterns, and what comes next
  • A 1-week checklist after you pick a tool
  • Anti-patterns to avoid
  • Next post
• References

Prologue — Why "CLI" again

Back in 2024 the default surface for AI coding tools was the IDE. Cursor defined the market, Copilot lived in a VS Code panel, Continue.dev was a sidebar. Then in the spring of 2026 every serious production-grade tool moved into the terminal. Claude Code led the way, OpenAI Codex CLI followed, JetBrains swallowed its pride and shipped Junie CLI in beta, and even Cursor released a standalone cursor-agent binary. Cline is an IDE extension but runs as a CLI too. Aider was always a CLI. Continue.dev pivoted to "Continuous AI" with a CLI at the core that runs on every PR.

Why CLI again? Three reasons.

1. Agents need freedom. Real autonomous agents combine Bash, Read, Edit, and Grep freely. Caging them inside an IDE panel constrains that freedom. The terminal was always the space for tool composition.
2. Workflows converge there. Git, CI, containers, SSH, tmux — a developer's real work converges on the terminal. Agents that live there fit naturally.
3. They are automatable. A CLI can be called by cron, GitHub Actions, a Slack bot, or another agent. IDE panels cannot.

This post compares seven CLI/terminal-native tools on the same axes. Where earlier posts covered "the whole market including IDEs," this one focuses only on terminal-native agent harnesses. After the comparison, we walk through three real scenarios — fix a flaky test, add an endpoint, refactor a module — and decide which tool fits which.

Models converge, harnesses differentiate. Seven tools call the same Claude / GPT / Gemini, but they behave wildly differently.

Prices and features move fast. Every number here is as of May 2026 and we focus on structural differences. Six months from now the numbers may shift, but the decision frame should still hold.

1. The comparison axes — what to actually look at

We decompose the seven tools across eight axes. The axes themselves are the decision frame.

Axis 1 · Agent loop strategy How the model gets called repeatedly. (a) Monolithic loop — a single main model makes all decisions. Aider and the default Codex CLI mode. (b) Architect/editor split — a strong model plans, a fast model edits. Aider architect, Codex CLI reasoning modes. (c) Main + subagents — main delegates to subagents that work with isolated context. Claude Code, Cursor Background Agents, Junie CLI. (d) Plan/Act toggle — the user explicitly switches modes. Cline's signature.

Axis 2 · File editing model This matters more than people think. (a) Search-and-replace blocks — the model emits OLD → NEW blocks and the harness applies them. Aider's classic format. Token-efficient and fails loudly. (b) Unified diff — patch format. Some Codex CLI modes. (c) Direct file write (write_file tool) — the model rewrites whole files through a tool call. Claude Code (Write), Cursor, Junie. Token-heavy on large files. (d) Targeted edit tool — the model passes exact old/new strings as tool arguments. Claude Code's Edit. Safe but matching can fail.

Axis 3 · Context strategy How code is found and shown to the model. (a) Embedding index — Cursor leads here. Fast semantic search but freshness issues. (b) grep/find first — Claude Code, Aider, Codex CLI. No index; clever search-tool composition. (c) Explicit add — Aider — the user picks files into context. Maximum control. (d) Auto-collection — the model decides what files to read on its own.

Axis 4 · Sub-agents / parallelism Can a single task split across multiple agents? Claude Code spawns subagents via the Task tool. Cursor Background supports up to 8 in parallel. Junie CLI calls them "agent skills." Aider and Continue are single-agent by default. The difference is decisive on large refactors.

Axis 5 · MCP support Model Context Protocol — by 2026 the industry standard. (a) First-class — Claude Code (Anthropic invented MCP), Codex CLI, Cursor CLI, Junie CLI. (b) Second-class — Cline supports stdio/SSE MCP with a marketplace. Continue supports it. (c) Partial — Aider accepts some MCP servers but integration is shallower. MCP is how you wire external tools (DBs, issue trackers, browsers, internal APIs) to the agent in a standard way.

Axis 6 · Pricing / cost model Three patterns. (a) Flat subscription — Claude Code Pro at 20 USD/month, Max at 100 and 200 USD. Predictable, friendly to heavy users. (b) BYOK (Bring Your Own Key) — Cline, Aider, Continue, Junie CLI. You pay model inference costs to the provider. (c) Token/credit — Cursor Max mode, Codex CLI API usage. High variance. Always estimate the heavy-user monthly cost — the same task can cost 10x more on one tool than another.

Axis 7 · OSS status (a) Open source — Aider (Apache), Cline (MIT), Continue (Apache), Codex CLI (Apache, Rust). (b) Closed — Claude Code (binary distribution, SDK partially open), Cursor CLI, Junie CLI (JetBrains license). In enterprise procurement OSS status can be decisive — audit, fork, on-prem deployment.

Axis 8 · Observability / safety Can you trace what the agent did? (a) Checkpoints — Cline commits to a shadow git after every tool call. Rollback is trivial. (b) Permission gates — Claude Code's yes/no prompts. Codex CLI is similar. (c) Sandboxing — Codex CLI ships bubblewrap on Linux and integrates Docker devcontainers. (d) Diff preview — every tool offers it to some degree, but depth varies.

Keep these eight axes in mind and now we look at each tool. Every chapter uses the same template.

2. Claude Code — the terminal-agent baseline

Surface · Strengths Pure CLI. Enter via the claude command. Runs anywhere in the codebase. Anthropic's own models (Opus 4.5, Sonnet 4.6) by default; other models only via the SDK. Since Anthropic invented MCP, MCP integration is a first-class citizen.

Agent loop A main agent runs the ReAct loop. When it needs to, it spawns subagents via the Task tool — each subagent gets its own context window, finishes its job, and returns only the result to the main agent. Context isolation is clean. The main agent never has to spend its 200k window on grunt work because the subagent does it in its own window.

File editing The Edit tool does targeted edits (old_string to new_string). The match must be exact, but it is safe. Whole-file rewrites are rare so token efficiency stays good. Write creates new files.

Context strategy No embedding index. Read, Glob, Grep, Bash find things on demand. The result: no index-freshness problem, and the model reasons about where to look. It scales well to large repos.

Subagents / MCP / pricing Subagents are the core feature. MCP is first-class on stdio and HTTP — a 6,000+ server ecosystem. Pricing is Pro at 20 USD/month, Max at 100 and 200 USD. Enterprise averages report about 13 USD per active day and 150 to 250 USD per developer per month. The flat-rate model favors heavy users versus token-metered tools.

Weaknesses Model lock-in — it really does run best on Claude. Other models work via the SDK but the seams show. Not fully closed but the core is a binary. Auditability is a concern for large teams.

One-line summary

Flat-rate CLI agent with first-class subagents and MCP. Locked to Claude, but inside that lane it is the smoothest of the bunch.

3. OpenAI Codex CLI — Rust rewrite and GPT-5.5

Surface · Strengths Enter via the codex command. OpenAI rewrote the original Node/TypeScript implementation in Rust in late 2025, and by spring 2026 about 95 percent of the codebase is Rust. Fast startup, low memory. Over 67,000 GitHub stars and a very active 10 to 15 commits per day cadence.

Agent loop You can pick GPT-5.5 (recommended in May 2026), GPT-5.4, or GPT-5.3-Codex, and tune reasoning levels. Subagents are documented in the official guide — one Codex agent reviewing another Codex agent's changes is a canonical pattern. MCP servers with the supports_parallel_tool_calls flag enable parallel tool calls — one reported workload dropped from 58 seconds to 31.

File editing Unified diff format dominates. The model emits patches and the harness applies them. Efficient on large-file changes.

Context strategy No embedding index. grep and find first. Same philosophy as Claude Code.

Subagents / MCP / pricing MCP first-class — stdio and streaming HTTP. Pricing is API metered plus optional ChatGPT Plus/Pro subscriptions that include some GPT-5.5 usage.

Sandbox — the real differentiator Bubblewrap-based sandbox on Linux. First-class Docker devcontainer integration. Host filesystem access is isolated. Even if you tell the agent to rm something, the host stays safe — a depth other CLI tools do not match.

Weaknesses GPT-only. Other providers require an OpenAI-compatible endpoint workaround. UX is rougher than Claude Code — Rust rewrite is ongoing and some commands churn.

One-line summary

OpenAI's terminal agent, rewritten lean in Rust. Best-in-class sandboxing. Locked to GPT-5.5.

4. JetBrains Junie CLI — the late arrival from the IDE world

Surface · Strengths Beta launched March 2026. Started as an in-IDE agent inside IntelliJ and PyCharm; then forked off into a standalone CLI. Runs in the terminal alone, inside any IDE, in CI/CD, on GitHub or GitLab.

Agent loop "LLM-agnostic" from day one — first-class support for OpenAI, Anthropic, Google, and Grok models. Where other tools lean into a vendor, Junie was designed to swap models freely. "Agent skills" define subagents. The "next-task prediction" pitch claims Junie understands project context and proactively suggests follow-up work.

File editing Borrows JetBrains' IDE analysis when integrated — AST-aware edits become possible. Standalone CLI mode is text-based, but inside the IDE it leverages indexing and refactoring tools the JetBrains platform already provides.

MCP / pricing MCP supported. BYOK by default — bring your own model keys, no platform charge. Junie also threw in one free week of Gemini 3 Flash at launch. Tied into JetBrains AI plans (Pro 100 USD/year, Ultimate 300 USD/year, Enterprise 720 USD/year).

One-click migration Explicitly advertises importing config from Claude Code, Codex, and others. As the late entrant it is openly trying to peel away existing users.

Weaknesses Beta. Stability and ecosystem are still thin. Most compelling inside JetBrains IDEs — strip out the IDE integration and the pure CLI does not yet stand out against the others. BYOK pricing means heavy users still have to model the inference bill separately.

One-line summary

Late but with a clear differentiator: model-agnostic and BYOK. Instant appeal for JetBrains shops, wait-and-see for everyone else.

5. Cline — from VS Code to CLI, the OSS champion

Surface · Strengths Originally a VS Code extension; in 2026 it also runs as a CLI assistant. MIT-licensed, 57,000+ GitHub stars, 4 million installs. Real open source.

Agent loop — Plan/Act toggle is the signature Plan mode — read-only, the architect role. Cheap on tokens, makes you and the agent agree on the plan first. Act mode — executes the plan. The explicit toggle is the point. The official docs are blunt: "skipping Plan and jumping straight into Act is the most common mistake."

File editing Mix of direct file write and targeted edits. The format depends on the chosen model.

Checkpoints — the observability champion After every tool call, Cline commits to a shadow git repo. Every edit, every command, every web request gets its own checkpoint. Three rollback modes: Restore Files, Restore Task Only, full reset. Deeper observability than anything else here — you can undo what the agent did six steps ago.

MCP / pricing MCP marketplace — runs its own marketplace with stdio and SSE servers. Pricing is BYOK — the extension is free, you pay inference cost on your own keys. Light users 5 to 50 USD/month, heavy users 100+. Team plan is 20 USD per user per month (post Q1 2026), first 10 seats free. Enterprise plan supports VPC, on-prem, and air-gapped deployments.

Weaknesses Pure-CLI standalone use is not as polished as the VS Code experience yet. The Plan/Act toggle is a love-it-or-hate-it design — users coming from Claude Code's smooth autonomy can find it friction-heavy.

One-line summary

Real OSS, BYOK, checkpoint-armored. Plan/Act is taste-dependent. With VS Code it is the strongest combination.

6. Aider — the original git-native

Surface · Strengths Paul Gauthier's tool, the oldest and most mature CLI agent here. Enter via aider. Apache-licensed. Treats git as the source of truth — you add files to context explicitly, the model proposes changes, and every change is auto-committed with a meaningful commit message.

Agent loop — the Architect/Editor pattern is the signature Two models in tandem. The architect — a strong reasoning model (o3, Opus 4.5) — proposes how to fix the request. The editor — a faster/cheaper model — turns that plan into Aider's diff format. Users fine-tune the cost/quality trade-off precisely.

File editing — the SEARCH/REPLACE original The model emits "this exact old code becomes this new code" diff blocks. The harness matches and applies. Match failures are loud — when the agent hallucinates code, application fails and the model retries. Token efficiency is best-in-class.

Context strategy — explicit add The user runs /add file.py to put a file into context. No auto-collection. Maximum control. In large repos this gives a certainty other tools cannot — "I am working on exactly these five files." /web adds web content, /voice adds voice input, watch mode triggers on comments — workflow integration runs deep.

Models / polyglot benchmark Supports every major model. Aider's polyglot leaderboard has become the de facto coding-model benchmark. As of May 2026: Claude Opus 4.5 at 89.4 percent, GPT-5 (high) at 88.0, Gemini 2.5 Pro Preview 06-05 at 82.2, o3 at 81.3. Mean score 58.1 percent.

MCP / pricing / weaknesses MCP partial — accepts some servers but integration depth is below the front-runners. Pricing is BYOK — the tool is free, you pay model costs. Weaknesses: no subagents (single agent). No auto-context (learning curve). Rough UX. Philosophy is closer to "one precise change unit" pair programming than to broad autonomy.

One-line summary

Git-native, the SEARCH/REPLACE original, Architect/Editor split. The most mature and the most controllable CLI tool. Precision over autonomy.

7. Cursor CLI / Background Agents — the IDE company's non-IDE surface

Surface · Strengths Cursor is famous for the IDE, but since January 2026 it ships cursor-agent, a standalone binary. Runs in the terminal with the same prompts, tools, and MCP integration as the IDE agent. Cursor 3.0 in April 2026 added Background Agents — asynchronous cloud-VM agents.

Agent loop — synchronous and asynchronous tracks cursor-agent is synchronous — a normal ReAct loop. Background Agents are asynchronous: they spin up a cloud VM, work on a separate branch, and push a PR when done. Up to 8 in parallel. Cursor 3.0's "Cloud handoff" lets you start an agent task locally and hand it off to the cloud — your machine can sleep while it keeps running.

File editing / context Mostly direct file write. The embedding index — Cursor's most-developed surface in the IDE — is partially carried into the CLI. The Cursor strength.

MCP / pricing MCP first-class. Tools defined in mcp.json are picked up automatically by the CLI. Pricing has five tiers — Hobby 0 USD, Pro 20 USD/month, Pro+ 60, Ultra 200, Teams 40 per user per month. Max mode (strong models) is token-metered with a 20 percent margin. Background Agents always run in Max mode — a 50-step task on Claude Sonnet runs 0.30 to 0.60 USD; complex tasks reach 4 to 5 USD.

Weaknesses At heart this is an IDE company. The CLI is a secondary surface, not a first-class citizen. Background Agents are powerful but pricey. Cloud-VM dependence — does not run in a closed network.

One-line summary

The IDE's embedding strength brought into the CLI. Background Agents' async parallelism is unique. Cloud dependence is a governance question.

8. Continue.dev — the OSS that pivoted to "Continuous AI"

Surface · Strengths Originally a VS Code/JetBrains sidebar chat. In 2026 it pivoted to "Continuous AI" — an open-source CLI that runs on every PR. Apache-licensed. Enforces team rules, catches issues, suggests fixes, all in CI automatically.

Agent loop The 2026 Agent mode flows requirement-analysis to plan to file-edit to terminal-exec to verify, autonomously. The CLI is built around per-PR execution. Tagline: "source-controlled AI checks, enforceable in CI."

File editing / context Context Providers — @codebase (architecture understanding), @docs (specific doc sites), @github (issues and PRs). The model receives context through explicit channels.

MCP / pricing MCP supported. Free OSS + Continue Hub paid plans (team collaboration, shared prompt templates, centralized config management). Supports nearly every model — Claude Opus 4.6 / Sonnet 4.6, GPT-4o / o3, Gemini 2.0 Pro, Llama 3.3, DeepSeek V3.

Weaknesses Agent maturity trails Claude Code, Codex, and Aider by a step. Its strength is "the agent that lives inside CI" — not interactive pair work.

One-line summary

OSS, CLI, CI-native is the triangle. Clear position as the per-PR automation agent. As an interactive coding partner, average.

9. The head-to-head comparison matrix

How to read it: the Signature column is the soul. One line that captures "what this tool does that the others do not." If the signature matches your workflow, dig deeper. If not, move on quickly.

What the edit model really costs — a closer look

The table does not show the practical impact of the edit model. Visualize the same one-line change handled by each of the seven tools and the difference becomes obvious.

File: src/auth.ts (200 lines)
Request: change getUser()'s throw message from "Not authorized" to "Unauthorized: missing token".

Aider (SEARCH/REPLACE):
  Model output: ~100 tokens (block form)
  Apply safety: match failure raises a clear error
  Token cost: minimal

Claude Code (Edit tool):
  Model output: ~80 tokens (old_string/new_string)
  Apply safety: match failure becomes a tool error - model retries
  Token cost: minimal

Codex CLI (unified diff):
  Model output: ~120 tokens (with context lines)
  Apply safety: failing hunks fall back to fuzzy match
  Token cost: small

Cursor / Junie (direct write):
  Model output: ~2000 tokens (re-emit the whole file)
  Apply safety: always applies
  Token cost: large (explodes with file size)

Cline (mixed):
  Varies by model choice

A single-line change can cost 20x more tokens depending on the tool. Over 100 small edits the monthly bill differs by 10x. For a developer averaging 50 small edits per day this is decisive.

The other half is behavior on match failure. Aider and Claude Code's targeted edits expect "exactly this string" matching, so a model hallucination causes apply to fail — the model is forced to re-read the real file and produce an accurate match. That is a safety feature. Direct-write tools risk overwriting other hallucinated regions silently.

10. Real workflows — which tool fits which job

The comparison table is half the decision. The other half is "how does it run on real work." We use three scenarios.

Workflow 1 · Fix a flaky test

Nature of the work: a test fails intermittently. Environment-dependent, timing-related, or coupled to other tests. Hard to reproduce.

What you need:

1. Re-run the test repeatedly to find the pattern (while for 100 runs, or vary the seed).
2. Isolate the suspect (time, randomness, global state).
3. Form a hypothesis, change code lightly, verify.
4. Land a real fix as a PR.

Good fits:

• Claude Code — Bash re-run loops are natural. Delegate "run 100 times and produce stats" to a subagent in isolated context. The main agent stays on hypothesis and fix.
• Codex CLI — bubblewrap sandbox lets you run tests with abandon. Host stays safe.
• Aider — strong once the fix is identified. Precise one-liner with SEARCH/REPLACE and an auto-commit.

Poor fits:

• Cursor Background — asynchronous; not the right shape for an unreproducible-bug debugging loop. The "let's run it right here together" cadence is too far away.
• Continue.dev — strong inside CI, not in interactive debugging.

Workflow 2 · Add a new endpoint

Nature of the work: follow existing patterns to add a route. Auth, validation, DB call, tests, docs. Repetitive but must be precise. Must obey existing conventions.

What you need:

1. Read existing endpoint code and learn the pattern.
2. Create new files and register routes in existing ones.
3. Add tests.
4. Update OpenAPI schema and docs.
5. Verify everything follows the conventions.

Good fits:

• Cursor CLI — embedding index finds "similar endpoints" fast for pattern learning. Strength.
• Junie CLI — JetBrains IDE integration borrows AST analysis for precise route registration and interface checks.
• Claude Code — Glob and Grep locate patterns; delegate test-writing to a subagent; the main agent focuses on the route.

Poor fits:

• Aider — possible but the explicit add is friction. You manually add multiple files for pattern learning. Precise but slow.
• Cursor Background — possible but convention-verification is human work. Throwing it async tends to mean reworking the result.

Workflow 3 · Refactor a module

Nature of the work: split a large module, change a signature, move to a different pattern. Dozens of files change at once. Partial application breaks the build.

What you need:

1. Identify the impact set precisely.
2. Apply consistent changes everywhere.
3. Verify by build and test.
4. Roll back on partial failure.

Good fits:

• Cursor Background Agents — async + up to 8 parallel is decisive. Split a refactor into modules and run them concurrently. Results come as PRs.
• Claude Code — subagents take "one module per subagent" split; main agent does integration and consistency checking.
• Cline — checkpoints as a safety net. When a big refactor breaks, you can undo at tool-call granularity.

Poor fits:

• Aider — explicit add across dozens of files is heavy. Possible, but the workflow is awkward.
• Continue.dev — strong at per-PR automation, not at "kicking off a big refactor right now" as an interactive entry point.

11. The decision tree — an honest guide

Which of these are you closest to?

Team size and governance first.

1. Solo IC, free hand. OSS preferred → Aider or Cline. Precise one-change unit work goes to Aider; VS Code integration and checkpoints to Cline. Flat-rate lover → Claude Code Pro.
2. Small team (2-10), speed-focused. Claude Code Max or Cursor Pro. If you live in the Claude ecosystem already, former; if embeddings and Background appeal, latter.
3. Medium-to-large team (10-50), policy and audit needed. Cline Enterprise (VPC/on-prem), Continue.dev (CI integration), or Junie CLI (JetBrains governance). Closed-source tools need security-team approval.

Workflow shape.

4. Test debugging, immediate feedback loop. Codex CLI (sandbox) or Claude Code (subagents).
5. Repetitive CRUD pattern additions. Cursor CLI (embeddings) or Junie CLI (IDE integration).
6. Big refactor / migration. Cursor Background Agents or Claude Code subagents.
7. Isolated single change, precise. Aider.
8. CI automation / per-PR automatic checks. Continue.dev.

Cost sensitivity.

9. Fixed budget, no per-call worry. Claude Code Pro from 20 USD/month.
10. Variable usage; pay less in light months. BYOK — Cline, Aider, Junie, or Continue.
11. Want the best regardless of cost. Claude Code Max plus Cursor Ultra plus Codex CLI Pro in parallel (an actual heavy-user pattern).

Avoiding model lock-in.

12. Free to swap models. Junie CLI (LLM-agnostic) or any BYOK OSS — Aider, Cline, Continue. Claude Code, Cursor, and Codex bind you somewhat to specific providers.

The most common mistake: assuming one tool covers everything. In 2026 the actual heavy-user pattern is two to three tools in parallel. Claude Code for interactive pair work, Continue for automatic PR checks, Cursor Background for big refactors — split by job. Tool spend rises; time spend falls much further.

Epilogue — checklist, anti-patterns, and what comes next

A 1-week checklist after you pick a tool

• Re-do three real PRs from your repo with that tool, end to end.
• Exercise edits on a large file, a small file, and a brand-new file.
• Set up one MCP integration that you actually use.
• Measure a full week of cost (API metering plus subscriptions).
• Walk security or compliance through the data-handling policy (if applicable).
• Shadow one teammate for 30 minutes — note where they get stuck.
• Write at least one paragraph on how this lands in CI.

Anti-patterns to avoid

1. Choosing by benchmark score alone. Aider polyglot leader does not equal best on your codebase. Model score and tool fit are different axes.
2. Ignoring the signature feature. Aider's Architect/Editor, Cline's Plan/Act, Cursor's Background — if you do not use the signature, you do not really know the tool. Try the weirdest part first.
3. Forcing one tool on every workflow. Interactive debugging and async big refactors want different tools. Two or three in combination usually beats one universally.
4. Not knowing what MCP is. In 2026 MCP is the standard for exposing internal tools, DBs, and trackers to agents. Ignoring it ties your agent's hands.
5. Autonomous mode with no checkpoints or rollback. Without Cline's checkpoints or git safety nets, one bad run wipes 30 minutes. Always have a rollback path.
6. Not estimating cost. With BYOK tools, monthly model spend is on you to estimate. People who say "the tool is free" routinely get 200 to 500 USD/month API bills.
7. Skipping human review. Merging an AI PR untouched ages into tech debt within six months. Human review does not shrink; it grows sharper.

Next post

Next we run the same task across all seven tools — same PR, different harness, different result. Quantitative comparison of the actual code changes, of cost, and an honest log of "where each tool got stuck."

After that: building an MCP server — wrap an internal tool as a standard MCP server and use it from all seven tools. Build once, run everywhere.

References

• Claude Code Agent Teams, Subagents, and MCP: The 2026 Playbook — Developers Digest
• Claude Code Pricing 2026 — Verdent Guides
• Junie CLI Beta — JetBrains Blog (2026-03)
• JetBrains Launches Air and Junie CLI — DevOps.com
• Cline GitHub — autonomous coding agent
• Cline Plan & Act Mode docs
• Aider Edit Formats docs
• Aider Polyglot Leaderboard
• Aider Guide 2026: Atomic Commits & Architect Mode — DeployHQ
• OpenAI Codex CLI — Features
• OpenAI Codex CLI — Changelog
• Codex MCP — OpenAI Developers
• The codex-rs Architecture: Rust Rewrite
• Cursor 2026: Composer, Agent Mode, MCP & Background Agent — DeployHQ
• Cursor Background Agent — Run Long Tasks
• Cursor Pricing 2026 — AI Productivity
• Continue GitHub — Continuous AI
• Continue.dev — Open Source AI Code Agent Guide (Better Stack)
• MCP — Model Context Protocol spec