Release v2.3.6

- Add planning_tools and planning_reasoning parameters to PraisonAIAgents
- Add RESEARCH_TOOLS list for safe planning research tools (web_search, read_file, etc.)
- Add tools, reasoning, and max_reasoning_steps parameters to PlanningAgent
- Add _get_agent() method to PlanningAgent for tool-enabled planning with Agent.chat()
- Update plan creation to use Agent with tools when available, fallback to bare LLM
- Add Planning

README.md

@@ -60,7 +60,9 @@ PraisonAI is a production-ready Multi-AI Agents framework with self-reflection,
 - 💾 **Prompt Caching** (Reduce costs & latency - OpenAI, Anthropic, Bedrock, Deepseek)
 - 🧠 **Claude Memory Tool** (Persistent cross-conversation memory - Anthropic Beta)
 - 💾 **File-Based Memory** (Zero-dependency persistent memory for all agents)
-- 📋 **Planning Mode** (Plan before execution like Cursor, Windsurf, Claude Code)
+- 📋 **Planning Mode** (Plan before execution - Agent & Multi-Agent)
+- 🔧 **Planning Tools** (Research with tools during planning)
+- 🧠 **Planning Reasoning** (Chain-of-thought planning)
 
 ## Using Python Code
 
@@ -104,7 +106,34 @@ Run:
 python app.py
 ```
 
-### 3. Deep Research Agent
+### 3. Agent with Planning Mode
+
+Enable planning for any agent - the agent creates a plan, then executes step by step:
+
+```python
+from praisonaiagents import Agent
+
+def search_web(query: str) -> str:
+    return f"Search results for: {query}"
+
+agent = Agent(
+    name="AI Assistant",
+    instructions="Research and write about topics",
+    planning=True,              # Enable planning mode
+    planning_tools=[search_web], # Tools for planning research
+    planning_reasoning=True      # Chain-of-thought reasoning
+)
+
+result = agent.start("Research AI trends in 2025 and write a summary")
+```
+
+**What happens:**
+1. 📋 Agent creates a multi-step plan
+2. 🚀 Executes each step sequentially
+3. 📊 Shows progress with context passing
+4. ✅ Returns final result
+
+### 4. Deep Research Agent
 
 Automated research with real-time streaming, web search, and citations using OpenAI or Gemini Deep Research APIs.
 
@@ -142,7 +171,7 @@ print(result.report)
 - 🛠️ Built-in tools: web search, code interpreter, MCP, file search
 - 🔄 Automatic provider detection from model name
 
-### 4. Query Rewriter Agent
+### 5. Query Rewriter Agent
 
 Transform user queries to improve RAG retrieval quality using multiple strategies.
 
@@ -177,9 +206,9 @@ result = agent.rewrite("What about cost?", chat_history=[...])
 - **CONTEXTUAL**: Resolve references using conversation history
 - **AUTO**: Automatically detect best strategy
 
-### 5. Agent Memory (Zero Dependencies)
+### 6. Agent Memory (Zero Dependencies)
 
-Enable persistent memory for agents - works out of the box without any extra packages. Features inspired by Claude, Gemini CLI, Codex CLI, Cursor, and Windsurf.
+Enable persistent memory for agents - works out of the box without any extra packages.
 
 ```python
 from praisonaiagents import Agent
@@ -204,7 +233,7 @@ result = agent.start("My name is John and I prefer Python")
 - **Entity**: People, places, organizations with attributes
 - **Episodic**: Date-based interaction history
 
-**Advanced Features (like Gemini CLI):**
+**Advanced Features:**
 ```python
 from praisonaiagents.memory import FileMemory
 
@@ -234,7 +263,7 @@ memory.handle_command("/memory save my_session")
 | `memory="sqlite"` | Built-in | SQLite with indexing |
 | `memory="chromadb"` | chromadb | Vector/semantic search |
 
-### 6. Rules & Instructions (like Cursor/Windsurf)
+### 6. Rules & Instructions
 
 PraisonAI auto-discovers instruction files from your project root and git root:
 
@@ -262,7 +291,7 @@ agent = Agent(name="Assistant", instructions="You are helpful.")
 # Rules are injected into system prompt automatically
 ```
 
-**@Import Syntax (like Claude Code):**
+**@Import Syntax:**
 ```markdown
 # CLAUDE.md
 See @README for project overview
@@ -283,7 +312,7 @@ activation: always  # always, glob, manual, ai_decision
 - Follow PEP 8
 ```
 
-### 7. Auto-Generated Memories (like Windsurf Cascade)
+### 7. Auto-Generated Memories
 
 ```python
 from praisonaiagents.memory import FileMemory, AutoMemory
@@ -298,7 +327,7 @@ memories = auto.process_interaction(
 # Extracts: name="John", preference="Python for backend"
 ```
 
-### 8. Workflows (like Windsurf)
+### 8. Workflows
 
 Create reusable multi-step workflows in `.praison/workflows/`:
 
