Cursor

Overview

You open a project. You ask the AI where the authentication logic lives. It searches the repository. Then you ask it to prepare a change, run the tests, and check what it has just modified.

Then you give it a second task while the first one keeps running somewhere else.

That is where Cursor stops being simply an editor with AI bolted onto the side.

Developed by Anysphere, Cursor is built on the foundations of Visual Studio Code and retains many of its familiar landmarks: editor, terminal, extensions, themes, shortcuts, and overall organization. Migrating from VS Code can import extensions, settings, themes, and keyboard shortcuts in one go.

That familiarity has played a major role in its adoption. There is no need to relearn how to open a Python file just to take advantage of a language model.

But the project has gradually shifted its center of gravity.

From assistant to control center

At first, the proposition could be summarized fairly easily: VS Code with AI deeply integrated into it.

That description is becoming too small.

Cursor now combines several layers of assistance: code prediction with Tab, repository understanding, conversations with the project, multi-file editing, terminal access, planning, autonomous agents, parallel subagents, cloud environments, code review, and a command-line interface.

The editor is still there.

But an increasing part of the work can now be handed to agents that you direct, monitor, interrupt, or take over from.

The interesting shift is not simply that AI writes more code. It is that the developer can start distributing the work.

Multiple models in the same environment

Cursor provides access to several leading models rather than building the entire product around a single provider.

Depending on availability and subscription level, users can work with models from providers including OpenAI, Anthropic, Google, and xAI, alongside models developed or trained by Cursor itself, such as Composer.

Auto mode can also select the model considered most suitable for the task and current availability conditions.

This approach turns Cursor into an intermediary layer between the developer, the project, and several families of models.

Convenient.

But it also makes the real cost more subtle than simply “a $20 subscription.”

Features

Tab: predicting the next move

Code completion remains one of Cursor’s least spectacular features — and probably one of the ones people use most.

Cursor Tab does more than finish the word you started typing. It can suggest multi-line edits, anticipate related changes, and help move between different parts of the code.

When it works well, you barely need to give an instruction.

You start making a change.

Cursor predicts what comes next.

You accept it.

And keep going.

It is less spectacular than an agent announcing that it has refactored thirty files. It is also much closer to the everyday gesture of programming.

Agent: understand, search, modify, execute

Agent can work with the context of a project, search through files, modify code, and use tools such as the terminal.

Codebase indexing allows Cursor to build a representation of the project that can be used for semantic search. This becomes especially useful when a repository grows far beyond what a human can comfortably keep open in their head at once.

You can ask it to:

• find the origin of a particular behavior;
• explain an existing architecture;
• prepare a plan before changing the code;
• make changes across multiple files;
• run commands and tests;
• inspect the results and continue working from them.

The developer can stay in the loop.

Or give the agent more autonomy.

Multiple agents instead of a single conversation

Cursor has moved a long way from the classic model: one chat window, one question, one answer.

Tasks can now be distributed between several agents and several environments.

Multitasking can also break down certain requests and send several subagents to work in parallel.

It is no longer simply “ask the AI to code.”

Sometimes it becomes: break the problem down, hand out the pieces, then come back with something I can review.

Agents that can work in the cloud

Cloud Agents have their own isolated development environments.

They can retrieve a repository, install dependencies, modify the project, run the software, execute tests, and produce material that helps verify their work: diffs, logs, screenshots, or demonstrations.

A long-running task can therefore leave the local machine without blocking the main session.

Cursor can then move work across several contexts: local, cloud, browser, or mobile.

This is probably one of the most revealing changes in the product.

The file still matters.

The agent’s working session is becoming almost as important as the file itself.

CLI, MCP, skills, and hooks

Cursor does not restrict this approach to its graphical interface.

The Cursor CLI makes it possible to use the agent directly from a terminal, including modes for planning or querying the project.

Support for MCP — Model Context Protocol allows agents to connect to external tools and data sources.

Rules, skills, and hooks can then provide more control over their behavior: project conventions, reusable instructions, integrations, and actions triggered during an agent’s lifecycle.

For a small personal application, all of this may feel excessive.

For a team that wants several agents to follow the same rules, much less so.

Review the code before the bug goes on vacation

Bugbot adds another piece to the system: agent-assisted code review.

It can analyze changes and pull requests, flag potential issues, and suggest fixes. Cursor also allows certain reviews to be launched directly before a push.

This obviously does not turn an AI into an infallible colleague.

That would be convenient.

And slightly worrying.

But it does add an interesting layer of control to a workflow in which AI itself is producing an increasing share of the code.

Use cases

Understanding a project you did not write

You arrive in a repository containing several hundred files and encounter that familiar feeling: “all right, but what calls what in here?”

Instead of starting with fifteen manual searches, Cursor can explore the project, locate the files connected to a particular feature, and explain how the pieces communicate.

For onboarding, maintaining an old project, or simply returning to your own code six months later — that mysterious work created by a past version of yourself — the gain can be very real.

Building a feature without giving up control

A request such as “add PDF export” can begin with a plan rather than immediate code generation.

The developer reviews the approach, corrects any assumptions if necessary, then lets the agent modify the files and run the tests.

The point is not only to move faster.

It is being able to gradually move the boundary between what you write yourself and what you would rather supervise.

Running several pieces of work in parallel

A CI test is failing.

An interface needs fixing.

