Skip to content
Published on

AI Coding Assistants 2026 — Cursor / Windsurf / Cline / Aider / Claude Code / Codex CLI / Copilot Workspace Deep Dive

🇰🇷KO🇺🇸EN🇯🇵JA
Split View필사 모드
Authors

Prologue — Four Years from Copilot to Agents

In June 2021, GitHub Copilot launched in preview. The pitch was a single line — "write a comment, get the code." It was smarter autocomplete; the human was still the one writing the program.

May 2026 looks completely different. A developer hands the AI a task. The AI reads files, edits them, runs terminal commands, executes tests, and fixes things when they break. The human says "do this" and reviews afterward. The author of the code has changed.

Key moments along the way:

  • November 2022 — ChatGPT launches. Coding chatbots become routine.
  • March 2023 — Cursor launches, embedding GPT-4 into a VSCode fork.
  • March 2024 — Cognition unveils Devin as "the AI software engineer."
  • July 2024 — GitHub Copilot Workspace enters beta. Task delegation begins.
  • August 2024 — Cline (then "Claude Dev") explodes on the VSCode marketplace.
  • February 2025 — Anthropic announces Claude Code, the CLI agent.
  • April 2025 — OpenAI acquires Codeium (Windsurf) for ~$3B.
  • April 2025 — OpenAI open-sources Codex CLI.
  • May 2025 — Cursor closes a Series B at a $9B valuation.
  • October 2025 — GitHub Copilot Agent goes GA and auto-files PRs.

The landscape as of May 2026:

  • Cursor is the most-loved IDE and has the Series B to prove it.
  • Windsurf sits inside OpenAI and is being woven into ChatGPT.
  • Cline / Roo Code are the de facto open-source agents inside VSCode.
  • Aider holds the git-native CLI pair-programmer throne.
  • Continue keeps the BYOLLM open-source IDE plugin alive.
  • Zed AI layers native AI workflows onto the Rust-built editor.
  • Claude Code is Anthropic's official CLI agent.
  • Codex CLI is OpenAI's open-source reply.
  • GitHub Copilot completed the four-stage evolution: autocomplete, chat, workspace, agent.
  • Sourcegraph Cody rules enterprise code indexing.
  • Tabnine survives in self-hosted and on-prem markets.
  • Augment arrived with a context engine as its weapon.

This piece compares 13 tools in one breath, with a recommendation for who should pick what.

1. The 2026 AI Coding Map — IDE / CLI / Autocomplete / Agent

Defining "AI coding tool" in one sentence is hard, because a single product often bundles autocomplete, chat, and agent modes. In 2026 the cleanest way to see the space is two axes.

1.1 Two Axes — Host (IDE / CLI / Web) × Capability

                          Capability →
                  autocomplete | chat | agent | task-delegation
        IDE fork  |  Cursor   |  Cursor / Windsurf  |  Cursor Composer
        VSCode ext|  Copilot  |  Continue / Cody    |  Cline / Roo Code
Host    Native    |  Tabnine  |  Zed AI             |  Zed AI
   ↓    CLI       |   -       |  Aider              |  Claude Code / Codex CLI
        Web/IDE   |   -       |  Copilot Workspace  |  Copilot Agent / Devin

One pattern jumps out — agents and task delegation grow weaker as you go up, stronger as you go down. Autocomplete lives entirely inside the IDE, but agents need terminal commands and file-system access, which pushes them toward CLI hosts.

1.2 Four Categories — Full-Stack IDE / VSCode Extension / CLI Agent / Cloud Agent

Category 1 — Full-stack IDE. Cursor, Windsurf, Zed AI. These either rewrite the editor (Zed) or fork VSCode (Cursor, Windsurf) to claim their own identity. Autocomplete, chat, and agent all live on one screen.

Category 2 — VSCode / JetBrains extension. GitHub Copilot, Continue, Cline, Roo Code, Sourcegraph Cody, Tabnine, Augment. Add-ons on top of existing editors. No editor change required.

Category 3 — CLI agent. Claude Code, Codex CLI, Aider. Agents that run in the terminal. They work without an IDE and can run alongside one. This was the fastest-growing category of 2025.

Category 4 — Cloud agent. GitHub Copilot Workspace + Agent, Devin (Cognition), Replit Agent. You delegate work in a browser or on GitHub, and the AI assembles a PR in a separate environment. Often called "async agents."

