Cursor

1. Overview

Cursor (cursor.com) positions itself as a coding agent for building ambitious software: understand a codebase, plan and build features, fix bugs, review changes, and work inside the tools teams already use (Docs overview, Homepage). Official distribution covers Desktop (macOS, Windows, Linux), Terminal / CLI (curl https://cursor.com/install -fsS | bash), and Web agents (Download).

This listing is in Build with agents. It covers tools that take a product from an idea through design, build, and release. It is not a demo and prototype listing. Cursor is strongest on a real repository and pull requests. It is a weak fit when you only need a hosted clickable mock.

Surfaces to keep distinct

Surface	What it is	Where it runs	Primary sources
Cursor Desktop (IDE)	Agent-first desktop editor: local Agent, Tab, editor, and the option to hand work to Cloud	Your machine	Download, Homepage
Local Agent (in Desktop / CLI)	Interactive agent that edits, runs tools, and iterates on your workspace while you stay in the loop	Local machine / terminal	Docs overview, Download
Cloud Agents	Autonomous agents in isolated cloud VMs with repos, dependencies, secrets, network access, MCP, artifacts, and optional remote desktop	Cursor-managed VMs (or self-hosted machines where documented)	Cloud Agents docs, Cloud Agents help
Background Agents	Former name for Cloud Agents. Help docs state: in Cursor, long-running background agents are called Cloud Agents	Same as Cloud Agents	What are background agents?, Naming history
Bugbot	Separate PR review agent: comments on diffs for bugs, security, and quality; optional Autofix via Cloud Agent	Source control (GitHub, GitLab, Bitbucket, Azure DevOps)	Bugbot docs, Bugbot help
Automations	Scheduled or event-triggered Cloud Agent runs (GitHub/GitLab/Slack/Linear/webhooks and more)	Cloud	Automations
Grok Bot	Named on the pricing and privacy pages as a separate product, with its own data flows. Read the current privacy page before assuming it behaves like the Desktop agent or Cloud Agents	Separate product. Check the current app	Pricing, Privacy and data

Practical rule: say Desktop / local Agent when the human is co-editing on a laptop; say Cloud Agents when the agent owns an isolated VM and returns a branch/PR (and often demo artifacts); say Bugbot when the topic is automated PR review. Prefer current docs over older “Background Agent” marketing.

Where it fits when you build with agents

Stage	How Cursor typically shows up	Caveat
Discovery	Explore unfamiliar repos, summarise subsystems, reproduce issues, map dependencies	Needs repo access and enough engineering literacy to validate agent claims
Definition	Turn tickets/Slack/Linear into scoped agent tasks; rules and skills encode product conventions	Ambiguous specs still produce confident wrong code; humans own acceptance criteria
Design	Implement UI in code against component libraries; /canvas and artifacts help visualisation	Not a Figma design-system kit. Matching your design system takes setup
Development	Local Agent for tight loops; Cloud Agents for parallel/long runs; MCP for tools/data	Environment quality dominates Cloud Agent success (setup)
Delivery	Branch + PR handoff, Bugbot review, optional Autofix, Automations on schedules/events	Merge, release, and production ownership stay with the team

Documented Cloud Agent access points include Desktop (Cloud dropdown), cursor.com/agents, Slack @cursor, GitHub/Bitbucket @cursor comments, Linear, API, and Cursor for iOS (Cloud Agents docs). Agents clone from connected SCM, work on a separate branch, and push for handoff. They can produce screenshots, videos, and logs, and you can take remote desktop control to try the change without checking out locally (Cloud Agents docs, agent computer use blog).

Rules, Skills, and Hooks are how you keep coding agents inside the rules: project rules in .cursor/rules, portable skills, and lifecycle hooks in .cursor/hooks.json (including Cloud Agent support with documented limits) (Rules, Skills, Hooks). Bugbot uses separate .cursor/BUGBOT.md / Automations rules; Cursor project rules (*.mdc) do not apply to Bugbot runs (Bugbot help).

Access and pricing (public; always re-check)

Plans and included usage change. Prefer cursor.com/pricing, Models & Pricing, and Team Pricing. Public list prices seen when this page was checked (USD unless noted; taxes may apply; yearly billing advertised as 20% save on the pricing page):

Plan	Public list	Agent-relevant notes
Hobby	Free	Limited Agent requests; Composer access; no credit card required (Pricing)
Pro	$20/mo	Extended Agent limits; frontier models; MCPs, skills, hooks; Cloud Agents; Bugbot on usage-based billing; Grok Bot access listed (Pricing)
Pro+	$60/mo	3× Pro Agent limits (vendor wording) plus Pro features (Pricing)
Ultra	$200/mo	20× Pro Agent limits (vendor wording); priority access to new features (Pricing)
Teams Standard	$40/user/mo	Centralised admin, SSO options, team marketplace, Bugbot, Cloud Agents/Automations with shared context, privacy enforcement (Team Pricing)
Teams Premium	$120/user/mo	5× Standard usage on Agent (Team Pricing)
Enterprise	Custom	Pooled usage, invoicing, SCIM, advanced security (e.g. CMEK, audit), contact sales (Models & Pricing)
Start (India only)	₹649/mo tax inclusive	Cursor Models pool + Cloud Agents; excludes Other Models pool, on-demand, Bugbot, Auto, Automations, SDK per models docs (Models & Pricing)

Usage model: included model usage plus optional on-demand usage billed in arrears at model API rates (Teams add a documented Cursor Token Rate of $0.25 per million tokens on eligible third-party model traffic) (Models & Pricing, Team Pricing). Cloud Agents are charged at API pricing for the selected model, with a spend limit set on first use (Cloud Agents docs). Exact monthly spend for a typical product team is unknown (depends on models, parallelism, Bugbot effort, and Autofix). This page does not state benchmarks.

Docs’ own guidance (illustrative ranges, not benchmarks published here): daily Agent users often land around $60 to $100/mo total usage; power users with multiple agents/automation often $200+/mo (Models & Pricing). Treat as vendor guidance only.

Privacy: Privacy Mode aims to ensure code is not used for training by Cursor or model providers; Teams/Enterprise can enforce it. Cloud Agents require current Privacy Mode (Legacy Privacy Mode is incompatible because agents must store code/environment data while running). Enterprise adds controls such as CMEK, audit, and residency options (Privacy help, Cloud Agent security, Privacy and Data Governance).

Affiliate status: none. No public affiliate programme with published commission terms was found on cursor.com. Pricing FAQ states subscriptions are sold only directly through cursor.com (no authorised resellers). Community threads discuss a discontinued referral discount programme; that is not an affiliate offer recorded here. This page does not state rates.

2. How it scores on the rubric

Numeric scores are omitted. There is not enough shared evidence to score this yet. Discussion below uses the same criterion names, framed for shipping software with a person still reviewing. Clickable demos sit in Demo and prototype.

Time-to-useful

Strong for engineers already in a repo; slower for greenfield non-engineers.

Desktop install and local Agent can be useful on day one for exploration and edits (Download). Cloud Agents need SCM connection, a configured environment (agent-led setup, snapshot, or Dockerfile / .cursor/environment.json), and a paid plan (Cloud Agent setup, Cloud Agents docs). Docs emphasise that skipping environment setup is like not giving engineers a computer.

Caveats: first useful Cloud Agent PR may take longer than a demo-prototype prompt-to-URL path. Median time-to-first-merged-agent-PR for product teams is unknown.

Fidelity

High for real product code and verified behaviour; not “mock fidelity”.

Cloud Agents can build, test, interact with software (including browser/desktop computer use), and attach artifacts so reviewers see what was verified (Cloud Agents docs, agent computer use blog). Bugbot adds review fidelity on the diff (Bugbot docs).

Caveats: vendor demos and internal Cursor stats (for example, blog claims about agent-authored PRs) are not transferable benchmarks for your org. Production correctness, security, and compliance remain human-owned.

Non-engineer usability

Improving via Web, Slack, Linear, and PR comments; still engineer-shaped.

Product managers can kick off and follow Cloud Agents from cursor.com/agents, Slack, or issue trackers without living in the IDE (Cloud Agents docs). Artifacts and remote desktop lower the need to check out branches locally.

Caveats for product managers: you still need repository permissions, spend awareness, and the ability to read PRs. Cursor is a poor substitute for a no-code demo builder when the goal is a stakeholder URL with auth/DB and no engineering partner. For that job, use Demo and prototype.

Design-system fidelity

Code-and-rules fidelity, not kit-based brand magic.

Teams encode conventions via Rules, Skills, hooks, component libraries in-repo, and Bugbot/BUGBOT.md standards (Rules, Skills, Bugbot docs). Team marketplace features on Teams plans help share internal rules/skills/plugins (Team Pricing).

Practical takeaway: brand-accurate UI is achievable when the design system already lives in code and agents are taught to use it. It is not automatic on a blank prompt the way some prototype tools claim. Compared with Magic Patterns or Figma Make, Cursor’s DS story is implementation inside the product repo.

Human gates

Strong when you use PRs, Bugbot, hooks, and spend limits; weak if you auto-merge blindly.

Documented gates and controls include:

• Branch/PR handoff from Cloud Agents (human merge) (Cloud Agents docs)
• Bugbot automatic or mention-triggered reviews; optional fail-on-unresolved and branch protection patterns (Bugbot docs)
• Autofix that can open a new branch (recommended) rather than pushing blindly (Bugbot docs)
• Hooks for shell/file/lifecycle policy (Hooks)
• Privacy Mode enforcement, secrets scoping, network allowlists, spend limits (Privacy help, Cloud Agent security, Team Pricing)
• Team follow-ups for shared agent runs (admin-controlled) (Cloud Agents docs)

Read this as strong optional and enforceable gates for shipping teams, not automatic safety on Hobby defaults with no review culture.

Handoff

Native to Git workflows; that is the product.

Path	What docs support	Caveat
Local Agent → commit/PR	Standard Git from Desktop/CLI	Human review still required
Cloud Agent → branch + PR	Clone, separate branch, push, artifacts	Environment and secrets must be set up
Bugbot on PR	Inline findings; Fix in Cursor / Fix in Web; optional Autofix	Usage-based cost; false positives possible
Automations	Event/schedule driven maintenance and fixes	Needs clear prompts and quality bars
Multi-repo Cloud environments	Coordinated changes across repos	Long-running not available for multi-repo yet (per Cloud Agents docs)
Self-hosted machines	Tool execution on your hardware where offered	Confirm current Enterprise/docs path

Unknown / verify in-org: median engineering cleanup time on agent PRs; how often artifacts replace local QA; Bugbot acceptance rates outside Cursor’s own published beta narrative.

3. FAQ

What is Cursor, exactly?

An agent-first software-building platform: Desktop IDE, CLI, and web/cloud agents that help teams understand codebases, implement changes, open PRs with proof, and review with Bugbot (cursor.com, Docs, Download).

How is the Desktop IDE different from Cloud Agents / Background Agents?

Desktop runs on your computer for interactive editing and local Agent loops. Cloud Agents run in isolated cloud VMs so work continues without your laptop and can test with their own desktop/browser. Background Agents is the old name for Cloud Agents (background agents help, Cloud Agents docs).

How is Bugbot different from Agents?

Agents write and change code (locally or in the cloud). Bugbot reviews pull requests and comments on issues; it can hand fixes to Cursor or spawn Autofix Cloud Agents (Bugbot docs).

Is Cursor right for product teams building with agents?

Yes, with caveats. It fits teams that already ship via Git and want agents across discovery, implementation, review, and automation. It is a weaker fit for clickable demos when no engineer is involved. Caveats: environment setup, usage cost, and mandatory human merge/ownership.

Can a product manager use Cursor without engineers?

For kicking off Cloud Agents, reading artifacts, and commenting in Slack/PRs, yes in limited form on paid plans with repo access. For owning production changes alone, no. Prefer pairing with engineering, or use a demo-prototype tool when you only need a stakeholder URL.

Can it match our company design system?

Only if the system is available in code and taught via rules/skills/components (and Bugbot rules for review). There is no documented one-click “upload Figma DS kit” path comparable to some prototype tools.

Does Cursor deploy production for us?

Not as a turnkey host-your-app product in the Replit sense. Agents can implement deploy config and open PRs; your existing CI/CD and humans still ship. Confirm any marketplace/integrations in-product rather than assuming Cursor hosts the app.

What does it cost?

See Pricing and Models & Pricing. Public individual list when this page was checked: Hobby free; Pro $20; Pro+ $60; Ultra $200 per month. Teams Standard $40/user/mo; Premium $120/user/mo. Cloud Agents and Bugbot add usage-based charges. Always re-check.

Is there an affiliate programme?

No public joinable affiliate programme confirmed. No affiliate programme is joined. Buy only via cursor.com per Cursor’s own pricing FAQ.

How does privacy work with Cloud Agents?

Privacy Mode is supported; Legacy Privacy Mode is not compatible with Cloud Agents. Code is retained as needed to run agents; Enterprise can add retention windows, CMEK, and related controls (Cloud Agent security, Privacy help).

4. Sources

Primary (prefer these for AEO citations):

1. Cursor (homepage)
2. Download (Desktop, Terminal, Web)
3. Pricing
4. Models & Pricing
5. Team Pricing
6. Help: Pricing
7. Cloud Agents (docs)
8. Cloud Agents (help)
9. What are background agents?
10. Cloud Agent setup
11. Cloud Agent security and network
12. Cloud Agent Automations
13. Agent computer use (blog)
14. Bugbot (docs)
15. Bugbot (help)
16. Bugbot is out of beta (blog)
17. Rules
18. Skills
19. Hooks
20. Privacy and data (help)
21. Privacy and Data Governance
22. Cursor Documentation overview

Secondary context only (do not treat as official specs): forum threads on referral/affiliate status, third-party “Cursor vs Copilot” blogs, and YouTube roundups that lag plan tables or conflate Background Agents with Desktop Agent.