AI Agent Stack: 10 Terminal Nodes for Every Team

Choosing an AI coding stack in May 2026 is not a question of quality — it is a question of which branch of the decision tree you belong on. Team size, use case, budget, and IDE preference each eliminate roughly half the available options before you price a single seat. This guide assembles those four axes into a visual decision tree with 10 terminal-node stack recommendations, all prices verified live on May 24, 2026.

The decision framework matters more than ever right now because seven pricing events land in the next 25 days — Codex Pro's 2× promo expires May 31, GitHub Copilot transitions to usage-based billing on June 1 (per-credit dollar pricing still undisclosed as of publication), and the Gemini CLI sunsets on June 18 for paid Google AI customers. The stack you pick on May 24 may have a materially different cost profile by June 19. We surface this as an imminent-cliff calendar so you can choose a routing window, not a forever-stack.

This post is the decision framework built on top of the tool catalog. For the underlying feature-parity catalog across 20 platforms, see our Q2 2026 agentic coding tools matrix. For per-task cost methodology, see the per-task / per-user cost framework. For the Claude Code Max breakeven math specifically, see our Claude Code ROI calculator.

The conventional framing for "which AI coding tool" is a price-vs-quality grid. That framing misses the real switching cost: IDE lock-in. When you commit to a surface, you commit to a migration cost if you want to change it later. Model costs decline; IDE migration costs don't.

VS Code is the lock-in winner — not because it is the best IDE, but because the extension model means Cursor (a VS Code fork), Cline (a VS Code extension), Continue.dev (a VS Code extension), and GitHub Copilot (a VS Code extension) all share the same editor. Switching between them is an extension swap, not a workflow rebuild. If your team is already in VS Code, the marginal cost of trying a second tool is near zero.

JetBrains gives you JetBrains AI Ultimate + Junie, the Claude Code JetBrains plugin, and the Cline JetBrains extension — all inside the same IDE family. Python data engineers and Java/Kotlin shops who live in IntelliJ should route here before evaluating VS Code alternatives.

Pure CLI removes the IDE constraint entirely. Claude Code runs in your terminal, VS Code extension, JetBrains plugin, Desktop app, and browser. Per Anthropic's official overview: “Available in your terminal, IDE, desktop app, and browser.” Codex CLI, Aider, Grok Build CLI, and Antigravity CLI are also terminal-native — they travel with you regardless of which editor you open. The tradeoff is losing editor-native autocomplete, inline diff rendering, and multi-file navigation context that IDE-native tools provide.

The original analysis here is that the IDE fork precedes the budget question in the routing tree. A $0 BYOK Cline user and a $39/mo Copilot Pro+ user are in the same VS Code branch — their budget differs but their switching cost is the same. A Claude Code CLI user is in a different branch entirely: they can swap any model, any backend, and any IDE surface without rebuilding their workflow.

Our lock-in tiers are a Digital Applied framework — well-reasoned but not vendor-confirmed. They classify tools by how portable your workflow is if you change your mind.

Tier 1 — OSS + BYOK (fully portable). Aider, Cline, and Continue.dev are open-source Apache 2.0 projects where both the model and the IDE surface are portable. You bring your own API keys, you own your config, and switching to a different model costs you nothing except the API rate. Per the Cline team: “You only pay for AI inference credits when you use AI models. This is usage-based pricing — you pay for what you use, nothing more.”

Tier 2 — Managed platform with BYOK escape.Cursor, Claude Code, Codex CLI, Windsurf, and Zed all offer managed tiers with their own model routing, but they let you substitute models or run BYOK configurations. The IDE or CLI surface is single-vendor; the model is swappable. Cursor's $20 Individual tier bundles both inference and the editor — but you can also bring OpenAI or Anthropic API keys if you prefer direct billing.

Tier 3 — Closed platform. Kiro (Anthropic-on-Bedrock only as of May 2026), Grok Build (xAI model only, SuperGrok Heavy gated), Antigravity 1.x (Gemini-only), and MS Copilot Studio (Microsoft-managed enterprise) are closed platforms. Antigravity 2.0 partially breaks the closed-platform rule — it reportedly runs Claude Sonnet 4.5 and GPT-OSS 120B in addition to Gemini 3.5 Flash, per Apidog's I/O coverage (May 19, 2026) — though this is single-source and should be treated as unconfirmed.

The critical observation is that Cursor + Composer 2.5 is the tightest Tier 2 binding in the market. Composer 2.5, launched May 18, 2026, is “built on the same open-source checkpoint as Composer 2, Moonshot's Kimi K2.5” per the Cursor team's launch blog— but the model is “available exclusively inside the Cursor IDE and through the @cursor/sdk — not as a general API.” This is the first commercial coding tool to bind a proprietary model + editor surface this tightly. If you pick this branch, you are accepting IDE lock-in that has no model-substitution escape valve.

