Release v3.5.2

Release v3.5.1
Release v3.5.0
2026-11-10 11:41:32 -10:00 · 2026-01-08 21:14:45 +00:00 · 2026-01-08 20:12:14 +00:00 · 2026-01-08 19:55:06 +00:00 · 2026-01-08 16:14:35 +00:00 · 2026-01-08 16:03:38 +00:00
300 changed files with 9989 additions and 1292 deletions
@@ -20,6 +20,7 @@ watch.sh
 docs.sh
 other
 output
+!src/praisonai/praisonai/cli/output/

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

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

@@ -0,0 +1,43 @@
+"""
+Basic Caching Configuration Example
+
+Demonstrates using caching for response and prompt caching.
+"""
+import os
+from praisonaiagents import Agent, CachingConfig
+
+# Ensure API key is set from environment
+assert os.getenv("OPENAI_API_KEY"), "OPENAI_API_KEY must be set"
+
+# Default caching (enabled)
+agent_cached = Agent(
+    instructions="You are a helpful assistant.",
+    caching=True,
+)
+
+# Disable caching
+agent_no_cache = Agent(
+    instructions="You are a helpful assistant.",
+    caching=False,
+)
+
+# Custom caching configuration
+agent_custom = Agent(
+    instructions="You are a helpful assistant.",
+    caching=CachingConfig(
+        enabled=True,
+        prompt_caching=True,  # Enable prompt caching for supported providers
+    ),
+)
+
+if __name__ == "__main__":
+    print("Testing CachingConfig...")
+    
+    print(f"Cached agent cache: {agent_cached.cache}")
+    print(f"No-cache agent cache: {agent_no_cache.cache}")
+    print(f"Custom agent cache: {agent_custom.cache}")
+    
+    result = agent_cached.chat("What is caching?")
+    print(f"Result: {result}")
+    
+    print("\nCachingConfig tests passed!")
@@ -0,0 +1,48 @@
+"""
+Basic Execution Configuration Example
+
+Demonstrates using execution presets for quick configuration.
+"""
+import os
+from praisonaiagents import Agent
+
+# Ensure API key is set from environment
+assert os.getenv("OPENAI_API_KEY"), "OPENAI_API_KEY must be set"
+
+# Default execution (max_iter=20, max_retry_limit=2)
+agent_default = Agent(
+    instructions="You are a helpful assistant.",
+)
+
+# Fast execution - fewer iterations, quick responses
+agent_fast = Agent(
+    instructions="You are a helpful assistant.",
+    execution="fast",
+)
+
+# Thorough execution - more iterations, comprehensive responses
+agent_thorough = Agent(
+    instructions="You are a research assistant.",
+    execution="thorough",
+)
+
+# Unlimited execution - for complex tasks
+agent_unlimited = Agent(
+    instructions="You are a complex problem solver.",
+    execution="unlimited",
+)
+
+if __name__ == "__main__":
+    print("Testing execution presets...")
+    
+    print(f"Default agent max_iter: {agent_default.max_iter}")
+    print(f"Fast agent max_iter: {agent_fast.max_iter}")
+    print(f"Thorough agent max_iter: {agent_thorough.max_iter}")
+    print(f"Unlimited agent max_iter: {agent_unlimited.max_iter}")
+    
+    # Test fast agent
+    print("\n--- Fast Execution ---")
+    result = agent_fast.chat("What is the capital of France?")
+    print(f"Result: {result}")
+    
+    print("\nAll execution preset tests passed!")
@@ -0,0 +1,45 @@
+"""
+ExecutionConfig Example
+
+Demonstrates using ExecutionConfig for fine-grained control over execution limits.
+"""
+import os
+from praisonaiagents import Agent, ExecutionConfig
+
+# Ensure API key is set from environment
+assert os.getenv("OPENAI_API_KEY"), "OPENAI_API_KEY must be set"
+
+# Custom execution configuration
+agent = Agent(
+    instructions="You are a helpful assistant.",
+    execution=ExecutionConfig(
+        max_iter=30,
+        max_rpm=100,
+        max_execution_time=60,
+        max_retry_limit=3,
+    ),
+)
+
+# Rate-limited agent for API quota management
+agent_rate_limited = Agent(
+    instructions="You are a helpful assistant.",
+    execution=ExecutionConfig(
+        max_iter=20,
+        max_rpm=10,  # Only 10 requests per minute
+    ),
+)
+
+if __name__ == "__main__":
+    print("Testing ExecutionConfig...")
+    
+    print(f"Custom agent max_iter: {agent.max_iter}")
+    print(f"Custom agent max_rpm: {agent.max_rpm}")
+    print(f"Custom agent max_execution_time: {agent.max_execution_time}")
+    print(f"Custom agent max_retry_limit: {agent.max_retry_limit}")
+    
+    # Test custom agent
+    print("\n--- Custom Execution ---")
+    result = agent.chat("What is machine learning?")
+    print(f"Result: {result}")
+    
+    print("\nExecutionConfig tests passed!")
@@ -0,0 +1,30 @@
+"""
+Basic Guardrails Configuration Example
+
+Demonstrates using guardrails for output validation.
+"""
+import os
+from praisonaiagents import Agent
+
+# Ensure API key is set from environment
+assert os.getenv("OPENAI_API_KEY"), "OPENAI_API_KEY must be set"
+
+def validate_length(output):
+    """Validate that output is not too short."""
+    if len(str(output.raw)) < 10:
+        return False, "Response too short"
+    return True, output
+
+# Enable guardrails with a validator function
+agent = Agent(
+    instructions="You are a helpful assistant.",
+    guardrails=validate_length,
+)
+
+if __name__ == "__main__":
+    print("Testing guardrails...")
+    
+    result = agent.chat("Explain what Python is.")
+    print(f"Result: {result}")
+    
+    print("\nGuardrails tests passed!")
@@ -0,0 +1,43 @@
+"""
+GuardrailConfig Example
+
+Demonstrates using GuardrailConfig for fine-grained control.
+"""
+import os
+from praisonaiagents import Agent, GuardrailConfig
+
+# Ensure API key is set from environment
+assert os.getenv("OPENAI_API_KEY"), "OPENAI_API_KEY must be set"
+
+def validate_no_code(output):
+    """Validate that output doesn't contain code blocks."""
+    if "```" in str(output.raw):
+        return False, "Response should not contain code blocks"
+    return True, output
+
+# Custom guardrail configuration
+agent = Agent(
+    instructions="You are a helpful assistant. Explain concepts without code.",
+    guardrails=GuardrailConfig(
+        validator=validate_no_code,
+        max_retries=3,
+        on_fail="retry",
+    ),
+)
+
+# LLM-based validation
+agent_llm = Agent(
+    instructions="You are a helpful assistant.",
+    guardrails=GuardrailConfig(
+        llm_validator="Ensure the response is helpful, accurate, and professional.",
+        max_retries=2,
+    ),
+)
+
+if __name__ == "__main__":
+    print("Testing GuardrailConfig...")
+    
+    result = agent.chat("What is a variable in programming?")
+    print(f"Result: {result}")
+    
+    print("\nGuardrailConfig tests passed!")
@@ -0,0 +1,297 @@
+"""
+Agent-Centric Autonomy Example.
+
+Demonstrates the new agent-centric autonomy features in PraisonAI Agents:
+- Agent(autonomy=True) for enabling autonomy
+- Progressive escalation stages (DIRECT, HEURISTIC, PLANNED, AUTONOMOUS)
+- Doom loop detection and recovery
+- Verification hooks
+- Subagent delegation
+"""
+
+from praisonaiagents import Agent
+
+
+def example_basic_autonomy():
+    """Basic autonomy example - simple question."""
+    print("\n" + "="*60)
+    print("Example 1: Basic Autonomy - Simple Question")
+    print("="*60)
+    
+    agent = Agent(
+        instructions="You are a helpful coding assistant.",
+        autonomy=True,
+    )
+    
+    # Analyze a simple question
+    prompt = "What is Python?"
+    signals = agent.analyze_prompt(prompt)
+    stage = agent.get_recommended_stage(prompt)
+    
+    print(f"Prompt: {prompt}")
+    print(f"Detected signals: {signals}")
+    print(f"Recommended stage: {stage}")
+    
+    # For simple questions, stage should be "direct"
+    assert stage == "direct", f"Expected 'direct', got '{stage}'"
+    print("✓ Simple question correctly identified as DIRECT stage")
+
+
+def example_file_reference():
+    """File reference detection example."""
+    print("\n" + "="*60)
+    print("Example 2: File Reference Detection")
+    print("="*60)
+    
+    agent = Agent(
+        instructions="You are a code reviewer.",
+        autonomy=True,
+    )
+    
+    prompt = "Read the main.py file and explain what it does"
+    signals = agent.analyze_prompt(prompt)
+    stage = agent.get_recommended_stage(prompt)
+    
+    print(f"Prompt: {prompt}")
+    print(f"Detected signals: {signals}")
+    print(f"Recommended stage: {stage}")
+    
+    assert "file_references" in signals, "Expected file_references signal"
+    assert stage == "heuristic", f"Expected 'heuristic', got '{stage}'"
+    print("✓ File reference correctly identified as HEURISTIC stage")
+
+
+def example_edit_intent():
+    """Edit intent detection example."""
+    print("\n" + "="*60)
+    print("Example 3: Edit Intent Detection")
+    print("="*60)
+    
+    agent = Agent(
+        instructions="You are a code editor.",
+        autonomy=True,
+    )
+    
+    prompt = "Edit the config.py file to add logging support"
+    signals = agent.analyze_prompt(prompt)
+    stage = agent.get_recommended_stage(prompt)
+    
+    print(f"Prompt: {prompt}")
+    print(f"Detected signals: {signals}")
+    print(f"Recommended stage: {stage}")
+    
+    assert "edit_intent" in signals, "Expected edit_intent signal"
+    assert stage == "planned", f"Expected 'planned', got '{stage}'"
+    print("✓ Edit intent correctly identified as PLANNED stage")
+
+
+def example_multi_step_task():
+    """Multi-step task detection example."""
+    print("\n" + "="*60)
+    print("Example 4: Multi-Step Task Detection")
+    print("="*60)
+    
+    agent = Agent(
+        instructions="You are a software architect.",
+        autonomy=True,
+    )
+    
+    prompt = """First analyze the codebase structure, 
+    then refactor the authentication module, 
+    and finally add comprehensive tests."""
+    
+    signals = agent.analyze_prompt(prompt)
+    stage = agent.get_recommended_stage(prompt)
+    
+    print(f"Prompt: {prompt[:50]}...")
+    print(f"Detected signals: {signals}")
+    print(f"Recommended stage: {stage}")
+    
+    assert "multi_step" in signals, "Expected multi_step signal"
+    assert stage == "autonomous", f"Expected 'autonomous', got '{stage}'"
+    print("✓ Multi-step task correctly identified as AUTONOMOUS stage")
+
+
+def example_custom_config():
+    """Custom autonomy configuration example."""
+    print("\n" + "="*60)
+    print("Example 5: Custom Autonomy Configuration")
+    print("="*60)
+    
+    agent = Agent(
+        instructions="You are a careful code reviewer.",
+        autonomy={
+            "max_iterations": 50,
+            "doom_loop_threshold": 5,
+            "auto_escalate": True,
+            "checkpoint_on_write": True,
+        },
+    )
+    
+    print(f"Autonomy enabled: {agent.autonomy_enabled}")
+    print(f"Max iterations: {agent.autonomy_config.get('max_iterations')}")
+    print(f"Doom loop threshold: {agent.autonomy_config.get('doom_loop_threshold')}")
+    print(f"Checkpoint on write: {agent.autonomy_config.get('checkpoint_on_write')}")
+    
+    assert agent.autonomy_enabled == True
+    assert agent.autonomy_config.get("max_iterations") == 50
+    print("✓ Custom configuration applied correctly")
+
+
+def example_doom_loop_detection():
+    """Doom loop detection example."""
+    print("\n" + "="*60)
+    print("Example 6: Doom Loop Detection")
+    print("="*60)
+    
+    agent = Agent(
+        instructions="You are a test agent.",
+        autonomy={"doom_loop_threshold": 3},
+    )
+    
+    # Simulate repeated actions
+    print("Simulating repeated actions...")
+    for i in range(3):
+        agent._record_action("read_file", {"path": "test.py"}, "content", True)
+        print(f"  Action {i+1}: read_file test.py")
+    
+    is_doom_loop = agent._is_doom_loop()
+    print(f"Doom loop detected: {is_doom_loop}")
+    
+    assert is_doom_loop == True, "Expected doom loop to be detected"
+    print("✓ Doom loop correctly detected after repeated actions")
+    
+    # Reset and verify
+    agent._reset_doom_loop()
+    is_doom_loop_after_reset = agent._is_doom_loop()
+    print(f"After reset: {is_doom_loop_after_reset}")
+    assert is_doom_loop_after_reset == False
+    print("✓ Doom loop correctly reset")
+
+
+def example_verification_hooks():
+    """Verification hooks example."""
+    print("\n" + "="*60)
+    print("Example 7: Verification Hooks")
+    print("="*60)
+    
+    # Create a simple mock verification hook
+    class MockTestRunner:
+        name = "pytest"
+        
+        def run(self, context=None):
+            return {"success": True, "output": "All 10 tests passed"}
+    
+    agent = Agent(
+        instructions="You are a test-driven developer.",
+        autonomy=True,
+        verification_hooks=[MockTestRunner()],
+    )
+    
+    print(f"Verification hooks registered: {len(agent._verification_hooks)}")
+    
+    # Run verification hooks
+    results = agent._run_verification_hooks()
+    print(f"Verification results: {results}")
+    
+    assert len(results) == 1
+    assert results[0]["success"] == True
+    print("✓ Verification hooks executed correctly")
+
+
+def example_subagent_delegation():
+    """Subagent delegation example."""
+    print("\n" + "="*60)
+    print("Example 8: Subagent Delegation")
+    print("="*60)
+    
+    agent = Agent(
+        instructions="You are a project manager.",
+        autonomy=True,
+    )
+    
+    # Check delegate method exists
+    assert hasattr(agent, "delegate"), "Agent should have delegate method"
+    assert callable(agent.delegate), "delegate should be callable"
+    
+    # Check _create_subagent method
+    subagent = agent._create_subagent("explorer")
+    print(f"Created subagent: {subagent.name}")
+    print(f"Subagent instructions: {subagent.instructions[:50]}...")
+    
+    assert "subagent_explorer" in subagent.name
+    print("✓ Subagent delegation works correctly")
+
+
+def example_explorer_profile():
+    """Explorer profile example."""
+    print("\n" + "="*60)
+    print("Example 9: Explorer Profile (Read-Only)")
+    print("="*60)
+    
+    from praisonaiagents.agents.profiles import BUILTIN_PROFILES, get_profile
+    
+    explorer = get_profile("explorer")
+    
+    print(f"Profile name: {explorer.name}")
+    print(f"Description: {explorer.description[:60]}...")
+    print(f"Tools: {explorer.tools}")
+    print(f"Read-only metadata: {explorer.metadata.get('read_only')}")
+    
+    # Verify explorer is read-only
+    write_tools = {"write_file", "delete_file", "bash", "shell"}
+    has_write_tools = any(tool in write_tools for tool in explorer.tools)
+    
+    assert not has_write_tools, "Explorer should not have write tools"
+    assert explorer.metadata.get("read_only") == True
+    print("✓ Explorer profile is correctly read-only")
+
+
+def example_run_autonomous_method():
+    """run_autonomous method example (without actual LLM call)."""
+    print("\n" + "="*60)
+    print("Example 10: run_autonomous Method")
+    print("="*60)
+    
+    agent = Agent(
+        instructions="You are a helpful assistant.",
+        autonomy=True,
+    )
+    
+    # Verify method exists
+    assert hasattr(agent, "run_autonomous"), "Agent should have run_autonomous method"
+    assert callable(agent.run_autonomous), "run_autonomous should be callable"
+    
+    print("✓ run_autonomous method exists and is callable")
+    print("  (Skipping actual execution to avoid LLM API calls)")
+
+
+def main():
+    """Run all examples."""
+    print("\n" + "#"*60)
+    print("# Agent-Centric Autonomy Examples")
+    print("#"*60)
+    
+    try:
+        example_basic_autonomy()
+        example_file_reference()
+        example_edit_intent()
+        example_multi_step_task()
+        example_custom_config()
+        example_doom_loop_detection()
+        example_verification_hooks()
+        example_subagent_delegation()
+        example_explorer_profile()
+        example_run_autonomous_method()
+        
+        print("\n" + "="*60)
+        print("All examples completed successfully! ✓")
+        print("="*60)
+        
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    main()
@@ -17,9 +17,7 @@ manager_agent = Agent(
    goal="Coordinate hierarchical task execution and manage team workflow",
    backstory="Experienced manager who excels at breaking down complex projects and coordinating teams",
    tools=[internet_search],
-    allow_delegation=True,
-    verbose=True
-)
+    allow_delegation=True)

 # Create specialist agent for execution
 research_agent = Agent(
@@ -27,9 +25,7 @@ research_agent = Agent(
    role="Market Research Analyst",
    goal="Conduct thorough market research and analysis",
    backstory="Expert researcher skilled in market analysis and competitive intelligence",
-    tools=[internet_search],
-    verbose=True
-)
+    tools=[internet_search])

 # Hierarchical task structure
 planning_task = Task(
@@ -61,8 +57,7 @@ execution_task = Task(
 agents_system = Agents(
    agents=[manager_agent, research_agent],
    tasks=[planning_task, execution_task],
-    process="sequential",
-    verbose=True
+    process="sequential", output="verbose"
 )

 print("Starting hierarchical agent generation...")
@@ -87,8 +87,7 @@ def demonstrate_code_agent():
    workflow = Agents(
        agents=[code_writer, code_reviewer, code_executor],
        tasks=[write_task, review_task, execute_task],
-        process="sequential",
-        verbose=True
+        process="sequential", output="verbose"
    )
    
    # Run the workflow
@@ -31,10 +31,8 @@ def demonstrate_basic_context_generation():
    
    # Create a ContextAgent using the factory function
    context_agent = create_context_agent(
-        llm="gpt-5-nano",
-        name="Basic Context Engineer",
-        verbose=True
-    )
+        llm="gpt-4o-mini",
+        name="Basic Context Engineer")
    
    # Example 1: Analyze codebase patterns
    print("\n📁 Example 1: Analyzing Codebase Patterns")
@@ -133,7 +131,7 @@ def demonstrate_context_agent_as_tool():
    print("=" * 60)
    
    # Create ContextAgent
-    context_agent = create_context_agent(llm="gpt-5-nano")
+    context_agent = create_context_agent(llm="gpt-4o-mini")
    
    # Example scenario: Product planning workflow
    project_path = str(project_root)
@@ -186,7 +184,7 @@ def show_context_engineering_benefits():
    
    # Context Engineering approach
    print("\n✅ Context Engineering Approach:")
-    context_agent = create_context_agent(llm="gpt-5-nano")
+    context_agent = create_context_agent(llm="gpt-4o-mini")
    
    # Generate comprehensive context
    analysis = context_agent.analyze_codebase_patterns(str(project_root))
@@ -13,7 +13,7 @@ image_agent = Agent(
    goal="Analyze images and videos to extract meaningful information",
    backstory="""You are an expert in computer vision and image analysis.
    You excel at describing images, detecting objects, and understanding visual content.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    reflection=False
 )

@@ -13,7 +13,7 @@ image_agent = Agent(
    goal="Analyze images and videos to extract meaningful information",
    backstory="""You are an expert in computer vision and image analysis.
    You excel at describing images, detecting objects, and understanding visual content.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    reflection=False
 )

@@ -126,8 +126,7 @@ def solve_math_problem_workflow():
    workflow = Agents(
        agents=[problem_solver_agent, calculation_agent, math_tutor_agent],
        tasks=[understand_task, solve_task, verify_task],
-        process="sequential",
-        verbose=True
+        process="sequential", output="verbose"
    )
    
    return workflow.start()
@@ -21,9 +21,8 @@ def example_auto_routing():
        role="Adaptive Research Assistant",
        goal="Research topics using the most appropriate AI model",
        backstory="I analyze task complexity and route to the best model",
-        models=["gpt-5-nano", "gpt-5-nano", "claude-3-5-sonnet-20241022"],
-        routing_strategy="auto",  # Automatic model selection
-        verbose=True
+        models=["gpt-4o-mini", "gpt-4o-mini", "claude-3-5-sonnet-20241022"],
+        routing_strategy="auto"  # Automatic model selection
    )
    
    # Create tasks with different complexity levels
