What Is Cursor? AI Code Editor Explained

Cursor is an AI-native code editor built by Anysphere, the startup founded by Aman Sanger and Michael Truell in 2022. First released in March 2023 as a fork of Visual Studio Code, Cursor wraps a familiar editor experience around deep, model-agnostic AI features: predictive Tab autocomplete, inline edits, multi-file agent execution, and a chat panel that understands your whole codebase. In June 2026, SpaceX agreed to acquire Anysphere outright in an all-stock deal valuing the company at $60 billion, making Cursor one of the fastest editor-to-acquisition stories in software history.

If you're new to AI-assisted programming, see our vibe coding explainer for the broader cultural shift Cursor represents.

Definition

Cursor is a desktop code editor for macOS, Windows, and Linux that integrates large language models directly into the editing loop rather than bolting them on as a sidebar extension. Instead of treating AI as an add-on — the way GitHub Copilot works inside stock VS Code — Cursor rebuilt the interaction model around the assumption that a model is always watching: predicting your next edit, executing multi-file refactors, reading your repository for context, and, in its Agent modes, running terminal commands autonomously.

Because Cursor is built on the open-source VS Code codebase, it inherits the entire VS Code extension ecosystem, keybindings, and settings layout. Engineers who already use VS Code typically migrate their setup in about five minutes: import settings, sign in, and the editor looks nearly identical except for the AI panels layered on top.

Think of it like moving from a manual transmission car to one with adaptive cruise control built into the same chassis. The steering wheel, pedals, and dashboard are unchanged. What's different is that the car is now constantly reading the road ahead and nudging you toward the next correct move before you consciously decide on it.

How Cursor actually works under the hood

Cursor is not itself a foundation model. It is an orchestration layer: a product that routes your code, your prompts, and your repository context to third-party and in-house models, then renders the results as inline diffs, chat messages, or terminal actions inside a VS Code-shaped interface. Understanding this separation matters because it explains both Cursor's flexibility (you can switch models) and its biggest technical bet (building its own coding models to reduce dependency on outside labs).

Tab: how predictive multi-line autocomplete works

Cursor's signature feature is Tab. Pressing Tab does not simply complete the current line the way older autocomplete tools do — it predicts your next edit location across the file, and sometimes across multiple files, then proposes a jump-and-accept sequence. Under the hood this relies on a technique researchers call "fill-in-the-middle" prediction, where the model is trained to see code both before and after the cursor position rather than only what came before it, so it can suggest changes that fit the surrounding structure rather than just extrapolating forward.

• It predicts your next edit location, not just the next character.
• It suggests entire function bodies, refactors, and renamed-symbol propagation across a file.
• It chains edits: hitting Tab repeatedly accepts a sequence of related changes one at a time, so a rename in one function can cascade to its callers without you retyping anything.

Most developer surveys and forum discussions cite Tab as the single biggest reason engineers switch from GitHub Copilot to Cursor, because Copilot's classic ghost-text completion only predicts forward from the cursor, while Tab predicts where the next change should happen at all.

Cmd+K: inline natural-language edits

Select a block of code, press Cmd+K (Ctrl+K on Windows and Linux), and type an instruction in plain English: "rewrite as async," "add error handling," "convert to TypeScript." The selection is replaced inline with a diff you can accept, reject, or partially apply line by line. This is the fastest way to make a small, scoped change without leaving your place in the file — the equivalent of asking a colleague sitting next to you to "just fix this bit" rather than opening a separate conversation about it.

Composer: multi-file agent execution

Composer, launched in September 2024, lets you describe a change that spans many files — "add a dark mode toggle that persists to localStorage" — and Cursor plans the edit, identifies which files need to change, and executes them as one combined diff you review before accepting. Composer is the feature that turned Cursor from "a smarter autocomplete" into something closer to a junior engineer you can hand a ticket to.

What is Cursor's Composer model, and how is it different from GPT or Claude inside Cursor?

Composer is also the name of Anysphere's own in-house coding model family, separate from the third-party models (GPT, Claude, Gemini) Cursor also supports. Composer 1 shipped in late 2025 as Anysphere's first agentic model built specifically for the multi-file editing workflow, and it was followed by Composer 1.5 in February 2026. According to Cursor's own release notes, Composer 1.5 targets a balance of speed and reasoning quality for everyday agent tasks rather than chasing frontier benchmark scores.