The matrix below is the decision tree output: 10 distinct profiles (team size × use case × budget × IDE preference) each mapped to a recommended stack, monthly cost, and lock-in tier. All prices verified live on May 24, 2026. For the full pricing methodology behind per-task cost estimates, see our Q2 2026 API pricing index. For the CLI-specific comparison underpinning Nodes 3, 6, and 7, see the Claude Code vs Codex vs Jules matrix.

The pattern across all 10 nodes is that the IDE preference filters you before the budget question matters. Nodes 1, 4, and 8 are the VS Code branch — spanning $0 to enterprise custom. Nodes 2 and 5 are the JetBrains branch. Nodes 3 and 7 are the CLI branch. Node 10 is the Google-ecosystem branch. Only Node 9 is truly outside the IDE categorization — it is the IT-managed enterprise branch that developers rarely control.

The forward-looking analysis: the Tier 3 / closed-platform nodes (9 and 10) are losing ground. Microsoft's computer-use GA is significant — no one else has shipped it as a managed enterprise SKU. But Antigravity 2.0's multi-model claim (if confirmed) would move Node 10 into Tier 2 territory, which would materially change the lock-in story for Google-stack shops. Watch the Antigravity changelog through June for official multi-model confirmation.

GitHub Copilot's pricing is not a token budget — it is a premium-request budget where each model consumes a different number of requests per prompt. The multipliers below are verified live from docs.github.com/copilot-requests on May 24, 2026.

The practical consequence: Copilot Pro ($10/mo, 300 premium requests) gives you 300 prompts on Sonnet 4.6 (1× multiplier) but only 20 effective prompts on Opus 4.7 (15× multiplier — 300 ÷ 15). Copilot Pro+ ($39/mo, 1,500 premium requests) gives you 100 Opus 4.7 prompts per month (1,500 ÷ 15). If your workflow requires frequent Opus 4.7 invocations, you should be on Claude Code Pro or Max rather than Copilot Pro+. The 10% auto-select discount (multipliers calculated at 0.9× for model-auto-selected prompts) provides marginal relief.

A second gotcha: GitHub pulled Gemini models from Copilot Chat web on May 20, 2026 — scoped to web only. The Gemini removal does NOT affect VS Code, JetBrains, or CLI Copilot surfaces. And as of publication, GitHub Copilot Pro “Upgrades are paused” — verified live on github.com/features/copilot/plans. New Pro sign-ups are currently not available.

June 1, 2026 is the Copilot usage-based billing transition. Per-credit dollar pricing has not been published as of May 24 — 8 days before the transition. Plan for uncertainty: any Copilot Pro+ routing recommendation in this post carries a [VERIFY ON OR AFTER JUNE 1] flag for per-credit cost claims.

The table below shows monthly stack cost at three team sizes for the most popular configurations, as of May 24, 2026. BYOK rows assume 50 tasks/seat/month at ~$1 effective task (illustrative — actual spend varies with model choice and cache discipline). The only vendor-anchored session cost is Anthropic's $0.705 worked example (50K in / 15K out, uncached) from Anthropic's pricing docs. BYOK numbers are illustrative, not vendor-disclosed. For the full per-task economics, see our token-vs-outcome pricing models guide and the data-point tracker we maintain.

The crossover point is roughly 25-30 seats. Below that threshold, BYOK at modeled Sonnet 4.6 rates typically beats paid subscriptions for high-volume users. Above 30 seats, Claude Code Team ($20-25/seat annual) and Cursor Teams ($40/user) compress per-seat cost sufficiently that subscription management overhead is worth the predictability. At 100 seats, the decision is not about cost per-seat — it is about enterprise features (audit logs, SSO, policy routing) that only appear in the Enterprise tiers.

The cache-discipline variable is the most underrated cost lever. Sonnet 4.6 at 80% cache hit drops from $0.60/task to ~$0.28/task — a 53% reduction. GPT-5.5 above 272K context incurs a 2× input surcharge for the full session — the “1M context gotcha” that makes GPT-5.5 appear cheaper than it is for long-context agentic workflows. These dynamics are documented in our cost-per-successful-task evaluation metric post.

A decision tree is supposed to be evergreen. We disclose the imminent-cliff window explicitly so the reader knows this recommendation has a half-life. Every date below is verified as of May 24, 2026. After June 18, re-verify each node's cost math.