@@ -52,8 +51,7 @@ def example_auto_routing():
    agents = Agents(
        agents=[research_agent],
        tasks=[simple_task, moderate_task, complex_task],
-        process="sequential",
-        verbose=True
+        process="sequential", output="verbose"
    )
    
    results = agents.start()
@@ -81,13 +79,11 @@ def example_cost_optimized_workflow():
        goal="Analyze data efficiently while minimizing costs",
        models={
            "gemini/gemini-1.5-flash": {},
-            "gpt-5-nano": {},
+            "gpt-4o-mini": {},
            "deepseek-chat": {}
        },
        model_router=cost_router,
-        routing_strategy="cost-optimized",
-        verbose=True
-    )
+        routing_strategy="cost-optimized")
    
    writer = RouterAgent(
        name="Quality Writer",
@@ -95,10 +91,9 @@ def example_cost_optimized_workflow():
        goal="Create high-quality content",
        models={
            "claude-3-5-sonnet-20241022": {},
-            "gpt-5-nano": {}
+            "gpt-4o-mini": {}
        },
-        routing_strategy="performance-optimized",  # Prefer better models
-        verbose=True
+        routing_strategy="performance-optimized"  # Prefer better models
    )
    
    # Create workflow tasks
@@ -121,8 +116,7 @@ def example_cost_optimized_workflow():
    workflow = Agents(
        agents=[analyzer, writer],
        tasks=[analysis_task, writing_task],
-        process="sequential",
-        verbose=True
+        process="sequential", output="verbose"
    )
    
    results = workflow.start()