1.3 Context Strategies — Local Embeddings vs Cloud RAG vs LSP-First

How each tool gathers context splits the market.

  • Local embeddings + RAG — Cursor's codebase index, Continue, Aider. Vectorize locally, send only the chunks the model needs.
  • Cloud RAG — Sourcegraph Cody, Augment. Index the whole codebase on a server and search from there.
  • LSP / AST first — Zed AI. Prefer the language-server tree over embeddings.
  • Agentic exploration — Claude Code, Codex CLI, Cline. Skip the prebuilt index; let the agent grep and find as it goes.

Late 2025 saw a swing toward "don't bother indexing in advance — let the agent search when it needs to." Cursor made indexing optional in September 2025.

2. Four Stages of Evolution — Autocomplete → Chat → Agentic → Task Delegation

Mapping 2021–2026 in one picture makes the trajectory obvious.

2.1 Stage 1 — Autocomplete (2021–)

  • Examples — GitHub Copilot (June 2021 preview, June 2022 GA), Tabnine, Codeium free tier.
  • Interaction — Gray text appears in the IDE. Press Tab to accept.
  • Models — Codex (GPT-3 based) at first, later GPT-4 / Claude / Gemini.
  • Limits — Changes larger than one function are hard. Context stops at the current file.

2.2 Stage 2 — Chat / Inline Edit (Nov 2022–)

  • Examples — Copilot Chat (March 2023), Cursor (March 2023), Continue (May 2023).
  • Interaction — Conversation in a side panel; code blocks appear; inline edit via Ctrl/Cmd+K.
  • Context — Current file, open tabs, and selection are sent automatically.
  • Limits — The human still drives every step. Multi-step work means manual copy-paste.

2.3 Stage 3 — Agentic (July 2024–)

  • Examples — Cursor Composer (July 2024), Cline (August 2024), Aider, Devin (March 2024 demo).
  • Interaction — Type "add this feature" and the AI reads files, edits them, runs commands.
  • Core — tool calls. Read, Edit, Bash, Grep. The model invokes them and decides what to do next.
  • Loop — Plan, act, observe, revise. The agent reruns failing tests and fixes itself.
  • Limits — Long sessions blow up the bill; the agent can dig deep in the wrong direction.

2.4 Stage 4 — Task Delegation (October 2024–)

  • Examples — Copilot Workspace (July 2024 beta → October 2025 GA), Copilot Agent (October 2025), Devin, Replit Agent.
  • Interaction — Label a GitHub issue or post a task in a web UI; the AI does the work in a separate cloud environment and returns a PR.
  • Difference — The IDE doesn't need a human in it. It's asynchronous.
  • Limits — Thin context, bad PRs at scale, reviewers spend the same time anyway.

2.5 What the Evolution Means — From Autocomplete to Coworker

The 2021 autocomplete was "smarter IntelliSense." The 2024 agent became "a junior engineer." The 2026 cloud agent is closer to "an async outsourced developer."

This evolution rewired pricing. Stage 1 cost $10/month and that was fine; stage 4 forces usage-based billing. We cover that in section 13.

3. Cursor — The Most-Loved IDE, $9B Series B Valuation

In March 2023, two MIT grads at Anysphere fused GPT-4 into a VSCode fork. Two years later, that fork is the most-loved AI IDE.

3.1 May 2025 — Series B at $9B Valuation

In August 2024, Cursor raised a 60MSeriesAledbyAndreessenHorowitzata60M Series A led by Andreessen Horowitz at a 400M valuation. In May 2025, Thrive Capital led a 900MSeriesBata900M Series B at a 9B valuation — a 22x jump in nine months.

Reports placed ARR above 100Mbyend−of−2024,andanalysesinMay2025peggeditcloseto100M by end-of-2024, and analyses in May 2025 pegged it close to 400M. That's one of the fastest ARR ramps in SaaS history.

3.2 Core Features — Composer, Tab, @ Context

Composer. Added July 2024, the multi-file agent. Open it with Cmd+I, type "add this feature," and the AI edits multiple files at once. From 2025 onward it also runs terminal commands — a full agent loop on par with Cline / Claude Code.

Tab. Cursor's home-grown "next edit prediction" model. Not single-line autocomplete; it reads the flow and suggests multi-line changes like "you changed the signature, here's the call-site update." One of the highest-satisfaction features.

