At the end of last month, Cursor announced Cursor 2.0, a new version of Cursor that brings agentic development to Cursor.
If you’re new to Cursor, we recommend first reading our Cursor AI: A Guide With 10 Practical Examples tutorial. As we know, Cursor is trusted by engineers from leading AI companies, including OpenAI, providing AI-assisted coding, intelligent code suggestions, and integration with various development tools.
In this tutorial, I’ll explore the main features of the new Cursor 2.0 by building a currency exchange web app in Python.
What's New In Cursor 2.0?
For a full list of features from Cursor 2, we encourage you to check their official changelog. In this tutorial, we focus on the features that are most relevant to small teams and solo developers.
Composer model
Cursor introduces its first in-house coding model named Composer. They claim it is ~4× faster than similarly capable models and is tuned specifically for agentic, multi-step code workflows. Its main goal is to reduce latency so you feel more like you’re interacting in real-time with the AI rather than waiting.
Multi-agent interface and orchestration
Cursor 2.0 shifts from one agent helping you to many agents running in parallel. Up to 8 agents can run in parallel on a single prompt. Each agent gets its own isolated copy of the codebase so they don’t conflict. A sidebar UI shows your agents/plans, and you can pick the best output from multiple runs.
Built-in browser and testing capabilities
The browser tool (previously beta) is now generally available. Agents can open a webpage inside Cursor, inspect DOM elements, forward DOM info to the agent, and test UI changes. This means your AI agent is more aware of the web environment and can validate changes rather than just editing code blindly.
Getting Started With Cursor 2.0
To get started, download and install Cursor 2 from their official website. Make sure to download version 2 and select the correct OS.
Most of the features we discuss in this tutorial require a Pro subscription, which costs around $20 per month. However, Cursor 2 comes with a one-week free trial, so you can experiment with it and follow along with this tutorial for free.
To access the free trial, you are required to input credit card details. You can avoid being charged and experience the 7-day trial by canceling the subscription before the trial ends.
A word of caution: After starting the free Pro trial, the interface shows a button to start using Pro features. This is misleading and not required to access the Pro features during the trial period. Clicking it will automatically end the free trial and charge you for the first month, which is probably not what you want.
Creating an App With Cursor 2.0
To test Cursor 2, we created a web app for currency conversion using Python. The app is entirely created using Cursor 2.
After installing it, switch to the new "Agents" view:
One of the new features of Cursor 2 is the ability to automatically browse our app to test it. Thus, I decided to create a Streamlit web app with Python.
Streamlit is an open-source Python framework designed for creating interactive web applications quickly and easily, especially for data science and machine learning projects.
With Streamlit, you can build user interfaces for your Python code by writing simple scripts, without needing any front-end experience. It’s commonly used for building dashboards, data visualizations, and tools that allow users to interact with data or models in real time through the web browser.
We use Streamlit to create an app to easily convert between currencies. Starting from an empty folder, here's the initial prompt I used:
Note that the model I used is the new Composer model from Cursor 2. Other models can be selected using the model selector below the prompt input.
This is the app it created:
Navigating the Cursor Agents view
The new "Agents" view organizes our changes as conversations with different AI models. The workflow is similar to using a ChatGPT conversation per feature, except it's all directly integrated inside Cursor 2.
We can use different models for each agent and even multiple models at once, as we will discuss later. The previous code editor view remains available, so we can easily switch between writing code, as we did with the previous version of Cursor, and working with agents.
Cursor's Composer Model
Composer is a new agent model developed by Cursor, designed specifically to assist with software engineering tasks efficiently and intelligently.
The model has been trained to solve real-world coding problems within large codebases by using a range of development tools, such as file editing, terminal commands, and semantic search.
Unlike traditional coding assistants that focus only on code completion, Composer can handle more complex tasks, including generating code edits, creating development plans, or providing informative answers based on the context of the problem it is given.
The model's training process relies on reinforcement learning, allowing it to adapt to different development environments and prioritize effective use of tools and response speed. This focus on speed and practical usefulness makes it well-suited for scenarios where developers want quick, relevant help without disrupting their workflow.
Composer was evaluated against benchmarks that reflect real requests from working engineers, ensuring that its output aligns with common software development practices. However, these benchmarks are private, and Composer doesn’t feature on the existing public AI benchmarks, so we should take these with a grain of salt.
Putting Composer to the test
One of the new features of Cursor 2 is its multi-agent interface.
The multi-agent interface makes it possible to have different models tackle the same coding problem, so we can compare results and select the most effective solution.
The interface includes tools to review changes made by each agent and a native testing feature that enables agents to iteratively improve their output until it meets the required criteria. This combination is particularly useful for handling complex projects, as it can help speed up reviewing, testing, and coding tasks.
We used this to compare the Composer model with other state-of-the-art AI coding models on a complex task. To activate multiple agents, we click on the 1x selector located under the prompt input and select "Use Multiple Models".
The task we used for this comparison was to add persistence in the default currencies. Right now, once the user refreshes the page, the list of currencies used for conversion is reset. We want this to be stored so that if the user revisits or reloads the page, the currencies remain saved.
We selected this task because it is a bit more complex, as the framework we're using to build our app isn't really designed to handle this type of feature.
I selected three models for this task:
- Composer
- Sonnet 4.5
- GPT-5 Codex
We can select up to eight models to work in parallel. However, that might be a little bit overkill if we plan to look at each output and select the best. I found three to be a sweet spot to have a variety of solutions, but not so many that it takes more time to check them than if I had actually implemented the solution myself.
Here's a video of three agents working on the problem in parallel. We observe that Composer is indeed much faster than the other two.
At the end, we can easily switch between the three outputs and check the differences in each of them. Then we can use the "Apply All" button on the one we want to integrate into our code.
In this specific instance, despite taking much longer, my preferred solution was the one proposed by GPT-5 Codex because it seemed less hacky and used existing libraries to solve the problem.
However, speed is quite important when it comes to code completions because it's a real-time use case. This is where Composer shines compared to other models, as it is able to provide good code suggestions very quickly, resulting in a smooth coding experience.
Planning mode
Instead of having the agent directly propose code changes, we can use the “Plan” mode to first work on an implementation plan. This makes it possible to iterate on the plan and make sure it is implementing what we want before making any changes to the code.
To use this mode, select the “Plan” option, like so:
In this mode, instead of code changes, we get a markdown plan of what the agent intends to do to implement the feature. In this case, this is what we got:
Say I want to use the streamlit_js_eval library to evaluate JavaScript code. This was something the GPT-5 Codex solution had used and that felt more robust than Composer’s solution. We can ask the agent to modify the plan accordingly:
After running it again, we see that the library is included in the new plan:
When we’re happy with the plan, we can make the changes by clicking the “Build” button.
The Browser Agent
Cursor’s Agent browser feature allows users to control a built-in web browser directly within the Cursor environment.
This means we can automate common tasks such as navigating web pages, filling out forms, clicking buttons, and capturing screenshots without needing any external tools or setup. The browser also provides direct access to console logs and network activity, making it easier to identify issues or debug web applications.
This feature is useful for a variety of tasks, including automated application testing, checking web accessibility, and comparing web designs to actual implementations.
To invoke it, we use the @Browser mention in the prompt.
A common use case for the browser agent is to test the application. For example, we ask it to test the currency converted by converting 100 USD into Euros and Japanese Yen:
When we do this, the cursor will automatically launch the application and run an integrated browser to perform the task we asked it to do.
During the process, it may need to execute some commands, which we need to manually approve. This is a safety mechanism so that we can review commands before they are executed.
In this case, it prompted me to execute a command to run the currency exchange application:
Here's a video of the process. The browser we see in the video is being controlled automatically by Cursor.