@@ -144,8 +138,8 @@ def example_auto_agents_multi_provider():
    auto_agents = AutoAgents(
        instructions="Create a market research report on electric vehicles. Include data analysis, competitor analysis, and future projections.",
        max_agents=3,
-        llm="gpt-5-nano",  # Default model for agent generation
-        verbose=True
+        llm="gpt-4o-mini",  # Default model for agent generation
+        output="verbose"
    )
    
    # After agents are created, upgrade them to multi-model agents
@@ -158,10 +152,8 @@ def example_auto_agents_multi_provider():
            goal=agent.goal,
            backstory=agent.backstory,
            tools=agent.tools,
-            models=["gpt-5-nano", "gemini/gemini-1.5-flash", "claude-3-haiku-20240307", "gpt-5-nano"],
-            routing_strategy="auto",
-            verbose=True
-        )
+            models=["gpt-4o-mini", "gemini/gemini-1.5-flash", "claude-3-haiku-20240307", "gpt-4o-mini"],
+            routing_strategy="auto")
        multi_model_agents.append(multi_agent)
    
    # Update the agents in the AutoAgents instance
@@ -192,7 +184,7 @@ def example_custom_routing():
    # Create custom model profiles for specific use cases
    custom_models = [
        ModelProfile(
-            name="gpt-5-nano",
+            name="gpt-4o-mini",
            provider="openai",
            complexity_range=(TaskComplexity.SIMPLE, TaskComplexity.VERY_COMPLEX),
            cost_per_1k_tokens=0.0075,
@@ -227,9 +219,7 @@ def example_custom_routing():
        backstory="I'm an expert coder who knows when to use different AI models",
        model_router=custom_router,
        routing_strategy="auto",
-        tools=[search_web],
-        verbose=True
-    )
+        tools=[search_web])
    
    # Create coding tasks
    tasks = [
@@ -252,8 +242,7 @@ def example_custom_routing():
    agents = Agents(
        agents=[coder],
        tasks=tasks,
-        process="sequential",
-        verbose=True
+        process="sequential", output="verbose"
    )
    
    results = agents.start()
@@ -18,8 +18,8 @@ from praisonaiagents.tools import duckduckgo

 # Define model options with cost considerations
 # Using different models for different complexity levels
-cheap_model = "gpt-5-nano"  # For simple tasks
-balanced_model = "gpt-5-nano"    # For moderate complexity  
+cheap_model = "gpt-4o-mini"  # For simple tasks
+balanced_model = "gpt-4o-mini"    # For moderate complexity  
 premium_model = "claude-3-5-sonnet-20241022"  # For complex tasks

 # Create RouterAgent with cost optimization strategy
@@ -38,9 +38,7 @@ router = RouterAgent(
    like writing, analysis, or research, use the balanced model. For complex tasks requiring 
    deep reasoning, creativity, or specialized knowledge, use the premium model.""",
    
-    tools=[duckduckgo],
-    verbose=True
-)
+    tools=[duckduckgo])

 # Example tasks of varying complexity levels

@@ -76,7 +74,7 @@ print("\n" + "="*80)
 print("COST OPTIMIZATION ROUTER DEMONSTRATION COMPLETED")
 print("="*80)
 print("The RouterAgent automatically selected appropriate models based on task complexity:")
-print("- Simple factual questions → Cheaper model (gpt-5-nano)")  
-print("- Moderate analysis tasks → Balanced model (gpt-5-nano)")
+print("- Simple factual questions → Cheaper model (gpt-4o-mini)")  
+print("- Moderate analysis tasks → Balanced model (gpt-4o-mini)")
 print("- Complex strategic analysis → Premium model (claude-3-5-sonnet)")
 print("- This approach optimizes costs while maintaining quality for each task type")
@@ -7,7 +7,7 @@ video_agent = Agent(
    goal="Analyze images and videos to extract meaningful information",
    backstory="""You are an expert in computer vision and image analysis.
    You excel at describing images, detecting objects, and understanding visual content.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    reflection=False
 )

@@ -2,7 +2,7 @@ from praisonaiagents import Agent, MCP

 qa_agent = Agent(
    instructions="""You are a Question Answering Agent.""",
-    llm="openai/gpt-5-nano",
+    llm="openai/gpt-4o-mini",
    tools=MCP("http://localhost:8080/agents/sse")
 )

@@ -2,17 +2,17 @@ from praisonaiagents import Agent

 weather_agent = Agent(
    instructions="""You are a weather agent that can provide weather information for a given city.""",
-    llm="gpt-5-nano"
+    llm="gpt-4o-mini"
 )

 stock_agent = Agent(
    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
-    llm="gpt-5-nano"
+    llm="gpt-4o-mini"
 )

 travel_agent = Agent(
    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
-    llm="gpt-5-nano"
+    llm="gpt-4o-mini"
 )

 weather_agent.launch(path="/weather", port=3030)
@@ -115,8 +115,7 @@ def create_market_research_agents(config: MarketResearchConfig):
            Analyze market size, trends, growth drivers, and overall market dynamics for 
            {config.industry} in {config.geography}. Provide quantitative data and cite sources.
            """,
-            tools=[Tools.internet_search],
-            verbose=False
+            tools=[Tools.internet_search], output="minimal"
        )
    
    if "competitive_analysis" in config.sections:
@@ -128,8 +127,7 @@ def create_market_research_agents(config: MarketResearchConfig):
            Analyze {config.company}'s competitive position in {config.industry} within {config.geography}.
            Identify key competitors, market share, and competitive advantages.
            """,
-            tools=[Tools.internet_search],
-            verbose=False
+            tools=[Tools.internet_search], output="minimal"
        )
    
    if "financial_performance" in config.sections:
@@ -141,8 +139,7 @@ def create_market_research_agents(config: MarketResearchConfig):
            Research {config.company}'s financial performance, revenue trends, profitability,
            and compare with industry benchmarks.
            """,
-            tools=[Tools.internet_search],
-            verbose=False
+            tools=[Tools.internet_search], output="minimal"
        )
    
    if "growth_opportunities" in config.sections:
@@ -154,8 +151,7 @@ def create_market_research_agents(config: MarketResearchConfig):
            Identify emerging opportunities, market gaps, expansion possibilities for {config.company}
            in {config.industry} within {config.geography}.
            """,
-            tools=[Tools.internet_search],
-            verbose=False
+            tools=[Tools.internet_search], output="minimal"
        )
    
    if "risk_assessment" in config.sections:
@@ -167,8 +163,7 @@ def create_market_research_agents(config: MarketResearchConfig):
            Identify and analyze potential risks, challenges, and threats facing {config.company}
            in {config.geography}. Consider regulatory, competitive, and market risks.
            """,
-            tools=[Tools.internet_search],
-            verbose=False
+            tools=[Tools.internet_search], output="minimal"
        )
    
    # Always include synthesizer
@@ -179,8 +174,7 @@ def create_market_research_agents(config: MarketResearchConfig):
        instructions=f"""
        Create a professional secondary market research report for {config.company} 
        in {config.industry} with clear structure, insights, and recommendations.
-        """,
-        verbose=False
+        """, output="minimal"
    )
    
    return agents