@ Context. In chat you can mention @File, @Folder, @Code, @Docs, @Web, @Git to add context explicitly. In 2025 @Codebase triggers full index search.

3.3 Model Routing — Auto vs Manual

Cursor Pro routes among Claude Sonnet 4 / Opus 4, GPT-5, Gemini 2.5 Pro, and more. "Auto" mode picks based on cost, speed, and complexity. Late 2025 surfaced more model controls to the user.

3.4 Pricing — Pro $20/month + Usage-based Ultra

  • Hobby — Free, limited autocomplete and 50 Pro-model calls/month.
  • Pro — $20/month, 500 fast premium requests, unlimited slow, unlimited Tab.
  • Ultra — $200/month (launched July 2025), much higher usage caps. Mirrors the Claude Max / ChatGPT Plus usage ladder.
  • Business / Enterprise — $40/seat, stronger privacy, SSO/SCIM.

The shift from simple per-seat in 2024 to usage-based in 2025 happened because Composer token costs dwarf stage-1 autocomplete.

3.5 Strengths and Weaknesses

Strengths. Smoothest UX. The Tab model predicts well. Composer handles multi-file work reliably. Widest model choice.

Weaknesses. Closed-source. VSCode extension compatibility occasionally breaks. Indexing can be slow on giant monorepos. Usage-based pricing makes costs harder to predict.

4. Windsurf (Codeium) — OpenAI Acquisition (April 2025)

Codeium started in 2021, first as a free Copilot alternative for autocomplete. In November 2024 it launched its own IDE, Windsurf. In April 2025, OpenAI bought it for about $3B — OpenAI's largest acquisition ever.

4.1 What the OpenAI Deal Means

The acquisition was announced April 2025 and closed July 2025 at ~$3B.

Two reasons OpenAI bought Codeium — first, it wanted its own IDE. GitHub Copilot sits inside Microsoft, and as model routing diversified, OpenAI-only share was eroding. Second, Codeium had strong enterprise sales and on-prem infrastructure. Codeium supported self-hosting and air-gapped deployments from day one and sold into banks and financial institutions.

4.2 What Sets Windsurf Apart — Cascade and Flows

Windsurf's agent is called Cascade. Similar to Cursor Composer with two differences:

  • Flows. Infers intent and proposes the next step. "You just created this file, you'll probably want a test."
  • Memory. Remembers context the user pinned (style guides, project rules) and reapplies it.

The UI is a VSCode fork, but simpler. Where Cursor reads as "powerful but complex," Windsurf reads as "back-to-basics."

4.3 Pricing and Share Shifts

After the acquisition, OpenAI tied Windsurf pricing to ChatGPT subscriptions.

  • Free — Limited usage.
  • Pro — $15/month, capped Cascade usage.
  • Pro Ultimate — $60/month.
  • Teams / Enterprise — Tiered seats.

ChatGPT Plus / Pro subscribers started getting some Windsurf usage bundled in. This is a major share-shifting variable for 2026.

4.4 Strengths and Weaknesses

Strengths. Best OpenAI model access. Self-hosting and on-prem. Cascade's intent inference feels smooth. Strong enterprise sales engine.

Weaknesses. Community energy lags Cursor. Post-acquisition organizational friction. Narrower model choice than Cursor (OpenAI-leaning).

5. Cline (formerly Claude Dev) — The Open-Source VSCode Agent

In July 2024, a developer named Saoud Rizwan shipped a VSCode extension called "Claude Dev." It exploded, and at Anthropic's request the project was renamed Cline (Claude + CLI).

5.1 The Category Cline Created — Full Agent Inside VSCode

Cline's identity is one line — a full agent that lives inside VSCode. It's a multi-file, terminal-integrated agent like Cursor Composer, but without replacing your editor.

How it works:

  1. User types a task in the side panel.
  2. Cline shows a "Plan."
  3. For each step, it proposes a file edit or terminal command and waits for the user to click Approve.
  4. It reads the result and proceeds or revises.

That approval step is Cline's signature. There is an Auto-Approve mode, but the default keeps the human in the loop at every action.

5.2 Model BYOK — Anthropic / OpenAI / OpenRouter / Local

Cline uses a bring-your-own-key (BYOK) model. Supported backends:

  • Anthropic (Claude Sonnet 4 / Opus 4)
  • OpenAI (GPT-5)
  • Google (Gemini 2.5 Pro)
  • OpenRouter (dozens of models)
  • AWS Bedrock, Azure OpenAI
  • Ollama / LM Studio (local)

