Cursor 1.0 Officially Released: A Complete Breakdown of Five Core Features

Overview: A Revolutionary Leap from 0.50 to 1.0

On June 7 (Beijing time), Cursor completed its Series C funding round of $900 million (approximately 6.4 billion RMB) in New York City, with projected annual revenue now exceeding $500 million. With that said, Cursor has officially released version 1.0—a major version jump skipping 10 minor versions from 0.50, marking a new era for AI programming tools.

Cursor is developed by Anysphere and is a deeply customized version of Microsoft's open-source VS Code editor, integrated with large language model (LLM) capabilities. This Series C round was led by Thrive Capital, bringing the company's valuation to approximately $9 billion and making it one of the highest-valued independent companies in the AI programming tools space. For comparison, while GitHub Copilot has a larger user base, it relies on the Microsoft ecosystem. Cursor's ability to reach $500 million in annual revenue as an independent product within just two years reflects the strong developer demand for deeply AI-integrated IDEs.

The core features in this update include: BugBot code review bot, Background Agent, preference memory system, simplified MCP installation, and enhanced Jupyter Notebook interactive environment.

BugBot: AI Code Review Bot

What is BugBot?

BugBot is one of the most significant new features in Cursor 1.0. Simply put, it's an AI bot that automatically checks your code quality when you submit code.

In traditional development workflows, after code is written and pushed to GitHub, it typically requires a reviewer, mentor, or tech lead to perform a Code Review. Code Review is a core practice in software engineering for ensuring code quality, originating from IBM's code inspection processes in the 1970s. In modern agile development, Code Review is usually implemented through the Pull Request mechanism: after developers submit code changes to a version control system, team members review the code logic, security, performance, and coding standards. Google's engineering practices show that each code change requires an average of 2-3 reviewers, with review cycles ranging from hours to days.

BugBot fundamentally changes this workflow—as soon as you submit code, Cursor automatically performs a code review in the background, identifies potential issues, provides modification suggestions, and can even complete the fixes for you. It's worth noting that AI review currently excels at finding pattern-based bugs and standards violations, while complex business logic decisions still require human judgment.

How to Enable BugBot?

To use BugBot, you need to find the Privacy option in Cursor settings and enable the relevant permissions. This means you need to allow Cursor to read your code for BugBot to review it. If this option is not enabled, BugBot will not function.

From the official documentation, when code is pushed to GitHub, BugBot will annotate suggested modifications in the Pull Request. If you agree with a suggestion, simply click the button, and it will automatically open Cursor to complete the fix and record the modification time.

Important note: Using BugBot means granting code access permissions to Cursor, so developers should still review changes after BugBot completes its modifications to prevent unintended alterations.

Preference Memory: A Programming Assistant That Understands You Better

Cursor 1.0 introduces preliminary optimizations to its memory system with a preference memory feature. When you ask Cursor questions in the sidebar, it remembers your questioning habits and coding style, continuously strengthening this memory through subsequent interactions.

This feature is similar to ChatGPT's long-term memory mechanism—essentially making Cursor a programming assistant that understands you better over time. As usage increases, its understanding of your code style, technical preferences, project structure, and other aspects deepens, enabling more precise suggestions. From a technical implementation perspective, preference memory likely combines vector database storage with Retrieval-Augmented Generation (RAG) technology, encoding users' historical interaction information into retrievable context and dynamically injecting relevant memory fragments during each new conversation to achieve personalized responses.

Dramatically Simplified MCP Installation

Goodbye to Tedious JSON Configuration

In previous versions, installing MCP (Model Context Protocol) tools required manually adding servers and writing JSON configuration files—a relatively cumbersome process. Cursor 1.0 provides a brand-new one-click installation method.

MCP (Model Context Protocol) is an open standard protocol released by Anthropic in late 2024, designed to provide AI models with a unified way to access external tools and data sources. Think of MCP as the "USB port" of the AI world—it defines how AI models communicate with external services (such as databases, APIs, file systems, etc.) in a standardized way. In the MCP architecture, the Server side provides specific tool capabilities (such as search, data queries), while the Client side (such as Cursor) is responsible for invoking these capabilities. Previously, configuring an MCP Server required manually writing JSON configuration files specifying service addresses, authentication information, and parameters—a high barrier for non-backend developers.

