leejk/ jk lee

Coding Agents: The Fork Is at the Model · 2026.05

Cursor — Visual IDE + Its Own Model

The daily editor for 64% of the Fortune 500

·
#coding-agents#cursor#landscape

Cursor stakes out the visual-IDE form factor plus BYOK multi-model plus two proprietary models of its own (Tab and Composer), with keystroke-granularity tab completion as its core — at 64% of the Fortune 500 and $2B ARR it took the daily-coding IDE market, the exact mirror of the CLI-first Claude Code and Codex. Its weaknesses are VS Code fork dependence, the 2026-04 pricing restructure, Composer context cutoff, no CLI-first autonomy, and a thin extension layer, but the senior consensus still holds: daily Cursor, deep refactor on another first-party agent.

TL;DR. Cursor's position is visual IDE + BYOK multi-model + two proprietary models of its own (Tab and Composer). Tab completion is its strongest fork and its core, with Composer (2025-10), Agent Mode, and Background Agent extending it onto the autonomy axis too. As of 2026-02, $2B ARR, 64% of the Fortune 500, Stripe at 80%. The exact mirror of Claude Code and Codex's CLI-first approach — the domain locked inside a visual IDE is both its core and its limit. The senior consensus still holds: daily Cursor, deep refactor on another first-party agent.

The Core

In the coding-agents category overview, Cursor was filed as the market-share-leading IDE, a VS Code fork. As of 2026-05 it has expanded one step further — visual IDE form factor + BYOK multi-model (OpenAI/Anthropic/Google/xAI) + two proprietary models of its own.

The two proprietary models are the key fork.

  • Tab — a proprietary, RL-trained model dedicated to code completion. It predicts not the next line but the next action — writing the next line, jumping to another file, refactoring a function, all at once (promptlayer analysis).
  • Composer — Cursor's first proprietary coding LLM, unveiled in Cursor 2.0 (2025-10). An MoE (mixture-of-experts) architecture, RL-trained inside real codebases. It completes agentic coding tasks in under 30 seconds, 4× faster than comparable systems (promptlayer announcement post).

Where Claude Code bet on seven extension types and Codex bet on multi-surface + an autonomous cloud sandbox, Cursor bets on visual IDE form factor + its own model. A position that takes BYOK freedom and own-model differentiation at the same time — the fork where the application layer reaches into the model layer (bdtechtalks analysis).

Five Strengths

1. The strongest tab-completion position — the Tab proprietary model

Tab isn't generic LLM autocomplete — it's RL-trained specifically for code completion. It reads the current task, recent changes, and related files as context and predicts the next action (write the next line, jump to another file, refactor a function) in multi-line, multi-cursor form (promptlayer analysis).

This is Cursor's core in the coding-agents category — the immediacy of inline suggestion. If Claude Code and Codex operate at the granularity of a terminal response, Cursor Tab operates at the granularity of a keystroke. And here it has almost no competition — while other IDE assistants use generic LLMs, Cursor bet on a dedicated model.

2. Composer + Agent Mode + Background Agent — three tiers of autonomy

Composer is the UI; Agent is the mode inside it. Multi-file editing starts in Composer (Cmd+I), and the Agent-mode toggle turns on autonomous execution — reading and changing files, running terminal commands, and iterating without human approval.

Background Agent is off-machine autonomy. A single GitHub issue lands as a draft PR while you're away. Same spirit as Claude Code's GitHub Action and Codex's cloud sandbox — all three first-party agents entered the same ground at roughly the same time.

On top of that, the .cursor/rules/ format turned AI behavior into version-controlled, file-scoped config. Same spirit as Claude Code's CLAUDE.md and Codex's plugin discovery.

3. BYOK multi-model + its own model — both at once

OpenAI, Anthropic, Google, and xAI are all selectable via BYOK, plus Tab and Composer. You toggle a different model per task — o3 for debugging, Composer for fast authoring, Opus 4.7 for big refactors, Gemini 3.1 Pro for multi-modal.

While Claude Code and Codex carry first-party lock-in as a weakness, Cursor layers its own model on top without that weakness. The fork where the application layer reaches into the model layer.

4. 64% of the Fortune 500 + $2B ARR — the enterprise default

Quoting the Cursor Enterprise page — 64% of the Fortune 500, 50,000+ enterprises, 100M+ enterprise code lines/day. As of 2026-02, $2B ARR (Sacra / AI Funding Tracker roundup), double the $1B ARR of 2025-11 in three months.