BYOK gives you cost transparency — you pay your provider directly for the tokens you used. Cline itself is free.

5.3 Roo Code — The Cline Fork

Late 2024 brought Roo Code (originally Roo Cline), a Cline fork that emphasizes faster feature shipping, more modes (Architect, Code, Debug, etc.), and custom user-defined modes.

The split:

  • Cline — Stable, defaults-first, approval-centric.
  • Roo Code — Experimental features faster, wider customization.

Pick by taste. Both are healthy on GitHub.

5.4 Strengths and Weaknesses

Strengths. Open-source. Uses stock VSCode. BYOK gives cost control. The approval model is safer. Fast-growing community.

Weaknesses. UX isn't as polished as Cursor. Approving every step gets old in long sessions. You eat all the model costs — a big task can cost $5–10 in one shot.

6. Aider — The CLI-First Pair Programmer

In May 2023, Paul Gauthier shipped Aider, the oldest CLI-first AI coding tool. While the others raced into IDEs, Aider started life as "a git-friendly CLI."

6.1 Aider's Identity — Married to Git

Aider hooks deep into git from the start.

  • Every change is auto-committed to git — a new commit per response.
  • Undo is git revert one line.
  • The AI writes the commit message.

This "AI change equals new git commit" model lets a human audit everything Aider does via git log. A bad change? Revert that commit.

6.2 How It Works

$ pip install aider-chat
$ cd my-project
$ aider --model sonnet
> add a /healthz endpoint that returns 200 OK

> Aider will edit these files:
  - app/main.py
  - tests/test_health.py

> Applied edit to app/main.py
> Applied edit to tests/test_health.py
> Committed: "Add /healthz endpoint with test"

Each response declares which files Aider will edit, applies them, and creates the git commit. Not autocomplete — conversational task delegation.

6.3 Repo Map — Token-Efficient Context

One of Aider's signature inventions is the Repo Map. Sending every file in a big repo balloons tokens, so Aider builds a "map" of class and function signatures and sends only that.

The model reads the map, decides which files deserve a full read, and asks for them. That's why Aider feels light on a monorepo.

6.4 Model Support

Aider supports virtually every major model via BYOK — Claude 4.5/5, GPT-5, Gemini 2.5 Pro, DeepSeek, Qwen, local Ollama, and so on. The LiteLLM library plugs it into 100+ backends.

6.5 Strengths and Weaknesses

Strengths. Most git-friendly. CLI-first works with any editor. Token-efficient Repo Map. Open-source. Free (you only pay your API).

Weaknesses. No GUI — punishing if you dislike the CLI. Weak IDE integration (you launch a separate terminal inside another IDE). No autocomplete like Cursor's.

7. Continue / Roo Code — The Open-Source Options

7.1 Continue — The Oldest Open-Source IDE Plugin

Continue launched May 2023 as an open-source IDE plugin for VSCode and JetBrains, offering side-panel chat, inline edit, and autocomplete.

Highlights:

  • BYOK first — Anthropic, OpenAI, Mistral, Ollama local, self-hosted, anything.
  • Block-level customization — Users can define context providers, slash commands, and tools.
  • Series A in 2024 — Heavybit Partners led, and enterprise sales started.

Continue was the "pre-Cline standard." Continue added agent features in 2025, but most teams consider Cline / Roo Code more refined for agentic work.

7.2 Roo Code — The Cline Fork Evolves

Restating from section 5:

  • Forked from Cline.
  • Many modes — Code, Architect, Ask, Debug, Custom Modes. Users can add their own.
  • MCP (Model Context Protocol) support landed fastest. Anthropic announced MCP in November 2024 as an external-tool integration standard; Roo Code embraced it most aggressively.
  • Boomerang Tasks — Delegate a task to another mode and get the result back.

Roo Code is "Cline plus more knobs." Pick Roo Code for breadth, Cline for stability.

7.3 Other Open-Source Options — Aider, Open Interpreter, Smol Developer

  • Aider — Covered in section 6.
  • Open Interpreter — Launched September 2023, a code-execution-first CLI. "ChatGPT Code Interpreter, locally."
  • Smol Developer — A May 2023 viral experiment that built whole apps from a one-line spec. Not actively developed today but remembered as a pioneer of agentic coding.

8. Zed AI — Zed Editor's AI Features

