hanzo-mcp 0.7.2__py3-none-any.whl → 0.7.6__py3-none-any.whl

hanzo_mcp/tools/agent/swarm_tool.py

@@ -1,7 +1,7 @@
-"""Swarm tool implementation for parallel and hierarchical agent execution.
+"""Swarm tool implementation using hanzo-agents SDK.
 
-This module implements the SwarmTool that enables both parallel execution of multiple
-agent instances and hierarchical workflows with specialized roles.
+This module implements the SwarmTool that leverages the hanzo-agents SDK
+for sophisticated multi-agent orchestration with flexible network topologies.
 """
 
 import asyncio
@@ -14,24 +14,90 @@ from mcp.server import FastMCP
 from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
-from hanzo_mcp.tools.agent.agent_tool import AgentTool
+# Import hanzo-agents SDK with fallback
+try:
+    from hanzo_agents import (
+        Agent, State, Network, Tool, History,
+        ModelRegistry, InferenceResult, ToolCall,
+        Router,
+    )
+    HANZO_AGENTS_AVAILABLE = True
+except ImportError:
+    # Define minimal stubs if hanzo-agents is not available
+    HANZO_AGENTS_AVAILABLE = False
+    class Agent: pass
+    class State: pass
+    class Network: pass
+    class Tool: pass
+    class History: pass
+    class ModelRegistry: pass
+    class InferenceResult: pass
+    class ToolCall: pass
+    class Router: pass
+
+# Import optional components with fallbacks
+try:
+    from hanzo_agents import DeterministicRouter, LLMRouter, HybridRouter
+except ImportError:
+    try:
+        # Try core module import
+        from hanzo_agents.core.router import DeterministicRouter, LLMRouter, HybridRouter
+    except ImportError:
+        # Define stubs if not available
+        class DeterministicRouter: pass
+        class LLMRouter: pass
+        class HybridRouter: pass
+
+try:
+    from hanzo_agents import create_memory_kv, create_memory_vector
+except ImportError:
+    try:
+        # Try core module import
+        from hanzo_agents.core.memory import create_memory_kv, create_memory_vector
+    except ImportError:
+        # Define stubs if not available
+        def create_memory_kv(*args, **kwargs): pass
+        def create_memory_vector(*args, **kwargs): pass
+
+try:
+    from hanzo_agents import sequential_router, conditional_router, state_based_router
+except ImportError:
+    try:
+        # Try core module import
+        from hanzo_agents.core.router import sequential_router, conditional_router, state_based_router
+    except ImportError:
+        # Define stubs if not available
+        def sequential_router(*args, **kwargs): pass
+        def conditional_router(*args, **kwargs): pass
+        def state_based_router(*args, **kwargs): pass
+
+try:
+    from hanzo_agents.core.cli_agent import (
+        ClaudeCodeAgent, OpenAICodexAgent,
+        GeminiAgent, GrokAgent
+    )
+except ImportError:
+    # Define stub classes if not available
+    class ClaudeCodeAgent(Agent):
+        pass
+    class OpenAICodexAgent(Agent):
+        pass
+    class GeminiAgent(Agent):
+        pass
+    class GrokAgent(Agent):
+        pass
+
+from hanzo_mcp.tools.agent.agent_tool import MCPAgent, MCPToolAdapter
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.context import create_tool_context
 from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.filesystem import get_read_only_filesystem_tools, Edit, MultiEdit
+from hanzo_mcp.tools.jupyter import get_read_only_jupyter_tools
+from hanzo_mcp.tools.common.batch_tool import BatchTool
 
 
 class AgentNode(TypedDict):
-    """Node in the agent network.
-    
-    Attributes:
-        id: Unique identifier for this agent
-        query: The specific query/task for this agent
-        model: Optional model override (e.g., 'claude-3-5-sonnet', 'gpt-4o')
-        role: Optional role description (e.g., 'architect', 'frontend', 'reviewer')
-        connections: List of agent IDs this agent connects to (sends results to)
-        receives_from: Optional list of agent IDs this agent receives input from
-        file_path: Optional specific file for the agent to work on
-    """
+    """Node in the agent network."""
     id: str
     query: str
     model: Optional[str]
@@ -42,40 +108,260 @@ class AgentNode(TypedDict):
 
 
 class SwarmConfig(TypedDict):
-    """Configuration for an agent network.
-    
-    Attributes:
-        agents: Dictionary of agent configurations keyed by ID
-        entry_point: ID of the first agent to execute (optional, defaults to finding roots)
-        topology: Optional topology type (tree, dag, pipeline, star, mesh)
-    """
+    """Configuration for an agent network."""
     agents: Dict[str, AgentNode]
     entry_point: Optional[str]
     topology: Optional[str]
 
 
 class SwarmToolParams(TypedDict):
-    """Parameters for the SwarmTool.
-    
-    Attributes:
-        config: Agent network configuration
-        query: Initial query to send to entry point agent(s)
-        context: Optional context shared by all agents
-        max_concurrent: Maximum number of concurrent agents (default: 10)
-    """
+    """Parameters for the SwarmTool."""
     config: SwarmConfig
     query: str
     context: Optional[str]
     max_concurrent: Optional[int]
+    use_memory: Optional[bool]
+    memory_backend: Optional[str]
+
+
+class SwarmState(State):
+    """State for swarm execution."""
+    
+    def __init__(self, 
+                 config: SwarmConfig,
+                 initial_query: str,
+                 context: Optional[str] = None):
+        """Initialize swarm state."""
+        super().__init__()
+        self.config = config
+        self.initial_query = initial_query
+        self.context = context
+        self.agent_results = {}
+        self.completed_agents = set()
+        self.current_agent = None
+        self.execution_order = []
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        base_dict = super().to_dict()
+        base_dict.update({
+            "config": self.config,
+            "initial_query": self.initial_query,
+            "context": self.context,
+            "agent_results": self.agent_results,
+            "completed_agents": list(self.completed_agents),
+            "current_agent": self.current_agent,
+            "execution_order": self.execution_order
+        })
+        return base_dict
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SwarmState":
+        """Create from dictionary."""
+        state = cls(
+            config=data.get("config", {}),
+            initial_query=data.get("initial_query", ""),
+            context=data.get("context")
+        )
+        state.agent_results = data.get("agent_results", {})
+        state.completed_agents = set(data.get("completed_agents", []))
+        state.current_agent = data.get("current_agent")
+        state.execution_order = data.get("execution_order", [])
+        return state
+
+
+class SwarmAgent(MCPAgent):
+    """Agent that executes within a swarm network."""
+    
+    def __init__(self,
+                 agent_id: str,
+                 agent_config: AgentNode,
+                 available_tools: List[BaseTool],
+                 permission_manager: PermissionManager,
+                 ctx: MCPContext,
+                 **kwargs):
+        """Initialize swarm agent."""
+        # Set name and description from config
+        self.name = agent_id
+        self.description = agent_config.get("role", f"Agent {agent_id}")
+        self.agent_config = agent_config
+        
+        # Initialize with specified model
+        model = agent_config.get("model")
+        if model:
+            model = self._normalize_model(model)
+        else:
+            model = "model://anthropic/claude-3-5-sonnet-20241022"
+        
+        super().__init__(
+            available_tools=available_tools,
+            permission_manager=permission_manager,
+            ctx=ctx,
+            model=model,
+            **kwargs
+        )
+    
+    def _normalize_model(self, model: str) -> str:
+        """Normalize model names to full format."""
+        model_map = {
+            "claude-3-5-sonnet": "model://anthropic/claude-3-5-sonnet-20241022",
+            "claude-3-opus": "model://anthropic/claude-3-opus-20240229",
+            "gpt-4o": "model://openai/gpt-4o",
+            "gpt-4": "model://openai/gpt-4",
+            "gemini-1.5-pro": "model://google/gemini-1.5-pro",
+            "gemini-1.5-flash": "model://google/gemini-1.5-flash",
+        }
+        
+        # Check if it's already a model:// URI
+        if model.startswith("model://"):
+            return model
+        
+        # Check mapping
+        if model in model_map:
+            return model_map[model]
+        
+        # Assume it's a provider/model format
+        if "/" in model:
+            return f"model://{model}"
+        
+        # Default to anthropic
+        return f"model://anthropic/{model}"
+    
+    async def run(self, state: SwarmState, history: History, network: Network) -> InferenceResult:
+        """Execute the swarm agent."""
+        # Build prompt with context
+        prompt_parts = []
+        
+        # Add role context
+        if self.agent_config.get("role"):
+            prompt_parts.append(f"Your role: {self.agent_config['role']}")
+        
+        # Add shared context
+        if state.context:
+            prompt_parts.append(f"Context:\n{state.context}")
+        
+        # Add inputs from connected agents
+        receives_from = self.agent_config.get("receives_from", [])
+        if receives_from:
+            inputs = {}
+            for agent_id in receives_from:
+                if agent_id in state.agent_results:
+                    inputs[agent_id] = state.agent_results[agent_id]
+            
+            if inputs:
+                prompt_parts.append("Input from previous agents:")
+                for input_agent, input_result in inputs.items():
+                    prompt_parts.append(f"\n--- From {input_agent} ---\n{input_result}")
+        
+        # Add file context if specified
+        if self.agent_config.get("file_path"):
+            prompt_parts.append(f"\nFile to work on: {self.agent_config['file_path']}")
+        
+        # Add the main query
+        prompt_parts.append(f"\nTask: {self.agent_config['query']}")
+        
+        # Add initial query if this is entry point
+        if state.current_agent == state.config.get("entry_point"):
+            prompt_parts.append(f"\nMain objective: {state.initial_query}")
+        
+        full_prompt = "\n\n".join(prompt_parts)
+        
+        # Execute using base class
+        messages = [
+            {"role": "system", "content": self._get_system_prompt()},
+            {"role": "user", "content": full_prompt}
+        ]
+        
+        # Call model
+        from hanzo_agents import ModelRegistry
+        adapter = ModelRegistry.get_adapter(self.model)
+        response = await adapter.chat(messages)
+        
+        # Store result in state
+        state.agent_results[self.name] = response
+        state.completed_agents.add(self.name)
+        state.execution_order.append(self.name)
+        
+        # Return result
+        return InferenceResult(
+            agent=self.name,
+            content=response,
+            metadata={
+                "agent_id": self.name,
+                "role": self.agent_config.get("role"),
+                "connections": self.agent_config.get("connections", [])
+            }
+        )
+
+
+class SwarmRouter(DeterministicRouter):
+    """Router for swarm agent orchestration."""
+    
+    def __init__(self, swarm_config: SwarmConfig):
+        """Initialize swarm router."""
+        self.swarm_config = swarm_config
+        self.agents_config = swarm_config["agents"]
+        self.entry_point = swarm_config.get("entry_point")
+        
+        # Build dependency graph
+        self.dependencies = {}
+        self.dependents = {}
+        
+        for agent_id, config in self.agents_config.items():
+            # Dependencies (agents this one waits for)
+            self.dependencies[agent_id] = set(config.get("receives_from", []))
+            
+            # Dependents (agents that wait for this one)
+            connections = config.get("connections", [])
+            for conn in connections:
+                if conn not in self.dependents:
+                    self.dependents[conn] = set()
+                self.dependents[conn].add(agent_id)
+    
+    def route(self, network, call_count, last_result, agent_stack):
+        """Determine next agent to execute."""
+        state = network.state
+        
+        # First call - start with entry point or roots
+        if call_count == 0:
+            if self.entry_point:
+                state.current_agent = self.entry_point
+                return self._get_agent_class(self.entry_point, agent_stack)
+            else:
+                # Find roots (no dependencies)
+                roots = [aid for aid, deps in self.dependencies.items() if not deps]
+                if roots:
+                    state.current_agent = roots[0]
+                    return self._get_agent_class(roots[0], agent_stack)
+        
+        # Find next agent to execute
+        for agent_id in self.agents_config:
+            if agent_id in state.completed_agents:
+                continue
+            
+            # Check if all dependencies are met
+            deps = self.dependencies.get(agent_id, set())
+            if deps.issubset(state.completed_agents):
+                state.current_agent = agent_id
+                return self._get_agent_class(agent_id, agent_stack)
+        
+        # No more agents to execute
+        return None
+    
+    def _get_agent_class(self, agent_id: str, agent_stack: List[type[Agent]]) -> type[Agent]:
+        """Get agent class for given agent ID."""
+        # Find matching agent by name
+        for agent_class in agent_stack:
+            if hasattr(agent_class, "name") and agent_class.name == agent_id:
+                return agent_class
+        
+        # Not found - this shouldn't happen
+        return None
 
 
 @final
 class SwarmTool(BaseTool):
-    """Tool for executing multiple agent tasks in parallel.
-    
-    The SwarmTool enables efficient parallel processing of multiple files or tasks
-    by spawning independent agent instances for each task.
-    """
+    """Tool for executing agent networks using hanzo-agents SDK."""
     
     @property
     @override
@@ -99,9 +385,9 @@ Features:
 - Agents automatically pass results to connected agents
 - Parallel execution with dependency management
 - Full editing capabilities for each agent
+- Memory and state management via hanzo-agents SDK
 
 Common Topologies:
-
 1. Tree (Architect pattern):
    architect → [frontend, backend, database] → reviewer
 
@@ -114,51 +400,11 @@ Common Topologies:
 4. DAG (Complex dependencies):
    Multiple agents with custom connections
 
-Usage Example:
-
-swarm(
-    config={
-        "agents": {
-            "architect": {
-                "id": "architect",
-                "query": "Analyze codebase and create refactoring plan",
-                "model": "claude-3-5-sonnet",
-                "connections": ["frontend", "backend", "database"]
-            },
-            "frontend": {
-                "id": "frontend",
-                "query": "Refactor UI components based on architect's plan",
-                "role": "Frontend Developer",
-                "connections": ["reviewer"]
-            },
-            "backend": {
-                "id": "backend", 
-                "query": "Refactor API endpoints based on architect's plan",
-                "role": "Backend Developer",
-                "connections": ["reviewer"]
-            },
-            "database": {
-                "id": "database",
-                "query": "Optimize database schema based on architect's plan",
-                "role": "Database Expert",
-                "connections": ["reviewer"]
-            },
-            "reviewer": {
-                "id": "reviewer",
-                "query": "Review all changes and ensure consistency",
-                "model": "gpt-4o",
-                "receives_from": ["frontend", "backend", "database"]
-            }
-        },
-        "entry_point": "architect"
-    },
-    query="Refactor the authentication system for better security and performance"
-)
-
 Models can be specified as:
 - Full: 'anthropic/claude-3-5-sonnet-20241022'
 - Short: 'claude-3-5-sonnet', 'gpt-4o', 'gemini-1.5-pro'
 - CLI tools: 'claude_cli', 'codex_cli', 'gemini_cli', 'grok_cli'
+- Model URIs: 'model://anthropic/claude-3-opus'
 """
     
     def __init__(
@@ -171,17 +417,7 @@ Models can be specified as:
         agent_max_iterations: int = 10,
         agent_max_tool_uses: int = 30,
     ):