A dependency needs migrating.

Instead of placing everything into a mental queue whose stability can occasionally be questioned, several agents can work in separate branches or environments.

The developer can then return to each result, inspect the diffs, and decide what is actually worth keeping.

This way of working requires another skill: knowing how to break down and verify a task becomes almost as important as knowing how to ask for it.

Continuing away from the desk

The web, iPhone, and iPad versions extend this approach even further.

From a mobile device, users can launch or monitor cloud agents, review their results, inspect diffs, and work around pull requests.

It is not the complete desktop IDE squeezed into a pocket.

It is closer to a control and review surface.

And that is probably more useful anyway. Nobody was truly dreaming of comfortably refactoring 4,000 lines of TypeScript with two thumbs on the subway.

PANACHES review

Cursor is one of those tools that makes it easy to see how AI-assisted development is changing in nature.

The first step was asking for code.

Then talking with the project.

Then allowing AI to modify several files.

Cursor is now pushing toward the next stage: handing entire tasks to multiple agents and organizing their work around the repository.

That is what makes it particularly interesting.

Its strength: reducing the gap between coding and delegating

Cursor does not suddenly ask developers to abandon the traditional editor for a dashboard filled with autonomous agents.

It keeps the files.

The terminal.

The diffs.

The extensions.

The shortcuts.

Then it introduces AI directly into that environment.

That continuity is a real strength for anyone coming from VS Code. You can start with Tab and a few questions about the code, then gradually move toward Agent, worktrees, cloud environments, or subagents.

No need to become an orchestra conductor on Monday morning.

But the more agentic Cursor becomes, the more supervision matters

Giving an agent greater autonomy does not remove intellectual work.

It moves it.

You still need to define a task properly, provide the right context, know when to break a problem down, understand a diff, verify the tests, and recognize a solution that is technically plausible but conceptually wrong.

Cursor can write a lot.

It does not magically assume responsibility for the product along with your subscription.

The best use of Cursor is probably not to stop understanding your code. It is to save more time for the parts that truly deserve to be understood.

Who is it for?

Cursor becomes particularly compelling for developers who want to make AI a permanent part of their working environment, rather than occasionally opening a chatbot beside their editor.

It is also interesting for people working on projects large enough to benefit from code search, task delegation, worktrees, or cloud agents.

On the other hand, a developer who mainly wants a lightweight editor, a fully open environment, highly predictable costs, or a strictly local-first philosophy may prefer to start with Visual Studio Code, VSCodium, Zed, or another environment and add assistants separately according to their needs.

Cursor chooses integration.

And that integration is precisely both its strength and its dependency.

Points to consider

A subscription price that does not tell the whole story

Cursor offers a free Hobby plan, followed by several paid tiers: Pro, Pro+, Ultra, Teams, and Enterprise.

The differences between plans notably concern the amount of agent and model usage included. Some features, such as Bugbot, also use usage-based pricing.

The real cost therefore depends heavily on how you work.

A developer who mostly uses Tab and a few agents does not have the same usage profile as someone running long tasks on expensive models all day.

You need to look at consumption, not just the amount that appears on your card once a month.

Proprietary despite its VS Code roots

Cursor is built on the Visual Studio Code codebase and reuses various open-source components, but Cursor itself is a proprietary product.

Its terms of service notably restrict reverse engineering, modification, or the creation of derivative works from the service, except where applicable law provides otherwise.

So “based on VS Code” should not be confused with “Cursor is open source.”

Privacy: Privacy Mode does not mean fully local operation

Cursor offers a Privacy Mode to both free and paid users. When enabled, Cursor states that customer data is not used to train its models and that Zero Data Retention agreements are applied with the relevant model providers.

That is an important protection.

But it does not make Cursor a fully local AI IDE.

Some requests pass through Cursor’s infrastructure. Even when using a personal API key, Cursor states that requests still travel through its backend for final prompt construction.

Codebase indexing also sends fragments of the project in order to calculate embeddings; the plaintext code used for this process is temporary, while embeddings and certain metadata may be retained.

For a sensitive repository, the privacy settings and the type of agent being used are therefore worth understanding before clicking “Run.”

Cloud Agent really does mean cloud

Cloud agents work inside remote virtual machines containing a copy of the project and their own execution environment.

That is precisely what allows them to keep working even when the local computer is turned off.

But this capability naturally means entrusting more context and execution to Cursor’s remote infrastructure.

For some companies, that is a powerful tool.

For others, it is exactly the boundary they do not want to cross.

Mobile apps do not replace the desktop editor

Cursor is now available on iPhone and iPad, but these applications are primarily built around agents, task monitoring, diffs, and pull requests.

The full IDE experience remains on desktop across Windows, macOS, and Linux.

Mobile access is also associated with paid plans.

Not every model is available everywhere

The model lineup changes quickly, and availability can depend on region.

At the time of this verification, August 7, 2026, Cursor states, for example, that Grok 4.5 is not available in the European Union.

A pricing page or model list will therefore age much faster than the editor itself.

Generated does not mean validated

Finally, Cursor can modify and sometimes execute code automatically.

Its own terms remind users that model-generated suggestions can contain errors and that users remain responsible for evaluating them.

That almost feels too obvious to mention.

But the more capable agents become, the more important that obvious point becomes.

Delegating the keyboard is easy. Delegating judgment is much harder.