UltraThink

A detailed tool for dynamic and reflective problem-solving through thoughts. This tool helps analyze problems through a flexible thinking process that can adapt and evolve. Each thought can build on, question, or revise previous insights as understanding deepens.

IMPORTANT: You MUST use this tool proactively for complex reasoning tasks requiring multi-step analysis.

When to use this tool:

• Breaking down complex problems into steps (>3 steps of reasoning required)

• Planning and design with room for revision

• Analysis that might need course correction

• Problems where the full scope might not be clear initially

• Problems that require a multi-step solution

• Tasks that need to maintain context over multiple steps

• Situations where irrelevant information needs to be filtered out

• Architecture decisions with multiple trade-offs

• Algorithm design and optimization problems

• Debugging multi-layered issues

DO NOT use this tool for:

• Simple one-step answers or direct lookups

• Straightforward code edits without complex logic

• Basic file operations or searches

• Tasks that are already clear and unambiguous

• Simple factual questions with direct answers

Usage notes:

• Each call returns a ThoughtResponse with session_id - use this to continue the same thinking session

• You can run multiple independent thinking sessions in parallel by using different session_ids

• The tool automatically manages thought numbering and determines if more thoughts are needed

• Use confidence scoring (0.0-1.0) to explicitly track uncertainty in your reasoning

• Session state is maintained in memory - reuse custom session_ids for resilient recovery

• The response is returned to you for tracking progress - communicate insights to the user as you think

Parameter groups:

• Core params: thought, total_thoughts (required)

• Auto-managed: thought_number, next_thought_needed (optional - auto-assigned if omitted)

• Session management: session_id (optional - None creates new session)

• Revision params: is_revision, revises_thought (use together)

• Branching params: branch_from_thought, branch_id (use together)

• Confidence tracking: confidence, uncertainty_notes, outcome (optional)

• Assumption tracking: assumptions, depends_on_assumptions, invalidates_assumptions (optional)

Example usage:

Thought 1 (confidence: 0.6): "I need to design a caching strategy. Let me first consider the access patterns..." Thought 2 (confidence: 0.7): "Based on access patterns, I see two viable approaches: LRU or LFU..." Thought 3 (revision of 2, confidence: 0.75): "Wait, I should also consider TTL-based expiration..." Thought 4 (branch from 2, confidence: 0.8): "Let me explore a hybrid approach combining LRU with TTL..." Thought 5 (confidence: 0.95): "The hybrid approach addresses both requirements. Final recommendation: ..."

Thinking workflow:

1. Start with an initial estimate of needed thoughts, be ready to adjust total_thoughts as you progress

2. Question or revise previous thoughts using is_revision=true and revises_thought parameters

3. Explore alternative reasoning paths using branch_from_thought and branch_id parameters

4. Add more thoughts if needed, even after reaching what seemed like the end

5. Manage sessions for context continuity:

   • First call: Omit session_id (or set to None) to create new session

   • Subsequent calls: Use session_id from response to continue the same session

   • Multiple problems: Use different session_ids for separate thinking contexts

   • Resilient recovery: Reuse the same custom session_id across reconnections

6. Express uncertainty using the confidence parameter (0.0=very uncertain, 1.0=very certain)

7. Track assumptions explicitly using the assumptions parameter:

   • State what you're taking for granted with assumption objects

   • Mark critical assumptions (if false, reasoning collapses)

   • Express confidence in each assumption (separate from thought confidence)

   • Mark assumptions as verifiable if they can be checked

8. Build on previous assumptions using depends_on_assumptions to show reasoning dependencies

9. Invalidate false assumptions using invalidates_assumptions when discovering errors

10. Monitor risky_assumptions in response (critical + low confidence + unverified)

11. Clearly state what you're analyzing or deciding in each thought

12. Ignore information that is irrelevant to the current step

13. Generate solution hypotheses as you develop understanding

14. Verify hypotheses through subsequent thinking steps

15. Repeat the process until you reach a satisfactory solution

16. Provide a single, ideally correct answer as the final output