The forward projection: after June 18, the effective tool landscape contracts. Gemini CLI users forced onto Antigravity CLI may find the migration smoother than expected — the Google Developers Blog transition guide notes the Antigravity CLI is “built in Go, snappier and more responsive.” But Antigravity 2.0's pricing ($20/$100/$200, repriced from $250 at launch) combined with the removal of a free-at-tier-2 CLI option is a meaningful change in the Google-stack cost model. Teams on Node 10 should budget the Antigravity AI Pro $20/mo as their new floor.

Cline, Continue.dev, and Aider are typically dismissed in “best AI coding tool” comparisons as DIY options for developers willing to manage their own API keys. That dismissal misses the per-seat economics at small-to-mid team sizes. At modeled 50 tasks/seat/month on Sonnet 4.6 ($0.60/task uncached, declining significantly with cache), BYOK effective burn is approximately $30/seat — below every managed-platform subscription at the mid tier.

The practical case for BYOK stacks is sharpest for teams whose primary pain is seat-license inflation. A 10-person team on Cursor Teams ($40/user) spends $400/mo on IDE licensing before any model inference. A 10-person team on Cline BYOK at modeled $30/seat spends ~$300/mo — a 25% reduction — with full model portability and no IDE subscription.

The counter-argument is real too: BYOK requires each developer to manage API keys, configure YAML (Continue.dev has deprecated JSON config), and absorb the complexity of model selection. For teams without a dedicated tooling engineer, that overhead can exceed the cost savings. Node 1 (solo developer) is the natural BYOK home; Node 4 (5-dev team) is the first point where managed-platform convenience starts winning the argument.

Aider is the strongest terminal-only BYOK option — free OSS, pip install, tree-sitter repo-map across 100+ languages, BYOK across OpenAI / Anthropic / Google / DeepSeek / Bedrock / Vertex. See our Aider terminal deep dive for the full config reference. For the Continue.dev OSS path, see the Continue.dev OSS guide.

Most decision trees treat Zed as one of N IDEs and rank it against Cursor and Windsurf. That framing is increasingly wrong. On May 20, 2026, the Zed team announced Terminal Threads: “Run Claude Code, Amp, or any terminal agent as threads in Zed's sidebar.” This makes Zed the meta-routing IDE — the editor you use when you want to run multiple agents (Claude Code, Codex CLI, Aider) without leaving your editor context.

Combined with Zed's Parallel Agents feature (launched April 22, 2026), which lets you run N agent contexts in parallel windows, and Zed's Rust-native performance profile, the positioning is distinct: Zed is not competing with Cursor on Composer 2.5 feature parity — it is competing on the meta-layer of agent orchestration within a single editor surface.

The Zed routing profile is strongest for:

• Developers who want to run Claude Code and Codex CLI side-by-side, comparing outputs on the same task.
• AI-research teams experimenting with multiple model backends (Tier 1 BYOK philosophy inside a standalone editor).
• Vim / Neovim emigres who want a modal-editing-friendly standalone editor with agent integration.

Zed Pro is $10/month with $5 of tokens included and unlimited edit predictions. Business is $30/seat. A two-week trial gives $20 in credits. Verified at zed.dev/pricing on May 24, 2026. See our Zed Parallel Agents review for the full setup.

Coding-tool decision trees usually stop at developer-tier subscriptions. The enterprise branch needs a different terminal node when IT governance, audit logging, compliance controls, and computer-use automation are requirements that developers cannot waive.

Microsoft Copilot Studio computer-use agents went generally available on May 13, 2026. Per the Microsoft Tech Community announcement: “Computer use in Microsoft Copilot Studio is now generally available, with expanded availability rolling out to all commercial geographies in Microsoft Power Platform.” This is the only major player shipping computer-use as a managed enterprise SKU — with policy controls, Copilot Credit billing visibility, and M365 compliance integration — as of publication.

The pricing has two paths. Path 1: M365 Copilot ($30/user/mo) includes internal agents at no additional credit cost for licensed users. Computer-use agent actions consume Copilot Credits separately. Path 2: Standalone Copilot Studio capacity packs at $200/mo for 25,000 Copilot Credits, or pay-as-you-go at $0.01/credit via Azure. Do not simplify to “$30/user/mo” — the computer-use action billing is layered on top of the M365 license.

Node 9 is not the right branch for developer teams choosing a coding IDE. It is the right branch for IT-led automation initiatives — workflow automation, enterprise app integration, browser-based legacy system access — where the managed compliance layer is non-negotiable. For the broader enterprise AI development context, our AI transformation services page covers how we help organizations route these decisions across the developer, IT, and CTO layers. See also Microsoft Copilot Cowork enterprise workflows for the broader M365 context.