Cursor 2.2 Debug Mode Fixed My Bugs Automatically (Multi-Agent Features)

Key Concepts

• Debug Mode: A feature that instruments code, captures runtime logs, and automatically fixes bugs.
• Plan Mode with Images: Enhancements to the planning feature that allow for visual representations (e.g., Mermaid diagrams) of plans and reports.
• Multi-Agent Judging: The ability for multiple AI agents to work concurrently on a task, with the system automatically selecting the best output.
• Pin Chat: A feature to mark important conversations or tasks for easy access.
• Instrumentation: Adding code to existing programs to monitor their execution and collect data, often used in debugging.
• Mermaid Diagrams: A JavaScript-based diagramming and charting tool that renders text-based definitions into diagrams.
• Concurrent Execution: Running multiple tasks or processes simultaneously.
• Sequential Execution: Running tasks or processes one after another.

Debug Mode: Fixing Code with AI

The latest version of Cursor introduces a significant feature: debug mode. This mode aims to help users fix complex bugs by automatically instrumenting their code. When a bug is reproduced, the agent captures runtime logs and then works to identify and fix the root cause. Users can then verify the fix.

Process of Debug Mode:

1. Initiation: The user selects "try mode" or chooses "debug mode" from a dropdown.
2. Issue Identification: The user prompts the agent to find issues, for example, "find if there are any issues with debug mode on."
3. Planning and Hypothesis: The agent analyzes the codebase, plans its next steps, and hypothesizes potential inputs or bugs, such as a key mismatch between functions.
4. Instrumentation: The agent automatically adds lines of code (instrumentation) to verify the bug. This is described as a method for identifying bugs within existing code.
5. Approval and Execution: The agent requests approval to run the instrumentation and confirms the bug.
6. Bug Fixing: The agent then proceeds to fix the identified error locations.
7. Verification: After fixing, the agent clears log files, confirms the bug analysis, and applies the fix.
8. Final Review: The user asks the agent to review again, run tests, and check for correctness. The agent runs tests and confirms the correct answer.
9. Outcome: The summary indicates that all errors were resolved. The user can see the specific files that were modified, such as the "hybrid evaluator file."

Key Argument: Debug mode automates the tedious process of bug identification and fixing by intelligently hypothesizing inputs and errors, and then applying targeted code modifications.

Plan Mode Improvement with Images

Cursor's plan mode has been enhanced with image integration, making plans and reports more understandable.

Process of Plan Mode with Images:

1. Initiation: A new chat is started, and "plan mode" is selected.
2. Prompting for Features: The user prompts the agent, for example, "search and find if any new important features can be added to the."
3. Agent Analysis: The agent reviews existing files, searches the web, and evaluates potential features for LLM benchmarking tools.
4. Report Generation (Initial): The agent writes a plan report, but initially, it lacks visual aids.
5. Adding Images: The user requests the addition of "mermaid images to understand this better for each feature."
6. Visualized Report: Images are added to the report, illustrating features like:
   • Parallel/Concurrent Run: A high-priority feature to improve the benchmarking tool, which currently only supports sequential execution.
   • Token Tracking: Another potential feature.
   • HTML Dashboard: A feature for better visualization.
   • CSV Export: For data export.

Focus on Parallel/Concurrent Execution: The user decides to focus on implementing parallel or concurrent execution.

Multi-Agent Judging: Collaborative Development

The update introduces a significant advancement in multi-agent judging, allowing multiple agents to collaborate on a task and for the system to intelligently select the best outcome.

Process of Multi-Agent Judging:

1. Task Assignment: The user copies instructions for parallel/concurrent test execution and switches to "agent mode."
2. Agent Selection: Two different agents are chosen: Gemini 3 Pro and Opus 4.5.
3. To-Do List Creation: The task is added as a to-do item in plan mode, visible in the agent tab.
4. Concurrent Work: Both Gemini 3 Pro and Opus 4.5 begin working on the feature simultaneously.
5. Output Comparison and Selection: A key advancement is that Cursor automatically determines which agent's output is superior.
   • Gemini 3 Pro: Preview implementation completed with concurrent 5 or concurrent 3 as default.
   • Opus 4.5: Still implementing, making changes to readme, changelog, and version upgrades.
6. Automatic Choice: The system automatically selects Opus 4.5, citing its advantages:
   • Better code organization with dedicated methods for sequential and parallel execution.
   • Superior error handling.
   • Real-time progress tracking.
   • Production-ready documentation.
7. Confirmation and Application: The user can confirm the suggested version and apply the changes.
8. Verification in Editor: The user can review the list of changed files in the editor.
9. Testing the Feature: The user prompts the agent to test the implemented feature.
   • A simple test is written, including the test name, prompt, and expected result.
   • The test runs both sequential and concurrent execution.
10. Performance Comparison:
    • Sequential Execution: Took 26 seconds to run tests one by one.
    • Parallel Execution: Took only 7 seconds to run all tests.

Key Argument: Multi-agent judging streamlines the development process by enabling parallel work and providing an intelligent mechanism to select the most effective solution, significantly improving efficiency and code quality.

Pin Chat: Organizing Conversations

A new feature called pin chat allows users to mark important conversations or tasks for quick access. By clicking a "more" (three dots) option and selecting "pin," a chat can be pinned. Pinned chats can also be unpinned.

Conclusion

The discussed updates to Cursor—debug mode, plan mode with images, and multi-agent judging—represent significant advancements in AI-assisted software development. Debug mode automates bug fixing, plan mode enhances clarity with visualizations, and multi-agent judging optimizes collaborative development by intelligently selecting the best agent outputs. The pin chat feature adds a layer of organizational convenience. These features collectively aim to make the development process more efficient, transparent, and effective.