Cursor
Anysphere · AI Code Editor with Cloud Agents
A VS Code fork rebuilt around AI — Agent handles multi-file edits and multi-step tasks, and Cloud Agents clone your repo into cloud VMs and push their work back for review. Now owned by SpaceX; trusted by over half of the Fortune 500, per Cursor.
Best for
VS Code developers who want multi-file AI editing, autonomous cloud agents, and model flexibility — not a plugin layered on top of an existing editor
Not ideal for
Developers who need offline AI features, work in Neovim, or prefer a lightweight editor without the memory overhead
Who it's for
Professional developers who want AI deeply embedded in a VS Code-compatible editor with autonomous agent capabilities
Capabilities
- Agent: multi-file edits and multi-step autonomous tasks — run tests, fix failures, review diffs
- Cloud Agents: isolated cloud VMs that clone your repo, work on a branch, and push changes for handoff
- Launch Cloud Agents from web, iOS, desktop, Slack, GitHub/Bitbucket PRs, Linear, or the API
- In-house Grok and Composer 2.5 models tuned for Cursor, plus Claude, Gemini, and GPT models
- Tab autocomplete with full project context, not just the open file
- Native MCP support for custom tools, internal docs, and ticket system integration
- Full VS Code extension and settings compatibility; JetBrains support via ACP
- Bugbot automated code review
Limitations
- Performance lags on very large projects — heavier memory footprint than plain VS Code
- All AI features require an internet connection — no offline mode
- Agent and multi-file edits require review; the model makes mistakes on complex logic
- Meaningful AI usage requires Pro ($20/mo) — free tier has limited agent requests
- Cloud Agents require a paid plan and bill at API rates
- Context can drift in long sessions without periodic re-anchoring
Use cases
- Refactoring across multiple files from a single plain-language instruction
- Running Cloud Agents to draft a feature branch autonomously while you work on something else
- Asking codebase questions and getting answers anchored to specific files and functions
- Writing or updating tests with full context of the existing implementation
- Using MCP to pull in Jira tickets, internal docs, or API specs at inference time
Our take
Cursor's real advantage is an editor-native agent experience: Agent, Tab, and Cloud Agents share full project context, and Cloud Agents can be kicked off from almost anywhere your team works. Its in-house Grok and Composer models, now backed by SpaceX, sit alongside third-party models, so you are not tied to one provider. The VS Code foundation means near-zero migration cost for developers already on VS Code. The trade-off is that it is heavier, costs more at scale than a plugin, and still requires careful review of agent output on complex logic.
Who should use it
Developers who are already on VS Code and want autonomous multi-file editing and cloud agents — specifically anyone who routinely works across large feature changes where the bottleneck is cross-file coordination.
Who should skip it
Neovim users, and JetBrains users who want a full native editor experience — Cursor's agent works in JetBrains via ACP on paid plans, but the full editor is VS Code-based. GitHub Copilot's multi-IDE plugin coverage may fit better there.
Strengths
- Cloud Agents run tasks in isolated VMs and can be launched from the editor, web, mobile, Slack, or Linear
- Full project context in every AI interaction: Agent, chat, and autocomplete all see the whole repo, not just the open file
- Model flexibility — Cursor's own Grok and Composer models plus Claude, Gemini, and GPT models, switchable per task
Weaknesses
- Performance degrades on very large projects — heavier memory footprint than a plain VS Code install
- All AI features require an internet connection, making it unsuitable for air-gapped or offline environments
- Meaningful AI usage requires Pro ($20/month) — the free Hobby tier's limits are quickly exhausted
Cursor pricing
Hobby
Free
Billed monthly
- Limited Agent requests
- Access to Composer
- No credit card required
Pro
$20/month
Billed monthly
- Unlimited Tab completions
- Included usage in two pools: Cursor models (Grok, Composer) and third-party models at API rates
- Generous limits for Grok and Grok Bot access
- Cloud Agents, MCP, skills, and hooks; Bugbot on usage-based billing
Pro+
$60/month
Billed monthly
- Larger usage pools than Pro
- Same features as Pro
Ultra
$200/month
Billed monthly
- Largest individual usage pools
- For developers running heavy cloud agent workloads
Teams
$40/user/month
Billed monthly
- Premium seats at $120/user/month with 5x Standard Agent limits
- Team-wide rules, skills, and automations
- SAML/OIDC SSO + team-level privacy mode
- Usage analytics and centralized billing
Free tier limits: Limited Agent requests with access to Composer. Adequate for evaluation but not sustained development use.
Note: Individual plans include usage in two pools — Cursor's in-house models and third-party models at API rates; additional usage is billed on-demand. Monthly and yearly billing available. Enterprise plan available with custom pricing, pooled usage, SCIM, audit logs, and an AI code tracking API.
Technical specs
Context window
Full project context (varies by model)
Modalities
Code, Text
API pricing
Subscription with usage pools; Cloud Agents API for launching agents (not a model API)
Available models
Where Cursor excels
Feature branch generation
Describe the feature in plain language; a Cloud Agent clones the repo, implements it across relevant files, runs tests, and pushes a branch for review — without blocking your current work.
Cross-file refactoring
Agent applies a single refactoring instruction across all affected files, showing diffs for review before changes are accepted.
Onboarding to an unfamiliar codebase
Codebase chat answers questions anchored to actual file paths and function definitions — faster than grep-and-read for navigating unknown repos.
Test generation with implementation context
Agent reads the existing implementation files and generates tests that match the actual behavior, not generic boilerplate.
Cursor vs. competitors
Cursor vs. GitHub Copilot
Copilot is a plugin that works inside many editors (VS Code, JetBrains, Neovim) and offers a cloud coding agent that works autonomously and opens pull requests. Cursor is a VS Code fork with AI built into the editor itself, its own in-house models, and Cloud Agents that can be launched from web, mobile, Slack, and Linear.
Cursor vs. Windsurf (now Devin Desktop)
Both are VS Code forks with agentic coding. Devin Desktop (formerly Windsurf, rebranded in June 2026) runs its agent through Devin Local — formerly Cascade — which competes directly with Cursor's Agent. Both Pro tiers cost $20/month; Devin Desktop's free tier includes unlimited Tab completions, while Cursor's free Hobby tier caps agent usage.
Frequently asked questions
How is Cursor different from GitHub Copilot?
Copilot is a plugin that adds AI to many existing editors and also offers a cloud coding agent that opens pull requests. Cursor is a VS Code fork where AI is built into the editor itself, with full project context, its own in-house models alongside third-party ones, and Cloud Agents you can launch from the editor, web, mobile, Slack, or Linear.
What are Cloud Agents in Cursor?
Cloud Agents run in isolated cloud VMs: they clone your repo, work on a task on a separate branch, and push their changes for you to review. You can launch them from the editor, Cursor Web, the iOS app, Slack, GitHub or Bitbucket PR comments, Linear, or the API. They require a paid plan and bill at API rates.
Does Cursor work with my existing VS Code extensions?
Yes. Cursor is a VS Code fork, so your existing extensions, themes, and keybindings carry over. The migration from VS Code is typically under five minutes.
Is the free tier usable for real development?
The free Hobby tier has limited Agent requests and access to Composer — enough to evaluate the tool, but most developers doing serious work upgrade to Pro ($20/month) for unlimited Tab completions and larger usage pools.
What AI models does Cursor use?
Cursor offers its own Grok and Composer models, jointly trained with SpaceXAI, plus third-party models including Claude (Sonnet 5, Fable 5.1), Gemini 3.x, and GPT-5.x. You can pick a model per task or let Auto routing choose.
Integrations & fit
Alternatives to consider
Cursor vs Windsurf (now Devin Desktop) — full comparison →Cursor vs GitHub Copilot — full comparison →Cursor Alternatives →Cognition
Developers who want an AI agent that can autonomously plan and execute larger coding tasks
FreemiumGitHub (Microsoft)
Developers on GitHub who want AI completion, chat, and agents embedded in their existing IDE and GitHub workflow
Freemium
Amazon Web Services
Developers and teams who want planned, documented changes (requirements, design, and tasks) before code is written, especially for multi-step features and teams already using AWS identity
FreemiumAbout Cursor
Cursor is a VS Code fork, so your existing extensions, themes, and keybindings carry over. The architectural difference from plugin-style assistants: the AI has full project context, not just the open file. Agent accepts a plain-language instruction, plans the work, and applies changes across the relevant files, running tests and fixing failures while showing diffs you review. Cloud Agents go further: they run in isolated cloud VMs, clone your repo, work on a separate branch, and push changes for handoff — and they can be launched from Cursor Web, the iOS app, the desktop app, Slack, GitHub or Bitbucket PR comments, Linear, or the API. Anysphere, Cursor's maker, was acquired by SpaceX in August 2026, and Cursor now ships its own Grok and Composer models, jointly trained with SpaceXAI, alongside third-party models from Anthropic, Google, OpenAI, and others. It natively integrates with MCP servers for custom tools, internal docs, and ticket systems, and JetBrains users can use Cursor's agent through the Agent Client Protocol (ACP). The Pro tier ($20/month) includes unlimited Tab completions and usage in two pools — Cursor's own models and third-party models at API rates; Pro+ ($60/month) and Ultra ($200/month) raise those allowances for heavier agent workloads. The honest trade-offs: performance degrades on very large projects, all AI features require an internet connection, and the model still makes mistakes on complex multi-file logic that require careful review.
Updates from Cursor
SpaceX completed its acquisition of Anysphere, Cursor's maker, following a partnership that began in April 2026. Cursor now ships Grok and Composer models jointly trained with SpaceXAI.
Cursor's agent became available in IntelliJ IDEA, PyCharm, WebStorm, and other JetBrains IDEs through the Agent Client Protocol, free for users on paid plans.
Are you the founder? Claim this listing →