Flagship adoption — OpenAI itself, Nvidia (40,000 engineers), Stripe, Shopify, Adobe, Uber, Coinbase, Midjourney. Stripe co-founder Patrick Collison: "Cursor adoption at Stripe went from single digits to over 80%" (digitalapplied roundup). The default IDE of the primary F500 market has hardened.

The signal here is that the visual IDE has settled in as the daily editor. While CLI-first agents take depth, Cursor took the everyday coding IDE — the one that consumes the largest share of the workday.

5. Visual IDE — ground CLI agents can't reach

The clearest differentiation. Where Claude Code, Codex CLI, and Aider are terminal-core, Cursor holds the entire visual domain of VS Code — side-by-side diffs, multi-file tabs, an integrated debugger, visual git, the UI extension ecosystem, and code you touch with a mouse.

In JetBrains AI Pulse Jan 2026 — Cursor 18% · Claude Code 18% · Copilot 29% — a tie. The visual-IDE assistant is the largest segment of the market, and Cursor is its AI-native option. In the same visual domain, GitHub Copilot leads at 29%, but the AI-first design standard belongs to Cursor.

Five Weaknesses

1. VS Code fork dependence — Microsoft policy-change risk

Cursor layers its own stack on top of a VS Code fork. VS Code extension-marketplace policy, VS Code build-system changes, and Microsoft license policy are all wired into ground Cursor doesn't control.

Head-on with the fact that GitHub Copilot is Microsoft's own product — the deeper Copilot takes VS Code's internal integration, the more pressure piles on Cursor to widen the fork distance. For a company whose core is a visual IDE, upstream dependence is the biggest long-term risk.

2. The 2026-04 pricing-restructure controversy

Cursor restructured its pricing model in 2026-04. Pro $20 became a $20-credit-pool basis, leaving users on the old slot-based model to adapt to per-model credit billing. "What Happened to Cursor Pricing?" hardened into a search term — that's how often the controversy recurred within the quarter.

Becoming 6 tiers — Pro+ $60 (3× credits) · Ultra $200 (20× credits) · Business $40/user · Enterprise custom — raised the complexity. More users fled to BYOK — wiring in Anthropic/OpenAI direct APIs removes the Cursor markup but also loses the credit pool (Vantage analysis).

This pricing fork is the flip side of the model-price explosion. GPT-5.5 doubled its API price on 2026-04-23, and Anthropic's Max $100/$200 tiers settled in alongside it. The structure where Cursor takes a markup is the ground colliding with the model-price explosion.

3. Composer context cutoff — truncates on big tasks

The weakness flagged in the coding-agents category overview — Composer truncates below the underlying model's full context window — the agent layer manages context more narrowly than the model allows. It can't take in multi-file work in a single breath, all the way through. The exact opposite of Claude Code's 1M context at standard pricing.

On big refactors and long-context multi-file work, you have to toggle the model to Opus 4.7 inside Cursor just to patch it over. Even then, the signal accumulates that the agent layer's context management can't use the model's full context — same spirit as Codex's 272K default-context weakness.

4. No CLI-first autonomous position

Cursor's core is a visual IDE. Background Agent took one step into off-machine autonomy, but the autonomy depth of CLI-first agents — Claude Code's GitHub Action auto-PR, Codex's multi-hour cloud-sandbox autonomy — is weak in Cursor.

There's little ground where a PR runs to the finish without Cursor — turn the IDE off and autonomy weakens to nothing beyond Background Agent. CI auto-fix, remote agents, multi-hour autonomy become the territory of other first-party agents.

5. A thin extension layer — only .cursor/rules/ + MCP

Cursor MCP and .cursor/rules/ exist, but next to Claude Code's seven extension types + Plugin marketplace and Codex's evolving plugin marketplace, the layer is thin.

Against 6,700+ skills · 840+ MCP servers · 2,500+ marketplaces hardened on top of Claude Code, the Cursor Marketplace is still settling its categories as of 2026-05. The visual IDE form factor is a step behind in the plugin domain — it inherits the Microsoft VS Code marketplace as a baseline, but the AI-native plugin standard is being defined first by Anthropic and OpenAI.

Use Cases — When to Reach for Cursor

