Cursor 2.0 Is INSANE: Multi-Agents Build Deploy Apps AUTOMATICALLY!

Key Concepts

• Cursor 2.0: An AI-powered code editor with enhanced agent capabilities.
• Composer: Cursor's first agent model, designed for building applications with multiple AI models.
• Agent Mode: A dedicated interface within Cursor for interacting with AI agents.
• Multi-Agent Interface: Allows users to leverage multiple AI models simultaneously for a single task.
• Test Sprite: An AI agent for automated software testing, fixing, and validation.
• Google Cloud Deployment: Publishing applications to Google Cloud services like Cloud Run.
• Kubernetes Deployment: Deploying applications to Kubernetes clusters using Terraform.
• Kubernetes Monitoring & Optimization: Analyzing and improving existing Kubernetes cluster performance.
• Worktree: A Git feature that allows for isolated development environments, similar to branches but with dedicated folders.

Cursor 2.0: Introducing Composer and Agent Capabilities

Cursor 2.0 introduces "Composer," its first agent model, designed to significantly enhance application development by leveraging multiple AI models concurrently. This new version features a distinct "Agent Mode" alongside the traditional code editor, providing a dedicated space for AI-driven tasks. Users can now instruct agents to perform complex operations, such as building a full-fledged bank statement analyzer application.

Key Features of Cursor 2.0:

• Composer Model: Described as four times faster for application creation and topping coding model charts.
• Multi-Agent Interface: Enables the selection of multiple AI models for a single task, allowing for diverse approaches and version generation.
• Integrated Browser: A built-in browser for previewing applications, selecting elements, and requesting automatic fixes or improvements.
• Agent Mode: A specialized interface for interacting with AI agents, separate from the file editor.

Building a Bank Statement Analyzer App with Agents

The transcript demonstrates the creation of an AI-powered bank statement analyzer application. The process involves:

1. Task Definition: The user instructs the agent to "create an AI powered application which can automatically provide insights when we provide our bank statement and for improvements. It should accept Excel, PDF or document format, a front end and a back end, a full-fledged application with database."
2. To-Do List Generation: The agent automatically generates a to-do list based on the request.
3. File Creation: The agent proceeds to create the necessary files for the application.
4. Application Execution: The user can then command the agent to "run the application." This includes installing packages, testing, and starting the server.
5. Application Preview: The application is accessible via a URL, allowing users to upload bank statements for analysis.

Integrating Test Sprite for Automated Testing and Debugging

A critical aspect highlighted is the necessity of testing AI applications. Test Sprite, an AI agent for testing, fixing, and validating software, is integrated into Cursor.

Test Sprite Functionality:

• Automated Testing: Users can instruct Test Sprite to test the application (e.g., backend or frontend).
• Test Script Generation: Test Sprite automatically generates test scripts based on provided information like README files.
• Centralized Dashboard: Test results are saved in Test Sprite's dashboard, providing a comprehensive overview.
• Error Identification: The dashboard reveals specific failures, such as "supported file formats: fail" or "endpoint handles files with no transaction: failed."
• Automated Fixing: Users can pass test reports to Test Sprite with instructions to "fix all these errors."
• API Key Integration: For applications requiring API keys (like OpenAI), Test Sprite can assist in setting them up in .env files.

Example: After an initial error in the bank statement analyzer, Test Sprite was used to identify and fix issues, leading to successful analysis and the display of financial statistics and insights like "consider reducing spending."

Deployment to Google Cloud and Kubernetes

Cursor 2.0 simplifies the deployment process to cloud platforms.

Google Cloud Deployment:

1. Request Deployment Files: The user asks the agent to "give me all required file or secret key to deploy this application to Google cloud."
2. File Generation: The agent generates necessary files such as cloudbuild.yaml, app.yaml, gitignore, and Cloud Run configuration files.
3. Deployment Plan: A detailed deployment plan is provided, outlining prerequisites like a Google Cloud account and OpenAI API key.
4. Automated Deployment: With the prerequisites met, the user can instruct the agent to "publish it now using Google cloud CLI." The agent handles Docker file building and authentication.
5. Cloud Run Endpoint: The application is successfully deployed to Google Cloud Run and accessible via an API endpoint.