Zed is the Rust-based editor from the founders of Atom, open-sourced in January 2024. Speed and real-time collaboration are its core, and from late 2024 it integrated Zed AI as a native workflow.

8.1 What Sets Zed AI Apart — Deeply Integrated AI

Cursor and Windsurf fork VSCode; Zed was written from scratch. Rust, GPU-accelerated rendering, collaboration baked in from day one.

Zed AI layers three pieces on top:

  • Assistant Panel — Side-panel chat, inline edit.
  • Edit Predictions — Next-edit prediction like Cursor Tab, powered by Zed's own model (Zeta).
  • Agent (July 2025–) — A multi-step agent landed in late 2025.

8.2 Models and Context

Zed AI supports BYOK across Anthropic, OpenAI, Google, Ollama, etc. There is also a Zed-run "Zed AI" subscription ($20/month) so you can skip BYOK entirely.

Context collection is LSP / Tree-sitter first. Zed already has deep language-server integration and reuses that tree directly.

8.3 Strengths and Weaknesses

Strengths. Editor speed is unmatched. Collaboration features. Clean design. Fits the Rust ecosystem.

Weaknesses. No VSCode extension ecosystem. Fewer plugins. AI features arrived later than in Cursor / Windsurf. Some languages are weakly supported (notably .NET and parts of mobile).

9. Claude Code (Anthropic, February 2025) — CLI Agent

In February 2025, Anthropic shipped Claude Code. Identity in one line — "a Claude agent that runs in your terminal." No IDE required, works alongside any editor.

9.1 Claude Code's Identity — Full Agent Without an IDE

Install is one npm line:

npm install -g @anthropic-ai/claude-code

Run:

$ claude
> implement a rate limiter middleware for express

> [Reads package.json, finds Express]
> [Reads src/app.ts]
> [Edits src/middleware/rateLimiter.ts]
> [Runs npm test]
> All tests pass.

You don't open an IDE. Vim, Emacs, Notepad, anything — Claude Code runs alongside it. That's the appeal of a CLI agent.

9.2 Core Features — Tools, Subagents, MCP

Tools. Read, Edit, Write, Bash, Grep, Glob, WebFetch, WebSearch. The model invokes these directly.

Subagents. Split a big task into subtasks and run them in parallel — "analyze these five files at once."

MCP (Model Context Protocol). Anthropic's November 2024 external-tool integration standard. Claude Code connects to MCP servers for GitHub, Slack, Linear, Postgres, and more.

Hooks. Bind user scripts to events like PreToolUse, PostToolUse, Stop. Enforce policies such as "always run prettier after every edit."

9.3 Pricing — Claude Pro / Max + API

  • Claude Pro — $20/month, includes a Claude Code usage allotment.
  • Claude Max — 100/month(5x)or100/month (5x) or 200/month (20x). For heavy users. Launched April 2025; the fastest-growing subscription Anthropic has shipped.
  • Direct API — Just bring a key and pay per token.

The Max tier mirrors the usage ladder of ChatGPT Plus / Pro, and Claude Code power users moved onto it quickly.

9.4 Strengths and Weaknesses

Strengths. Tightest integration with Anthropic's models. CLI-first plays well with any editor. Subagents, MCP, and hooks are powerful. As a first-party tool, stability and feature pace are excellent.

Weaknesses. Anchored to Claude (other models supported only weakly). Pro/Max prices sting for heavy users. CLI-first means weaker visual UX than IDE tools.

10. Codex CLI (OpenAI, April 2025) — The Anthropic Counter

Two months after Anthropic's Claude Code shipped in February 2025, OpenAI open-sourced Codex CLI — April 2025. Two giants in the same category.

10.1 Codex CLI's Identity — Open-Source GPT Agent

The name is confusing, because OpenAI Codex from 2021 (the GPT-3 code model) was a different thing. Codex CLI is the new CLI agent shipped in April 2025.

Highlights:

  • Open-source (Apache 2.0) — Code on GitHub.
  • GPT-5 first — OpenAI models lead, but routing options exist.
  • Sandboxed execution — macOS Seatbelt / Linux landlock isolate commands.
  • Multimodal input — Image and screenshot support.

10.2 How It Works