-        """Initialize the swarm tool.
-        
-        Args:
-            permission_manager: Permission manager for access control
-            model: Optional model name override (defaults to Claude Sonnet)
-            api_key: Optional API key for the model provider
-            base_url: Optional base URL for the model provider
-            max_tokens: Optional maximum tokens for model responses
-            agent_max_iterations: Max iterations per agent (default: 10)
-            agent_max_tool_uses: Max tool uses per agent (default: 30)
-        """
+        """Initialize the swarm tool."""
         self.permission_manager = permission_manager
         # Default to latest Claude Sonnet if no model specified
         from hanzo_mcp.tools.agent.code_auth import get_latest_claude_model
@@ -192,246 +428,140 @@ Models can be specified as:
         self.agent_max_iterations = agent_max_iterations
         self.agent_max_tool_uses = agent_max_tool_uses
         
+        # Set up available tools for agents
+        self.available_tools: list[BaseTool] = []
+        self.available_tools.extend(
+            get_read_only_filesystem_tools(self.permission_manager)
+        )
+        self.available_tools.extend(
+            get_read_only_jupyter_tools(self.permission_manager)
+        )
+        
+        # Add edit tools
+        self.available_tools.append(Edit(self.permission_manager))
+        self.available_tools.append(MultiEdit(self.permission_manager))
+        
+        # Add batch tool
+        self.available_tools.append(
+            BatchTool({t.name: t for t in self.available_tools})
+        )
+    
     @override
     async def call(
         self,
         ctx: MCPContext,
         **params: Unpack[SwarmToolParams],
     ) -> str:
-        """Execute the swarm tool.
-        
-        Args:
-            ctx: MCP context
-            **params: Tool parameters
-            
-        Returns:
-            Combined results from all agents
-        """
+        """Execute the swarm tool."""
         tool_ctx = create_tool_context(ctx)
         await tool_ctx.set_tool_info(self.name)
         
-        # Extract parameters
-        agents = params.get("agents", [])
-        manager_query = params.get("manager_query")
-        reviewer_query = params.get("reviewer_query")
-        common_context = params.get("common_context", "")
-        max_concurrent = params.get("max_concurrent", 10)
-        
-        if not agents:
-            await tool_ctx.error("No agents provided")
-            return "Error: At least one agent must be provided."
-        
         # Extract parameters
         config = params.get("config", {})
         initial_query = params.get("query", "")
         context = params.get("context", "")
+        max_concurrent = params.get("max_concurrent", 10)
+        use_memory = params.get("use_memory", False)
+        memory_backend = params.get("memory_backend", "sqlite")
         
         agents_config = config.get("agents", {})
-        entry_point = config.get("entry_point")
         
-        await tool_ctx.info(f"Starting swarm execution with {len(agents_config)} agents")
+        if not agents_config:
+            await tool_ctx.error("No agents provided")
+            return "Error: At least one agent must be provided."
+        
+        # hanzo-agents SDK is required (already imported above)
         