Kubernetes Deployment:

1. Request Terraform Code: The user requests the agent to "delete from cloud run and publish it in Kubernetes cluster using terraform code."
2. Terraform Code Generation: The agent generates comprehensive Terraform code, including main.tf, variables.tf, and outputs.tf, for Kubernetes deployment.
3. Automated Deployment: The user can then instruct the agent to "deploy it for me in Kubernetes." This process involves creating VPC artifacts, registry, compute, and network resources.
4. Terraform Apply: The agent executes terraform apply to deploy the application to the Kubernetes cluster.
5. Kubernetes Cluster Management: The transcript notes that even Cloud Run runs on Kubernetes, and direct Kubernetes management offers greater customization. The deployment process, which previously took days, is now achievable in minutes.
6. Application Verification: The deployed application is verified on the Kubernetes cluster by checking pods, services, and accessing the application endpoint.
7. Automated Destruction: The agent can also be instructed to "destroy the whole application" using terraform destroy.

Monitoring and Optimizing Existing Kubernetes Clusters

The agentic system extends to analyzing and optimizing existing cloud deployments.

Example: MySQL and PHP Pod Optimization:

1. Problem Identification: The user describes a scenario where a website sometimes experiences downtime, potentially related to a MySQL or PHP pod.
2. Pod Analysis: The agent is asked to "check my MySQL pod from my Kubernetes cluster." It retrieves information, logs, and service details.
3. Resource Usage Check: The agent is then instructed to "check resource usage for my PHP pods in the last one day." It analyzes CPU and memory usage, identifying limits and requests.
4. Optimization Strategy: Based on the analysis, the user requests an "optimization strategy." The agent provides recommendations, such as increasing CPU limits, optimizing readiness probes, and adjusting HPA (Horizontal Pod Autoscaler) scaling behavior.
5. Automated Implementation: The user can then ask the agent to "implement this strategy." The agent modifies deployment configurations, increases CPU limits, and verifies the changes using kubectl get commands.
6. Outcome: The optimization is completed within minutes, with CPU targets, memory targets, CPU limits, and CPU requests all adjusted.

Multi-Agent Collaboration and Worktrees

Cursor 2.0 enables advanced multi-agent collaboration, particularly when working with Git repositories.

Implementing Login with Multiple Agents:

1. Git Initialization: To enable multi-agent mode, a Git repository must be initialized (git init).
2. Agent Selection: Users can select multiple agents and even assign custom models to each (e.g., Composer, Sonnet 4.5, GPT 5.1 Fast, Gemini 2.5 Flash, Grok First).
3. Worktree Creation: Each agent operates within its own "worktree," which is described as similar to a branch but with a dedicated folder. This allows for isolated development.
4. Parallel Task Execution: Multiple agents work concurrently on the same task (e.g., implementing login functionality).
5. Review and Merge: Completed tasks from each agent can be reviewed individually. Users can then choose to apply one agent's work or merge changes.
6. In-Browser Preview: A preview of the application, including agent-generated UI elements like a login page, can be viewed directly within Cursor.
7. Model Comparison: The multi-agent system facilitates comparing the output of different models and selecting the preferred implementation.

Conclusion

Cursor 2.0, with its Composer model and enhanced agent capabilities, represents a significant leap in AI-assisted software development. The platform streamlines complex tasks from initial application creation and automated testing with Test Sprite to seamless deployment on Google Cloud and Kubernetes, and even sophisticated monitoring and optimization of existing infrastructure. The multi-agent interface and worktree functionality further empower developers by enabling parallel development and comparison of different AI model outputs, ultimately accelerating the development lifecycle and democratizing advanced DevOps practices.