@@ -315,7 +344,7 @@ result = manager.execute(
 )
 ```
 
-### 9. Hooks (like Windsurf Cascade Hooks)
+### 9. Hooks
 
 Configure in `.praison/hooks.json`:
 

docker/Dockerfile

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     flask \
-    "praisonai>=2.3.5" \
+    "praisonai>=2.3.6" \
     "praisonai[api]" \
     gunicorn \
     markdown

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.3.5" \
+    "praisonai>=2.3.6" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.3.5" \
+    "praisonai>=2.3.6" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.3.5" \
+    "praisonai>=2.3.6" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

src/praisonai-agents/README.md

@@ -86,7 +86,30 @@ result = agents.start()
 
 ### Planning Mode 🆕
 
-Plan before execution, like Cursor, Windsurf, and Claude Code:
+#### Single Agent Planning (Simplest)
+
+Enable planning for any single agent:
+
+```python
+from praisonaiagents import Agent
+
+def search_web(query: str) -> str:
+    return f"Search results for: {query}"
+
+agent = Agent(
+    name="AI Assistant",
+    instructions="Research and write about topics",
+    planning=True,              # Enable planning mode
+    planning_tools=[search_web], # Tools for planning research
+    planning_reasoning=True      # Chain-of-thought reasoning
+)
+
+result = agent.start("Research AI trends in 2025 and write a summary")
+```
+
+#### Multi-Agent Planning
+
+Plan before execution with multiple agents:
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
@@ -97,20 +120,23 @@ writer = Agent(name="Writer", role="Content Writer")
 research_task = Task(description="Research AI benefits", agent=researcher)
 write_task = Task(description="Write summary", agent=writer)
 
-# Enable planning mode
 agents = PraisonAIAgents(
     agents=[researcher, writer],
     tasks=[research_task, write_task],
     planning=True,              # Enable planning
-    planning_llm="gpt-4o-mini", # Fast LLM for planning
-    auto_approve_plan=True      # Auto-approve plans
+    planning_tools=[search_web], # Tools for planning research
+    planning_reasoning=True,     # Chain-of-thought reasoning
+    auto_approve_plan=True       # Auto-approve plans
 )
 
 result = agents.start()
 ```
 
 **Features:**
-- **Plan Creation**: LLM creates step-by-step implementation plans
+- **Single Agent Planning**: `Agent(planning=True)` - simplest API
+- **Multi-Agent Planning**: `PraisonAIAgents(planning=True)` - orchestrated
+- **Planning Tools**: Research with tools before creating plans
+- **Reasoning Mode**: Chain-of-thought planning with tool use
 - **Todo Lists**: Auto-generated from plans with progress tracking
 - **Read-Only Mode**: `plan_mode=True` restricts agents to safe tools
 - **Approval Flow**: Review and approve plans before execution
