How to Fix Cursor AI Running Slow (2026)

How to Fix Cursor AI Running Slow (2026)

Cursor AI is a powerful code editor, but performance issues can make it frustrating to use. Slow completions, laggy UI, high memory usage, and unresponsive AI features are common complaints, especially on larger projects or older machines.

This guide covers the most common causes of Cursor running slow and how to fix each one, ordered from most impactful to least.

Quick Diagnosis: What Type of Slow?

Before applying fixes, identify what is actually slow:

Symptom	Likely Cause	Jump To
AI chat responses take forever	Network, rate limits, model selection	Fix 1, Fix 2
Cursor Tab completions are delayed	Indexing, file size, extensions	Fix 3, Fix 4
Entire editor is laggy (typing, scrolling)	Memory, extensions, project size	Fix 5, Fix 6
High CPU usage	Indexing, extensions, file watchers	Fix 4, Fix 7
Slow startup	Extensions, workspace size	Fix 6, Fix 8
Agent mode hangs or times out	Context size, model limits	Fix 9

Fix 1: Switch to a Faster Model

The simplest fix for slow AI responses: use a faster model.

1. Open Cursor chat (Cmd+L / Ctrl+L)
2. Click the model dropdown at the top
3. Switch to a faster model

Model	Speed	Quality	Best For
GPT-4o mini	Fastest	Good	Quick completions, boilerplate
Gemini 2.5 Flash	Very fast	Good	General coding, free with own key
Claude Sonnet	Medium	Excellent	Complex reasoning
GPT-5.1 Codex	Slower	Excellent	Deep problem solving
Claude Opus	Slowest	Best	Architecture-level tasks

Using a fast model for routine tasks and reserving slower, more powerful models for complex problems makes a significant difference in perceived speed.

Fix 2: Check Network and Rate Limits

Slow AI responses are often network-related, not Cursor's fault.

Check Your Connection

# Test latency to OpenAI
curl -o /dev/null -s -w "Time: %{time_total}s\n" https://api.openai.com/v1/models

# Test latency to Anthropic
curl -o /dev/null -s -w "Time: %{time_total}s\n" https://api.anthropic.com/v1/messages

If response times exceed 2 seconds, your network is the bottleneck.

Check Rate Limits

If you are on the free Hobby plan, you are limited to 50 fast requests per month. After that, all requests become "slow" (queued behind paid users). Check your usage:

1. Go to Settings > Subscription
2. Look at "Premium requests used this month"
3. If you have used all fast requests, responses will be slower for the rest of the month

Solutions:

• Upgrade to Pro ($20/month) for 500 fast requests
• Use your own API key (Google AI Studio is free) to bypass Cursor's rate limits entirely
• Wait for the monthly reset

Disable VPN

VPNs add latency to every API call. If you are using a VPN, try disconnecting it temporarily to see if AI responses speed up.

Fix 3: Optimize Cursor Indexing

Cursor indexes your project files to provide codebase-aware AI responses. On large projects, this indexing can slow things down.

Check Indexing Status

Look at the bottom status bar in Cursor. If it shows "Indexing..." the AI will be slower until indexing completes.

Exclude Unnecessary Files

Create or edit .cursorignore in your project root:

# Dependencies
node_modules/
vendor/
.venv/
__pycache__/

# Build output
dist/
build/
.next/
out/

# Large files
*.min.js
*.min.css
*.map
*.lock

# Data
*.csv
*.sql
*.sqlite
*.db

# Assets
*.png
*.jpg
*.gif
*.mp4
*.woff2
*.ttf

# Generated
coverage/
.turbo/
.cache/

This reduces the number of files Cursor needs to index and search, directly improving performance.

Reduce Workspace Size

If your project has multiple large subdirectories you do not need:

# Instead of opening the monorepo root
cursor /path/to/monorepo

# Open just the service you are working on
cursor /path/to/monorepo/services/api

Fix 4: Disable Unnecessary Extensions

Extensions are the number one cause of general editor slowness. Each extension adds overhead to every keystroke and file operation.

Find Slow Extensions

1. Open Command Palette (Cmd+Shift+P / Ctrl+Shift+P)
2. Type: Developer: Show Running Extensions
3. Sort by activation time
4. Disable any extension that takes over 500ms to activate

Commonly Problematic Extensions

Extension	Issue	Alternative
GitLens (full)	Heavy memory usage	Use GitLens Lite or built-in Git
Prettier (on save)	Slow on large files	Use format on manual save only
ESLint (workspace-wide)	Scans all files	Limit to open files only
Docker	Background container monitoring	Disable when not using Docker
Remote - SSH	Persistent connection overhead	Close when not in remote session
Multiple AI extensions	Conflict with Cursor's built-in AI	Disable non-Cursor AI extensions

Disable All Extensions Temporarily

To test if extensions are the problem:

# Launch Cursor with all extensions disabled
cursor --disable-extensions

If Cursor runs smoothly without extensions, re-enable them one by one to find the culprit.

Fix 5: Free Up Memory

Cursor is based on Electron (Chromium), so it can be memory-hungry. Check your memory usage:

macOS

# Check Cursor memory usage
ps aux | grep -i cursor | awk '{sum += $6} END {print sum/1024 " MB"}'

Windows

Open Task Manager, look for Cursor processes, and check total memory.

Memory Optimization