The next jump was larger. In March 2026, Anysphere released a new model whose technical report — published about a week later — disclosed that it was built through continued pretraining on an open base model, Moonshot AI's Kimi K2.5, refined with large-scale reinforcement learning on coding tasks. Composer 2.5, announced May 18, 2026, extended that same lineage with meaningfully improved reasoning and tool-use behavior over Composer 2, according to Cursor's official announcement. Under the SpaceX partnership, Anysphere is now training a substantially larger successor model from scratch using roughly ten times the compute of the earlier Composer models, a scale-up made possible by SpaceX's cloud and satellite-linked compute infrastructure.

Why build your own model at all when you can just call GPT-4.1 or Claude Sonnet through an API? Speed and cost are the practical answer. An in-house model tuned specifically for Cursor's editing patterns can run cheaper and faster on the huge volume of small, repetitive edit predictions Tab needs to make thousands of times a day, while the frontier third-party models stay available for the harder reasoning tasks inside Chat and Agent mode.

Chat: whole-repository conversation

A right-sidebar chat panel that can reference your entire codebase rather than just the open file. Using @-mentions, you can pull specific symbols, files, folders, external documentation, or live web search results directly into the conversation as grounding context, so the model isn't guessing about a function it has never seen.

Cursor Rules: project memory

Project-specific instructions stored in a .cursor/rules directory (or the older single-file .cursorrules format) prime every AI interaction in that repository with your team's coding conventions, naming rules, and forbidden patterns — for example, "never use any in TypeScript" or "all API routes must validate input with Zod." Rules act like a style guide the AI actually reads before every response, instead of a document that lives in a wiki nobody opens.

Agent Mode: autonomous multi-step execution

Agent Mode, introduced through 2025, operates closer to how Claude Code works: it can run terminal commands, read and edit files across the repository, and iterate on its own output — running a test, seeing it fail, and fixing the failure — until a task is done, rather than stopping after one suggested diff. This is the clearest signal of where AI coding tools are heading generally: from suggestion engines toward agents that complete a defined task loop with minimal supervision.

Model choice and MCP support

Cursor is model-agnostic. Inside a single session you can switch between GPT-4.1, o3, Claude Sonnet 4.5, Claude Opus 4.1, Gemini 2.5 Pro, and Anysphere's own Composer models on a per-request basis, picking whichever model suits the task at hand — a fast, cheap model for routine completions, and a slower, more capable one for a gnarly bug. Cursor also added support for the Model Context Protocol (MCP) in 2025, an open standard originally developed by Anthropic, so external tools — databases, ticketing systems, browser automation — can plug directly into a Cursor session as additional context sources.

Cursor's growth, from side project to SpaceX subsidiary

Cursor's usage and revenue growth is one of the fastest trajectories recorded in enterprise software. Anysphere crossed $100 million in annualized recurring revenue (ARR) in January 2025, reached $500 million by June 2025, passed $1 billion by November 2025, and hit roughly $2 billion by February 2026, according to reporting compiled from company disclosures and industry coverage. By mid-2026, ARR was estimated at around $2.6 billion ahead of the SpaceX deal, with some outlets projecting a run rate closer to $4 billion for the full year.

Milestone	Approximate date	Figure
First public release	March 2023	v0.1, VS Code fork
$100M ARR	January 2025	Fastest to $100M ARR at the time
Series B	Late 2024	$9B valuation
Composer launches	September 2024	Multi-file agent edits
$1B ARR	November 2025	—
Series D	2025	$29.3B valuation, led by Accel and Coatue
Composer 1 / Composer 1.5	Late 2025 / Feb 2026	Anysphere's first in-house coding models
SpaceX option agreement	April 2026	Right to invest ~$10B or acquire for $60B
SpaceX acquisition announced	June 16, 2026	$60B all-stock merger, Form 8-K filed with SEC
Composer 2.5	May 18, 2026	Built on Kimi K2.5 base, larger RL training run

Table: Cursor and Anysphere's growth timeline, 2023–2026. Revenue and valuation figures compiled from company statements and financial press coverage.

The SpaceX acquisition, explained

On June 16, 2026, SpaceX filed an 8-K with the SEC disclosing that its subsidiary, X67 Inc., would merge with Anysphere in an all-stock transaction valuing the startup at $60 billion — reportedly the largest startup acquisition on record. The deal followed an option SpaceX had secured in April 2026 giving it the choice to either invest around $10 billion for a partnership with Cursor or acquire the company outright later in the year, and it arrived just days after SpaceX completed its own IPO, reported to have raised $75 billion, according to CNBC's coverage. Under the deal terms, all outstanding Anysphere common and preferred shares convert into SpaceX Class A stock, with the exchange ratio set against Anysphere's $60 billion valuation and SpaceX's trailing volume-weighted share price at closing. The transaction is expected to close in the third quarter of 2026, pending regulatory approval.