-        # Build agent network
-        agent_instances = {}
-        agent_results = {}
-        execution_queue = asyncio.Queue()
-        completed_agents = set()
+        await tool_ctx.info(f"Starting swarm execution with {len(agents_config)} agents using hanzo-agents SDK")
         
-        # Create agent instances
+        # Create state
+        state = SwarmState(
+            config=config,
+            initial_query=initial_query,
+            context=context
+        )
+        
+        # Create agent classes dynamically
+        agent_classes = []
         for agent_id, agent_config in agents_config.items():
+            # Check for CLI agents
             model = agent_config.get("model", self.model)
             
-            # Support CLI tools
-            cli_tools = {
-                "claude_cli": self._get_cli_tool("claude_cli"),
-                "codex_cli": self._get_cli_tool("codex_cli"),
-                "gemini_cli": self._get_cli_tool("gemini_cli"),
-                "grok_cli": self._get_cli_tool("grok_cli"),
+            cli_agents = {
+                "claude_cli": ClaudeCodeAgent,
+                "codex_cli": OpenAICodexAgent,
+                "gemini_cli": GeminiAgent,
+                "grok_cli": GrokAgent,
             }
             
-            if model in cli_tools:
-                agent = cli_tools[model]
+            if model in cli_agents:
+                # Use CLI agent
+                agent_class = type(f"Swarm{agent_id}", (cli_agents[model],), {
+                    "name": agent_id,
+                    "description": agent_config.get("role", f"Agent {agent_id}"),
+                    "agent_config": agent_config
+                })
             else:
-                # Regular agent with model
-                agent = AgentTool(
-                    permission_manager=self.permission_manager,
-                    model=self._normalize_model(model),
-                    api_key=self.api_key,
-                    base_url=self.base_url,
-                    max_tokens=self.max_tokens,
-                    max_iterations=self.agent_max_iterations,
-                    max_tool_uses=self.agent_max_tool_uses,
-                )
+                # Create dynamic SwarmAgent class
+                agent_class = type(f"Swarm{agent_id}", (SwarmAgent,), {
+                    "name": agent_id,
+                    "__init__": lambda self, aid=agent_id, acfg=agent_config: SwarmAgent.__init__(
+                        self,
+                        agent_id=aid,
+                        agent_config=acfg,
+                        available_tools=self.available_tools,
+                        permission_manager=self.permission_manager,
+                        ctx=ctx
+                    )
+                })
             
-            agent_instances[agent_id] = agent
+            agent_classes.append(agent_class)
         
-        # Find entry points (agents with no incoming connections)
-        if entry_point:
-            await execution_queue.put((entry_point, initial_query, {}))
-        else:
-            # Find root agents (no receives_from)
-            roots = []
-            for agent_id, agent_config in agents_config.items():
-                if not agent_config.get("receives_from"):
-                    # Check if any other agent connects to this one
-                    has_incoming = False
-                    for other_config in agents_config.values():
-                        if other_config.get("connections") and agent_id in other_config["connections"]:
-                            has_incoming = True
-                            break
-                    if not has_incoming:
-                        roots.append(agent_id)
-            
-            if not roots:
-                await tool_ctx.error("No entry point found in agent network")
-                return "Error: Could not determine entry point for agent network"
-            
-            for root in roots:
-                await execution_queue.put((root, initial_query, {}))
-        
-        # Execute agents in network order
-        async def execute_agent(agent_id: str, query: str, inputs: Dict[str, str]) -> str:
-            """Execute a single agent in the network."""
-            async with semaphore:
-                try:
-                    agent_config = agents_config[agent_id]
-                    agent = agent_instances[agent_id]
-                    
-                    await tool_ctx.info(f"Executing agent: {agent_id} ({agent_config.get('role', 'Agent')})")
-                    
-                    # Build prompt with context and inputs
-                    prompt_parts = []
-                    
-                    # Add role context
-                    if agent_config.get("role"):
-                        prompt_parts.append(f"Your role: {agent_config['role']}")
-                    
-                    # Add shared context
-                    if context:
-                        prompt_parts.append(f"Context:\n{context}")
-                    
-                    # Add inputs from connected agents
-                    if inputs:
-                        prompt_parts.append("Input from previous agents:")
-                        for input_agent, input_result in inputs.items():
-                            prompt_parts.append(f"\n--- From {input_agent} ---\n{input_result}")
-                    
-                    # Add file context if specified
-                    if agent_config.get("file_path"):
-                        prompt_parts.append(f"\nFile to work on: {agent_config['file_path']}")
-                    
-                    # Add the main query
-                    prompt_parts.append(f"\nTask: {agent_config['query']}")
-                    
-                    # Combine query with initial query if this is entry point
-                    if query and query != agent_config['query']:
-                        prompt_parts.append(f"\nMain objective: {query}")
-                    
-                    full_prompt = "\n\n".join(prompt_parts)
-                    
-                    # Execute the agent
-                    result = await agent.call(ctx, prompts=full_prompt)
-                    
-                    await tool_ctx.info(f"Agent {agent_id} completed")
-                    return result
-                    
-                except Exception as e:
-                    error_msg = f"Agent {agent_id} failed: {str(e)}"
-                    await tool_ctx.error(error_msg)
-                    return f"Error: {error_msg}"
-        
-        # Process agent network
-        running_tasks = set()
-        
-        while not execution_queue.empty() or running_tasks:
-            # Start new tasks up to concurrency limit
-            while not execution_queue.empty() and len(running_tasks) < max_concurrent:
-                agent_id, query, inputs = await execution_queue.get()
-                
-                if agent_id not in completed_agents:
-                    # Check if all dependencies are met
-                    agent_config = agents_config[agent_id]
-                    receives_from = agent_config.get("receives_from", [])
-                    
-                    # Collect inputs from dependencies
-                    ready = True
-                    for dep in receives_from:
-                        if dep not in agent_results:
-                            ready = False
-                            # Re-queue for later
-                            await execution_queue.put((agent_id, query, inputs))
-                            break
-                        else:
-                            inputs[dep] = agent_results[dep]
-                    
-                    if ready:
-                        # Execute agent
-                        task = asyncio.create_task(execute_agent(agent_id, query, inputs))
-                        running_tasks.add(task)
-                        
-                        async def handle_completion(task, agent_id=agent_id):
-                            result = await task
-                            agent_results[agent_id] = result
-                            completed_agents.add(agent_id)
-                            running_tasks.discard(task)
-                            
-                            # Queue connected agents
-                            agent_config = agents_config[agent_id]
-                            connections = agent_config.get("connections", [])
-                            for next_agent in connections:
-                                if next_agent in agents_config:
-                                    await execution_queue.put((next_agent, "", {agent_id: result}))
-                        
-                        asyncio.create_task(handle_completion(task))
-            
-            # Wait a bit if we're at capacity
-            if running_tasks:
-                await asyncio.sleep(0.1)
+        # Create memory if requested
+        memory_kv = None
+        memory_vector = None
+        if use_memory:
+            memory_kv = create_memory_kv(memory_backend)
+            memory_vector = create_memory_vector("simple")
         
-        # Wait for all tasks to complete
-        if running_tasks:
-            await asyncio.gather(*running_tasks, return_exceptions=True)
+        # Create router
+        router = SwarmRouter(config)
         
-        # Format results
-        return self._format_network_results(agents_config, agent_results, entry_point)
-    
-    def _normalize_model(self, model: str) -> str:
-        """Normalize model names to full format."""
-        model_map = {
-            "claude-3-5-sonnet": "anthropic/claude-3-5-sonnet-20241022",
-            "claude-3-opus": "anthropic/claude-3-opus-20240229",
-            "gpt-4o": "openai/gpt-4o",
-            "gpt-4": "openai/gpt-4",
-            "gemini-1.5-pro": "google/gemini-1.5-pro",
-            "gemini-1.5-flash": "google/gemini-1.5-flash",
-        }
-        return model_map.get(model, model)
-    
-    def _get_cli_tool(self, tool_name: str):
-        """Get CLI tool instance."""
-        # Import here to avoid circular imports
-        if tool_name == "claude_cli":
-            from hanzo_mcp.tools.agent.claude_cli_tool import ClaudeCLITool
-            return ClaudeCLITool(self.permission_manager)
-        elif tool_name == "codex_cli":
-            from hanzo_mcp.tools.agent.codex_cli_tool import CodexCLITool
-            return CodexCLITool(self.permission_manager)
-        elif tool_name == "gemini_cli":
-            from hanzo_mcp.tools.agent.gemini_cli_tool import GeminiCLITool
-            return GeminiCLITool(self.permission_manager)
-        elif tool_name == "grok_cli":
-            from hanzo_mcp.tools.agent.grok_cli_tool import GrokCLITool
-            return GrokCLITool(self.permission_manager)
-        return None
+        # Create network
+        network = Network(
+            state=state,
+            agents=agent_classes,
+            router=router,
+            memory_kv=memory_kv,
+            memory_vector=memory_vector,
+            max_steps=self.agent_max_iterations * len(agents_config),
+        )
+        
+        # Execute
+        try:
+            final_state = await network.run()
+            
+            # Format results
+            return self._format_network_results(
+                agents_config,
+                final_state.agent_results,
+                final_state.execution_order,
+                config.get("entry_point")
+            )
+            
+        except Exception as e:
+            await tool_ctx.error(f"Swarm execution failed: {str(e)}")
+            return f"Error: {str(e)}"
     
     def _format_network_results(
         self,
         agents_config: Dict[str, Any],
         results: Dict[str, str],
+        execution_order: List[str],
         entry_point: Optional[str]
     ) -> str:
         """Format results from agent network execution."""
-        output = ["Agent Network Execution Results"]
+        output = ["Agent Network Execution Results (hanzo-agents SDK)"]
         output.append("=" * 80)
         output.append(f"Total agents: {len(agents_config)}")
         output.append(f"Completed: {len(results)}")
@@ -440,69 +570,33 @@ Models can be specified as:
         if entry_point:
             output.append(f"Entry point: {entry_point}")
         
-        output.append("\nExecution Flow:")
+        output.append(f"\nExecution Order: {' → '.join(execution_order)}")
         output.append("-" * 40)
         
-        # Show results in execution order
-        def format_agent_tree(agent_id: str, level: int = 0) -> List[str]:
-            lines = []
-            indent = "  " * level
-            
-            if agent_id in agents_config:
-                config = agents_config[agent_id]
-                role = config.get("role", "Agent")
-                model = config.get("model", "default")
-                
-                status = "✅" if agent_id in results and not results[agent_id].startswith("Error:") else "❌"
-                lines.append(f"{indent}{status} {agent_id} ({role}) [{model}]")
-                
-                # Show connections
-                connections = config.get("connections", [])
-                for conn in connections:
-                    if conn in agents_config:
-                        lines.extend(format_agent_tree(conn, level + 1))
-            
-            return lines
-        
-        # Start from entry point or roots
-        if entry_point:
-            output.extend(format_agent_tree(entry_point))
-        else:
-            # Find roots
-            roots = []
-            for agent_id in agents_config:
-                has_incoming = False
-                for config in agents_config.values():
-                    if config.get("connections") and agent_id in config["connections"]:
-                        has_incoming = True
-                        break
-                if not has_incoming:
-                    roots.append(agent_id)
-            
-            for root in roots:
-                output.extend(format_agent_tree(root))
-        
         # Detailed results
         output.append("\n\nDetailed Results:")
         output.append("=" * 80)
         
-        for agent_id, result in results.items():
-            config = agents_config.get(agent_id, {})
-            role = config.get("role", "Agent")
-            
-            output.append(f"\n### {agent_id} ({role})")
-            output.append("-" * 40)
-            
-            if result.startswith("Error:"):
-                output.append(result)
-            else:
-                # Show first part of result
-                lines = result.split('\n')
-                preview_lines = lines[:10]
-                output.extend(preview_lines)
+        for agent_id in execution_order:
+            if agent_id in results:
+                config = agents_config.get(agent_id, {})
+                role = config.get("role", "Agent")
+                model = config.get("model", "default")
                 
-                if len(lines) > 10:
-                    output.append(f"... ({len(lines) - 10} more lines)")
+                output.append(f"\n### {agent_id} ({role}) [{model}]")
+                output.append("-" * 40)
+                
+                result = results[agent_id]
+                if result.startswith("Error:"):
+                    output.append(result)
+                else:
+                    # Show first part of result
+                    lines = result.split('\n')
+                    preview_lines = lines[:10]
+                    output.extend(preview_lines)
+                    
+                    if len(lines) > 10:
+                        output.append(f"... ({len(lines) - 10} more lines)")
         
         return "\n".join(output)
     
@@ -518,6 +612,8 @@ Models can be specified as:
             query: str,
             context: Optional[str] = None,
             max_concurrent: int = 10,
+            use_memory: bool = False,
+            memory_backend: str = "sqlite"
         ) -> str:
             # Convert to typed format
             typed_config = SwarmConfig(
@@ -531,5 +627,7 @@ Models can be specified as:
                 config=typed_config,
                 query=query,
                 context=context,
-                max_concurrent=max_concurrent
+                max_concurrent=max_concurrent,
+                use_memory=use_memory,
+                memory_backend=memory_backend
             )