@@ -269,8 +263,7 @@ async def generate_market_research_report(job_id: str, config: MarketResearchCon
        workflow = Agents(
            agents=list(agents.values()),
            tasks=tasks,
-            process="sequential",
-            verbose=False
+            process="sequential", output="minimal"
        )
        
        job_status[job_id]["progress"] = 30
@@ -2,7 +2,7 @@ from praisonaiagents import Agent, MCP

 search_agent = Agent(
    instructions="""You are a weather agent that can provide weather information for a given city.""",
-    llm="openai/gpt-5-nano",
+    llm="openai/gpt-4o-mini",
    tools=MCP("http://localhost:8080/sse")
 )
 search_agent.launch(path="/weather", port=3030)
@@ -1,4 +1,4 @@
 from praisonaiagents import Agent

-agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-5-nano")
+agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
 agent.launch(path="/ask", port=3030)
@@ -0,0 +1,52 @@
+"""
+Basic Agent Autonomy Example.
+
+This example demonstrates the core autonomy features with a real API call.
+Run with: python 00_autonomy_basic.py
+
+Requirements:
+- OPENAI_API_KEY environment variable set
+"""
+
+from praisonaiagents import Agent
+
+def main():
+    # Create an agent with autonomy enabled
+    agent = Agent(
+        instructions="You are a helpful assistant. Be concise.",
+        autonomy=True,
+    )
+    
+    print("=" * 50)
+    print("Agent Autonomy Basic Example")
+    print("=" * 50)
+    
+    # Test 1: Signal detection (no API call)
+    print("\n1. Signal Detection (fast, no API call):")
+    prompts = [
+        "What is Python?",
+        "Read src/main.py and explain it",
+        "Refactor the auth module and add tests",
+    ]
+    
+    for prompt in prompts:
+        stage = agent.get_recommended_stage(prompt)
+        print(f"   '{prompt[:40]}...' → {stage}")
+    
+    # Test 2: Simple chat with autonomy (real API call)
+    print("\n2. Simple Chat (real API call):")
+    response = agent.chat("What is 2 + 2? Answer with just the number.")
+    print(f"   Response: {response}")
+    
+    # Test 3: Check autonomy status
+    print("\n3. Autonomy Status:")
+    print(f"   Enabled: {agent.autonomy_enabled}")
+    print(f"   Config: {agent.autonomy_config}")
+    
+    print("\n" + "=" * 50)
+    print("✓ Basic autonomy example completed successfully!")
+    print("=" * 50)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,94 @@
+"""
+Advanced Agent Autonomy Example.
+
+Demonstrates advanced autonomy features:
+- Custom configuration
+- Doom loop detection
+- Verification hooks
+- Subagent delegation
+
+Run with: python 01_autonomy_advanced.py
+
+Requirements:
+- OPENAI_API_KEY environment variable set
+"""
+
+from praisonaiagents import Agent
+from praisonaiagents.agents.profiles import get_profile, BUILTIN_PROFILES
+
+
+def main():
+    print("=" * 60)
+    print("Agent Autonomy Advanced Example")
+    print("=" * 60)
+    
+    # 1. Custom autonomy configuration
+    print("\n1. Custom Autonomy Configuration:")
+    agent = Agent(
+        instructions="You are a coding assistant.",
+        autonomy={
+            "max_iterations": 30,
+            "doom_loop_threshold": 5,
+            "auto_escalate": True,
+        },
+    )
+    print(f"   Max iterations: {agent.autonomy_config.get('max_iterations')}")
+    print(f"   Doom loop threshold: {agent.autonomy_config.get('doom_loop_threshold')}")
+    print(f"   Auto escalate: {agent.autonomy_config.get('auto_escalate')}")
+    
+    # 2. Doom loop detection
+    print("\n2. Doom Loop Detection:")
+    for i in range(5):
+        agent._record_action("read_file", {"path": "test.py"}, "content", True)
+    
+    is_doom = agent._is_doom_loop()
+    print(f"   After 5 repeated actions: doom_loop={is_doom}")
+    
+    agent._reset_doom_loop()
+    is_doom_after = agent._is_doom_loop()
+    print(f"   After reset: doom_loop={is_doom_after}")
+    
+    # 3. Verification hooks
+    print("\n3. Verification Hooks:")
+    
+    class MockTestRunner:
+        name = "pytest"
+        def run(self, context=None):
+            return {"success": True, "output": "5 tests passed"}
+    
+    agent_with_hooks = Agent(
+        instructions="You are a test-driven developer.",
+        autonomy=True,
+        verification_hooks=[MockTestRunner()],
+    )
+    
+    results = agent_with_hooks._run_verification_hooks()
+    print(f"   Hook results: {results}")
+    
+    # 4. Subagent delegation
+    print("\n4. Subagent Delegation:")
+    subagent = agent._create_subagent("explorer")
+    print(f"   Created subagent: {subagent.name}")
+    print(f"   Profile: explorer (read-only)")
+    
+    # 5. Explorer profile details
+    print("\n5. Explorer Profile:")
+    explorer = get_profile("explorer")
+    print(f"   Tools: {explorer.tools}")
+    print(f"   Read-only: {explorer.metadata.get('read_only')}")
+    print(f"   Blocked tools: {explorer.metadata.get('blocked_tools')}")
+    
+    # 6. Available profiles
+    print("\n6. Available Agent Profiles:")
+    for name in BUILTIN_PROFILES:
+        profile = get_profile(name)
+        if not profile.hidden:
+            print(f"   - {name}: {profile.description[:50]}...")
+    
+    print("\n" + "=" * 60)
+    print("✓ Advanced autonomy example completed successfully!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,51 @@
+"""
+run_autonomous() Example.
+
+Demonstrates the unified autonomous loop with real API calls.
+
+Run with: python 02_run_autonomous.py
+
+Requirements:
+- OPENAI_API_KEY environment variable set
+"""
+
+from praisonaiagents import Agent
+
+
+def main():
+    print("=" * 60)
+    print("run_autonomous() Example")
+    print("=" * 60)
+    
+    # Create agent with autonomy
+    agent = Agent(
+        instructions="You are a helpful assistant. When asked a question, provide a clear answer and say 'Task completed' at the end.",
+        autonomy={"max_iterations": 5},
+    )
+    
+    # Test 1: Simple task (should complete in 1 iteration)
+    print("\n1. Simple Task (direct stage):")
+    result = agent.run_autonomous(
+        "What is the capital of France? Say 'Task completed' after answering.",
+        max_iterations=3,
+    )
+    
+    print(f"   Success: {result.success}")
+    print(f"   Completion reason: {result.completion_reason}")
+    print(f"   Iterations: {result.iterations}")
+    print(f"   Stage: {result.stage}")
+    print(f"   Duration: {result.duration_seconds:.2f}s")
+    print(f"   Output: {result.output[:100]}...")
+    
+    # Test 2: Check result attributes
+    print("\n2. Result Attributes:")
+    print(f"   Has actions: {len(result.actions) > 0}")
+    print(f"   Has error: {result.error is not None}")
+    
+    print("\n" + "=" * 60)
+    print("✓ run_autonomous() example completed successfully!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,110 @@
+"""
+Verification Hooks Example.
+
+Demonstrates how to use verification hooks with Agent autonomy.
+
+Run with: python 03_verification_hooks.py
+
+Requirements:
+- OPENAI_API_KEY environment variable set
+"""
+
+from praisonaiagents import Agent
+
+# Agent-centric quickstart
+agent = Agent(
+    name="VerificationHooksDemo",
+    instructions="You are a helpful assistant demonstrating verification hooks."
+)
+
+# --- Advanced: Low-level Verification API ---
+from praisonaiagents.hooks.verification import (
+    VerificationHook,
+    VerificationResult,
+    BaseVerificationHook,
+    CommandVerificationHook,
+)
+
+
+class SimpleTestHook(BaseVerificationHook):
+    """A simple test verification hook."""
+    
+    name = "simple_test"
+    
+    def _execute(self, context=None):
+        return VerificationResult(
+            success=True,
+            output="All tests passed!",
+            details={"tests_run": 5, "passed": 5, "failed": 0},
+        )
+
+
+class LintHook(BaseVerificationHook):
+    """A lint verification hook."""
+    
+    name = "lint"
+    
+    def _execute(self, context=None):
+        return VerificationResult(
+            success=True,
+            output="No lint errors found",
+            details={"files_checked": 10, "errors": 0, "warnings": 2},
+        )
+
+
+def main():
+    print("=" * 60)
+    print("Verification Hooks Example")
+    print("=" * 60)
+    
+    # 1. Create hooks
+    print("\n1. Creating Verification Hooks:")
+    test_hook = SimpleTestHook()
+    lint_hook = LintHook()
+    
+    print(f"   - {test_hook.name}: {type(test_hook).__name__}")
+    print(f"   - {lint_hook.name}: {type(lint_hook).__name__}")
+    
+    # 2. Run hooks manually
+    print("\n2. Running Hooks Manually:")
+    test_result = test_hook.run()
+    lint_result = lint_hook.run()
+    
+    print(f"   Test result: success={test_result.success}, output='{test_result.output}'")
+    print(f"   Lint result: success={lint_result.success}, output='{lint_result.output}'")
+    
+    # 3. Create agent with verification hooks
+    print("\n3. Agent with Verification Hooks:")
+    agent = Agent(
+        instructions="You are a test-driven developer.",
+        autonomy=True,
+        verification_hooks=[test_hook, lint_hook],
+    )
+    
+    print(f"   Hooks registered: {len(agent._verification_hooks)}")
+    
+    # 4. Run verification hooks through agent
+    print("\n4. Running Hooks Through Agent:")
+    results = agent._run_verification_hooks()
+    
+    for result in results:
+        print(f"   - {result['hook']}: success={result['success']}")
+    
+    # 5. CommandVerificationHook example (without running)
+    print("\n5. CommandVerificationHook (structure only):")
+    cmd_hook = CommandVerificationHook(
+        name="pytest",
+        command=["python", "-m", "pytest", "-v"],
+        timeout=30.0,
+    )
+    print(f"   Name: {cmd_hook.name}")
+    print(f"   Command: {cmd_hook.command}")
+    print(f"   Timeout: {cmd_hook.timeout_seconds}s")
+    
+    print("\n" + "=" * 60)
+    print("✓ Verification hooks example completed successfully!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()
@@ -28,7 +28,7 @@ def capture_and_analyze():
        role="Camera Feed Analyzer",
        goal="Analyze camera captures in real-time",
        backstory="Expert in real-time visual analysis with computer vision skills",
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    # Initialize camera (0 for default camera)
@@ -42,7 +42,7 @@ class ContinuousCameraMonitor:
            role="Security Camera Analyst",
            goal="Monitor camera feeds for activities and security events",
            backstory="Expert security analyst with computer vision skills specialized in real-time monitoring",
-            llm="gpt-5-nano"
+            llm="gpt-4o-mini"
        )
    
    def capture_frame(self, cap):
@@ -57,7 +57,7 @@ def analyze_with_multiple_agents():
        role="Security Specialist",
        goal="Identify security threats and suspicious activities",
        backstory="Expert security analyst with years of experience in surveillance and threat detection",
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    object_detector = Agent(
@@ -65,7 +65,7 @@ def analyze_with_multiple_agents():
        role="Object Recognition Specialist", 
        goal="Identify and catalog all objects in the scene",
        backstory="Computer vision expert specializing in object detection and classification",
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    scene_analyst = Agent(
@@ -73,7 +73,7 @@ def analyze_with_multiple_agents():
        role="Scene Understanding Expert",
        goal="Provide comprehensive scene analysis and context",
        backstory="Environmental analyst expert in understanding spatial relationships and scene context",
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    # Create specialized tasks
@@ -39,7 +39,7 @@ class CameraVideoAnalyzer:
            role="Video Content Analyzer",
            goal="Analyze video content for activities, objects, and events",
            backstory="Expert in video analysis and temporal event detection with computer vision expertise",
-            llm="gpt-5-nano"
+            llm="gpt-4o-mini"
        )
    
    def record_video_segment(self, duration_seconds=10):
@@ -13,7 +13,7 @@ async def main():
        workspace=".",
        output_format="json",
        force=True,
-        model="gpt-5",
+        model="gpt-4o",
        stream_partial=True
    )
    
@@ -34,7 +34,7 @@ class ContextEngineeringWorkflow:
    to achieve higher success rates in AI-driven development tasks.
    """
    
-    def __init__(self, project_path: str, llm: str = "gpt-5-nano"):
+    def __init__(self, project_path: str, llm: str = "gpt-4o-mini"):
        self.project_path = project_path
        self.llm = llm
        self.context_data = {}
@@ -59,16 +59,12 @@ class ContextEngineeringWorkflow:
            4. Define success metrics
            5. Specify technical constraints
            """,
-            llm=self.llm,
-            verbose=True
-        )
+            llm=self.llm)
        
        # 2. Context Engineering Agent - Generates comprehensive context
        self.context_engineer = create_context_agent(
            llm=self.llm,
-            name="Context Engineering Specialist",
-            verbose=True
-        )
+            name="Context Engineering Specialist")
        
        # 3. Software Architect Agent - Designs implementation using context
        self.architect = Agent(
@@ -87,9 +83,7 @@ class ContextEngineeringWorkflow:
            4. Consider security and performance implications
            5. Document architectural decisions and rationale
            """,
-            llm=self.llm,
-            verbose=True
-        )
+            llm=self.llm)
        
        # 4. Senior Developer Agent - Implements using context-enhanced guidance
        self.developer = Agent(
@@ -107,9 +101,7 @@ class ContextEngineeringWorkflow:
            4. Write clean, maintainable code
            5. Follow the implementation blueprint exactly
            """,
-            llm=self.llm,
-            verbose=True
-        )
+            llm=self.llm)
        
        # 5. QA Engineer Agent - Validates using context-generated criteria
        self.qa_engineer = Agent(
@@ -127,9 +119,7 @@ class ContextEngineeringWorkflow:
            4. Check for security vulnerabilities
            5. Validate performance requirements
            """,
-            llm=self.llm,
-            verbose=True
-        )
+            llm=self.llm)
    
    def run_context_engineering_workflow(self, feature_request: str):
        """
@@ -325,8 +315,7 @@ class ContextEngineeringWorkflow:
                implementation_task,
                qa_task
            ],