1. Close unused tabs. Each open tab consumes memory. Keep only files you are actively working on open.
2. Close unused terminal instances. Each integrated terminal is a separate process.
3. Restart Cursor periodically. Memory leaks accumulate over time. Restart every few hours during heavy use.
4. Increase Node memory limit (if you see "JavaScript heap out of memory"):

# macOS/Linux: Add to ~/.zshrc or ~/.bashrc
export NODE_OPTIONS="--max-old-space-size=8192"

# Then restart Cursor

Recommended System Memory

Project Size	Minimum RAM	Recommended RAM
Small (<100 files)	8 GB	8 GB
Medium (100-1000 files)	8 GB	16 GB
Large (1000-10000 files)	16 GB	32 GB
Monorepo (10000+ files)	16 GB	32 GB+

Fix 6: Optimize Cursor Settings

Several settings can improve performance:

Open Settings JSON (Cmd+Shift+P > "Preferences: Open Settings (JSON)"):

{
  // Reduce file watcher overhead
  "files.watcherExclude": {
    "**/node_modules/**": true,
    "**/.git/objects/**": true,
    "**/.git/subtree-cache/**": true,
    "**/dist/**": true,
    "**/build/**": true,
    "**/.next/**": true
  },

  // Reduce search overhead
  "search.exclude": {
    "**/node_modules": true,
    "**/dist": true,
    "**/build": true,
    "**/*.min.js": true,
    "**/.next": true
  },

  // Reduce editor overhead
  "editor.minimap.enabled": false,
  "editor.bracketPairColorization.enabled": false,
  "editor.renderWhitespace": "none",
  "editor.smoothScrolling": false,
  "workbench.list.smoothScrolling": false,

  // Reduce git overhead
  "git.autorefresh": false,
  "git.decorations.enabled": false,

  // Limit terminal overhead
  "terminal.integrated.scrollback": 1000,

  // Disable telemetry
  "telemetry.telemetryLevel": "off"
}

Fix 7: Fix High CPU Usage

Identify the Cause

1. Open Help > Toggle Developer Tools (Cmd+Shift+I)
2. Go to the Performance tab
3. Click Record, perform normal actions for 30 seconds, then stop
4. Look for long-running tasks

Common CPU Hogs

File watcher overload: Large node_modules or generated directories trigger constant file system events. Fix with files.watcherExclude (see Fix 6).

TypeScript language server: On large TypeScript projects, the language server can spike CPU:

{
  "typescript.tsserver.maxTsServerMemory": 4096,
  "typescript.disableAutomaticTypeAcquisition": true
}

Search indexing: If Cursor continuously re-indexes, ensure your .cursorignore excludes large directories.

Fix 8: Speed Up Startup

If Cursor takes more than 10 seconds to open:

1. Reduce workspace trust prompts. In Settings, set security.workspace.trust.enabled to false for trusted projects.
2. Open smaller workspaces. Split your monorepo into multiple Cursor windows by service/package.
3. Disable startup extensions. Extensions with "activationEvents": ["*"] run on every startup. Disable ones you rarely use.
4. Clear the cache:

# macOS
rm -rf ~/Library/Application\ Support/Cursor/Cache
rm -rf ~/Library/Application\ Support/Cursor/CachedData

# Windows
rmdir /s "%APPDATA%\Cursor\Cache"
rmdir /s "%APPDATA%\Cursor\CachedData"

# Linux
rm -rf ~/.config/Cursor/Cache
rm -rf ~/.config/Cursor/CachedData

Fix 9: Fix Slow Agent Mode

Agent mode (Composer) can be slow because it processes large amounts of context.

Reduce context size:

• Use @file to reference specific files instead of @codebase
• Break large tasks into smaller, focused requests
• Clear the agent conversation and start fresh when context gets too long

Choose the right model:

• Use Claude Sonnet for most agent tasks (good balance of speed and quality)
• Use Gemini 2.5 Flash for quick, multi-file changes
• Reserve GPT-5.1 Codex and Claude Opus for complex architectural changes

Set token limits: In Cursor settings, you can limit the max tokens for agent responses. Lower limits mean faster responses for simpler tasks.

Nuclear Option: Reinstall Cursor

If nothing else works, a clean reinstall often resolves persistent issues:

# macOS: Fully remove Cursor
rm -rf /Applications/Cursor.app
rm -rf ~/Library/Application\ Support/Cursor
rm -rf ~/Library/Caches/Cursor
rm -rf ~/Library/Preferences/com.cursor.*

# Then download fresh from cursor.com

Back up your .cursor/mcp.json and .cursorrules files before reinstalling.

Performance Checklist

Use this checklist to systematically address slow performance:

• Using a fast model for routine tasks (GPT-4o mini, Gemini Flash)
• Network latency under 1 second to API endpoints
• .cursorignore excludes node_modules, build, and large files
• Fewer than 20 active extensions
• No duplicate AI extensions (Copilot, Cody, etc.)
• File watchers exclude unnecessary directories
• Fewer than 15 tabs open at once
• Cursor restarted in the last 4 hours
• At least 8GB RAM available for Cursor
• Not running on battery / power saving mode

Wrapping Up

Most Cursor performance issues come down to three things: too many extensions, too large a project scope, and inefficient model selection. Start with the quick fixes (switch model, add .cursorignore, disable extensions) before moving to deeper optimizations. In most cases, the first three fixes resolve the problem entirely.

If you are building applications with AI-generated media and need reliable, fast APIs for images, video, and avatars, Hypereal AI offers low-latency inference with competitive pricing. Sign up free to test it out.