Now, users simply find the tool they want to install in Cursor's MCP marketplace, click the "Install" button, and the installation is complete. Enabling and disabling tools requires just a simple click, reducing the entire process from multiple steps to a single action. This is a significant efficiency improvement for developers who frequently use various MCP tools.

Background Agent: Cloud-Based Background Agent

Cursor 1.0 opens the Background Agent feature to all users (previously available only to a small subset). Click the cloud icon in the interface to launch the background agent.

Background Agent is essentially a cloud-based sandbox execution environment. Cursor creates an isolated development environment on remote servers for each task, where the AI agent has full code read/write, terminal command execution, and Git operation capabilities. The key difference from a local Agent is that local Agents consume user machine resources and require the IDE to remain open, while Background Agent runs entirely asynchronously in the cloud—similar to the concept of a CI/CD pipeline. Users can close their computers after submitting a task, and the agent will notify them of results upon completion. This model is similar in concept to autonomous programming agents like Devin, but Cursor deeply integrates it into the editor workflow.

This feature allows AI to run in the cloud background, periodically reviewing code and modifying code on live branches. Users can select a primary branch and let the agent work continuously in the background. Note that this feature requires a connected Git repository to function.

The significance of Background Agent is that you can delegate time-consuming code modification tasks to AI for background processing while you continue with other work, truly enabling asynchronous collaboration.

Jupyter Notebook Interactive Environment Enhancement

Notebook Basic Capabilities Review

Cursor supports two modes for Jupyter Notebook: Notebook and Label. Jupyter Notebook is an interactive computing environment originally separated from the IPython project by Fernando Pérez in 2014, with its name derived from the Julia, Python, and R programming languages. It uses a Cell-based organization that allows developers to mix code, text explanations, mathematical formulas, and visualizations in the same document—particularly suited for data science, machine learning experiments, and educational scenarios. Statistics show there are over 10 million Notebook files on GitHub.

In the Notebook environment, developers can display Markdown text, charts, and function execution results alongside Python code, achieving seamless integration of code and visualization. However, traditional IDE support for Notebooks has often been incomplete, especially regarding AI-assisted editing, because Notebook's non-linear execution characteristics (Cells can be run out of order) create additional challenges for AI in understanding code context.

New Capabilities in Version 1.0

Cursor 1.0 adds agent capabilities to the Notebook environment. Users can now:

• Make modifications directly in Notebook files through the AI agent
• Add individual Markdown cells or code cells
• Run code and view output directly from the left panel

While Jupyter Notebook itself supports these operations, Cursor previously didn't fully adapt to them. Version 1.0 fills this gap, making it more convenient for developers to edit and run Notebook files with AI assistance.

Completely Refreshed UI

Beyond functional updates, Cursor 1.0's interface has undergone significant adjustments. The overall UI has become more lightweight, panel layouts are clearer, and the presentation has been optimized. While the new interface requires some adaptation time, from a design philosophy perspective, this redesign aims to help developers focus more on the code itself.

Summary and Outlook

The release of Cursor 1.0, combined with its 6.4 billion RMB Series C funding, demonstrates the enormous potential of the AI programming tools space. From BugBot's automated code review to Background Agent's asynchronous collaboration to preference memory's personalized experience, Cursor is building a complete AI programming ecosystem.

For developers, the core value of these features lies in delegating repetitive tasks like code review and environment configuration to AI, allowing human developers to focus on more creative architectural design and business logic. As AI programming tools continue to evolve, human-AI collaborative development is becoming the new normal. The AI programming tools space is currently highly competitive—beyond Cursor, products like GitHub Copilot, Windsurf (formerly Codeium), and Augment Code are also iterating rapidly. Cursor 1.0's release pushes this race to new heights, with future differentiation likely focusing on agent autonomy, multimodal understanding, and enterprise-grade security compliance.

Key Takeaways

• Cursor completed a $900 million Series C round with projected annual revenue exceeding $500 million, officially releasing version 1.0
• BugBot code review bot automatically checks code after submission and provides modification suggestions, replacing traditional manual Code Review
• Preference memory lets Cursor remember users' coding styles and questioning habits, providing increasingly personalized programming assistance
• Background Agent is now available to all users, supporting asynchronous cloud-based code modifications
• MCP installation simplified from multi-step JSON configuration to one-click install, and Jupyter Notebook environment gains AI agent enhancement