-            process="sequential",
-            verbose=True
+            process="sequential", output="verbose"
        )
        
        # Execute workflow
@@ -382,7 +371,7 @@ def run_example_workflow():
    project_path = str(project_root)
    workflow = ContextEngineeringWorkflow(
        project_path=project_path,
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    # Example feature request
@@ -446,7 +435,7 @@ if __name__ == "__main__":
    print("(Note: Full execution requires complete environment setup)")
    
    project_path = str(project_root)
-    workflow = ContextEngineeringWorkflow(project_path, "gpt-5-nano")
+    workflow = ContextEngineeringWorkflow(project_path, "gpt-4o-mini")
    
    print(f"\n✅ Workflow Setup Complete:")
    print(f"   • Project path: {project_path}")
@@ -68,7 +68,7 @@ def method_1_simple_loop():
        goal="Process each task from the CSV file efficiently",
        backstory="Expert at handling repetitive tasks from CSV data",
        instructions="Process each task thoroughly and provide detailed output",
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    # Create a loop task that will automatically process each CSV row
@@ -127,7 +127,7 @@ def method_2_manual_csv():
        4. Create a summary of the processing results
        5. Save results to a new CSV file if needed
        """,
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    # Create a task for manual CSV processing
@@ -187,7 +187,7 @@ def method_3_url_processing():
        4. Create a detailed analysis report
        5. Save results with analysis data
        """,
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    # Create the URL processing task
@@ -264,7 +264,7 @@ def method_4_advanced_processing():
        4. Create separate files for valid and invalid data
        5. Provide detailed validation reports
        """,
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    # Create a processing agent
@@ -281,7 +281,7 @@ def method_4_advanced_processing():
        3. Generate comprehensive results
        4. Create detailed output reports
        """,
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    # Create validation task
@@ -24,9 +24,7 @@ knowledge_agent = Agent(
    goal="Store and retrieve knowledge efficiently",
    backstory="Expert in managing and utilizing stored knowledge",
    knowledge=["sample.pdf"],
-    knowledge_config=config,
-    verbose=True
-)
+    knowledge_config=config)

 # Define a task for the agent
 knowledge_task = Task(
@@ -140,7 +140,7 @@ def main():
        instructions="You are an AI research assistant. Use your knowledge base to answer questions about artificial intelligence topics.",
        knowledge=sample_documents,  # Will use default knowledge config
        knowledge_config=rerank_config,  # Use reranking config
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    print("7. Agent with reranking knowledge:")
@@ -16,7 +16,7 @@ rag_agent = Agent(
    name="RAG Agent",
    role="Information Specialist",
    goal="Retrieve knowledge efficiently",
-    llm="gpt-5-nano"
+    llm="gpt-4o-mini"
 )

 # Define a task for the agent
@@ -103,8 +103,7 @@ def demonstrate_reasoning_extraction():
    workflow = Agents(
        agents=[cot_agent, reasoning_extractor],
        tasks=[problem_task, extract_task],
-        process="sequential",
-        verbose=True
+        process="sequential", output="verbose"
    )
    
    return workflow.start()
@@ -187,8 +186,7 @@ def advanced_reasoning_patterns():
    workflow = Agents(
        agents=[cot_agent, reasoning_validator],
        tasks=[deductive_task, inductive_task, abductive_task, validation_task],
-        process="sequential",
-        verbose=True
+        process="sequential", output="verbose"
    )
    
    return workflow.start()
@@ -2,7 +2,7 @@ from praisonaiagents import Agent, Task, Agents

 agent = Agent(
    instructions="You are a loop agent that creating a loop of tasks.",
-    llm="gpt-5-nano"
+    llm="gpt-4o-mini"
 )

 task = Task(
@@ -80,8 +80,7 @@ def conditional_routing_example():
    workflow = Agents(
        agents=[analyzer_agent, processor_agent],
        tasks=[analysis_task, premium_task, standard_task, basic_task],
-        process="workflow",
-        verbose=True
+        process="workflow", output="verbose"
    )
    
    return workflow.start()
@@ -113,8 +112,7 @@ def loop_pattern_example():
    workflow = Agents(
        agents=[processor_agent, validator_agent],
        tasks=[process_task, finalize_task],
-        process="workflow",
-        verbose=True
+        process="workflow", output="verbose"
    )
    
    return workflow.start()
@@ -188,8 +186,7 @@ def decision_tree_example():
    workflow = Agents(
        agents=[analyzer_agent, processor_agent],
        tasks=all_tasks,
-        process="workflow",
-        verbose=True
+        process="workflow", output="verbose"
    )
    
    return workflow.start()
@@ -275,8 +272,7 @@ def dynamic_routing_example():
    workflow = Agents(
        agents=[dynamic_router, processor_agent],
        tasks=[route_task, escalate_task, automate_task, review_task, standard_task],
-        process="workflow",
-        verbose=True
+        process="workflow", output="verbose"
    )
    
    return workflow.start()
@@ -165,8 +165,7 @@ def reflection_workflow_example():
    workflow = Agents(
        agents=[creator_agent, reviewer_agent, polisher_agent],
        tasks=[create_task, review_task, polish_task],
-        process="sequential",
-        verbose=True
+        process="sequential", output="verbose"
    )
    
    return workflow.start()
@@ -17,12 +17,7 @@ reflection_agent = Agent(
    goal="Demonstrate self-reflection and iterative improvement patterns",
    backstory="Expert researcher with strong self-reflection and continuous improvement capabilities",
    tools=[internet_search],
-    reflection=True,
-    
-    
-    
-    verbose=True
-)
+    reflection=True)

 # Create task that benefits from self-reflection
 reflection_task = Task(
@@ -46,7 +46,7 @@ def main():
        goal="Analyze each URL from the CSV list",
        backstory="Expert at analyzing websites and URLs",
        instructions="Analyze each URL and provide insights about the website",
-        llm="gpt-5-nano"  # You can change this to any supported model
+        llm="gpt-4o-mini"  # You can change this to any supported model
    )
    
    # Step 3: Create a task that will loop through the CSV
@@ -27,7 +27,7 @@ def example_with_tool():
        role="Information Researcher",
        goal="Research and provide information",
        tools=[latency_tracking_tool],  # Add our custom tool
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    # Start tracking manually
@@ -60,7 +60,7 @@ def example_with_wrappers():
        name="Analyst",
        role="Data Analyst",
        goal="Analyze data and provide insights",
-        llm="gpt-5-nano",
+        llm="gpt-4o-mini",
        request_id="request_2"  # Unique request ID
    )
    
@@ -83,7 +83,7 @@ def example_with_context_manager():
        name="Calculator",
        role="Math Expert",
        goal="Solve mathematical problems",
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    request_id = "request_3"
@@ -126,7 +126,7 @@ def example_mcp_tracking():
                name="Assistant",
                role="MCP Assistant",
                goal="Handle MCP requests",
-                llm="gpt-5-nano"
+                llm="gpt-4o-mini"
            )
            plan = agent.chat("Plan: Search for Python documentation")
        
@@ -166,7 +166,7 @@ def example_concurrent_tracking():
                name=f"Agent_{i}",
                role="Concurrent Worker",
                goal="Process requests concurrently",
-                llm="gpt-5-nano"
+                llm="gpt-4o-mini"
            )
            
            with tracker.track("processing", request_id):