1. Daily coding / writing new features — Tab's inline-suggestion immediacy. Keystroke-granularity work is the highest-frequency activity. Cursor for daily is half the senior consensus.

2. Visual work / UI design / visual debugging — side-by-side diffs, integrated debugger, multi-file tabs, visual git. Work you can't see in a terminal. Ground CLI agents fundamentally can't reach.

3. The standard IDE for F500 / large teams — 64% F500 · Stripe 80% · Nvidia 40,000 engineers. Where team standardization, SSO, SOC, and enterprise audit are the first gate.

4. BYOK multi-model + own-model toggle — workflows that swap o3 for debugging, Composer for fast authoring, Opus 4.7 for big refactors, Gemini for multi-modal per task. Where model freedom comes first.

5. Exploring an unfamiliar codebase / onboarding — Tab's jump-to-definition + next-action prediction is strong for navigating an unfamiliar codebase. The AI-native IDE's visual domain is strong at reading code back.

Synergies with Other Agents

Cursor + Claude Code — the core of the senior consensus

The most settled position. The Cursor for daily editing, Claude Code for heavy refactor noted in the Claude Code review is the senior consensus. In the same git repo, they don't conflict even running side by side.

The split:

  • Cursor: tab completion · writing new features · single-file editing · visual debugging · UI work
  • Claude Code: multi-file refactor · 1M context · running skills/plugins · autonomous GH Action · multi-agent

It's common to keep CLAUDE.md (Claude Code) and .cursor/rules/ (Cursor) as rules for different layers. The two tools split at the agent layer but share the git repo and file system.

Cursor + Codex extension — OpenAI first-party inside the IDE

The ground where Codex shipped an official extension into forked IDEs like Cursor and Windsurf. A Cursor user can call the OpenAI Codex agent directly on top of that IDE. Cursor's visual layer + Codex's cloud-sandbox autonomy combine in one IDE.

This is where Codex's multi-surface strategy works best, and the mirror is that Cursor having BYOK makes it a channel for OpenAI too.

Cursor + Background Agent + CI

Wire Background Agent into GitHub Actions for issue trigger → automatic PR creation. Same spirit as Claude Code's GH Action and Codex's cloud sandbox, but hardened separately inside Cursor. The path for F500 adoption teams to wire into internal CI.

Cursor + BYOK multi-model toggle — cross-model adversarial in-IDE

Cursor's BYOK freedom implements bitter-medicine's cross-model review pattern inside a single IDE. You can run write the same code with Composer → review with Opus 4.7 → review once more with Gemini with a single model toggle.

The ground where Claude Code and Codex had to wire in an external MCP server or adversarial-review skill is, in Cursor, a default capability. It wires the judge pattern into the IDE granularity of a solo workflow.

Synthesis

The Claude Code review fixed the category claim as even if BYOK takes the model, the first-party takes the extension layer, and the Codex review added that the agent's own axis of differentiation sits on different ground even between two first-party agents.

Cursor draws the line once more — the axis of differentiation splits even between first-party and the application layer.

  • Claude Code: seven extension types + 1M context (layer depth)
  • Codex: multi-surface + autonomous cloud sandbox + token efficiency
  • Cursor: visual IDE + BYOK multi-model + two of its own models (Tab and Composer)

The three axes sit in different dimensions. Market share split too — the visual-IDE market (the largest position) is split by Cursor and Copilot, while the CLI-first agent market (senior / power-user) is split by Claude Code and Codex. Daily coding is in the visual; deep work is in the CLI.

The senior consensus has been consistent — daily Cursor, deep refactor on another first-party agent. Cursor and Codex generate, Claude Code selects is the judge pattern applied three ways. The fork where Cursor's own model (Composer) enters the first-party model market is the biggest signal of 2026 Q3 — if the application layer reaches down into the model layer, the category claim ("the real fork is at the model") gets shaken once more.

For now, the single claim suffices: Cursor took the visual-IDE position and, with its own model, went one layer deeper. VS Code fork dependence, the 2026-04 pricing restructure, Composer's context cutoff, the absent CLI-autonomy position, and the thin extension layer are weaknesses, but the daily-editor position is the domain with the largest share of the workday, long-term. The asymmetry of taking that ground is wired into a $50B market value and $2B ARR.

References

Primary sources (Cursor official)

Pricing / revenue

Technical / analysis

Comparisons / market data

Same topic