How to Enable and Use Deep Mode in Amp CLI

Mar 27, 2026

I was working on a complex refactoring task the other day when I realized Amp’s default mode wasn’t cutting it. The AI kept giving me surface-level suggestions when I needed deep architectural thinking. That’s when I remembered: Amp has a “deep mode” specifically designed for this kind of autonomous problem-solving.

The Problem: Default Mode Falls Short

Amp’s standard pair programmer mode is great for interactive coding sessions. But when I threw a complex multi-file refactoring at it, the responses felt shallow. I needed something that could think through implications across the entire codebase.

The Solution: Deep Mode

Deep mode in Amp uses GPT-5.4 with high reasoning settings. It’s built for autonomous problem-solving rather than back-and-forth pair programming. The key insight: deep mode thinks longer before responding, which means better analysis for complex tasks.

How to Enable Deep Mode

Method 1: CLI Command Palette

The quickest way to activate deep mode:

1. Press Ctrl-O to open the command palette
2. Type: mode: use deep
3. Press Enter to confirm

That’s it. You’re now in deep mode.

Method 2: Editor Extension

If you’re using the Amp editor extension, look for the mode dropdown in the prompt field. Select “deep” from the available options.

Deep Mode Reasoning Levels: deep^2 vs deep^3

Here’s something I discovered by accident: deep mode has two reasoning levels.

┌─────────┬─────────────────────────────────────────────┐
│ Level   │ Description                                 │
├─────────┼─────────────────────────────────────────────┤
│ deep^2  │ Default deep mode (balanced reasoning)      │
│ deep^3  │ Maximum reasoning (for complex tasks)      │
└─────────┴─────────────────────────────────────────────┘

To switch from deep^2 to deep^3, press Opt-D (or Alt-D on some systems). This toggles between the two reasoning levels.

Ctrl-O    → Open command palette
Opt-D     → Toggle deep^2 ↔ deep^3 (when deep mode is active)

When to Use Deep Mode

Deep mode excels at:

Complex refactoring: Restructuring code across multiple files
Architecture decisions: Understanding system-wide implications
Bug hunting: Deep analysis of intricate logic flows
Code generation: Producing substantial code blocks autonomously

I found it particularly useful when I needed Amp to “think through” a problem rather than just respond quickly. The trade-off is speed—deep mode takes longer to respond, but the quality of analysis is worth it for complex tasks.

A Real Example

I recently used deep mode to migrate a legacy authentication system. Here’s what happened:

1. Enabled deep mode: Ctrl-O → mode: use deep
2. Switched to deep^3: Opt-D (because this was complex)
3. Described the migration task with full context
4. Waited ~30 seconds for the response
5. Got a detailed migration plan with edge cases covered

The same query in pair programmer mode gave me a basic migration script. Deep mode gave me a complete strategy including rollback procedures and testing approach.

Common Mistakes

I made these mistakes when starting with deep mode:

Using deep mode for everything: Not necessary. Quick fixes and simple questions work fine in pair programmer mode.
Not using deep^3 when needed: For truly complex problems, deep^3’s extended reasoning makes a real difference.
Expecting instant responses: Deep mode thinks longer. That’s the point. Don’t cancel the request thinking it’s stuck.
Confusing modes: Deep mode is for autonomous problem-solving. Pair programmer mode is for interactive collaboration. They serve different purposes.

Summary

Deep mode unlocks Amp’s most powerful reasoning capabilities:

Enable via Ctrl-O → mode: use deep
Upgrade to deep^3 with Opt-D for complex tasks
Use it when you need deep analysis, not quick answers

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 Amp Official Documentation

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!