@@ -56,7 +56,7 @@ def create_mcp_agent_with_tracking(request_id: str = "mcp_request"):
        name="MCPAssistant",
        role="MCP Request Handler",
        goal="Handle MCP requests with latency tracking",
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    return agent
@@ -23,7 +23,7 @@ def handle_mcp_request(query: str, request_id: str = "mcp_1"):
        name="Assistant",
        role="MCP Handler",
        goal="Process requests",
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    plan = f"I will search for information about {query}"
    time.sleep(0.1)  # Simulate planning time
@@ -29,7 +29,7 @@ qa_generator = Agent(
    role="Question Creator",
    goal="Create challenging math and logic questions",
    backstory="Expert in educational content creation",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=[write_csv, count_questions]
 )

@@ -38,9 +38,8 @@ total_questions_evaluator = Agent(
    role="Total Questions Evaluator",
    goal="Evaluate the total number of questions in qa_pairs.csv file",
    backstory="Expert in evaluating the total number of questions in a file",
-    llm="gpt-5-nano",
-    tools=[count_questions],
-    verbose=False
+    llm="gpt-4o-mini",
+    tools=[count_questions], output="minimal"
 )

 cot_generator = Agent(
@@ -49,8 +48,7 @@ cot_generator = Agent(
    goal="Generate and manage chain of thought solutions for Q&A pairs",
    backstory="Expert in breaking down problems and generating detailed solution steps",
    tools=[cot_save],
-    llm="gpt-5-nano",
-    verbose=False
+    llm="gpt-4o-mini", output="minimal"
 )

 upload_to_huggingface = Agent(
@@ -59,8 +57,7 @@ upload_to_huggingface = Agent(
    goal="Upload the generated chain of thought solutions to a Huggingface dataset",
    backstory="Expert in saving data to Huggingface",
    tools=[cot_upload_to_huggingface],
-    llm="gpt-5-nano",
-    verbose=False
+    llm="gpt-4o-mini", output="minimal"
 )

 # Define tasks with workflow improvements
@@ -135,8 +132,7 @@ agents = Agents(
    agents=[qa_generator, total_questions_evaluator, cot_generator, upload_to_huggingface],
    tasks=[generate_task, evaluate_total_questions_task, generate_cot_task, upload_to_huggingface_task],
    process="workflow",
-    max_iter=30,
-    verbose=False
+    max_iter=30, output="minimal"
 )

 agents.start()
@@ -39,9 +39,7 @@ research_agent = Agent(
    role="Information Researcher",
    goal="Research topics and demonstrate callback monitoring",
    backstory="Expert researcher that demonstrates callback functionality",
-    tools=[internet_search],
-    verbose=True
-)
+    tools=[internet_search])

 # Create a simple task
 research_task = Task(
@@ -99,7 +99,6 @@ sync_agent = Agent(
    backstory="Expert in sync operations and data organization",
    tools=[sync_search_tool],
    reflection=False,
-    verbose=True,
    markdown=True
 )

@@ -110,7 +109,6 @@ async_agent = Agent(
    backstory="Expert in async operations and data organization",
    tools=[async_search_tool],
    reflection=False,
-    verbose=True,
    markdown=True
 )

@@ -54,7 +54,6 @@ async_agent = Agent(
    backstory="Expert in efficient data retrieval and parallel search operations",
    tools=[async_search_tool],
    reflection=False,
-    verbose=True,
    markdown=True
 )

@@ -64,7 +63,6 @@ summary_agent = Agent(
    goal="Create concise summaries from multiple search results",
    backstory="Expert in analyzing and synthesizing information from multiple sources",
    reflection=True,
-    verbose=True,
    markdown=True
 )

@@ -61,7 +61,6 @@ async_agent = Agent(
    backstory="Expert in parallel search operations and data retrieval",
    tools=[async_search_tool],
    reflection=False,
-    verbose=True,
    markdown=True
 )

@@ -73,7 +72,6 @@ summary_agent = Agent(
 Skilled at identifying patterns, trends, and connections between different topics.
 Specializes in creating clear, structured summaries that highlight key insights.""",
    reflection=True,  # Enable self-reflection for better summary quality
-    verbose=True,
    markdown=True
 )

@@ -22,7 +22,6 @@ agents = AutoAgents(
    instructions="Search for information about AI Agents",
    tools=[duckduckgo],
    process="sequential",  # or "hierarchical"
-    verbose=True,
    max_agents=3  # Maximum number of agents to create
 )

@@ -89,8 +89,7 @@ feedback_task = Task(
 workflow = Agents(
    agents=[llm_caller, action_agent, feedback_agent],
    tasks=[monitor_task, action_task, feedback_task],
-    process="workflow",
-    verbose=True
+    process="workflow", output="verbose"
 )

 def main():
@@ -23,13 +23,13 @@ def code_interpreter(code: str):

 code_agent = Agent(
    name="code_agent",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    backstory="Expert in writing Python scripts",
    reflection=False
 )
 execution_agent = Agent(
    name="execution_agent",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    backstory="Expert in executing Python scripts",
    reflection=False,
    tools=[code_interpreter]
@@ -56,8 +56,7 @@ evaluate_task = Task(
 workflow = Agents(
    agents=[generator, evaluator],
    tasks=[generate_task, evaluate_task],
-    process="workflow",
-    verbose=True
+    process="workflow", output="verbose"
 )

 # Run optimization workflow
@@ -124,10 +124,9 @@ def main():
        goal="Uncover cutting-edge developments in AI and data science",
        backstory="""You are an expert at a technology research group, 
        skilled in identifying trends and analyzing complex data.""",
-        verbose=True,
        allow_delegation=False,
        tools=[internet_search_tool],
-        llm="gpt-5-nano",
+        llm="gpt-4o-mini",
        markdown=True,
        
        
@@ -140,9 +139,8 @@ def main():
        goal="Craft compelling content on tech advancements",
        backstory="""You are a content strategist known for 
        making complex tech topics interesting and easy to understand.""",
-        verbose=True,
        allow_delegation=True,
-        llm="gpt-5-nano",
+        llm="gpt-4o-mini",
        tools=[],
        markdown=True
    )
@@ -193,9 +191,8 @@ def main():
    agents = Agents(
        agents=[researcher, writer],
        tasks=[task1, task2, task3, task4],
-        verbose=True,
        process="sequential",
-        manager_llm="gpt-5-nano"
+        manager_llm="gpt-4o-mini"
    )

    agents.start()
@@ -36,10 +36,9 @@ researcher = Agent(
    goal="Uncover cutting-edge developments in AI and data science",
    backstory="""You are an expert at a technology research group, 
    skilled in identifying trends and analyzing complex data.""",
-    verbose=True,
    allow_delegation=False,
    tools=[internet_search_tool],
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    markdown=True,
    
    
@@ -51,9 +50,8 @@ writer = Agent(
    goal="Craft compelling content on tech advancements",
    backstory="""You are a content strategist known for 
    making complex tech topics interesting and easy to understand.""",
-    verbose=True,
    allow_delegation=True,
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=[],
    markdown=True
 )
@@ -102,9 +100,9 @@ task4 = Task(
 agents = Agents(
    agents=[researcher, writer],
    tasks=[task1, task2, task3, task4],
-    verbose=False,
+    output="minimal",
    process="sequential",  # "sequential" or "hierarchical"
-    manager_llm="gpt-5-nano"
+    manager_llm="gpt-4o-mini"
 )

 result = agents.start()
@@ -82,9 +82,7 @@ def main():
        name="Security Demo Agent",
        role="System Administrator",
        goal="Demonstrate human approval for dangerous operations",
-        tools=[python_tools, file_tools, shell_tools],
-        verbose=True
-    )
+        tools=[python_tools, file_tools, shell_tools])
    
    # Define tasks that will trigger approval prompts
    tasks = [
@@ -113,8 +111,7 @@ def main():
    # Create and run process
    process = Agents(
        agents=[agent],
-        tasks=tasks,
-        verbose=True
+        tasks=tasks, output="verbose"
    )
    
    print("\n🚀 Starting process with approval-required operations...")
@@ -160,9 +157,7 @@ async def async_demo():
        name="Async Demo Agent",
        role="Async Operations Specialist", 
        goal="Demonstrate async approval workflow",
-        tools=[python_tools],
-        verbose=True
-    )
+        tools=[python_tools])
    
    # This would trigger approval in async context
    task = Task(
@@ -173,8 +168,7 @@ async def async_demo():
    
    process = Agents(
        agents=[agent],
-        tasks=[task],
-        verbose=True
+        tasks=[task], output="verbose"
    )
    
    try:
@@ -23,8 +23,7 @@ task = Task(
 # Create and start the workflow
 agents = Agents(
    agents=[agent],
-    tasks=[task],
-    verbose=True
+    tasks=[task], output="verbose"
 )

 agents.start()
@@ -33,14 +33,14 @@ def main():
        role="Research Analyst",
        goal="Research and document key information about topics",
        backstory="Expert at analyzing and storing information in memory",
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    retriever = Agent(
        role="Information Retriever",
        goal="Retrieve and verify stored information from memory",
        backstory="Specialist in searching and validating information from memory",
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )

    # Task 1: Process the facts
@@ -103,8 +103,7 @@ def main():
    # Initialize Agents with memory configuration
    agents = Agents(
        agents=[researcher, retriever],
-        tasks=[store_task, verify_task, query_task, query_both_task],
-        verbose=True,  # Use same verbose level as memory
+        tasks=[store_task, verify_task, query_task, query_both_task],  # Use same verbose level as memory
        memory=True,
        embedder={
            "provider": "openai",
@@ -117,7 +116,7 @@ def main():
    # agents = Agents(
    #     agents=[researcher, retriever],
    #     tasks=[store_task, verify_task, query_task, query_both_task],
-    #     verbose=True,  # Use same verbose level as memory
+    #     # Use same verbose level as memory
    #     memory=True
    # )
    
@@ -9,19 +9,19 @@ fact3 = "The year the first Josinga was released is 2007"
 fact_agent = Agent(
    name="Fact Agent",
    instructions="You are a fact agent, you store and retrieve facts in memory",
-    llm="gpt-5-nano"
+    llm="gpt-4o-mini"
 )

 research_agent = Agent(
    name="Research Agent",
    instructions="You are a research analyst, you research and document key points about topics",
-    llm="gpt-5-nano"
+    llm="gpt-4o-mini"
 )

 blog_agent = Agent(
    name="Blog Agent",
    instructions="You are a blog writer, you write a blog post about the research",
-    llm="gpt-5-nano"
+    llm="gpt-4o-mini"
 )

 fact_task = Task(
@@ -7,7 +7,7 @@ vision_agent = Agent(
    goal="Analyze images and videos to extract meaningful information",
    backstory="""You are an expert in computer vision and image analysis.
    You excel at describing images, detecting objects, and understanding visual content.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    reflection=False
 )

@@ -96,8 +96,7 @@ synthesize_task = Task(
 workflow = Agents(
    agents=[router, worker1, worker2, worker3, synthesizer],
    tasks=[router_task, worker1_task, worker2_task, worker3_task, synthesize_task],
-    process="workflow",
-    verbose=True
+    process="workflow", output="verbose"
 )

 # Run orchestrated workflow
@@ -68,7 +68,7 @@ workflow = Agents(
    agents=[agent1, agent2, agent3],
    tasks=[initial_task, analysis_task, final_task],
    process="workflow",  # Use workflow process type
-    verbose=True
+    output="verbose"
 )

 # Run the workflow
@@ -12,8 +12,7 @@ researcher = Agent(
    role="Technology Research Analyst",
    goal="Analyze and structure information about AI developments",
    backstory="Expert analyst specializing in AI technology trends",
-    verbose=True,
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=[Tools.internet_search],
    reflection=False
 )
@@ -24,8 +23,7 @@ analyst = Agent(
    role="Data Insights Specialist",
    goal="Structure and analyze research findings",
    backstory="Senior data analyst with expertise in pattern recognition",
-    verbose=True,
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    reflection=False
 )

@@ -50,7 +48,7 @@ agents = Agents(
    agents=[researcher, analyst],
    tasks=[research_task, analysis_task],
    process="sequential",
-    verbose=True
+    output="verbose"
 )
 result = agents.start()
 print(result)
@@ -35,7 +35,7 @@ def get_structured_analysis(query: str, verbose: bool = True) -> AnalysisReport:
        verbose=verbose,
        reflection=True,  # Enable self-reflection for better quality
        markdown=True,
-        llm="gpt-5-nano"
+        llm="gpt-4o-mini"
    )
    
    # Create the analysis prompt
@@ -108,8 +108,7 @@ task = Task(
 # Create and start the workflow
 agents = Agents(
    agents=[agent],
-    tasks=[task],
-    verbose=True
+    tasks=[task], output="verbose"
 )

 agents.start()
@@ -183,8 +183,7 @@ llm_guardrail_task = Task(
 # Execute tasks with guardrails
 agents = Agents(
    agents=[email_agent, content_agent, business_agent, research_agent, llm_guardrail_agent],
-    tasks=[email_task, content_task, business_task, research_task, llm_guardrail_task],
-    verbose=True
+    tasks=[email_task, content_task, business_task, research_task, llm_guardrail_task], output="verbose"
 )

 print("="*80)
@@ -39,9 +39,7 @@ production_agent = Agent(
    backstory="Production-ready agent with built-in safety and compliance checks",
    tools=[internet_search],
    guardrails=content_guardrail,
-    max_retries=3,
-    verbose=True
-)
+    max_retries=3)

 # Create secure task with validation
 secure_task = Task(
@@ -0,0 +1,182 @@
+"""
+Unified Handoff Configuration Example.
+
+Demonstrates the new HandoffConfig features:
+- Context policies (full, summary, none, last_n)
+- Cycle detection
+- Max depth limiting
+- Timeout configuration
+- Programmatic handoff via Agent.handoff_to()
+"""
+
+from praisonaiagents import Agent, handoff, HandoffConfig, ContextPolicy
+
+# Create specialized agents
+research_agent = Agent(
+    name="Research Agent",
+    role="Research Specialist",
+    goal="Conduct thorough research on topics",
+    backstory="Expert researcher with access to comprehensive knowledge bases."
+)
+
+writer_agent = Agent(
+    name="Writer Agent",
+    role="Content Writer",
+    goal="Create well-written content based on research",
+    backstory="Professional writer skilled in creating engaging content."
+)
+
+editor_agent = Agent(
+    name="Editor Agent",
+    role="Content Editor",
+    goal="Review and polish written content",
+    backstory="Experienced editor with keen eye for quality and clarity."
+)
+
+# Create coordinator with handoffs using new config options
+coordinator = Agent(
+    name="Coordinator",
+    role="Project Coordinator",
+    goal="Coordinate tasks between specialized agents",
+    backstory="Expert at understanding requirements and delegating to the right specialist.",
+    instructions="""Analyze the request and delegate to the appropriate specialist:
+    - For research tasks, use transfer_to_research_agent
+    - For writing tasks, use transfer_to_writer_agent
+    - For editing tasks, use transfer_to_editor_agent
+    Always explain your delegation decision.""",
+    handoffs=[
+        # Handoff with summary context policy (default - safe)
+        handoff(
+            research_agent,
+            context_policy="summary",
+            timeout_seconds=120,
+            max_depth=5,
+        ),
+        # Handoff with full context
+        handoff(
+            writer_agent,
+            context_policy="full",
+            timeout_seconds=180,
+        ),
+        # Handoff with custom config
+        handoff(
+            editor_agent,
+            config=HandoffConfig(
+                context_policy=ContextPolicy.LAST_N,
+                max_context_messages=5,
+                detect_cycles=True,
+                max_depth=3,
+            ),
+        ),
+    ]
+)
+
+
+def demo_llm_driven_handoff():
+    """Demonstrate LLM-driven handoff via tool calls."""
+    print("=" * 60)
+    print("Demo 1: LLM-Driven Handoff")
+    print("=" * 60)
+    
+    response = coordinator.chat("I need to research the latest trends in AI agents")
+    print(f"\nFinal Response:\n{response}")
+
+
+def demo_programmatic_handoff():
+    """Demonstrate programmatic handoff via Agent.handoff_to()."""
+    print("\n" + "=" * 60)
+    print("Demo 2: Programmatic Handoff (Agent.handoff_to)")
+    print("=" * 60)
+    
+    # Create a simple agent for programmatic handoff
+    source_agent = Agent(
+        name="Source Agent",
+        role="Task Initiator",
+        goal="Initiate tasks and hand them off",
+    )
+    
+    target_agent = Agent(
+        name="Target Agent",
+        role="Task Executor",
+        goal="Execute delegated tasks",
+    )
+    
+    # Programmatic handoff with custom config
+    config = HandoffConfig(
+        context_policy=ContextPolicy.SUMMARY,
+        timeout_seconds=60,
+        detect_cycles=True,
+    )
+    
+    result = source_agent.handoff_to(
+        target_agent,
+        prompt="Summarize the key benefits of multi-agent systems",
+        config=config,
+    )
+    
+    print(f"\nHandoff Result:")
+    print(f"  Success: {result.success}")
+    print(f"  Target: {result.target_agent}")
+    print(f"  Duration: {result.duration_seconds:.2f}s")
+    if result.response:
+        print(f"  Response: {result.response[:200]}...")
+
+
+def demo_handoff_chain():
+    """Demonstrate a handoff chain with depth tracking."""
+    print("\n" + "=" * 60)
+    print("Demo 3: Handoff Chain")
+    print("=" * 60)
+    
+    # Create a chain: Analyst -> Researcher -> Writer
+    analyst = Agent(
+        name="Analyst",
+        role="Requirements Analyst",
+        goal="Analyze requirements and delegate research",
+    )
+    
+    researcher = Agent(
+        name="Researcher",
+        role="Research Specialist",
+        goal="Research topics and provide findings",
+    )
+    
+    writer = Agent(
+        name="Writer",
+        role="Technical Writer",
+        goal="Write documentation based on research",
+    )
+    
+    # Chain: Analyst hands off to Researcher
+    result1 = analyst.handoff_to(
+        researcher,
+        prompt="Research best practices for agent handoffs",
+        config=HandoffConfig(max_depth=5),
+    )
+    print(f"\nStep 1 - Analyst -> Researcher:")
+    print(f"  Success: {result1.success}")
+    print(f"  Depth: {result1.handoff_depth}")
+    
+    # Researcher hands off to Writer
+    if result1.success:
+        result2 = researcher.handoff_to(
+            writer,
+            prompt=f"Write documentation based on: {result1.response[:100] if result1.response else 'research findings'}",
+            config=HandoffConfig(max_depth=5),
+        )
+        print(f"\nStep 2 - Researcher -> Writer:")
+        print(f"  Success: {result2.success}")
+        print(f"  Depth: {result2.handoff_depth}")
+
+
+if __name__ == "__main__":
+    print("\n🤝 Unified Handoff Configuration Demo\n")
+    
+    # Run demos
+    demo_llm_driven_handoff()
+    demo_programmatic_handoff()
+    demo_handoff_chain()
+    
+    print("\n" + "=" * 60)
+    print("All demos completed!")
+    print("=" * 60)
@@ -16,7 +16,7 @@ class DynamicAgentSystem:
    def __init__(self):
        self.user_preferences = {}
        self.llm_config = {
-            "model": os.getenv("LLM_MODEL", "gpt-5-nano"),
+            "model": os.getenv("LLM_MODEL", "gpt-4o-mini"),
            "temperature": 0.7
        }
    
@@ -13,7 +13,7 @@ default_topic = os.getenv("RESEARCH_TOPIC", "AI trends")
 user_topic = input(f"Topic to research [{default_topic}]: ") or default_topic

 # Get other configuration from environment
-llm_model = os.getenv("LLM_MODEL", "gpt-5-nano")
+llm_model = os.getenv("LLM_MODEL", "gpt-4o-mini")
 temperature = float(os.getenv("LLM_TEMPERATURE", "0.7"))
 max_retries = int(os.getenv("MAX_RETRIES", "3"))

@@ -30,7 +30,7 @@ with st.sidebar:
    # Model selection
    model = st.selectbox(
        "Select Model",
-        ["gpt-5-nano", "gpt-5-nano", "gpt-3.5-turbo", "claude-3-opus"],
+        ["gpt-4o-mini", "gpt-4o-mini", "gpt-3.5-turbo", "claude-3-opus"],
        index=0
    )
    
@@ -105,10 +105,7 @@ knowledge_agent = Agent(
    instructions="""You are an expert in healthcare AI. Use the knowledge base to provide 
    comprehensive, accurate answers. Always cite specific information from the documents 
    when possible. If the knowledge base doesn't contain sufficient information, clearly 
-    state this and provide general guidance based on your training.""",
-    
-    verbose=True
-)
+    state this and provide general guidance based on your training.""")

 # Test advanced knowledge retrieval with various question types

@@ -2,7 +2,7 @@ from praisonaiagents import Agent, MCP

 search_agent = Agent(
    instructions="""You help book apartments on Airbnb.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @openbnb/mcp-server-airbnb --ignore-robots-txt")
 )

@@ -10,7 +10,7 @@ aws_region = os.getenv("AWS_REGION")
 aws_kb_agent = Agent(
    instructions="""You are a helpful assistant that can interact with AWS Knowledge Base.
    Use the available tools when relevant to retrieve and process AWS information.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-aws-kb-retrieval",
              env={
                  "AWS_ACCESS_KEY_ID": aws_access_key,
@@ -8,7 +8,7 @@ brave_api_key = os.getenv("BRAVE_API_KEY")
 search_agent = Agent(
    instructions="""You are a helpful assistant that can search the web for information.
    Use the available tools when relevant to answer user questions.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-brave-search", env={"BRAVE_API_KEY": brave_api_key})
 )

@@ -3,7 +3,7 @@ from praisonaiagents import Agent, MCP
 agent = Agent(
    instructions="""You are a helpful assistant that can check stock prices and perform other tasks.
    Use the available tools when relevant to answer user questions.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools = MCP("/Users/praison/miniconda3/envs/mcp/bin/python /Users/praison/stockprice/app.py")
 )

@@ -8,7 +8,7 @@ databutton_api_key = os.getenv("DATABUTTON_API_KEY")
 databutton_agent = Agent(
    instructions="""You are a helpful assistant that can interact with Databutton.
    Use the available tools when relevant to answer user questions.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("uvx databutton-app-mcp@latest", env={"DATABUTTON_API_KEY": databutton_api_key})
 )

@@ -8,7 +8,7 @@ everart_api_key = os.getenv("EVERART_API_KEY")
 everart_agent = Agent(
    instructions="""You are a helpful assistant that can interact with Everart.
    Use the available tools when relevant to generate and manage art.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-everart",
              env={"EVERART_API_KEY": everart_api_key})
 )
@@ -6,7 +6,7 @@ import os
 fetch_agent = Agent(
    instructions="""You are a helpful assistant that can fetch and process web content.
    Use the available tools when relevant to retrieve and convert web pages to markdown.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("python -m mcp_server_fetch")
 )

@@ -11,7 +11,7 @@ allowed_dirs = [
 filesystem_agent = Agent(
    instructions="""You are a helpful assistant that can interact with the filesystem.
    Use the available tools when relevant to manage files and directories.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-filesystem", args=allowed_dirs)
 )

@@ -8,7 +8,7 @@ gdrive_credentials = os.getenv("GDRIVE_CREDENTIALS_PATH", "servers/gcp-oauth.key
 gdrive_agent = Agent(
    instructions="""You are a helpful assistant that can interact with Google Drive.
    Use the available tools when relevant to manage files and folders.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-gdrive",
              env={"GDRIVE_CREDENTIALS_PATH": gdrive_credentials})
 )
@@ -11,7 +11,7 @@ git_token = os.getenv("GIT_TOKEN")  # For private repos
 git_agent = Agent(
    instructions="""You are a helpful assistant that can perform Git operations.
    Use the available tools when relevant to manage repositories, commits, and branches.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("python -m mcp_server_git",
              env={
                  "GIT_USERNAME": git_username,
@@ -8,7 +8,7 @@ github_token = os.getenv("GITHUB_PERSONAL_ACCESS_TOKEN")
 github_agent = Agent(
    instructions="""You are a helpful assistant that can interact with GitHub.
    Use the available tools when relevant to answer user questions.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-github", env={"GITHUB_PERSONAL_ACCESS_TOKEN": github_token})
 )

@@ -9,7 +9,7 @@ gitlab_api_url = os.getenv("GITLAB_API_URL", "https://gitlab.com/api/v4")
 gitlab_agent = Agent(
    instructions="""You are a helpful assistant that can interact with GitLab.
    Use the available tools when relevant to answer user questions.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-gitlab", 
              env={
                  "GITLAB_PERSONAL_ACCESS_TOKEN": gitlab_token,
@@ -8,7 +8,7 @@ maps_api_key = os.getenv("GOOGLE_MAPS_API_KEY")
 maps_agent = Agent(
    instructions="""You are a helpful assistant that can interact with Google Maps.
    Use the available tools when relevant to handle location-based queries.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-google-maps",
              env={"GOOGLE_MAPS_API_KEY": maps_api_key})
 )
@@ -2,7 +2,7 @@ from praisonaiagents import Agent, MCP

 search_agent = Agent(
    instructions="""You are a weather agent that can provide weather information for a given city.""",
-    llm="openai/gpt-5-nano",
+    llm="openai/gpt-4o-mini",
    tools=MCP("http://localhost:8080/sse")
 )

@@ -8,7 +8,7 @@ memory_file_path = os.getenv("MEMORY_FILE_PATH", "/path/to/custom/memory.json")
 memory_agent = Agent(
    instructions="""You are a helpful assistant that can store and retrieve information.
    Use the available tools when relevant to manage memory operations.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-memory",
              env={"MEMORY_FILE_PATH": memory_file_path})
 )
@@ -2,7 +2,7 @@ from praisonaiagents import Agent, MCP

 search_agent = Agent(
    instructions="""You help book apartments on Airbnb.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @openbnb/mcp-server-airbnb --ignore-robots-txt")
 )

@@ -5,7 +5,7 @@ api_key = os.getenv("PERPLEXITY_API_KEY")

 agent = Agent(
    instructions="You are a helpful assistant that can search the web for information. Use the available tools when relevant to answer user questions.",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("uvx perplexity-mcp", 
        env={"PERPLEXITY_API_KEY": api_key, "PERPLEXITY_MODEL": "sonar" })
 )
@@ -2,7 +2,7 @@ from praisonaiagents import Agent, MCP

 search_agent = Agent(
    instructions="""You help search the web.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("http://localhost:8931/sse")
 )

@@ -8,7 +8,7 @@ postgres_url = "postgresql://localhost/mydb"
 postgres_agent = Agent(
    instructions="""You are a helpful assistant that can interact with PostgreSQL databases.
    Use the available tools when relevant to manage database operations.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-postgres", args=[postgres_url])
 )

@@ -5,7 +5,7 @@ import os
 puppeteer_agent = Agent(
    instructions="""You are a helpful assistant that can automate web browser interactions.
    Use the available tools when relevant to perform web automation tasks.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-puppeteer")
 )

@@ -8,7 +8,7 @@ redis_url = "redis://localhost:6379"
 redis_agent = Agent(
    instructions="""You are a helpful assistant that can interact with Redis.
    Use the available tools when relevant to manage Redis operations.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-redis", args=[redis_url])
 )

@@ -9,7 +9,7 @@ sentry_token = os.getenv("SENTRY_AUTH_TOKEN")
 sentry_agent = Agent(
    instructions="""You are a helpful assistant that can analyze Sentry error reports.
    Use the available tools when relevant to inspect and debug application issues.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("python -m mcp_server_sentry --auth-token", args=[sentry_token])
 )

@@ -5,7 +5,7 @@ import os
 sequential_agent = Agent(
    instructions="""You are a helpful assistant that can break down complex problems.
    Use the available tools when relevant to perform step-by-step analysis.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-sequential-thinking")
 )

@@ -9,7 +9,7 @@ slack_team_id = os.getenv("SLACK_TEAM_ID")
 slack_agent = Agent(
    instructions="""You are a helpful assistant that can interact with Slack.
    Use the available tools when relevant to manage Slack communications.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("npx -y @modelcontextprotocol/server-slack",
              env={
                  "SLACK_BOT_TOKEN": slack_token,
@@ -6,7 +6,7 @@ import os
 time_agent = Agent(
    instructions="""You are a helpful assistant that can handle time-related operations.
    Use the available tools when relevant to manage timezone conversions and time information.""",
-    llm="gpt-5-nano",
+    llm="gpt-4o-mini",
    tools=MCP("python -m mcp_server_time --local-timezone=America/New_York")
 )
Author	SHA1	Message	Date
Mervin Praison	d3f6eb4096	Release v3.5.2	2026-01-08 21:14:45 +00:00
Mervin Praison	c691b0a4c0	Release v3.5.1	2026-01-08 20:12:14 +00:00
Mervin Praison	b59675eeb4	Release v3.5.0	2026-01-08 19:55:06 +00:00
Mervin Praison	7e0739c6c4	Fix test_api.py to mock urllib.request.urlopen instead of subprocess.run	2026-01-08 16:14:35 +00:00
Mervin Praison	7519bc85d2	Fix test_api.py mock setup for stderr.read()	2026-01-08 16:03:38 +00:00
Mervin Praison	c7471092d0	Update test_typer_cli.py: chat is now a Typer command, not legacy	2026-01-08 15:52:35 +00:00
Mervin Praison	c344ee1bad	Update test_chat_flag.py to not require deprecated chat_mode flag	2026-01-08 15:42:12 +00:00
Mervin Praison	77bbf1ae66	Fix test_approval_system.py to handle tuple return from parse_args()	2026-01-08 15:33:37 +00:00
Mervin Praison	695d4d8843	Add console.py to output module (was gitignored) The output/ directory was in .gitignore, so console.py wasn't committed. Force-adding it to fix the ModuleNotFoundError in CI.	2026-01-08 15:28:17 +00:00
Mervin Praison	08f0736db5	Fix async test infrastructure and CLI output module export Core SDK fixes: - Add local async test runner in conftest.py that works when pytest-asyncio is not installed - Register 'asyncio' marker to remove PytestUnknownMarkWarning - Add @requires_wrapper skip decorator for tests that depend on praisonai wrapper - Add @requires_knowledge skip decorator for tests that need knowledge dependencies Wrapper CLI fixes: - Add missing set_output_controller export to cli/output/__init__.py - Update test_doctor_cli.py to test actual CLI subcommands instead of non-existent options Result: Core SDK unit tests pass (1181 passed, 21 skipped), wrapper integration tests pass (17 passed)	2026-01-08 15:07:35 +00:00