@@ -248,7 +274,7 @@ router = RouterAgent(
 
 ## Memory
 
-PraisonAI provides a comprehensive memory system with features inspired by Claude, Gemini CLI, Codex CLI, Cursor, and Windsurf.
+PraisonAI provides a comprehensive memory system.
 
 ### Quick Start (Zero Dependencies)
 
@@ -293,7 +319,7 @@ agent = Agent(name="Memory Agent", memory=memory)
 | **Episodic** | Date-based interaction memories | JSON files |
 | **Graph** | Relationship-based memory | Mem0/Neo4j |
 
-### Session Save/Resume (like Gemini CLI)
+### Session Save/Resume
 
 ```python
 from praisonaiagents.memory import FileMemory
@@ -314,7 +340,7 @@ session_data = memory.resume_session("ml_project")
 sessions = memory.list_sessions()
 ```
 
-### Context Compression (like Gemini CLI)
+### Context Compression
 
 ```python
 # Auto-compress when memory gets full
@@ -327,7 +353,7 @@ def llm_summarize(prompt):
 summary = memory.compress(llm_func=llm_summarize, max_items=10)
 ```
 
-### Checkpointing (like Gemini CLI)
+### Checkpointing
 
 ```python
 # Create checkpoint before risky operations
@@ -369,9 +395,9 @@ result = memory.handle_command("/memory help")
 
 ---
 
-## Rules & Instructions (like Cursor/Windsurf)
+## Rules & Instructions
 
-PraisonAI automatically discovers and applies rules from multiple sources, similar to Cursor, Windsurf, Claude Code, and Codex CLI.
+PraisonAI automatically discovers and applies rules from multiple sources.
 
 ### Supported Instruction Files
 
@@ -494,7 +520,7 @@ project/
         └── global.md
 ```
 
-### @Import Syntax (like Claude Code)
+### @Import Syntax
 
 Include other files in your rules:
 
@@ -505,7 +531,7 @@ See @docs/architecture.md for system design
 @~/.praison/my-preferences.md
 ```
 
-### Auto-Generated Memories (like Windsurf Cascade)
+### Auto-Generated Memories
 
 ```python
 from praisonaiagents.memory import FileMemory, AutoMemory
@@ -520,7 +546,7 @@ memories = auto.process_interaction(
 # Extracts: name="John", preference="Python for backend"
 ```
 
-### Workflows (like Windsurf)
+### Workflows
 
 Create reusable multi-step workflows:
 
@@ -537,7 +563,7 @@ result = manager.execute(
 )
 ```
 
-### Hooks (like Windsurf Cascade Hooks)
+### Hooks
 
 ```python
 from praisonaiagents.memory import HooksManager

src/praisonai-agents/praisonaiagents/agent/agent.py

@@ -239,7 +239,10 @@ class Agent:
         web_fetch: Optional[Union[bool, Dict[str, Any]]] = None,
         prompt_caching: Optional[bool] = None,
         claude_memory: Optional[Union[bool, Any]] = None,
-        plan_mode: bool = False
+        plan_mode: bool = False,
+        planning: bool = False,
+        planning_tools: Optional[List[Any]] = None,
+        planning_reasoning: bool = False
     ):
         """Initialize an Agent instance.
 
@@ -526,6 +529,10 @@ Your Goal: {self.goal}
         self.user_id = user_id or "praison"
         self.reasoning_steps = reasoning_steps
         self.plan_mode = plan_mode  # Read-only mode for planning
+        self.planning = planning  # Enable planning mode
+        self.planning_tools = planning_tools  # Tools for planning phase
+        self.planning_reasoning = planning_reasoning  # Enable reasoning during planning
+        self._planning_agent = None  # Lazy loaded PlanningAgent
         self.web_search = web_search
         self.web_fetch = web_fetch
         self.prompt_caching = prompt_caching
@@ -2492,10 +2499,88 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
 
     def run(self, prompt: str, **kwargs):
         """Alias for start() method"""
-        return self.start(prompt, **kwargs) 
+        return self.start(prompt, **kwargs)
+    
+    def _get_planning_agent(self):
+        """Lazy load PlanningAgent for planning mode."""
+        if self._planning_agent is None and self.planning:
+            from ..planning import PlanningAgent
+            self._planning_agent = PlanningAgent(
+                llm=self.llm if hasattr(self, 'llm') else (self.llm_instance.model if hasattr(self, 'llm_instance') else "gpt-4o-mini"),
+                tools=self.planning_tools,
+                reasoning=self.planning_reasoning,
+                verbose=1 if self.verbose else 0
+            )
+        return self._planning_agent
+    
+    def _start_with_planning(self, prompt: str, **kwargs):
+        """Execute with planning mode - creates plan then executes each step."""
+        from rich.console import Console
+        from rich.panel import Panel
+        from rich.markdown import Markdown
+        
+        console = Console()
+        
+        # Step 1: Create the plan
+        console.print("\n[bold blue]📋 PLANNING PHASE[/bold blue]")
+        console.print("[dim]Creating implementation plan...[/dim]\n")
+        
+        planner = self._get_planning_agent()
+        plan = planner.create_plan_sync(request=prompt, agents=[self])
+        
+        if not plan or not plan.steps:
+            console.print("[yellow]⚠️ Planning failed, falling back to direct execution[/yellow]")
+            return self.chat(prompt, **kwargs)
+        
+        # Display the plan
+        console.print(Panel(
+            Markdown(plan.to_markdown()),
+            title="[bold green]Generated Plan[/bold green]",
+            border_style="green"
+        ))
+        
+        # Step 2: Execute each step
+        console.print("\n[bold blue]🚀 EXECUTION PHASE[/bold blue]\n")
+        
+        results = []
+        context = ""
+        
+        for i, step in enumerate(plan.steps):
+            progress = (i + 1) / len(plan.steps)
+            bar_length = 30
+            filled = int(bar_length * progress)
+            bar = "█" * filled + "░" * (bar_length - filled)
+            
+            console.print(f"[dim]Progress: [{bar}] {progress * 100:.0f}%[/dim]")
+            console.print(f"\n[bold]📌 Step {i + 1}/{len(plan.steps)}:[/bold] {step.description[:60]}...")
+            
+            # Build prompt with context from previous steps
+            step_prompt = step.description
+            if context:
+                step_prompt = f"{step.description}\n\nContext from previous steps:\n{context}"
+            
+            # Execute the step
+            result = self.chat(step_prompt, **kwargs)
+            results.append(result)
+            
+            # Update context for next step
+            context += f"\n\nStep {i + 1} result: {result[:500] if result else 'No result'}"
+            
+            console.print(f"   [green]✅ Completed[/green]")
+        
+        console.print(f"\n[bold green]🎉 EXECUTION COMPLETE[/bold green]")
+        console.print(f"[dim]Progress: [{'█' * bar_length}] 100%[/dim]")
+        console.print(f"Completed {len(plan.steps)}/{len(plan.steps)} steps!\n")
+        
+        # Return the final result
+        return results[-1] if results else None
 
     def start(self, prompt: str, **kwargs):
         """Start the agent with a prompt. This is a convenience method that wraps chat()."""
+        # Check if planning mode is enabled
+        if self.planning:
+            return self._start_with_planning(prompt, **kwargs)
+        
         # Check if streaming is enabled (either from kwargs or agent's stream attribute)
         stream_enabled = kwargs.get('stream', getattr(self, 'stream', False))
         

src/praisonai-agents/praisonaiagents/agents/agents.py

@@ -127,7 +127,7 @@ def process_task_context(context_item, verbose=0, user_id=None):
         return str(context_item)  # Fallback for unknown types
 
 class PraisonAIAgents:
-    def __init__(self, agents, tasks=None, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None, memory=False, memory_config=None, embedder=None, user_id=None, max_iter=10, stream=True, name: Optional[str] = None, planning: bool = False, planning_llm: Optional[str] = None, auto_approve_plan: bool = False):
+    def __init__(self, agents, tasks=None, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None, memory=False, memory_config=None, embedder=None, user_id=None, max_iter=10, stream=True, name: Optional[str] = None, planning: bool = False, planning_llm: Optional[str] = None, auto_approve_plan: bool = False, planning_tools: Optional[List] = None, planning_reasoning: bool = False):
         # Add check at the start if memory is requested
         if memory:
             try:
@@ -217,6 +217,8 @@ class PraisonAIAgents:
         self.planning = planning
         self.planning_llm = planning_llm or "gpt-4o-mini"
         self.auto_approve_plan = auto_approve_plan
+        self.planning_tools = planning_tools
+        self.planning_reasoning = planning_reasoning
         self._current_plan = None
         self._todo_list = None
         self._planning_agent = None
@@ -1566,7 +1568,9 @@ Context:
             self._planning_agent = PlanningAgent(
                 llm=self.planning_llm,
                 read_only=True,
-                verbose=self.verbose
+                verbose=self.verbose,
+                tools=self.planning_tools,
+                reasoning=self.planning_reasoning
             )
         return self._planning_agent
     

src/praisonai-agents/praisonaiagents/planning/__init__.py

@@ -73,6 +73,23 @@ RESTRICTED_TOOLS = [
     "pip_install",
 ]
 
+# Research tools that are safe for planning research
+RESEARCH_TOOLS = [
+    "web_search",
+    "search_web",
+    "duckduckgo_search",
+    "tavily_search",
+    "brave_search",
+    "google_search",
+    "read_url",
+    "fetch_url",
+    "read_file",
+    "list_directory",
+    "search_codebase",
+    "grep_search",
+    "find_files",
+]
+
 __all__ = [
     "Plan",
     "PlanStep",
@@ -83,4 +100,5 @@ __all__ = [
     "ApprovalCallback",
     "READ_ONLY_TOOLS",
     "RESTRICTED_TOOLS",
+    "RESEARCH_TOOLS",
 ]

src/praisonai-agents/praisonaiagents/planning/planner.py

@@ -139,7 +139,10 @@ Provide a concise analysis that will help in creating an implementation plan.'''
         self,
         llm: str = "gpt-4o-mini",
         read_only: bool = True,
-        verbose: int = 0
+        verbose: int = 0,
+        tools: Optional[List] = None,
+        reasoning: bool = False,
+        max_reasoning_steps: int = 5
     ):
         """
         Initialize PlanningAgent.
@@ -148,12 +151,19 @@ Provide a concise analysis that will help in creating an implementation plan.'''
             llm: LLM model to use for planning
             read_only: Whether to restrict to read-only tools
             verbose: Verbosity level
+            tools: Optional list of tools for research during planning
+            reasoning: Whether to enable reasoning mode with chain-of-thought
+            max_reasoning_steps: Maximum reasoning iterations (default 5)
         """
         self.llm_model = llm
         self.read_only = read_only
         self.verbose = verbose
+        self.tools = tools or []
+        self.reasoning = reasoning
+        self.max_reasoning_steps = max_reasoning_steps
         self.allowed_tools = READ_ONLY_TOOLS.copy() if read_only else []
         self._llm = None
+        self._agent = None
         
     def _get_llm(self):
         """Lazy load LLM instance."""
@@ -162,6 +172,28 @@ Provide a concise analysis that will help in creating an implementation plan.'''
             self._llm = LLM(model=self.llm_model)
         return self._llm
     
+    def _get_agent(self):
+        """
+        Lazy load Agent instance for tool-enabled planning.
+        
+        Returns:
+            Agent instance if tools are provided, None otherwise
+        """
+        if not self.tools:
+            return None
+            
+        if self._agent is None:
+            from ..agent.agent import Agent
+            self._agent = Agent(
+                name="Planning Research Agent",
+                role="Research and Planning Specialist",
+                goal="Research information and create detailed implementation plans",
+                llm=self.llm_model,
+                tools=self.tools,
+                verbose=self.verbose > 0
+            )
+        return self._agent
+    
     def _format_agents_info(self, agents: List['Agent']) -> str:
         """
         Format agent information for the prompt.
@@ -321,8 +353,6 @@ Provide a concise analysis that will help in creating an implementation plan.'''
         Returns:
             Plan instance with steps
         """
-        llm = self._get_llm()
-        
         # Format the prompt
         prompt = self.PLANNING_PROMPT.format(
             request=request,
@@ -333,9 +363,16 @@ Provide a concise analysis that will help in creating an implementation plan.'''
         
         if self.verbose >= 2:
             logger.info(f"Creating plan for: {request[:100]}...")
-            
-        # Get LLM response
-        response = llm.get_response(prompt)
+        
+        # Use Agent with tools if available, otherwise use bare LLM
+        agent = self._get_agent()
+        if agent is not None:
+            # Use Agent.chat() for tool-enabled planning
+            response = agent.chat(prompt)
+        else:
+            # Use bare LLM for simple planning
+            llm = self._get_llm()
+            response = llm.get_response(prompt)
         
         # Parse response into Plan
         plan = self._parse_plan_response(response)

src/praisonai-agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.183"
+version = "0.0.184"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [

src/praisonai-agents/test_agent_planning.py

@@ -0,0 +1,16 @@
+from praisonaiagents import Agent
+
+def search_web(query: str) -> str:
+    return "AI trends: LLMs, multimodal AI, autonomous agents"
+
+agent = Agent(
+    name="AI Assistant",
+    role="Research and Writing Specialist",
+    llm="gpt-4o-mini",
+    planning=True,
+    planning_tools=[search_web],
+    planning_reasoning=True
+)
+
+result = agent.start("Research AI trends in 2025 and write a 2 sentence summary")
+print(result)

src/praisonai-agents/test_planning_modes_clean.py

@@ -0,0 +1,22 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+def search_web(query: str) -> str:
+    return f"Results: AI trends include LLMs, multimodal AI, autonomous agents"
+
+researcher = Agent(name="Researcher", role="Research Analyst", llm="gpt-4o-mini")
+writer = Agent(name="Writer", role="Content Writer", llm="gpt-4o-mini")
+
+task1 = Task(description="Research AI trends in 2025", agent=researcher)
+task2 = Task(description="Write a 2 sentence summary", agent=writer)
+
+agents = PraisonAIAgents(
+    agents=[researcher, writer],
+    tasks=[task1, task2],
+    planning=True,
+    planning_tools=[search_web],
+    planning_reasoning=True,
+    auto_approve_plan=True
+)
+
+result = agents.start()
+print(result)

src/praisonai-agents/test_planning_simple.py

@@ -0,0 +1,28 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+def search_web(query: str) -> str:
+    return "AI trends: LLMs, multimodal AI, autonomous agents"
+
+agent = Agent(
+    name="AI Assistant",
+    role="Research and Writing Specialist",
+    llm="gpt-4o-mini",
+    instructions="Research AI trends in 2025 and write a 2 sentence summary"
+)
+
+task = Task(
+    description="Research AI trends in 2025 and write a 2 sentence summary",
+    agent=agent
+)
+
+agents = PraisonAIAgents(
+    agents=[agent],
+    tasks=[task],
+    planning=True,
+    planning_tools=[search_web],
+    planning_reasoning=True,
+    auto_approve_plan=True
+)
+
+result = agents.start()
+print(result)

src/praisonai-agents/test_planning_tools_example.py

@@ -0,0 +1,34 @@
+from praisonaiagents import Agent
+from praisonaiagents.planning import PlanningAgent
+
+def search_web(query: str) -> str:
+    return f"Results for '{query}': LLMs, multimodal AI, autonomous agents"
+
+researcher = Agent(name="Researcher", role="Research Analyst", llm="gpt-4o-mini")
+writer = Agent(name="Writer", role="Content Writer", llm="gpt-4o-mini")
+
+print("\n=== TEST 1: Basic Planning (NO tools) ===")
+planner1 = PlanningAgent(llm="gpt-4o-mini")
+plan1 = planner1.create_plan_sync(
+    request="Write about AI trends 2025",
+    agents=[researcher, writer]
+)
+print(f"Plan: {plan1.name}, Steps: {len(plan1.steps)}")
+
+print("\n=== TEST 2: Planning WITH tools ===")
+planner2 = PlanningAgent(llm="gpt-4o-mini", tools=[search_web])
+plan2 = planner2.create_plan_sync(
+    request="Write about AI trends 2025",
+    agents=[researcher, writer]
+)
+print(f"Plan: {plan2.name}, Steps: {len(plan2.steps)}")
+
+print("\n=== TEST 3: Planning WITH tools + reasoning ===")
+planner3 = PlanningAgent(llm="gpt-4o-mini", tools=[search_web], reasoning=True)
+plan3 = planner3.create_plan_sync(
+    request="Write about AI trends 2025",
+    agents=[researcher, writer]
+)
+print(f"Plan: {plan3.name}, Steps: {len(plan3.steps)}")
+
+print("\n✅ Done!")

src/praisonai-agents/tests/test_planning_tools.py

@@ -0,0 +1,407 @@
+"""
+Test-Driven Development tests for Planning Mode with Tools Support.
+
+This module contains tests for:
+- PlanningAgent with tools parameter
+- PlanningAgent with reasoning mode
+- PraisonAIAgents with planning_tools parameter
+- Research-enabled planning
+"""
+
+import pytest
+import json
+from unittest.mock import Mock, MagicMock, patch, AsyncMock
+
+
+# =============================================================================
+# SECTION 1: PlanningAgent Tools Parameter Tests
+# =============================================================================
+
+class TestPlanningAgentToolsParameter:
+    """Tests for PlanningAgent tools parameter."""
+    
+    def test_planning_agent_accepts_tools_parameter(self):
+        """Test that PlanningAgent accepts tools parameter."""
+        from praisonaiagents.planning import PlanningAgent
+        
+        def search_tool(query: str) -> str:
+            """Search the web."""
+            return f"Results for {query}"
+        
+        planner = PlanningAgent(tools=[search_tool])
+        
+        assert planner.tools is not None
+        assert len(planner.tools) == 1
+        
+    def test_planning_agent_tools_default_empty(self):
+        """Test that tools defaults to empty list."""
+        from praisonaiagents.planning import PlanningAgent
+        
+        planner = PlanningAgent()
+        
+        assert planner.tools == []
+        
+    def test_planning_agent_with_multiple_tools(self):
+        """Test PlanningAgent with multiple tools."""
+        from praisonaiagents.planning import PlanningAgent
+        
+        def tool1(x: str) -> str:
+            return x
+        def tool2(x: str) -> str:
+            return x
+        def tool3(x: str) -> str:
+            return x
+        
+        planner = PlanningAgent(tools=[tool1, tool2, tool3])
+        
+        assert len(planner.tools) == 3
+
+
+# =============================================================================
+# SECTION 2: PlanningAgent Internal Agent Tests
+# =============================================================================
+
+class TestPlanningAgentInternalAgent:
+    """Tests for PlanningAgent internal Agent creation."""
+    
+    def test_planning_agent_creates_internal_agent_when_tools_provided(self):
+        """Test that internal Agent is created when tools are provided."""
+        from praisonaiagents.planning import PlanningAgent
+        
+        def search_tool(query: str) -> str:
+            """Search the web."""
+            return f"Results for {query}"
+        
+        planner = PlanningAgent(tools=[search_tool])
+        
+        # Internal agent should be created lazily
+        agent = planner._get_agent()
+        
+        assert agent is not None
+        assert agent.tools is not None
+        
+    def test_planning_agent_no_internal_agent_without_tools(self):
+        """Test that no internal Agent is created without tools."""
+        from praisonaiagents.planning import PlanningAgent
+        
+        planner = PlanningAgent()
+        
+        agent = planner._get_agent()
+        
+        assert agent is None
+        
+    def test_planning_agent_internal_agent_uses_planning_llm(self):
+        """Test that internal Agent uses the planning LLM."""
+        from praisonaiagents.planning import PlanningAgent
+        
+        def search_tool(query: str) -> str:
+            return "results"
+        
+        planner = PlanningAgent(llm="gpt-4o", tools=[search_tool])
+        agent = planner._get_agent()
+        
+        assert agent is not None
+        # The agent should use the same LLM model
+        assert agent.llm == "gpt-4o"
+
+
+# =============================================================================
+# SECTION 3: PlanningAgent Create Plan with Tools Tests
+# =============================================================================
+
+class TestPlanningAgentCreatePlanWithTools:
+    """Tests for create_plan_sync with tools."""
+    
+    def test_create_plan_sync_uses_agent_when_tools_provided(self):
+        """Test that create_plan_sync uses Agent.chat when tools provided."""
+        from praisonaiagents.planning import PlanningAgent
+        from praisonaiagents import Agent
+        
+        def search_tool(query: str) -> str:
+            """Search the web for information."""
+            return f"Search results for: {query}"
+        
+        planner = PlanningAgent(tools=[search_tool])
+        
+        # Mock the internal agent's chat method
+        mock_agent = MagicMock()
+        mock_agent.chat = MagicMock(return_value=json.dumps({
+            "name": "Research Plan",
+            "description": "Plan created with research",
+            "steps": [
+                {"description": "Research topic", "agent": "Researcher"},
+                {"description": "Write content", "agent": "Writer"}
+            ]
+        }))
+        mock_agent.tools = [search_tool]
+        mock_agent.llm = "gpt-4o-mini"
+        
+        planner._agent = mock_agent
+        
+        agents = [Agent(name="Researcher", role="Researcher")]
+        plan = planner.create_plan_sync(
+            request="Research AI trends",
+            agents=agents
+        )
+        
+        # Verify agent.chat was called (not LLM.get_response)
+        mock_agent.chat.assert_called_once()
+        assert plan.name == "Research Plan"
+        
+    def test_create_plan_sync_uses_llm_when_no_tools(self):
+        """Test that create_plan_sync uses LLM when no tools provided."""
+        from praisonaiagents.planning import PlanningAgent
+        from praisonaiagents import Agent
+        
+        planner = PlanningAgent()
+        
+        # Mock the LLM
+        mock_llm = MagicMock()
+        mock_llm.get_response = MagicMock(return_value=json.dumps({
+            "name": "Simple Plan",
+            "description": "Plan without research",
+            "steps": [{"description": "Step 1"}]
+        }))
+        
+        planner._llm = mock_llm
+        
+        agents = [Agent(name="Worker", role="Worker")]
+        plan = planner.create_plan_sync(
+            request="Simple task",
+            agents=agents
+        )
+        
+        # Verify LLM.get_response was called
+        mock_llm.get_response.assert_called_once()
+        assert plan.name == "Simple Plan"
+
+
+# =============================================================================
+# SECTION 4: PraisonAIAgents planning_tools Parameter Tests
+# =============================================================================
+
+class TestPraisonAIAgentsPlanningTools:
+    """Tests for PraisonAIAgents planning_tools parameter."""
+    
+    def test_praisonaiagents_accepts_planning_tools(self):
+        """Test that PraisonAIAgents accepts planning_tools parameter."""
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+        
+        def search_tool(query: str) -> str:
+            return "results"
+        
+        agent = Agent(name="Test", role="Tester")
+        task = Task(description="Test task", agent=agent)
+        
+        agents = PraisonAIAgents(
+            agents=[agent],
+            tasks=[task],
+            planning=True,
+            planning_tools=[search_tool]
+        )
+        
+        assert agents.planning_tools is not None
+        assert len(agents.planning_tools) == 1
+        
+    def test_praisonaiagents_planning_tools_default_none(self):
+        """Test that planning_tools defaults to None."""
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+        
+        agent = Agent(name="Test", role="Tester")
+        task = Task(description="Test task", agent=agent)
+        
+        agents = PraisonAIAgents(
+            agents=[agent],
+            tasks=[task],
+            planning=True
+        )
+        
+        assert agents.planning_tools is None
+        
+    def test_praisonaiagents_passes_tools_to_planning_agent(self):
+        """Test that planning_tools are passed to PlanningAgent."""
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+        
+        def search_tool(query: str) -> str:
+            return "results"
+        
+        agent = Agent(name="Test", role="Tester")
+        task = Task(description="Test task", agent=agent)
+        
+        agents = PraisonAIAgents(
+            agents=[agent],
+            tasks=[task],
+            planning=True,
+            planning_tools=[search_tool]
+        )
+        
+        # Get the planning agent
+        planning_agent = agents._get_planning_agent()
+        
+        assert planning_agent is not None
+        assert planning_agent.tools is not None
+        assert len(planning_agent.tools) == 1
+
+
+# =============================================================================
+# SECTION 5: PlanningAgent Reasoning Mode Tests
+# =============================================================================
+
+class TestPlanningAgentReasoningMode:
+    """Tests for PlanningAgent reasoning mode."""
+    
+    def test_planning_agent_accepts_reasoning_parameter(self):
+        """Test that PlanningAgent accepts reasoning parameter."""
+        from praisonaiagents.planning import PlanningAgent
+        
+        planner = PlanningAgent(reasoning=True)
+        
+        assert planner.reasoning is True
+        
+    def test_planning_agent_reasoning_default_false(self):
+        """Test that reasoning defaults to False."""
+        from praisonaiagents.planning import PlanningAgent
+        
+        planner = PlanningAgent()
+        
+        assert planner.reasoning is False
+        
+    def test_planning_agent_accepts_max_reasoning_steps(self):
+        """Test that PlanningAgent accepts max_reasoning_steps parameter."""
+        from praisonaiagents.planning import PlanningAgent
+        
+        planner = PlanningAgent(reasoning=True, max_reasoning_steps=10)
+        
+        assert planner.max_reasoning_steps == 10
+        
+    def test_planning_agent_max_reasoning_steps_default(self):
+        """Test that max_reasoning_steps defaults to 5."""
+        from praisonaiagents.planning import PlanningAgent
+        
+        planner = PlanningAgent(reasoning=True)
+        
+        assert planner.max_reasoning_steps == 5
+
+
+# =============================================================================
+# SECTION 6: PraisonAIAgents planning_reasoning Parameter Tests
+# =============================================================================
+
+class TestPraisonAIAgentsPlanningReasoning:
+    """Tests for PraisonAIAgents planning_reasoning parameter."""
+    
+    def test_praisonaiagents_accepts_planning_reasoning(self):
+        """Test that PraisonAIAgents accepts planning_reasoning parameter."""
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+        
+        agent = Agent(name="Test", role="Tester")
+        task = Task(description="Test task", agent=agent)
+        
+        agents = PraisonAIAgents(
+            agents=[agent],
+            tasks=[task],
+            planning=True,
+            planning_reasoning=True
+        )
+        
+        assert agents.planning_reasoning is True
+        
+    def test_praisonaiagents_planning_reasoning_default_false(self):
+        """Test that planning_reasoning defaults to False."""
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+        
+        agent = Agent(name="Test", role="Tester")
+        task = Task(description="Test task", agent=agent)
+        
+        agents = PraisonAIAgents(
+            agents=[agent],
+            tasks=[task],
+            planning=True
+        )
+        
+        assert agents.planning_reasoning is False
+        
+    def test_praisonaiagents_passes_reasoning_to_planning_agent(self):
+        """Test that planning_reasoning is passed to PlanningAgent."""
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+        
+        agent = Agent(name="Test", role="Tester")
+        task = Task(description="Test task", agent=agent)
+        
+        agents = PraisonAIAgents(
+            agents=[agent],
+            tasks=[task],
+            planning=True,
+            planning_reasoning=True
+        )
+        
+        planning_agent = agents._get_planning_agent()
+        
+        assert planning_agent.reasoning is True
+
+
+# =============================================================================
+# SECTION 7: Integration Tests
+# =============================================================================
+
+class TestPlanningToolsIntegration:
+    """Integration tests for planning with tools."""
+    
+    def test_planning_with_tools_and_reasoning(self):
+        """Test planning with both tools and reasoning enabled."""
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+        
+        def search_tool(query: str) -> str:
+            return "search results"
+        
+        agent = Agent(name="Researcher", role="Research Analyst")
+        task = Task(description="Research AI trends", agent=agent)
+        
+        agents = PraisonAIAgents(
+            agents=[agent],
+            tasks=[task],
+            planning=True,
+            planning_tools=[search_tool],
+            planning_reasoning=True,
+            auto_approve_plan=True
+        )
+        
+        assert agents.planning is True
+        assert agents.planning_tools is not None
+        assert agents.planning_reasoning is True
+        
+        planning_agent = agents._get_planning_agent()
+        assert planning_agent.tools is not None
+        assert planning_agent.reasoning is True
+
+
+# =============================================================================
+# SECTION 8: RESEARCH_TOOLS List Tests
+# =============================================================================
+
+class TestResearchToolsList:
+    """Tests for RESEARCH_TOOLS list in planning module."""
+    
+    def test_research_tools_list_exists(self):
+        """Test that RESEARCH_TOOLS list exists."""
+        from praisonaiagents.planning import RESEARCH_TOOLS
+        
+        assert RESEARCH_TOOLS is not None
+        assert isinstance(RESEARCH_TOOLS, list)
+        
+    def test_research_tools_contains_search_tools(self):
+        """Test that RESEARCH_TOOLS contains common search tools."""
+        from praisonaiagents.planning import RESEARCH_TOOLS
+        
+        expected_tools = [
+            "web_search",
+            "search_web",
+            "duckduckgo_search",
+        ]
+        
+        for tool in expected_tools:
+            assert tool in RESEARCH_TOOLS, f"{tool} should be in RESEARCH_TOOLS"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

src/praisonai-agents/uv.lock

@@ -2422,7 +2422,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.183"
+version = "0.0.184"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

src/praisonai/README.md

@@ -60,7 +60,9 @@ PraisonAI is a production-ready Multi-AI Agents framework with self-reflection,
 - 💾 **Prompt Caching** (Reduce costs & latency - OpenAI, Anthropic, Bedrock, Deepseek)
 - 🧠 **Claude Memory Tool** (Persistent cross-conversation memory - Anthropic Beta)
 - 💾 **File-Based Memory** (Zero-dependency persistent memory for all agents)
-- 📋 **Planning Mode** (Plan before execution like Cursor, Windsurf, Claude Code)
+- 📋 **Planning Mode** (Plan before execution - Agent & Multi-Agent)
+- 🔧 **Planning Tools** (Research with tools during planning)
+- 🧠 **Planning Reasoning** (Chain-of-thought planning)
 
 ## Using Python Code
 
@@ -104,7 +106,34 @@ Run:
 python app.py
 ```
 
-### 3. Deep Research Agent
+### 3. Agent with Planning Mode
+
+Enable planning for any agent - the agent creates a plan, then executes step by step:
+
+```python
+from praisonaiagents import Agent
+
+def search_web(query: str) -> str:
+    return f"Search results for: {query}"
+
+agent = Agent(
+    name="AI Assistant",
+    instructions="Research and write about topics",
+    planning=True,              # Enable planning mode
+    planning_tools=[search_web], # Tools for planning research
+    planning_reasoning=True      # Chain-of-thought reasoning
+)
+
+result = agent.start("Research AI trends in 2025 and write a summary")
+```
+
+**What happens:**
+1. 📋 Agent creates a multi-step plan
+2. 🚀 Executes each step sequentially
+3. 📊 Shows progress with context passing
+4. ✅ Returns final result
+
+### 4. Deep Research Agent
 
 Automated research with real-time streaming, web search, and citations using OpenAI or Gemini Deep Research APIs.
 
@@ -142,7 +171,7 @@ print(result.report)
 - 🛠️ Built-in tools: web search, code interpreter, MCP, file search
 - 🔄 Automatic provider detection from model name
 
-### 4. Query Rewriter Agent
+### 5. Query Rewriter Agent
 
 Transform user queries to improve RAG retrieval quality using multiple strategies.
 
@@ -177,9 +206,9 @@ result = agent.rewrite("What about cost?", chat_history=[...])
 - **CONTEXTUAL**: Resolve references using conversation history
 - **AUTO**: Automatically detect best strategy
 
-### 5. Agent Memory (Zero Dependencies)
+### 6. Agent Memory (Zero Dependencies)
 
-Enable persistent memory for agents - works out of the box without any extra packages. Features inspired by Claude, Gemini CLI, Codex CLI, Cursor, and Windsurf.
+Enable persistent memory for agents - works out of the box without any extra packages.
 
 ```python
 from praisonaiagents import Agent
@@ -204,7 +233,7 @@ result = agent.start("My name is John and I prefer Python")
 - **Entity**: People, places, organizations with attributes
 - **Episodic**: Date-based interaction history
 
-**Advanced Features (like Gemini CLI):**
+**Advanced Features:**
 ```python
 from praisonaiagents.memory import FileMemory
 
@@ -234,7 +263,7 @@ memory.handle_command("/memory save my_session")
 | `memory="sqlite"` | Built-in | SQLite with indexing |
 | `memory="chromadb"` | chromadb | Vector/semantic search |
 
-### 6. Rules & Instructions (like Cursor/Windsurf)
+### 6. Rules & Instructions
 
 PraisonAI auto-discovers instruction files from your project root and git root:
 
@@ -262,7 +291,7 @@ agent = Agent(name="Assistant", instructions="You are helpful.")
 # Rules are injected into system prompt automatically
 ```
 
-**@Import Syntax (like Claude Code):**
+**@Import Syntax:**
 ```markdown
 # CLAUDE.md
 See @README for project overview
@@ -283,7 +312,7 @@ activation: always  # always, glob, manual, ai_decision
 - Follow PEP 8
 ```
 
-### 7. Auto-Generated Memories (like Windsurf Cascade)
+### 7. Auto-Generated Memories
 
 ```python
 from praisonaiagents.memory import FileMemory, AutoMemory
@@ -298,7 +327,7 @@ memories = auto.process_interaction(
 # Extracts: name="John", preference="Python for backend"
 ```
 
-### 8. Workflows (like Windsurf)
+### 8. Workflows
 
 Create reusable multi-step workflows in `.praison/workflows/`:
 
@@ -315,7 +344,7 @@ result = manager.execute(
 )
 ```
 
-### 9. Hooks (like Windsurf Cascade Hooks)
+### 9. Hooks
 
 Configure in `.praison/hooks.json`:
 

src/praisonai/praisonai.rb

@@ -3,8 +3,8 @@ class Praisonai < Formula
   
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.3.5.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.3.5.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.3.6.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.3.6.tar.gz | shasum -a 256`.split.first
     license "MIT"
   
     depends_on "[email protected]"

src/praisonai/praisonai/deploy.py

@@ -57,7 +57,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.3.5 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.3.6 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

src/praisonai/praisonai/version.py

@@ -1 +1 @@
-__version__ = "2.3.5"
+__version__ = "2.3.6"

src/praisonai/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.0.183",
+    "praisonaiagents>=0.0.184",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",

src/praisonai/uv.lock

@@ -4197,7 +4197,7 @@ requires-dist = [
     { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.0.22" },
     { name = "praisonai-tools", marker = "extra == 'autogen-v4'", specifier = ">=0.0.22" },
     { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.0.22" },
-    { name = "praisonaiagents", specifier = ">=0.0.183" },
+    { name = "praisonaiagents", specifier = ">=0.0.184" },
     { name = "pyautogen", marker = "extra == 'autogen'", specifier = "==0.2.29" },
     { name = "pydantic", marker = "extra == 'chat'", specifier = "<=2.10.1" },
     { name = "pydantic", marker = "extra == 'code'", specifier = "<=2.10.1" },
@@ -4252,7 +4252,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.183"
+version = "0.0.184"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -4261,9 +4261,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ba/fb/0971e0a371e5f8636ce34fb3fb556c8438db352f866a646df197998c7465/praisonaiagents-0.0.183.tar.gz", hash = "sha256:fccb8e97b43cda260ecd1f470eeb25abfa8c3f2610995bdede89a337054a4eab", size = 409014, upload-time = "2025-12-15T21:04:24.104Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/56/219e1f1eca6f0d521822f83fda970b44decba97dd49346c75cba00684bce/praisonaiagents-0.0.184.tar.gz", hash = "sha256:c09d036a35c5e34a3a40ffee01b94fa50ca6f6cc07f4a67a52ea1cbba42c139e", size = 412203, upload-time = "2025-12-15T22:13:47.78Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/e8/df5b543876604c2ea93e630dfb8482742a479c06d422b840f1f0d4430802/praisonaiagents-0.0.183-py3-none-any.whl", hash = "sha256:d5c4796dc74d639321e65aa09b9f15a74848a4a969c844260a7097801e76bda3", size = 397016, upload-time = "2025-12-15T21:04:21.085Z" },
+    { url = "https://files.pythonhosted.org/packages/93/a5/ffa998f4b99b763f9ff1d2ecc0a96b9669747b36563d9e453be3d4f9df3a/praisonaiagents-0.0.184-py3-none-any.whl", hash = "sha256:6aaa099cf181a9b7ac2ff446a6658ae8e2b687d55dc68a89a8eaa3f8ff1a0705", size = 398575, upload-time = "2025-12-15T22:13:46.253Z" },
 ]
 
 [[package]]