Cursor (code editor)
Last reviewed
Sources
48 citations
Review status
Source-backed
Revision
v9 ยท 8,113 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
Sources
48 citations
Review status
Source-backed
Revision
v9 ยท 8,113 words
Add missing citations, update stale details, or suggest a clearer explanation.
Cursor is an AI-powered code editor developed by Anysphere Inc. Built as a fork of Visual Studio Code (VS Code), Cursor integrates large language model capabilities directly into the editing experience, offering AI-driven autocomplete, multi-file editing, inline code generation, and autonomous agent workflows. Since its launch in 2023, Cursor became the fastest B2B software company in history to reach $1 billion in annual recurring revenue, crossing that mark in roughly two years and outpacing prior record holders Slack, Zoom, and Snowflake [45]. By early 2026 it had surpassed $2 billion in annualized revenue, attracted over two million total users (with more than one million paying customers), and served roughly 50,000 enterprise teams [1][7][32][45].
Cursor has become a central product in the broader trend of AI-assisted software development, competing with GitHub Copilot, Windsurf (formerly Codeium), Claude Code, and other AI coding tools. Its rapid valuation growth, from $400 million in August 2024 to a reported $50 billion in April 2026, reflects the intensity of investor interest in AI development tools [2][32]. In April 2026, Cursor shipped its third major version, Cursor 3, which rebuilt the interface around an agent-first model in which most code is written by AI and the developer's role shifts toward orchestrating a fleet of parallel agents [33].
Cursor is used to write, edit, review, and maintain software with the help of artificial intelligence. Developers use it for AI autocomplete that predicts multi-line edits, inline natural-language editing, codebase-wide chat and question answering, multi-file refactors, and autonomous agents that plan tasks, run terminal commands, and open pull requests. It is positioned as a drop-in replacement for VS Code, which remains the most widely used development environment: 75.9% of respondents to the Stack Overflow 2025 Developer Survey reported using VS Code, while Cursor itself was used by 18% of respondents in the same survey, its first year on the list [46]. Cursor's growth has been driven by professional and enterprise software teams: by early 2026 roughly 60% of its revenue came from enterprise customers, and tools built on Cursor were writing an estimated 150 million lines of enterprise code per day [32].
Anysphere Inc. was incorporated in 2022 by four MIT undergraduate students: Michael Truell (CEO), Sualeh Asif (Chief Product Officer), Arvid Lunnemark (Chief Technology Officer), and Aman Sanger (Chief Operating Officer) [3]. The four founders met during their undergraduate studies at the Massachusetts Institute of Technology, where they bonded over hackathons and a shared conviction that artificial intelligence would fundamentally transform software development.
After graduating, all four rejected offers from major technology companies. They did not immediately build a code editor. Instead, Anysphere spent nearly a year working on mechanical engineering tools, a period that Truell has described as "wandering in the desert" [3]. The pivot to building an AI-powered code editor came after the founders concluded that the developer tools market offered a larger opportunity and better alignment with advances in large language models.
Anysphere raised an $8 million seed round led by the OpenAI Startup Fund, with participation from former GitHub CEO Nat Friedman and Dropbox co-founder Drew Houston, among others [4]. Neo, which runs both an accelerator and a venture fund, led the pre-seed investment. The company launched Cursor in 2023 as a VS Code fork with deep AI integration, positioning it as an alternative to GitHub Copilot that offered more comprehensive AI features beyond simple code completion.
Cursor's adoption accelerated rapidly through 2024 and 2025. The product gained traction among individual developers first, then expanded into enterprise teams. By mid-2025, Cursor was used by over half of the Fortune 500, including NVIDIA, Uber, Spotify, Instacart, and OpenAI itself [5]. Major League Baseball also adopted the platform, illustrating its reach beyond traditional technology companies. By March 2026, approximately 67% of the Fortune 500 and roughly 70% of the Fortune 1,000 were using Cursor, with named enterprise customers including Adobe, Salesforce, and PwC [32].
The term "vibe coding," popularized by Andrej Karpathy in early 2025, became closely associated with Cursor. The phrase describes a development workflow where programmers describe their intent in natural language and let AI handle much of the actual code writing, a style of work that Cursor's interface was specifically designed to support. Notably, Cursor CEO Michael Truell warned in December 2025 that vibe coding could create "shaky foundations" in software systems, cautioning that building layers without understanding the code can cause things to "start to kind of crumble" over time [22].
Cursor's revenue scaled faster than any prior business-to-business software company. The product reached $100 million in annualized revenue in January 2025, $500 million by June 2025, $1 billion by November 2025, and $2 billion by February 2026 [45]. Reaching $1 billion ARR in roughly two years made Cursor the fastest B2B software company on record to hit that milestone, ahead of benchmarks such as Slack (about four years) and Zoom (about five years) [45]. Anysphere achieved this with a relatively small team of around 300 employees in late 2025.
| Milestone | Approximate timing | Note |
|---|---|---|
| $100M ARR | January 2025 | Reached within roughly a year of broad adoption |
| $500M ARR | June 2025 | Coincided with the $9.9B Series C |
| $1B ARR | November 2025 | Fastest B2B software company on record to $1B [45] |
| $2B ARR | February 2026 | Preceded the reported $50B round [32][45] |
| $6B+ ARR run rate | Forecast end of 2026 | Internal projection [32] |
Anysphere has used acquisitions and targeted hires to accelerate product development and build enterprise capabilities.
| Date | Target | Type | Purpose |
|---|---|---|---|
| November 2024 | Supermaven | Talent and product | AI code-completion startup founded by Jacob Jackson; team folded into Cursor, standalone product wound down in late 2025 |
| July 2025 | Koala | Acqui-hire | Engineering talent staffed a new enterprise-readiness team; Koala's CRM product not adopted, Koala shut down |
| 2025 | Resourcely founder | Key hire | Hired Travis McPeak (Resourcely co-founder/CEO) to lead Cursor's security team |
| December 2025 | Graphite | Acquisition | Cash-and-equity deal for the NY code-review startup, well above its prior $290M valuation; Graphite technology informed BugBot and PR review [32] |
Cursor has evolved through multiple major releases since launch. The 2.0 release in late 2025 marked the shift to an agent-first architecture, and 3.0 in April 2026 reorganized the editor around a dedicated Agents Window.
| Version | Release Date | Key Features |
|---|---|---|
| 0.1 | Early 2023 | Initial launch as VS Code fork with AI chat and completions |
| 0.44 | Early 2025 | DeepSeek R1 and DeepSeek v3 model support, conversation summarization |
| 0.45 | Early 2025 | New codebase understanding model, improved Tab model for long context |
| 0.50 | May 2025 | Background Agents, unified request-based pricing, Max Mode, refreshed inline edit |
| 1.0 | June 2025 | Credit-based pricing system, stability improvements |
| 2.0 | Late 2025 | Agent-first architecture, Composer model, BugBot, expanded background agents |
| 2.3 | Early 2026 | Automations, JetBrains IDE support, MCP Apps, Cursor Marketplace plugins |
| 2.6 | March 2026 | Interactive UIs in agent chats, team marketplaces, Debug mode, Composer 2 |
| 3.0 | April 2, 2026 | Agents Window, Design Mode, cloud agents, parallel agent orchestration, new PR review [33] |
| 3.1 | April 13, 2026 | Tiled Layout splits Agents Window into panes for parallel agent sessions [34] |
| 3.2 | April 24, 2026 | /multitask subagents, /worktree, /best-of-n, multi-root workspaces for cross-repo agents [35] |
| 3.3 | May 7, 2026 | PR review improvements, build plan in parallel, split-PR support, Security Reviewer beta [36] |
| 3.4 | May 13, 2026 | Cloud agent dev environments with multi-repo, Dockerfile setup, audit logs, scoped egress [37] |
Anysphere's fundraising history reflects one of the fastest valuation trajectories in startup history. The valuation climbed from $400 million in August 2024 to a reported $50 billion in April 2026, a roughly 125-fold increase in under two years [2][6][32].
| Round | Date | Amount | Valuation | Lead Investors |
|---|---|---|---|---|
| Pre-seed | 2022 | Undisclosed | Undisclosed | Neo |
| Seed | 2023 | $8M | Undisclosed | OpenAI Startup Fund |
| Series A | August 2024 | $60M | $400M | Andreessen Horowitz (a16z), Thrive Capital |
| Series B | December 2024 | $105M | $2.6B | Thrive Capital |
| Series C | June 2025 | $900M | $9.9B | Thrive Capital, Accel, Andreessen Horowitz, DST Global |
| Series D | November 2025 | $2.3B | $29.3B | Accel, Coatue Management |
| Series E (reported) | April 2026 | $2B+ | $50B | Andreessen Horowitz, Thrive Capital, NVIDIA, Battery Ventures [32] |
The Series A in August 2024, co-led by Andreessen Horowitz and Thrive Capital at a $400 million valuation, included participation from Stripe CEO Patrick Collison [6]. Four months later, the Series B brought the valuation to $2.6 billion. The Series C in June 2025 raised $900 million at $9.9 billion, and the Series D in November 2025 raised $2.3 billion at $29.3 billion, with Google and NVIDIA also participating [2]. In April 2026, multiple outlets reported Anysphere was in advanced talks for a $2B+ round at a $50 billion valuation, led by Andreessen Horowitz and Thrive Capital, with NVIDIA as a strategic co-investor and new investor Battery Ventures participating; the $50 billion figure represented roughly a 70% increase over the $29.3 billion valuation set just five months earlier [32]. The round followed Anysphere reaching $2 billion in ARR in February 2026, with internal forecasts of a run rate above $6 billion by the end of 2026 [32].
Cursor is built as a fork of VS Code, which means it inherits VS Code's extension ecosystem, settings, themes, and keybindings. Developers switching from VS Code can import their existing configuration with a single click. On top of this foundation, Cursor adds a suite of AI-powered features.
Cursor's Tab feature provides AI-powered code completions that go beyond single-line suggestions. The system uses a specialized Tab model that predicts not just the next line of code but the developer's next action, suggesting multi-line edits, entire function implementations, and cross-file refactors that ripple through the codebase. Unlike basic autocomplete, Tab is context-aware: it considers the surrounding code, open files, and recent changes to generate more relevant suggestions. Developers accept suggestions by pressing the Tab key [16].
| Capability | Traditional autocomplete | Cursor Tab |
|---|---|---|
| Scope | Single line or token | Multi-line, multi-edit |
| Context awareness | Current file only | Surrounding code, open files, recent changes |
| Edit type | Insertions only | Insertions, deletions, and modifications |
| Cross-file | No | Yes, suggests changes across related files |
| Action prediction | Next token | Next developer action (edit, navigate, refactor) |
| Speed | Instant | Near-instant (specialized lightweight model) |
The Tab model is optimized for speed, running on a lightweight specialized model that provides suggestions with minimal latency, typically appearing within 100 to 200 milliseconds of the developer's last keystroke. This responsiveness is critical for the feature to feel natural rather than disruptive to the coding flow [16].
The integrated chat panel allows developers to ask questions about their codebase, request explanations of code, generate new code, and get debugging assistance. Chat is aware of the project context and can reference specific files, functions, and symbols. Developers can attach files, documentation, or error messages to provide additional context.
The Cmd+K shortcut (Ctrl+K on Windows/Linux) opens an inline editing interface that allows developers to describe a desired change in natural language. Cursor generates a diff showing the proposed edits, which the developer can accept, reject, or modify. This feature is designed for quick, targeted modifications without switching to a separate chat interface.
Cursor indexes the entire project repository to provide codebase-wide context to its AI features. This means that suggestions and responses take into account not just the current file but the broader project structure, imported modules, type definitions, and coding patterns used throughout the repository. The indexing system enables features like "find usages" and "go to definition" to be enhanced with AI understanding.
One of Cursor's distinguishing features is the ability to propose and apply coordinated changes across multiple files simultaneously. When a task requires modifications to several files (such as adding a new API endpoint, which might involve changes to routing, controller, model, and test files), Cursor can generate all the necessary changes as a unified diff that the developer reviews before applying.
Agent mode allows Cursor to execute complex, multi-step tasks autonomously. When given a high-level instruction (such as "add user authentication to this application"), the agent plans the necessary steps, creates and modifies files, runs terminal commands, reads error output, and iterates until the task is complete. The developer can monitor progress, provide guidance, or intervene at any point.
In late 2025 and early 2026, Cursor expanded agent capabilities significantly [8]:
| Step | Action | Description |
|---|---|---|
| 1 | Task analysis | Agent reads the instruction and analyzes the codebase |
| 2 | Plan creation | Develops a step-by-step plan for the task |
| 3 | File creation/modification | Creates new files or edits existing ones |
| 4 | Terminal execution | Runs build commands, tests, installations |
| 5 | Error handling | Reads error output and iterates on fixes |
| 6 | Verification | Runs tests to verify the changes work correctly |
| 7 | Output | Presents diff for review or opens PR (background agents) |
Introduced with Cursor 3 on April 2, 2026, the Agents Window replaces the older Composer pane with a dedicated full-screen workspace for running many AI agents in parallel. Cursor describes the new interface as one that "allows you to run many agents in parallel across repos and environments: locally, in worktrees, in the cloud, and on remote SSH," treating each as a destination the user can move tasks between with one click [33]. Cursor 3.1 (April 13, 2026) added a Tiled Layout that splits the window into panes, each tracking a separate agent session [34].
Cursor CEO Michael Truell framed the release as the start of what he called "the third era of AI software development," in a manifesto published on the Cursor blog on February 26, 2026 [47]. Truell describes three eras: the first, Tab autocomplete, where the developer types and the model predicts the next line; the second, synchronous agents, where the developer describes a task and watches the agent execute it; and the third, arriving with Cursor 3, in which "fleets of agents" work autonomously while the developer defines the problem and reviews the finished artifacts [47].
The Agents Window introduces three commands that organize parallel execution:
| Command | Function |
|---|---|
/worktree | Creates a separate git worktree so an agent's changes happen in isolation from the user's current branch |
/best-of-n | Runs the same task in parallel across multiple models, each in its own worktree, then compares outcomes so the user can pick the best diff |
/multitask | Launches async subagents that parallelize requests and break larger tasks into smaller chunks executed simultaneously [35] |
Design Mode lets the user click on UI elements directly in a browser preview and annotate them visually instead of describing changes in text [33]. The agent receives those annotations as structured pointers, reducing iteration time on layout and styling. Design Mode integrates with the Cursor Browser visual editor (see below).
A single agent session in Cursor 3.2 can target a reusable workspace made of multiple folders, each typically a separate git repository [35]. This lets one agent prompt span frontend, backend, and shared libraries without retargeting. Multi-root workspaces also flow into cloud agent dev environments, reusing the same multi-repo configuration locally and in cloud sandboxes.
In early 2026, Cursor shipped Composer, its first proprietary agentic coding model, claiming it is four times faster than similarly capable models from other providers [8]. Composer was designed specifically for code generation and editing tasks and is integrated into Cursor's agent mode. To let the model sustain long agent runs, Anysphere trained Composer to compress its own context inside the reinforcement-learning loop: rather than relying on a separate multi-thousand-token summarization prompt, the model stops to write its own "phase summary," cutting context from more than 5,000 tokens down to roughly 1,000, using about one-fifth the tokens of the traditional approach while reducing compression errors by approximately 50% [48].
Anysphere released Composer 2 on March 19, 2026, the next generation of its in-house coding model [17][18]. The standard variant is priced at $0.50 per million input tokens and $2.50 per million output tokens, with a "Fast" variant at $1.50/$7.50 per million tokens. According to Cursor's and third-party benchmarks:
| Benchmark | Composer 2 | Claude Opus 4.6 | GPT-5.4 |
|---|---|---|---|
| Terminal-Bench 2.0 | 61.7 | 58.0 | 75.1 |
| CursorBench | 61.3 | Lower | Higher |
| SWE-bench Multilingual | 73.7 | Comparable | Higher |
| Input price ($/M tokens) | $0.50 | $5.00 | $2.50 |
| Output price ($/M tokens) | $2.50 | $25.00 | $15.00 |
Composer 2 edges out Claude Opus 4.6 on CursorBench and Terminal-Bench 2.0, where it scores 61.7 to Opus 4.6's 58.0, but GPT-5.4 still leads on raw benchmarks with 75.1 on Terminal-Bench 2.0 [18][38]. Anysphere positions Composer 2 on a Pareto frontier: at $0.50 per million input tokens it is roughly 90% cheaper per input token than Opus 4.6's $5.00 in the same accuracy band, making it the preferred default for high-volume parallel agent workloads [17][18][38]. Composer 2 runs at roughly 200 tokens per second in internal measurements, supporting rapid plan-act-verify iteration.
The Memories feature, introduced in 2025, allows Cursor's AI assistant to remember facts from conversations and apply them in future sessions. When enabled through the settings, Cursor generates a .cursor/rules/journal.mdc file that serves as a learning journal for each project, capturing important patterns, preferences, and project-specific intelligence. This persistent context helps the AI provide increasingly relevant suggestions over time as it learns the developer's coding style and project conventions [24].
BugBot is an automated code review feature that runs as part of Cursor's background agent infrastructure. When enabled, BugBot automatically reviews pull requests for bugs, logic errors, and potential issues before human review, functioning as an AI-powered first pass on code quality. BugBot includes "Fix in Cursor" prompts that allow developers to address flagged issues directly in the editor [19]. In May 2026, Anysphere announced BugBot would shift from $40-per-seat-per-month to usage-based billing for Teams and Individual plans, effective at the first renewal after June 8, 2026, and exposed a configurable effort level; Anysphere's internal benchmarks indicate high-effort runs find roughly 35% more bugs while resolution rate stays around 80% [39].
On April 30, 2026, Cursor introduced two always-on security agents that run alongside BugBot in the background-agent infrastructure [40]:
| Agent | What it does | Trigger |
|---|---|---|
| Security Reviewer | Inspects every PR for security vulnerabilities, authentication regressions, privacy and data-handling issues, agent tool auto-approvals, and prompt injection attacks; leaves inline comments with severity and remediation guidance | On every PR |
| Vulnerability Scanner | Runs scheduled scans of the codebase for known CVEs, outdated dependencies, and configuration issues; can post findings to Slack | Scheduled |
Security Reviewer launched in beta on Teams and Enterprise plans on May 1, 2026, complementing BugBot's correctness reviews with a security-focused second agent before human reviewers see the PR [40].
Cursor's terminal is AI-enhanced, allowing developers to describe commands in natural language and have the appropriate terminal commands generated. The agent mode also uses the terminal to run builds, tests, and other development tasks.
Cursor added Jupyter Notebook integration, opening the editor to data science and machine learning workflows. Developers can use Cursor's AI features within notebook cells, making it possible to leverage agent mode for data analysis, visualization, and model training tasks [23].
With the v2.6 release in March 2026, Cursor introduced MCP Apps, which enable interactive user interfaces directly inside agent chat conversations. These include charts from services like Amplitude, diagrams from Figma, and whiteboards from tldraw. This feature allows agents to display rich visual outputs rather than text-only responses [23].
Cursor Browser is a commercial browser product paired with a visual editor that combines the user's web app, codebase, and visual editing tools in one window [41]. Users can drag elements, inspect components and props, and describe changes while pointing and clicking, with the agent translating visual edits into code changes. It is the consumer surface for the agent-and-DOM integration that also powers Design Mode.
Separately, in late January 2026, Anysphere ran an internal demonstration in which a swarm of OpenAI-powered agents used Cursor to build a working web browser in roughly one week, producing about three million lines of code with a Rust rendering engine; Truell framed it as a proof point that long-horizon multi-agent sessions were tractable on production infrastructure [42].
Cloud agent development environments, expanded with Cursor 3.4 on May 13, 2026, are reusable cloud sandboxes pre-configured with cloned repositories, dependencies, credentials, and build systems [37]. They let parallel agents run end-to-end workflows in environments matching production conventions without bootstrapping from scratch.
| Capability | What it provides |
|---|---|
| Multi-repo environments | One environment holds all repos an agent needs, aligned with multi-root workspaces |
| Dockerfile-based setup | Define environments via Dockerfile, with build secrets and faster caching |
| Interactive configuration | Cursor asks questions, flags missing credentials, and validates setup |
| Version history and audit log | Per-environment version history and audit log of every team action |
| Scoped egress and secrets | Outbound network access and secrets restricted at the environment level |
Anysphere also shipped Remote Agents in early April 2026, letting a developer run Cursor on any machine via agent worker start, which registers the machine as a named worker and exposes URLs at cursor.com/agents and cursor.com/automations for dispatching tasks [43].
Cursor provides a layered system for configuring how its AI assistant behaves, allowing developers to enforce coding standards, architecture patterns, and project-specific conventions.
Cursor's configuration system has two levels: User Rules (global standards that apply across all projects) and Project Rules (project-specific configurations that take priority over user rules). This layered approach allows developers to maintain consistent personal preferences while customizing behavior for individual codebases [25].
The original configuration method involved creating a .cursorrules file in the project root containing all AI rules in a single file. This approach is now deprecated in favor of the more modular .mdc file system, though .cursorrules files continue to function for backward compatibility [25].
The current recommended approach uses a .cursor/rules/ directory containing multiple .mdc (Markdown Configuration) files. Each .mdc file handles a different rule category and supports metadata including a description (explaining when Cursor should apply the rule) and globs (file/directory patterns to which the rule applies). This modular system provides several advantages over the monolithic .cursorrules approach.
| Feature | .cursorrules (deprecated) | .cursor/rules/*.mdc (current) |
|---|---|---|
| File count | Single file | Multiple files |
| Organization | All rules together | Rules separated by category |
| Scope control | Entire project | Per-file or per-directory via globs |
| Metadata | None | Description and glob patterns |
| Nested rules | Not supported | Rules auto-attach when files in their directory are referenced |
| Update workflow | Edit one large file | Update individual focused files |
Best practices include keeping one concern per rule file, splitting large specifications into multiple composable .mdc files, anchoring rules with concrete code samples and explicit glob patterns, and writing rules as if they were internal documentation [25]. A community-maintained collection of .cursorrules and .mdc configurations is available on GitHub under the "awesome-cursorrules" repository.
Cursor is model-agnostic by design. Rather than being locked to a single AI provider, it integrates models from multiple sources and allows users to choose which model powers their interactions.
| Provider | Models Available |
|---|---|
| Anthropic | Claude Sonnet, Claude Opus, including Claude Opus 4.6 |
| OpenAI | GPT-4, GPT-4o, GPT-5 family (including GPT-5.4), o1, o3 |
| Gemini models | |
| xAI | Grok models |
| DeepSeek | DeepSeek R1, DeepSeek v3 |
| Anysphere (proprietary) | Composer, Composer 2, cursor-small |
| Custom | Users can connect their own API keys for any compatible model |
The ability to use custom API keys is a notable differentiator. Developers who have access to specific models through their organizations or personal accounts can route Cursor's AI features through those models, providing flexibility that some competing tools lack.
Cursor also offers an "Auto" model selection mode that dynamically chooses the best model for each request based on task complexity. However, some users have reported unexpected cost implications with Auto mode, as it may select premium models more frequently than anticipated [20].
Cursor supports the Model Context Protocol (MCP), an open protocol that standardizes how applications provide context and tools to large language models. MCP functions as a plugin system for Cursor, allowing developers to extend the agent's capabilities by connecting it to external data sources, APIs, and services through standardized interfaces [9].
Key aspects of Cursor's MCP implementation include:
MCP resources (as distinct from tools) are not yet supported in Cursor as of early 2026 [9].
| Integration | Function |
|---|---|
| GitHub MCP | Create PRs, review code, manage issues directly from agent |
| Slack MCP | Read messages, post updates, trigger workflows |
| Database MCP | Query databases, run migrations, inspect schemas |
| Deployment MCP | Deploy applications, check status, rollback changes |
| Notion MCP | Read documentation, update project wikis |
| Linear MCP | Create tickets, update status, manage sprints |
| Figma MCP | View designs, extract assets, generate UI code |
| Amplitude MCP | View analytics charts and data within agent conversations |
On March 4, 2026, Cursor became available in JetBrains IDEs, including IntelliJ IDEA, PyCharm, and WebStorm, through the Agent Client Protocol (ACP). This integration allows developers who rely on JetBrains IDEs for Java, Python, and multilanguage development to use Cursor's AI agent capabilities, including support for models from OpenAI, Anthropic, Google, and Cursor's proprietary Composer. Users can install the Cursor ACP plugin directly from the ACP Registry within their JetBrains IDE and authenticate with their existing Cursor account [23][26].
This expansion beyond the VS Code fork marks a significant strategic shift for Cursor, enabling the company to reach developers who prefer JetBrains' language-specific tooling without requiring them to switch editors entirely.
Cursor launched a plugin marketplace in March 2026 with over 30 plugins from partners including Atlassian, Datadog, GitLab, and Hugging Face. The marketplace allows third-party developers to build and distribute integrations that extend Cursor's agent capabilities. Teams on Business and Enterprise plans can also create private team marketplaces for sharing internal plugins [23].
Cursor offers a tiered pricing structure that was significantly revised in June 2025, when the company shifted from a fixed request-count model to a credit-based system [10].
| Plan | Price | Key Features |
|---|---|---|
| Hobby | Free | Limited agent requests, limited Tab completions |
| Pro | $20/month | Unlimited Tab completions, extended agent requests, $20 monthly credit pool for premium models |
| Pro+ | $60/month | All Pro features, $60 monthly credit pool (3x Pro) |
| Ultra | $200/month | All Pro features, 20x Pro usage, priority access to new features |
| Business (Teams) | $40/user/month | All Pro features, centralized billing, SSO, admin controls, team management |
| Enterprise | Custom pricing | Enforced privacy mode, SAML SSO, SCIM provisioning, usage analytics, custom model access policies |
Annual billing provides a 20% discount across all paid plans. The credit-based pricing model means that the effective number of requests per month depends on which AI model the developer uses, with more capable models consuming more credits per request. Despite the architectural overhaul in Cursor 3, the Pro tier price has remained at $20/month [33].
The shift to credits in June 2025 was a significant change from the previous model, which offered a fixed number of "fast" and "slow" requests per month. Under the credit system:
Cursor offers free access for students. Students can sign up with a school email address and verify their eligibility through Cursor's student page to receive complimentary access to Pro-level features [10].
As an AI-powered tool that processes source code, Cursor's privacy and security practices are a significant consideration for individual developers and enterprise teams.
Cursor offers a Privacy Mode that enforces zero data retention with model providers. When Privacy Mode is enabled, neither Cursor nor any third-party model provider retains code or chat prompts for training purposes. Code is held in memory only for the duration of an AI request. For Enterprise plan users, Privacy Mode is enforced by default [27].
For users who created accounts after October 15, 2025, in the default "Share Data" mode, prompts and limited telemetry may be shared with OpenAI when directly using OpenAI models. However, in Privacy Mode, Cursor has a zero data retention agreement with all model providers [27].
Cursor is SOC 2 Type 2 certified and undergoes annual penetration testing. The platform is also compliant with GDPR and CCPA requirements. Data is protected with AES-256 encryption at rest and TLS 1.2+ in transit [27].
Several security vulnerabilities have been discovered in Cursor during 2025:
| CVE | Severity | Description |
|---|---|---|
| CVE-2025-54135 (CurXecute) | Critical | Malicious Slack messages processed by Cursor's AI could rewrite MCP configuration files and execute arbitrary commands |
| CVE-2025-54136 (MCPoison) | High | Trust-validation flaw in Cursor's handling of MCP server approvals allowing previously trusted servers to be silently modified |
| CVE-2025-59944 | High | Case-sensitivity bug enabling remote code execution |
| CVE-2025-61590 to CVE-2025-61593 | High | Multiple remote code execution vulnerabilities affecting versions 1.7 and below |
| Open-folder autorun | High | Malicious repositories with .vscode/tasks.json could trigger silent code execution because Cursor ships with Workspace Trust disabled by default |
Security researchers have recommended disabling Auto-Run Mode in Cursor settings so that shell commands require explicit user approval, as Auto-Run Mode represents a significant security risk when working with untrusted codebases [28][29]. The April 30, 2026 launch of Security Reviewer and Vulnerability Scanner [40] formalized always-on security review inside Cursor itself, complementing existing third-party scanners and BugBot's quality reviews.
Cursor operates in a rapidly evolving market for AI-powered development tools. The competitive landscape as of May 2026 includes several major players, and surveys show experienced developers use an average of 2.3 AI coding tools rather than committing to one [30].
| Tool | Workplace adoption | Notes |
|---|---|---|
| VS Code + GitHub Copilot | ~42% of AI coding market | Largest installed base, multi-IDE support |
| Cursor | ~18% | Tied with Claude Code among standalone AI editors |
| Claude Code | ~18% | Strong growth from terminal-first launch |
| Windsurf | ~1M+ developers, 4,000+ enterprises | Growing fast under Cognition AI ownership |
The total AI coding tool market is estimated at more than $7 billion in 2026 [44]. In the independent Stack Overflow 2025 Developer Survey of more than 49,000 developers, VS Code remained the most used development environment at 75.9%, while Cursor, in its first year on the list, was used by 18% of respondents, ahead of Claude Code (10%) and Windsurf (5%) [46].
GitHub Copilot, developed by GitHub (a subsidiary of Microsoft), is the most widely adopted AI coding assistant. The core difference is architectural: Copilot is an extension that layers AI onto existing editors (VS Code, Visual Studio, JetBrains IDEs, Neovim), whereas Cursor is a standalone editor (a VS Code fork) that builds its AI features, codebase indexing, and parallel-agent infrastructure into the application itself. Copilot benefits from deep integration with the GitHub ecosystem and offers individual plans starting at $10/month and enterprise plans with additional features. In 2025 and 2026, GitHub expanded Copilot's capabilities to include agent mode and multi-model support, narrowing some of the feature gaps that initially differentiated Cursor [11].
Windsurf, previously known as Codeium, rebranded in 2025 and launched its own AI-native IDE. Following its acquisition by Cognition AI (makers of Devin) in July 2025, Windsurf is now developed alongside the Devin autonomous coding agent. Windsurf emphasizes autonomous agentic workflows through its proprietary "Cascade" system and positions itself as faster and more affordable than Cursor, with its Pro plan at $15/month versus Cursor's $20/month. Its proprietary SWE-1.5 model scored 40.08 on SWE-Bench but runs at roughly 950 tokens per second on Cerebras hardware, trading raw accuracy for retry budget in iterative agent workflows [11][21][44].
Claude Code, developed by Anthropic, is a terminal-based AI coding assistant taking a fundamentally different approach from Cursor's IDE-centric model. Claude Code operates primarily in the command line, optimizing for execution depth rather than editor velocity. By early 2026, Claude Code went from zero to the number one CLI coding tool in eight months and launched a browser-based IDE at claude.ai/code with VS Code integration. The two tools are not mutually exclusive [30].
Zed is a high-performance code editor written in Rust that has added AI features including LLM-powered code generation and editing. Zed differentiates itself on speed and efficiency, targeting developers who prioritize a lightweight, fast editing experience.
Developers can also assemble AI capabilities within standard VS Code using extensions like GitHub Copilot, Codeium, and others. This approach offers maximum flexibility but lacks the deep integration that purpose-built AI editors provide.
| Feature | Cursor | GitHub Copilot | Windsurf | Claude Code | Zed |
|---|---|---|---|---|---|
| Interface | VS Code fork (IDE) plus Agents Window | Extension for multiple editors | Custom IDE | Terminal / VS Code extension | Custom IDE (Rust) |
| Multi-file editing | Yes | Yes (agent mode) | Yes (Cascade) | Yes | Limited |
| Model flexibility | Multiple providers + custom keys | Multiple providers | Proprietary (SWE-1.5) + frontier | Claude models only | Limited |
| Agent mode | Yes (Agents Window, parallel) | Yes | Yes (Cascade) | Yes (autonomous) | Emerging |
| Background / cloud agents | Yes (cloud VMs, multi-repo envs) | Yes (Copilot Workspace) | Limited | Yes (via API) | No |
| MCP support | Yes (first-class) | Yes | Limited | Yes | Limited |
| Automations | Yes (event-driven) | Limited | No | No | No |
| Proprietary model | Composer 2 | Not applicable | SWE-1.5 | Not applicable | Not applicable |
| Always-on security review | Yes (Security Reviewer beta, May 2026) | Limited | No | Limited | No |
| JetBrains support | Yes (via ACP, 2026) | Yes (native plugin) | No | No | No |
| Starting price | Free (Hobby) | $10/month | $15/month | Usage-based (Anthropic API) | Free |
| Pro price | $20/month | $19/month (Pro) | $15/month | $20/month (Max plan) | N/A |
| Enterprise plan | $40/user/month | Custom pricing | $60/user/month | Custom pricing | Custom pricing |
Cursor's growth metrics place it among the fastest-growing SaaS companies ever recorded.
| Metric | Value | Date |
|---|---|---|
| Daily active users | 1,000,000+ | December 2025 |
| Total users | 2,000,000+ | Early 2026 [32] |
| Paying customers | 1,000,000+ | April 2026 [32] |
| Enterprise teams | ~50,000 | Early 2026 [32] |
| Lines of enterprise code per day | ~150 million | March 2026 [32] |
| ARR | $100M / $500M / $1B / $2B | Jan 2025 / Jun 2025 / Nov 2025 / Feb 2026 [45] |
| Forecast ARR | $6B+ run rate | End of 2026 [32] |
| Year-over-year ARR growth | 9,900% | 2025 |
| Fortune 500 / Fortune 1,000 adoption | ~67% / ~70% | March / Early 2026 [32] |
| Enterprise revenue share | ~60% | Early 2026 |
| Employees | 300+ | Late 2025 |
The 9,900% year-over-year ARR growth figure reported in 2025 is among the highest ever recorded for a SaaS company [1]. By early 2026, approximately 60% of Cursor's revenue came from enterprise customers [32]. Crossing $1 billion in ARR in roughly two years made Cursor the fastest B2B software company on record to reach that level, ahead of cloud-era benchmarks such as Slack and Zoom [45].
As a VS Code fork, Cursor inherits the Electron-based architecture that powers VS Code. This means it runs as a desktop application built on web technologies (HTML, CSS, JavaScript/TypeScript) with Node.js for backend operations. Cursor extends this foundation with:
Cursor supports macOS, Windows, and Linux. Configuration files, extensions, and themes from VS Code are compatible, and the editor can import existing VS Code settings during initial setup.
To sustain long-running agents, Anysphere trained its in-house Composer models to manage their own context budget. Cursor reports that, rather than relying on a large fixed summarization prompt, the model writes its own "phase summary" during a task, compressing context from more than 5,000 tokens to roughly 1,000, which uses about one-fifth of the tokens of the conventional method while cutting compression-induced errors by approximately 50% [48].
In January 2026, Cursor also shipped a CLI (command-line interface) with agent modes and cloud handoff capabilities, expanding its reach beyond the graphical IDE [30]. The remote agents feature announced in April 2026 builds on the CLI by letting any registered machine act as a worker that can be controlled through cursor.com/agents and cursor.com/automations [43].
Cursor has become one of the products most closely associated with the "vibe coding" movement that emerged in early 2025. The term, coined by Andrej Karpathy, describes a style of programming where developers describe intent in natural language and let AI generate the code, often without closely reviewing every line of output.
The trend has had measurable economic impact. AI-assisted development roles on freelancing platforms like Upwork and Toptal grew by over 650% between late 2023 and early 2025. Companies including Visa, Reddit, and DoorDash now expect "vibe coding" skills in developer candidates, reporting that AI-assisted developers are commonly up to 40% faster without sacrificing correctness [22].
Despite Cursor's central role in enabling vibe coding workflows, CEO Michael Truell has been candid about the risks, warning in a December 2025 interview that using AI tools without strong engineering discipline may lead to fragile code that is hard to maintain, scale, or secure over time [22].
Anysphere has also hinted at research directions including "self-driving codebases," a concept that would push autonomy further by having AI systems manage larger portions of code maintenance and evolution without human intervention [23]. The January 2026 swarm-built browser demonstration was Anysphere's first public proof point along this trajectory, in which fleets of agents took on a multi-week project with minimal human steering [42].
As of May 2026, Cursor holds a commanding position in the AI code editor market. The company is in advanced talks to raise more than $2 billion at a $50 billion valuation, roughly 70% above its November 2025 valuation of $29.3 billion [32]. With over two million users, more than one million paying customers, $2B+ ARR, and Cursor tools writing an estimated 150 million lines of enterprise code per day, the product has established itself as one of the defining tools of the AI-assisted development era; its climb from launch to $1 billion ARR in about two years stands as the fastest in B2B software history [32][45]. The headline shifts of spring 2026 are the Cursor 3 reorganization around parallel agents and the formalization of always-on security review.
The competitive landscape continues to intensify: GitHub Copilot has added agent mode and multi-model support, Windsurf (now under Cognition AI) is growing with its SWE-1.5 model and competitive pricing, and Claude Code has rapidly gained adoption as a terminal-first alternative. Cursor's model-agnostic approach, deep codebase context, proprietary Composer 2 model, parallel-agent infrastructure, multi-repo cloud environments, JetBrains expansion, and early mover advantage in agent-mode development have helped it maintain a strong position among professional developers and enterprise teams.