Why would a rocket and satellite company buy a code editor? The public rationale centers on compute and AI infrastructure: SpaceX's Starlink network and ground infrastructure represent enormous latent compute capacity, and pairing that with a coding-model company gives Anysphere the scale to train frontier-sized models like the next Composer generation without depending entirely on rented cloud GPUs from a third party. It's an unusual pairing on paper, similar to how cloud providers acquired chip design teams a decade earlier: the acquirer isn't buying the product category, it's buying leverage over the compute stack the product depends on.

Pricing (2026)

Cursor's pricing structure expanded through 2026 to add higher tiers as usage among professional and enterprise users grew.

Plan	Price	Notes
Hobby	Free	Limited Tab completions and limited Agent requests
Pro	$20/month	Unlimited Tab, ~$20 monthly credit pool for premium model requests
Pro+	$60/month	Roughly 3x the premium-model usage of Pro
Ultra	$200/month	About 20x Pro's usage allowance, priority access to new features
Teams Standard	$40/user/month	Shared rules and commands, centralized billing, usage analytics
Teams Premium	$120/user/month ($96 annual)	~5x the agent limits of Teams Standard, org-wide privacy controls
Enterprise	Custom	SOC 2, SAML/OIDC SSO, custom contracts

Table: Cursor pricing tiers as of mid-2026. Annual billing generally applies roughly a 20% discount versus monthly billing on paid tiers. Figures sourced from Cursor's public pricing documentation and independent pricing trackers; confirm current numbers at cursor.com before purchasing.

The most important thing to understand about Cursor pricing is that the subscription fee isn't really paying for "the editor" — VS Code itself is free and open source. It's paying for a bundled allotment of inference against expensive frontier models. That's why heavier users on Pro sometimes hit rate limits mid-month and why the Ultra tier exists at all: for someone running Agent mode continuously across a large codebase, model inference cost is the real bottleneck, not the interface.

Cursor vs alternatives

Editor	Model	Pricing	Strength	Weakness
Cursor	Multi-model (GPT, Claude, Gemini, Composer)	$20/mo Pro	Strongest Tab autocomplete; Composer agent	Subscription required for full power; heavy compute cost passed to user
VS Code + Copilot	GPT-4o, Claude (via GitHub)	~$10/mo	Cheaper, huge existing ecosystem	Weaker multi-file edits, less agentic
Claude Code	Claude Opus / Sonnet	Pay per token	Terminal-first; strong autonomous agent	Not a GUI editor
Windsurf	Multi-model	~$15/mo Pro	Cascade agent, flow-state UX	Smaller ecosystem
Zed	Multi-model (bring your own key)	Free / $20 Pro	Rust-built, very fast rendering	Smaller AI feature set
Continue.dev	Bring your own model	Free (open source)	Open source, runs inside VS Code or JetBrains	More setup, less polished UX

Table: How Cursor compares to other AI-assisted editors as of 2026.

For a full head-to-head with the closest competitor on flow-based agentic editing, see our Windsurf vs Cursor comparison. That article focuses on choosing between the two; this one focuses on how Cursor itself works and where it fits. Another AI coding tool that works inside VS Code is Cline, the VS Code AI coding agent.

A typical Cursor workflow

A common pattern for an experienced engineer building a feature looks like this:

1. Ask Composer to scaffold the feature. For example: "add an auth route with email magic links, following the existing route conventions in /api."
2. Review the combined diff. Composer shows every file it wants to touch in one view; accept what's correct, reject or edit what isn't.
3. Tab through the follow-up edits Cursor predicts — import statements, type updates, related test file changes — accepting each with a single keypress rather than retyping.
4. Use Cmd+K to polish specific selections, such as "add JSDoc comments here" or "make this function generic over the input type."
5. Debug through Chat with @file mentions when something breaks, pulling in the failing test output and the relevant source file as context.

This loop is why many engineering teams report meaningful throughput gains on routine, well-specified work — boilerplate, CRUD routes, test scaffolding, refactors with a clear target shape. It's also the loop that lowers the barrier to entry for non-engineers experimenting with vibe coding, since Composer's plan-then-diff structure makes it possible to build something functional without deeply understanding every line it generates.

