Developer-Controlled Verification Mode to Reduce Agent Token Usage

Ideas Feature Requests
, ,
1

Feature request for product/service

Cursor IDE

Describe the request

:rocket: Feature Request: Developer-Controlled Verification Mode

Reduce Agent Token Usage While Keeping the AI Autonomous

Summary:
Allow developers to execute verification commands in their own
terminal while Cursor automatically consumes the output and continues
reasoning. This reduces unnecessary agent execution, saves tokens, and
provides a much better workflow for medium and large codebases.

:heart: First, Thank You

Cursor has become my primary IDE for professional software development.

I mainly work on large enterprise applications (Laravel, .NET, Python
services, Docker, Kubernetes, React, etc.), and Agent Mode has become an
incredible productivity tool.

However, after hundreds of hours using Agent Mode, I’ve noticed one
workflow limitation that becomes increasingly expensive on larger
repositories.

:pushpin: The Current Workflow

Whenever the agent wants to verify its work, it executes terminal
commands itself.

Typical examples include:

  • pytest
  • python manage.py test
  • uv run pytest
  • npm test
  • pnpm test
  • cargo test
  • go test ./...
  • dotnet test
  • docker compose up
  • docker compose build
  • kubectl apply
  • terraform plan
  • Long-running AI evaluation scripts
  • Integration test suites
  • End-to-end Playwright/Cypress tests

Current flow:

          Cursor Agent
               │
               ▼
      Needs verification
               │
               ▼
     Requests terminal access
               │
               ▼
      Executes command itself
               │
               ▼
      Waits for command to finish
               │
               ▼
 Reads stdout / stderr / exit code
               │
               ▼
        Continues reasoning

This workflow is perfectly reasonable for small projects.

:red_exclamation_mark:The Problem on Large Projects

On enterprise repositories, a single debugging session may last 20–40
minutes.

During that session the agent might execute:

  • pytest 6 times
  • docker compose up 3 times
  • npm test 5 times
  • python manage.py migrate
  • python manage.py test
  • Playwright tests multiple times

Every execution requires:

  • Agent reasoning
  • Command approval
  • Waiting for completion
  • Reading the output
  • Continuing the conversation

Even though my terminal is already open and I could execute those
commands instantly.

The AI doesn’t really need to execute the command.

It only needs:

  • stdout
  • stderr
  • exit code

:light_bulb: Proposed Feature

Developer-Controlled Verification Mode

Add a project/user preference.

Command Execution

(•) AI Executes Commands      ← Current behavior

( ) Developer Executes Commands

( ) Hybrid Mode

:brain: New Workflow

Instead of this:

Agent
   │
   ▼
Run pytest?
   │
   ▼
Click "Run"
   │
   ▼
Agent executes
   │
   ▼
Reads output
   │
   ▼
Continues

Allow this:

                Cursor Agent
                     │
                     ▼
         Verification Required
                     │
                     ▼
        Displays exact command

pytest tests/api/test_users.py -v

                     │
                     ▼
              Agent pauses
                     │
                     ▼
      Developer runs command
      (Own terminal / tmux / SSH /
       Docker / Remote machine)
                     │
                     ▼
 Cursor automatically captures

   ✓ stdout
   ✓ stderr
   ✓ exit code

                     │
                     ▼
        Agent resumes automatically

The AI still reasons exactly as it does today.

The only difference is who executes the command.

:gear: Hybrid Mode

Hybrid mode could automatically execute lightweight commands while
requiring manual execution for expensive operations.

Safe to Execute Automatically

  • ls
  • pwd
  • cat
  • grep
  • find
  • git status

Require Developer Execution

  • pytest
  • uv run pytest
  • python manage.py test
  • python manage.py migrate
  • docker compose build
  • docker compose up
  • npm test
  • pnpm test
  • cargo test
  • go test ./…
  • dotnet test
  • kubectl apply
  • terraform plan
  • Playwright
  • Cypress
  • Long-running scripts

:chart_increasing: Benefits

:white_check_mark: Lower token usage

The agent spends less time repeatedly executing verification commands.

:white_check_mark: Faster development

Developers already have a running terminal.

They can execute commands immediately without waiting for another
approval cycle.

:white_check_mark: Better enterprise workflow

Works naturally with:

  • Docker
  • SSH
  • Remote development
  • tmux
  • WSL
  • Dev Containers
  • Kubernetes
  • Existing terminal setups

:white_check_mark: More developer control

Developers decide when expensive commands should run while the AI
focuses on reasoning.

:sparkles: Optional Enhancements

1. Duplicate Verification Detection

If the same verification command has already been requested recently and
the relevant files haven’t changed, avoid requesting it again.

This would eliminate unnecessary repeated test runs.

2. Resume Automatically

As soon as Cursor detects the command has finished, the agent should
continue without asking the user to manually paste the output.

:bullseye: Why This Matters

For small projects, the current workflow is perfectly fine.

For medium and large repositories, however, developers usually already
have:

  • a running terminal
  • Docker containers
  • remote environments
  • SSH sessions
  • custom aliases
  • tmux panes

The AI does not need to own command execution.

It only needs the result.

Providing this as an optional mode would reduce unnecessary agent
execution, lower token usage, and create a smoother workflow for power
users and enterprise teams.

:folded_hands: Thank You

Thank you for considering this feature. I believe it would significantly
improve Agent Mode for developers working on larger codebases while
preserving Cursor’s existing workflow for everyone else.

Operating System (if it applies)

Windows 10/11

5

Hey, thanks for the detailed breakdown. The diagrams and examples really help make the flow clear.

Some of what you describe as Hybrid mode is already covered by the Run Mode settings in Agent settings. There are three modes right now:

  • Allowlist: only pre-approved commands run automatically, everything else waits for approval
  • Auto-review: a 3-step check Allowlist to Sandbox to LLM classifier. Safe read-only commands run automatically, expensive or risky ones go to confirmation. You can steer the classifier with natural language instructions via .cursor/permissions.json using allow_instructions and block_instructions. That is pretty close to your safe vs expensive split
  • Run Everything: no restrictions

More details: Terminal | Cursor Docs. One important note is that the classifier is non-deterministic. It is best-effort convenience, not a security boundary. For strict control, it is better to use Allowlist plus manual confirmation.

But the main idea you brought up, where the agent sends an expensive command to your own external terminal like tmux, SSH, Docker, remote, and Cursor then reads stdout, stderr, exit code and continues, is not supported yet. All the modes above work with the terminal inside Cursor. For an external terminal, right now there is only Copy Command on the approval card, with no automatic output capture.

I will keep the thread open in Feature Requests. If it gets upvotes, that will help us gauge interest specifically in external execution with auto capture. Let me know if Auto-review plus permissions.json would cover your use case at least partially.