$ npm install -g @openai/codex
$ codex
> refactor src/auth/* to use the new SessionManager

> [Reads 7 files in src/auth/]
> [Plans 4 edits]
> [Asks for approval]
> y
> [Edits complete]
> [Runs npm test]

The UX is nearly identical to Claude Code. The differences are model, open-source posture, and OpenAI-ecosystem integration.

10.3 ChatGPT Subscription Integration

Late 2025, OpenAI started bundling Codex CLI usage into ChatGPT Plus / Pro. ChatGPT Plus (20/month)getsafreeCodexCLIallotment.ChatGPTPro(20/month) gets a free Codex CLI allotment. ChatGPT Pro (200/month) gets a much larger one.

That directly competes with Claude Code (Claude Pro/Max). The pricing model is nearly identical.

10.4 Strengths and Weaknesses

Strengths. Open-source. Best integration with OpenAI models. Bundled with ChatGPT. Safe sandbox. Fast feature pace.

Weaknesses. Claude-model support is limited (hard to swap in Anthropic). Less than a year old, so stability lags Claude Code by a step. Smaller community resources so far.

11. GitHub Copilot Workspace + Copilot Agent

GitHub Copilot started in 2021 as autocomplete; by 2026 it has shipped all four stages — autocomplete, chat, workspace, agent.

11.1 The Four-Stage Evolution

  • June 2021 — Copilot autocomplete.
  • March 2023 — Copilot Chat.
  • July 2024 — Copilot Workspace beta announced.
  • October 2025 — Copilot Agent GA (evolution of Copilot Workspace).

11.2 Copilot Workspace — The Delegation Mode

Copilot Workspace is a browser-based work environment. Open a GitHub issue, click "Work on this in Copilot Workspace," and a separate browser environment walks you through:

  1. Spec — Copilot reads the issue and drafts a task spec.
  2. Plan — It plans which files to change and how.
  3. Implementation — You approve, it writes code.
  4. PR — It opens a PR with the change.

You can edit and approve at every step. A textbook example of "human-supervised agent."

11.3 Copilot Agent — Async Task Delegation

Copilot Agent went GA in October 2025 and goes a step further. Label a GitHub issue and Copilot auto-files the PR. No browser session required.

Flow:

  1. Add the "Copilot" label to a GitHub issue.
  2. Copilot works in a separate environment (minutes to tens of minutes).
  3. It submits a PR.
  4. A human reviews.

That is the GitHub version of "AI SWE" that Devin / Cognition showcased in 2024.

11.4 Pricing

  • Copilot Individual — $10/month, autocomplete and chat baseline.
  • Copilot Pro — $19/month (from May 2025), more usage and agent options.
  • Copilot Pro+ — $39/month, top tier usage.
  • Copilot Business — $19/seat/month.
  • Copilot Enterprise — $39/seat/month plus Workspace/Agent usage.

Workspace and Agent usage often get billed separately depending on plan.

11.5 Strengths and Weaknesses

Strengths. Deepest GitHub integration. Highest enterprise penetration. Supports Microsoft, OpenAI, and Anthropic models. The PR-grain async agent is powerful.

Weaknesses. Many users say Cursor / Cline feel smoother as IDE agents. Value drops outside GitHub Enterprise. Model selection can feel opaque.

12. Sourcegraph Cody / Tabnine / Augment

12.1 Sourcegraph Cody — The Enterprise Code-Search King

Sourcegraph has been building "code search for big companies" since 2013. In June 2023 it layered Cody, an AI coding tool, on top of that search infrastructure.

Highlights:

  • Enterprise context — Uses Sourcegraph's index of the whole company codebase.
  • VSCode / JetBrains extension — Works in any editor.
  • On-prem available — Sourcegraph Enterprise supports self-hosting.
  • BYOK — Anthropic, OpenAI, Google, and self-hosted models all supported.

For massive monorepos (tens of millions of lines), Cody's indexing infrastructure is widely seen as the strongest at pulling precise context.

Pricing: Free / Pro $9/month / Enterprise separate.

12.2 Tabnine — The Self-Hosted / On-Prem King

Tabnine has been around since 2018. From day one it prioritized "protecting enterprise IP" — your code never leaves the company; you can run the model in-house.

Highlights:

  • Local / on-prem model execution — Self-host inside your VPC.
  • Privacy and IP protection — Never trains on your code.
  • Agent features added in 2025 — Tabnine joined the agent party, late but it joined.
  • Compliance market — Strong in banks, defense, and government.

Pricing: Pro 12/month/Enterprise12/month / Enterprise 39/seat/month.

It's quieter in the consumer conversation than Cursor / Windsurf, but for compliance-heavy organizations it's often the first choice.

12.3 Augment — The Context-Engine Challenger

Coming out of stealth in April 2024, Augment brought a "context engine" as its weapon — arguing that pulling the right context from a giant monorepo is the real challenge.

Highlights:

  • Company codebase cloud indexing — Similar to Sourcegraph Cody.
  • Context engine — Uses call graphs and symbol graphs, not just embeddings.
  • Series B in 2024 — Sutter Hill led; valuation disclosed.
  • VSCode / JetBrains extension.

Augment's pitch: "If Cursor is great on small projects, Augment is better past 500k lines."

Pricing: Enterprise per-seat tiers.

13. Pricing Models Are Changing — Free-Tier Squeeze, Usage-Based (Claude Max, Cursor Pro)

The 2026 AI coding pricing landscape differs from 2023 in two ways.

13.1 The Free-Tier Squeeze

In 2023, Copilot had broad free tiers for students and OSS maintainers, and Codeium offered nearly unlimited free autocomplete. As of May 2026:

  • Cursor Hobby — Free, but premium-model calls capped at 50/month.
  • Windsurf Free — Usage cut significantly.
  • Copilot Free — Free only for students and OSS maintainers; general $10/month.
  • Claude Code free — Doesn't exist. Need Claude Pro ($20) or API access.
  • Codex CLI free — A small bundle inside ChatGPT Free, at most.

The reason is simple: model costs went up. A single user can burn hundreds of thousands of tokens a day, and free can no longer afford it.

13.2 The Usage Ladder — 20/20 / 100 / $200

The big 2025 change was that "usage-ladder subscriptions" became standard.

  • ChatGPT Plus 20/month,∗∗PlusPro∗∗20/month, **Plus Pro** 200/month.
  • Claude Pro 20/month,∗∗Max5x∗∗20/month, **Max 5x** 100/month, Max 20x $200/month.
  • Cursor Pro 20/month,∗∗Ultra∗∗20/month, **Ultra** 200/month.
  • Copilot Pro+ $39/month.

A 200/monthtiersolidifiedlate2025.Themarketconvergedon"heavyuserspay200/month tier solidified late 2025. The market converged on "heavy users pay 200." Team seats settled around $40–60.

13.3 Token Pay-as-You-Go vs Subscription

A single big task can cost 1–5inrawmodeltokens.Runtensuchtasksaday,andyou′reat1–5 in raw model tokens. Run ten such tasks a day, and you're at 30–150 daily — $1,000–4,500 a month.

For those users a subscription is meaningless — direct token billing is cheaper. That's why BYOK tools like Cline / Aider / Roo Code are popular with heavy users: you watch your token cost and control it.

For light users the subscription is the clear deal — $20 a month for "unlimited within caps."

14. Korea / Japan Adoption — Toss, Kakao, Mercari, CyberAgent

14.1 Korea — Toss, Kakao, Naver

Toss (Viva Republica) brought in GitHub Copilot Enterprise across the company in 2024, then ran department-by-department PoCs on Cursor and Claude Code through 2025 before expanding. Toss's engineering blog reported that "Cursor cut PR cycle time by 30%." Internally Toss maintains a shared prompt library aligned to its code standards.

Kakao rolled out GitHub Copilot Business company-wide in 2024 and in 2025 piloted its own AI assistant integrated with Kakao Cloud. Kakao Enterprise has published a case study of self-hosting Continue on top of its KoGPT successor model.

Naver has been running a code assistant on top of HyperCLOVA X internally since 2023, opening parts of it externally in 2025. Naver restricts external API usage for security reasons and prefers in-house models.

Coupang, Woowa Brothers, and LINE Korea all adopted GitHub Copilot Business or Enterprise. Coupang reportedly pairs it with Sourcegraph Cody for codebase indexing.

14.2 Japan — Mercari, CyberAgent, LINE/LY

Mercari adopted GitHub Copilot Business in 2023; by 2024 daily usage among engineers was effectively universal. In 2025 Mercari began rolling out Cursor department-by-department. The Mercari engineering blog has published comparisons of Copilot Workspace and Cursor Composer.

CyberAgent, true to a company that owns its own LLMs (CALM series), self-hosts its AI coding stack. It published a 2024 case study on running Continue against its own model. In 2025 it also rolled in GitHub Copilot in parallel.

LINE / LY (LY Corporation) brought in Copilot Business in 2024 and is reportedly running in-house model PoCs through 2025. Post-merger with Yahoo Japan, internal AI coding policies are being unified.

DeNA, SmartHR, and Money Forward have all rolled out GitHub Copilot or Cursor, and Cursor adoption among Japanese startups has accelerated quickly.

14.3 Common Patterns — Security First, Rising BYOLLM Interest

What large Korean and Japanese enterprises share:

  1. Rejecting external code transmission — Many companies flat-out refuse to send code to external APIs. Tabnine, Sourcegraph Enterprise, and Continue + in-house models are preferred.
  2. Copilot Business code-protection clause — Copilot Business and above guarantee no training on user input, which lowered the bar for entry.
  3. Open-source tools on top of in-house LLMs — Companies like CyberAgent, Naver, and Kakao that own LLMs layer open-source clients (Continue, Cline) on top.
  4. Late-2025 Cursor acceleration — UX advantages drove Cursor adoption to start displacing Copilot.

15. Who Should Pick What — Full-Stack / CLI Lover / Team / Student / Free

15.1 Decision Tree

Who are you?

Full-stack solo dev?
├── Want autocomplete + agent → Cursor Pro ($20)
├── Free first → GitHub Copilot Free (student/OSS) or Continue + own key
└── Prefer OpenAI → Windsurf Pro ($15)

Senior who lives in the CLI?
├── Prefer Claude → Claude Code + Claude Pro ($20) or Max ($100/$200)
├── Prefer GPT → Codex CLI + ChatGPT Plus ($20) or Pro ($200)
└── git-friendly + any model → Aider + own API key

Want agents but won't leave VSCode?
├── Prefer stability → Cline + own API key
├── Prefer experimental features → Roo Code + own API key
└── Bound by company policy → GitHub Copilot Agent

Large monorepo (tens to hundreds of millions of lines)?
├── Indexing first → Sourcegraph Cody or Augment
├── Compliance first → Tabnine (on-prem)
└── Cloud OK → Cursor + @Codebase

Enterprise?
├── Security max → Tabnine Enterprise (on-prem) or Cody Enterprise
├── GitHub-centric → Copilot Enterprise + Workspace
├── Own LLM available → Continue or Cline + in-house model
└── General rollout → Cursor Business or Copilot Business

Student / free?
├── Verifiable student → GitHub Copilot Free
├── OSS maintainer → Copilot Free
├── BYOK with own key → Continue + Anthropic/OpenAI free credits
└── Fully free → Aider + DeepSeek/Qwen open models

15.2 Persona Recommendations

Persona 1 — Indie full-stack dev. Cursor Pro ($20). Autocomplete, chat, and Composer in one screen — the UX is unmatched. Cost is reasonable.

Persona 2 — Senior backend dev who lives in the CLI. Claude Code + Claude Max ($100) or Aider + own key. Everything stays in the terminal. You control model spend.

Persona 3 — Only occasional toy projects. GitHub Copilot Free (student) or Continue + open models. No big work, so free is enough.

Persona 4 — Large company backend team. Copilot Enterprise + in-house Sourcegraph Cody. Security and compliance are vetted, and GitHub integration is deep.

Persona 5 — Startup team of 5–20. Cursor Business ($40/seat) or Windsurf Teams. Per-seat usage is predictable; UX is fast.

Persona 6 — Data / ML engineer. Cursor Pro or Continue + own key. Notebooks and scripts thrive in IDE-style tools, and free model swap-in matters.

Persona 7 — Security / finance / government. Tabnine Enterprise (on-prem) or Sourcegraph Cody Enterprise. For organizations that cannot send code outside.

Persona 8 — Want both Anthropic and OpenAI models. Cline or Roo Code + both API keys. You route between models yourself.

15.3 Recheck in Six Months

These recommendations are May 2026. Given the speed of change, revisit in six months:

  • Cursor's pricing direction (Series B cash could expand free tiers or push usage billing harder).
  • Whether ChatGPT-bundled Windsurf settles in.
  • Copilot Agent PR quality (today reports say 30–50% are merge-ready as-is).
  • MCP adoption. A stronger external-tool standard amplifies Cline / Roo Code / Claude Code.
  • Open-source model quality (DeepSeek, Qwen). Cheaper BYOK makes BYOK tools more attractive.

References

Discuss on Twitter • View on GitHub