Where Tab specifically saves time versus Copilot-style completion

Tab's advantage shows up most clearly in refactors that touch a symbol used in many places. Renaming a function and updating every call site by hand is mechanical but slow; Tab's jump-and-accept chain lets you propagate that change file by file with repeated Tab presses instead of retyping or running a separate find-and-replace tool. Classic ghost-text completion, by contrast, only ever predicts what comes next at the current cursor position, so it can't drive that kind of propagated edit at all.

How Composer's plan-then-diff approach reduces risk versus free-form agent edits

Composer doesn't silently rewrite files. It proposes a single reviewable diff across every file it intends to touch before anything is committed to disk, and a developer accepts or rejects that plan as a whole or piece by piece. That review gate is the main difference between "an agent that edits your repository" and "an agent you'd actually trust to edit your repository" — the human stays the last checkpoint before a change lands.

Privacy, security, and data handling

By default, code you edit in Cursor is sent to whichever model provider is powering the current request for inference — that's true of any AI coding tool that calls a hosted model rather than running one locally. Cursor's Privacy Mode, which is the default setting on Business and Enterprise plans and can be enabled manually on individual plans, ensures that code sent for inference is not stored or used to train models. Anysphere states Cursor is SOC 2 Type II certified, an independent audit standard covering how a vendor handles security, availability, and confidentiality of customer data — the same standard most enterprise SaaS vendors are expected to carry before a security team will approve a purchase.

For teams under strict regulatory regimes — healthcare data under HIPAA, financial data under various banking regulations, government contracts requiring on-premises processing — Privacy Mode and SOC 2 certification help but don't automatically satisfy every compliance requirement. Teams in those categories typically still need a dedicated review with their security and legal functions before rolling Cursor out broadly, regardless of what the vendor's default settings are.

When Cursor is the wrong choice

• Headless or remote workflows. If you're working over SSH on a remote server without a local GUI, a terminal-first tool like Claude Code or an open-source agent like Aider fits that environment better than a desktop editor.
• Strict enterprise data policies. Some organizations require fully self-hosted or air-gapped tooling that no hosted inference product, Cursor included, can currently satisfy end to end.
• Very small, one-off scripts. For a 20-line shell script you'll run once, launching an AI-assisted editor and reviewing a diff is more overhead than just writing the script.
• Teams standardized on a different IDE ecosystem, such as JetBrains' full suite for large Java or Kotlin codebases, where switching editors has a real retraining cost that may not be worth the productivity gain from Tab alone.
• Budget-constrained solo developers who don't need multi-file agent edits regularly — GitHub Copilot's lower price point may cover 80% of the value at roughly half the monthly cost.

History and funding

• 2022 — Anysphere founded by MIT alumni Aman Sanger and Michael Truell.
• March 2023 — Cursor's first public release as a VS Code fork.
• September 2024 — Composer launches; multi-file agent edits become production-ready.
• Late 2024 — Series B funding round at a $9 billion valuation, backed by Thrive Capital, a16z, and OpenAI's Startup Fund.
• January 2025 — Anysphere reportedly reaches $100 million ARR, one of the fastest climbs to that milestone recorded in software.
• 2025 — MCP support and Agent Mode ship; ARR passes $1 billion by November.
• 2025 Series D — $2.3 billion raised at a $29.3 billion valuation, led by Accel and Coatue Management.
• Late 2025 — Composer 1, Anysphere's first in-house agentic coding model, ships.
• February 2026 — Composer 1.5 released.
• April 2026 — SpaceX secures an option to invest roughly $10 billion in Cursor or acquire Anysphere outright later in the year.
• March 2026 — A new model built on continued pretraining of Kimi K2.5 with large-scale reinforcement learning ships; technical report follows about a week later.
• May 18, 2026 — Composer 2.5 announced, with a larger successor model in training using roughly 10x the compute.
• June 16, 2026 — SpaceX files an 8-K disclosing an all-stock merger agreement valuing Anysphere at $60 billion; deal expected to close in Q3 2026.

Common misconceptions about Cursor

"Cursor is just Copilot with a different UI." The two tools solve overlapping but distinct problems. Copilot's classic mode is fundamentally a forward-predicting autocomplete layered onto an unmodified editor. Cursor's Tab predicts edit locations, not just next tokens, and Composer executes coordinated multi-file changes as a single reviewable unit — a workflow Copilot's extension model wasn't originally built around, even as GitHub has added more agentic features of its own over time.

"AI editors write all the code, so you don't need to understand it." Composer and Agent Mode can generate large, working diffs, but every workflow still routes through a human review step before code merges. Teams that skip that review step, treating generated diffs as automatically correct, are the ones who end up with subtle bugs in production — the tool accelerates typing and boilerplate, it doesn't remove the need for a reviewer who understands what the code does.

"Switching models inside Cursor is free." Different models are metered differently against your monthly credit pool. A single Composer or Opus-class request against a hard problem can consume noticeably more of your allowance than a Tab completion, which is why heavy users on lower tiers sometimes hit limits well before the end of a billing cycle.

"Cursor being acquired by SpaceX means it becomes a SpaceX-only tool." Nothing in the publicly disclosed deal terms restricts Cursor to SpaceX engineering teams or changes its availability as a general-purpose product; the stated rationale for the acquisition centers on compute infrastructure for training future models, not restricting the customer base.

FAQ

Q: Is Cursor free? A: Yes. There is a free Hobby tier with limited Tab completions and limited Agent requests. Most professional users pay for Pro at $20/month, which unlocks unlimited Tab and a monthly credit pool for premium model requests; heavier users can step up to Pro+ ($60/month) or Ultra ($200/month).

Q: Is Cursor better than GitHub Copilot? A: For predictive Tab autocomplete and coordinated multi-file edits, most user reports favor Cursor. Copilot is cheaper and integrates natively with the GitHub ecosystem, so the right choice depends on workflow and budget rather than a single universal answer.

Q: Can Cursor use Claude or GPT? A: Yes. Cursor is model-agnostic and lets you switch between GPT-4.1, o3, Claude Sonnet 4.5, Claude Opus 4.1, Gemini 2.5 Pro, and Anysphere's own Composer models on a per-request basis.

Q: Does Cursor store my code? A: By default, code may be sent to whichever model provider is handling a given request for inference. Privacy Mode, which is on by default for Business and Enterprise plans and available to enable on individual plans, ensures that code sent for inference isn't stored or used for training. Cursor states it is SOC 2 Type II certified.

Q: How does Cursor compare to Claude Code? A: Cursor is a GUI editor built on the VS Code fork and optimized for in-editor flow. Claude Code is a terminal-first agent that runs commands and edits files autonomously without a graphical editor. Many engineers use both: Cursor for interactive coding sessions, Claude Code for longer autonomous background tasks.

Q: Can I use Cursor offline? A: No. All AI features require network access to a model provider. The underlying editor works offline the way VS Code does, but Tab, Chat, Composer, and Agent all require an active connection.

Q: Is Cursor now owned by SpaceX? A: SpaceX announced an agreement to acquire Anysphere, Cursor's parent company, in an all-stock deal valuing it at $60 billion, disclosed in a June 16, 2026 SEC filing. The deal was expected to close in the third quarter of 2026, pending regulatory approval; check current company statements for the latest status of the transaction.

Q: What is Composer, and is it different from GPT-4 or Claude inside Cursor? A: Composer refers to two related things: the multi-file agent editing feature, and Anysphere's own in-house family of coding models (Composer 1, 1.5, and 2.5) that power that feature by default, distinct from the third-party GPT, Claude, and Gemini models Cursor also supports.

Q: Does Cursor work with existing VS Code extensions? A: Yes. Because Cursor is a fork of VS Code, it supports the same extension marketplace, keybindings, and settings format, so most existing VS Code configurations and extensions carry over directly.

Q: How much does Cursor cost for a team? A: Teams pricing starts at $40 per user per month for Teams Standard, which includes shared rules, centralized billing, and usage analytics; Teams Premium runs $120 per user per month ($96 with annual billing) with roughly 5x the agent usage limits. Enterprise pricing is custom and adds SOC 2 documentation and SSO.

Sources

• Anysphere/Cursor official documentation and blog
• Cursor: Introducing Composer 1.5
• Cursor: Introducing Composer 2.5
• Forbes: SpaceX Buys Cursor In Largest Startup Acquisition Ever At $60 Billion (June 16, 2026)
• CNBC: SpaceX to acquire the AI coding startup Cursor for $60 billion (June 16, 2026)
• Visual Studio Code open-source project — github.com/microsoft/vscode
• Anthropic Model Context Protocol specification
• GitHub Copilot product documentation