strands-swarms 0.1.1__tar.gz → 0.1.2__tar.gz

strands_swarms-0.1.2/.claude/settings.local.json

@@ -0,0 +1,12 @@
+{
+  "permissions": {
+    "allow": [
+      "WebFetch(domain:strandsagents.com)",
+      "Bash(python -c:*)",
+      "Bash(python3:*)",
+      "Bash(pip show:*)",
+      "Bash(pip install:*)",
+      "Bash(tree:*)"
+    ]
+  }
+}

{strands_swarms-0.1.1 → strands_swarms-0.1.2}/.gitignore

@@ -27,3 +27,4 @@ htmlcov/
 
 # mypy
 .mypy_cache/
+*.lock

strands_swarms-0.1.2/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: strands-swarms
+Version: 0.1.2
+Summary: Task-based workflow orchestration for Strands Agents
+Project-URL: Homepage, https://github.com/JackXu0/strands-swarms
+Project-URL: Issues, https://github.com/JackXu0/strands-swarms/issues
+Author-email: Zhuocheng Xu <zhuocheng.xu@icloud.com>
+License: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: strands-agents>=0.1.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.15.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.13.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# strands-swarms
+
+[![CI](https://github.com/JackXu0/strands-swarms/actions/workflows/ci.yml/badge.svg)](https://github.com/JackXu0/strands-swarms/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/strands-swarms)](https://pypi.org/project/strands-swarms/)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+**Turn natural language into multi-agent workflows — automatically.**
+
+Give `DynamicSwarm` a query, and it automatically plans the workflow, spawns specialized agents, and executes tasks with dependencies. No manual graph configuration or agent wiring required.
+
+```python
+swarm = DynamicSwarm(available_tools={...}, available_models={...})
+result = swarm.execute("Research AI trends and write a summary report")
+# → Spawns researcher + writer agents, handles dependencies, returns final report
+```
+
+## Inspiration
+
+This project is inspired by [Kimi K2.5's Agent Swarm](https://www.kimi.com/blog/kimi-k2-5.html) — where a trainable orchestrator dynamically creates and coordinates sub-agents without predefined roles or workflows. The goal is to build an open-source foundation for training orchestrators that can spin up agent swarms on the fly.
+
+## How It Works
+
+![Architecture](assets/architecture.png)
+
+## Installation
+
+```bash
+pip install strands-swarms
+```
+
+## Quick Start
+
+```python
+from strands import tool
+from strands.models import BedrockModel
+from strands_swarms import DynamicSwarm
+
+# Define your tools
+@tool
+def search_web(query: str) -> str:
+    """Search the web for information."""
+    return f"[Search Results for '{query}']\n- Result 1: Latest developments..."
+
+@tool
+def analyze_data(data: str) -> str:
+    """Analyze data and extract insights."""
+    return f"[Analysis]\nKey insights: ..."
+
+@tool
+def write_file(path: str, content: str) -> str:
+    """Write content to a file."""
+    return f"Successfully wrote {len(content)} characters to {path}"
+
+# Configure models
+powerful_model = BedrockModel(model_id="us.anthropic.claude-3-opus-20240229-v1:0")
+fast_model = BedrockModel(model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0")
+
+# Create the swarm
+swarm = DynamicSwarm(
+    available_tools={
+        "search_web": search_web,
+        "analyze_data": analyze_data,
+        "write_file": write_file,
+    },
+    available_models={
+        "powerful": powerful_model,
+        "fast": fast_model,
+    },
+    orchestrator_model=powerful_model,
+    default_agent_model="fast",
+)
+
+# Execute with natural language
+result = swarm.execute("Research the latest AI trends and write a summary report")
+
+print(f"Status: {result.status}")
+print(f"Agents spawned: {result.agents_spawned_count}")
+for agent in result.agents_spawned:
+    print(f"  - {agent.name}: {agent.role}")
+print(f"Tasks created: {result.tasks_created_count}")
+for task in result.tasks_created:
+    depends = f" (depends: [{', '.join(task.depends_on)}])" if task.depends_on else ""
+    print(f"  - {task.name} -> {task.agent}{depends}")
+print(f"Final response: {result.final_response}")
+```
+<details>
+<summary>Example output (see examples/simple.py)</summary>
+
+```
+Status: Status.COMPLETED
+Agents spawned: 2
+  - researcher: AI trends researcher
+  - writer: AI trends summary writer
+Tasks created: 3
+  - web_research -> researcher
+  - analyze_trends -> researcher (depends: [web_research])
+  - write_summary -> writer (depends: [analyze_trends])
+Final response: <thinking>
+The job is complete. The researchers gathered comprehensive information on the latest AI trends through web searches, analyzed that information to identify the most important developments and themes, and the writer put it together into a clear summary report touching on:
+
+- Major AI breakthroughs in the last year across language, vision, multimodal and generative models
+- Potential applications of these advancing AI capabilities 
+- Rapid growth in enterprise adoption and startup investment
+- Key technical challenges like robustness, interpretability and scalability 
+- Important societal and ethical considerations around safety, bias and responsible use
+- Longer-term possibilities around artificial general intelligence
+
+The report provides a succinct yet informative overview of the state of the art in AI and the key trends shaping the field. It directly addresses the original request, so no further analysis or synthesis is needed. The final report can be delivered as-is to the human who made the request.
+</thinking>
+
+Here is a summary report on the latest trends in artificial intelligence:
+
+Artificial intelligence continues to progress rapidly, with significant developments over the past year in areas like natural language processing, computer vision, multimodal learning, and generative AI. Powerful language models can now engage in human-like dialogue and assist with writing. AI systems can perceive and reason jointly about text, images, audio and video. New generative models can create highly realistic images from textual descriptions. And AI has achieved human-level performance on complex strategy games.
+
+These advances open up transformative potential applications — enhancing creative workflows, accelerating scientific discovery, enabling more natural human-computer interaction. Enterprises across sectors are increasingly adopting AI technologies, and venture capital investment into AI startups reached record levels in 2022.
+
+However, key technical challenges remain in making AI systems more robust, interpretable and scalable. Important societal considerations are also in play around AI ethics, safety, bias and responsible use. Longer-term, some believe AI could progress toward human-level artificial general intelligence, though this remains a future possibility.
+
+In summary, AI capabilities are advancing quickly, with potentially profound impacts across domains in the coming years. Ongoing research aims to further enhance performance while addressing crucial challenges. Organizations will need to balance leveraging AI's competitive advantages with deploying it in a trustworthy manner. The field's rapid progress looks set to continue — and to reshape the world in the process.
+```
+
+</details>
+
+## Status & Roadmap
+
+> **Current version: Rollout-only**
+>
+> This release supports **rollout execution** (string-in, string-out) — ideal for inference and deployment.
+>
+> **Coming soon:** RL support via [strands-sglang](https://github.com/strands-agents/strands-sglang) integration.
+
+- [x] Rollout execution — string-in, string-out multi-agent workflows
+- [x] Dynamic orchestration — automatic agent creation and task assignment
+- [ ] Streaming trajectory output — consume `stream_async()`
+- [ ] RL support — training and fine-tuning via strands-sglang
+
+## Contributing
+
+Contributions welcome! Please feel free to submit issues and pull requests.
+
+## License
+
+Apache-2.0

strands_swarms-0.1.2/README.md

@@ -0,0 +1,143 @@
+# strands-swarms
+
+[![CI](https://github.com/JackXu0/strands-swarms/actions/workflows/ci.yml/badge.svg)](https://github.com/JackXu0/strands-swarms/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/strands-swarms)](https://pypi.org/project/strands-swarms/)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+**Turn natural language into multi-agent workflows — automatically.**
+
+Give `DynamicSwarm` a query, and it automatically plans the workflow, spawns specialized agents, and executes tasks with dependencies. No manual graph configuration or agent wiring required.
+
+```python
+swarm = DynamicSwarm(available_tools={...}, available_models={...})
+result = swarm.execute("Research AI trends and write a summary report")
+# → Spawns researcher + writer agents, handles dependencies, returns final report
+```
+
+## Inspiration
+
+This project is inspired by [Kimi K2.5's Agent Swarm](https://www.kimi.com/blog/kimi-k2-5.html) — where a trainable orchestrator dynamically creates and coordinates sub-agents without predefined roles or workflows. The goal is to build an open-source foundation for training orchestrators that can spin up agent swarms on the fly.
+
+## How It Works
+
+![Architecture](assets/architecture.png)
+
+## Installation
+
+```bash
+pip install strands-swarms
+```
+
+## Quick Start
+
+```python
+from strands import tool
+from strands.models import BedrockModel
+from strands_swarms import DynamicSwarm
+
+# Define your tools
+@tool
+def search_web(query: str) -> str:
+    """Search the web for information."""
+    return f"[Search Results for '{query}']\n- Result 1: Latest developments..."
+
+@tool
+def analyze_data(data: str) -> str:
+    """Analyze data and extract insights."""
+    return f"[Analysis]\nKey insights: ..."
+
+@tool
+def write_file(path: str, content: str) -> str:
+    """Write content to a file."""
+    return f"Successfully wrote {len(content)} characters to {path}"
+
+# Configure models
+powerful_model = BedrockModel(model_id="us.anthropic.claude-3-opus-20240229-v1:0")
+fast_model = BedrockModel(model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0")
+
+# Create the swarm
+swarm = DynamicSwarm(
+    available_tools={
+        "search_web": search_web,
+        "analyze_data": analyze_data,
+        "write_file": write_file,
+    },
+    available_models={
+        "powerful": powerful_model,
+        "fast": fast_model,
+    },
+    orchestrator_model=powerful_model,
+    default_agent_model="fast",
+)
+
+# Execute with natural language
+result = swarm.execute("Research the latest AI trends and write a summary report")
+
+print(f"Status: {result.status}")
+print(f"Agents spawned: {result.agents_spawned_count}")
+for agent in result.agents_spawned:
+    print(f"  - {agent.name}: {agent.role}")
+print(f"Tasks created: {result.tasks_created_count}")
+for task in result.tasks_created:
+    depends = f" (depends: [{', '.join(task.depends_on)}])" if task.depends_on else ""
+    print(f"  - {task.name} -> {task.agent}{depends}")
+print(f"Final response: {result.final_response}")
+```
+<details>
+<summary>Example output (see examples/simple.py)</summary>
+
+```
+Status: Status.COMPLETED
+Agents spawned: 2
+  - researcher: AI trends researcher
+  - writer: AI trends summary writer
+Tasks created: 3
+  - web_research -> researcher
+  - analyze_trends -> researcher (depends: [web_research])
+  - write_summary -> writer (depends: [analyze_trends])
+Final response: <thinking>
+The job is complete. The researchers gathered comprehensive information on the latest AI trends through web searches, analyzed that information to identify the most important developments and themes, and the writer put it together into a clear summary report touching on:
+
+- Major AI breakthroughs in the last year across language, vision, multimodal and generative models
+- Potential applications of these advancing AI capabilities 
+- Rapid growth in enterprise adoption and startup investment
+- Key technical challenges like robustness, interpretability and scalability 
+- Important societal and ethical considerations around safety, bias and responsible use
+- Longer-term possibilities around artificial general intelligence
+
+The report provides a succinct yet informative overview of the state of the art in AI and the key trends shaping the field. It directly addresses the original request, so no further analysis or synthesis is needed. The final report can be delivered as-is to the human who made the request.
+</thinking>
+
+Here is a summary report on the latest trends in artificial intelligence:
+
+Artificial intelligence continues to progress rapidly, with significant developments over the past year in areas like natural language processing, computer vision, multimodal learning, and generative AI. Powerful language models can now engage in human-like dialogue and assist with writing. AI systems can perceive and reason jointly about text, images, audio and video. New generative models can create highly realistic images from textual descriptions. And AI has achieved human-level performance on complex strategy games.
+
+These advances open up transformative potential applications — enhancing creative workflows, accelerating scientific discovery, enabling more natural human-computer interaction. Enterprises across sectors are increasingly adopting AI technologies, and venture capital investment into AI startups reached record levels in 2022.
+
+However, key technical challenges remain in making AI systems more robust, interpretable and scalable. Important societal considerations are also in play around AI ethics, safety, bias and responsible use. Longer-term, some believe AI could progress toward human-level artificial general intelligence, though this remains a future possibility.
+
+In summary, AI capabilities are advancing quickly, with potentially profound impacts across domains in the coming years. Ongoing research aims to further enhance performance while addressing crucial challenges. Organizations will need to balance leveraging AI's competitive advantages with deploying it in a trustworthy manner. The field's rapid progress looks set to continue — and to reshape the world in the process.
+```
+
+</details>
+
+## Status & Roadmap
+
+> **Current version: Rollout-only**
+>
+> This release supports **rollout execution** (string-in, string-out) — ideal for inference and deployment.
+>
+> **Coming soon:** RL support via [strands-sglang](https://github.com/strands-agents/strands-sglang) integration.
+
+- [x] Rollout execution — string-in, string-out multi-agent workflows
+- [x] Dynamic orchestration — automatic agent creation and task assignment
+- [ ] Streaming trajectory output — consume `stream_async()`
+- [ ] RL support — training and fine-tuning via strands-sglang
+
+## Contributing
+
+Contributions welcome! Please feel free to submit issues and pull requests.
+
+## License
+
+Apache-2.0

strands_swarms-0.1.2/examples/simple.py

@@ -0,0 +1,51 @@
+from strands import tool
+from strands.models import BedrockModel
+from strands_swarms import DynamicSwarm
+
+# Define your tools
+@tool
+def search_web(query: str) -> str:
+    """Search the web for information."""
+    return f"[Search Results for '{query}']\n- Result 1: Latest developments..."
+
+@tool
+def analyze_data(data: str) -> str:
+    """Analyze data and extract insights."""
+    return f"[Analysis]\nKey insights: ..."
+
+@tool
+def write_file(path: str, content: str) -> str:
+    """Write content to a file."""
+    return f"Successfully wrote {len(content)} characters to {path}"
+
+# Configure models
+powerful_model = BedrockModel(model_id="us.anthropic.claude-3-opus-20240229-v1:0")
+fast_model = BedrockModel(model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0")
+
+# Create the swarm
+swarm = DynamicSwarm(
+    available_tools={
+        "search_web": search_web,
+        "analyze_data": analyze_data,
+        "write_file": write_file,
+    },
+    available_models={
+        "powerful": powerful_model,
+        "fast": fast_model,
+    },
+    orchestrator_model=powerful_model,
+    default_agent_model="fast",
+)
+
+# Execute with natural language
+result = swarm.execute("Research the latest AI trends and write a summary report")
+
+print(f"Status: {result.status}")
+print(f"Agents spawned: {result.agents_spawned_count}")
+for agent in result.agents_spawned:
+    print(f"  - {agent.name}: {agent.role}")
+print(f"Tasks created: {result.tasks_created_count}")
+for task in result.tasks_created:
+    depends = f" (depends: [{', '.join(task.depends_on)}])" if task.depends_on else ""
+    print(f"  - {task.name} -> {task.agent}{depends}")
+print(f"Final response: {result.final_response}")

{strands_swarms-0.1.1 → strands_swarms-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "strands-swarms"
-version = "0.1.1"
+version = "0.1.2"
 description = "Task-based workflow orchestration for Strands Agents"
 authors = [
     {name = "Zhuocheng Xu", email = "zhuocheng.xu@icloud.com"}

{strands_swarms-0.1.1 → strands_swarms-0.1.2}/src/strands_swarms/__init__.py

@@ -26,37 +26,35 @@ Example:
         '''Search the web.'''
         return f"Results for: {query}"
 
-    swarm = DynamicSwarm(
-        available_tools={"search_web": search_web},
-        verbose=True,
-    )
+    # Basic usage
+    swarm = DynamicSwarm(available_tools={"search_web": search_web})
     result = swarm.execute("Research AI trends and summarize")
+
+    # Streaming trajectory
+    import asyncio
+
+    async def run():
+        async for event in swarm.stream_async(
+            "Research AI trends and summarize",
+            include_subagent_events=False,
+        ):
+            print(event)
+
+    asyncio.run(run())
 """
 
 # Re-export strands types for convenience
-from strands.hooks import HookProvider, HookRegistry
 from strands.multiagent.base import Status
 
-from .events import (
-    AgentSpawnedEvent,
-    ExecutionCompletedEvent,
-    # Execution events
-    ExecutionStartedEvent,
-    PlanningCompletedEvent,
-    PlanningStartedEvent,
-    # Hook provider
-    PrintingHookProvider,
-    SwarmCompletedEvent,
-    SwarmFailedEvent,
-    # Planning/Orchestration events
-    SwarmStartedEvent,
-    TaskCompletedEvent,
-    TaskCreatedEvent,
-    TaskFailedEvent,
-    TaskStartedEvent,
+from .definition import (
+    AgentDefinition,
+    DynamicSwarmCapabilities,
+    SessionConfig,
+    SwarmDefinition,
+    TaskDefinition,
 )
+from .dynamic_swarm import DynamicSwarm, DynamicSwarmResult, build_swarm
 from .orchestrator import create_orchestrator_agent
-from .swarm import DynamicSwarm, DynamicSwarmResult
 
 __version__ = "0.1.1"
 
@@ -64,25 +62,14 @@ __all__ = [
     # Main API
     "DynamicSwarm",
     "DynamicSwarmResult",
-    # Orchestrator (handles both planning AND completion in same conversation)
+    "build_swarm",
+    # Definition types
+    "DynamicSwarmCapabilities",
+    "SwarmDefinition",
+    "AgentDefinition",
+    "TaskDefinition",
+    "SessionConfig",
+    # Orchestrator
     "create_orchestrator_agent",
-    # Status enum
     "Status",
-    # Events (for custom hooks)
-    "SwarmStartedEvent",
-    "PlanningStartedEvent",
-    "AgentSpawnedEvent",
-    "TaskCreatedEvent",
-    "PlanningCompletedEvent",
-    "ExecutionStartedEvent",
-    "TaskStartedEvent",
-    "TaskCompletedEvent",
-    "TaskFailedEvent",
-    "ExecutionCompletedEvent",
-    "SwarmCompletedEvent",
-    "SwarmFailedEvent",
-    # Hook system
-    "PrintingHookProvider",
-    "HookProvider",
-    "HookRegistry",
 ]

strands_swarms-0.1.2/src/strands_swarms/definition.py

@@ -0,0 +1,169 @@
+"""Swarm definition types - data structures for defining multi-agent workflows."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Callable
+
+from strands.session.file_session_manager import FileSessionManager
+
+# ANSI Color Constants (for consistent agent output coloring)
+AGENT_COLORS: list[str] = [
+    "\033[94m",  # Blue
+    "\033[92m",  # Green
+    "\033[93m",  # Yellow
+    "\033[95m",  # Magenta
+    "\033[96m",  # Cyan
+    "\033[91m",  # Red
+]
+
+if TYPE_CHECKING:
+    from strands.models import Model
+
+
+@dataclass(frozen=True)
+class DynamicSwarmCapabilities:
+    """Immutable configuration for available tools and models."""
+
+    available_tools: dict[str, Callable[..., Any]]
+    available_models: dict[str, "Model"]
+    default_model: str | None = None
+
+    def validate_tools(self, tool_names: list[str]) -> None:
+        """Validate that all tool names exist in available tools."""
+        for tool_name in tool_names:
+            if tool_name not in self.available_tools:
+                available = list(self.available_tools.keys())
+                raise ValueError(
+                    f"Tool '{tool_name}' not in available tools: {available}"
+                )
+
+    def validate_model(self, model_name: str | None) -> None:
+        """Validate that the model name exists in available models."""
+        if model_name and model_name not in self.available_models:
+            available = list(self.available_models.keys())
+            raise ValueError(
+                f"Model '{model_name}' not in available models: {available}"
+            )
+
+    @property
+    def available_tool_names(self) -> list[str]:
+        return list(self.available_tools.keys())
+
+    @property
+    def available_model_names(self) -> list[str]:
+        return list(self.available_models.keys())
+
+
+@dataclass
+class AgentDefinition:
+    """Definition of a sub-agent to be spawned."""
+
+    name: str
+    role: str
+    instructions: str | None = None
+    tools: list[str] = field(default_factory=list)
+    model: str | None = None
+    color: str | None = None
+
+    def build_system_prompt(self) -> str:
+        parts = [f"You are a {self.role}."]
+        if self.instructions:
+            parts.append(f"\n\nInstructions:\n{self.instructions}")
+        return "\n".join(parts)
+
+
+@dataclass
+class TaskDefinition:
+    """Definition of a task to be executed by a sub-agent."""
+
+    name: str
+    agent: str
+    description: str | None = None
+    depends_on: list[str] = field(default_factory=list)
+
+
+@dataclass
+class SessionConfig:
+    """Configuration for session persistence."""
+
+    session_id: str
+    storage_dir: str = "./.swarm_sessions"
+
+    def for_agent(self, agent_name: str) -> FileSessionManager:
+        return FileSessionManager(
+            session_id=f"{self.session_id}-{agent_name}",
+            storage_dir=self.storage_dir,
+        )
+
+    def for_graph(self) -> FileSessionManager:
+        return FileSessionManager(
+            session_id=f"{self.session_id}-graph",
+            storage_dir=self.storage_dir,
+        )
+
+
+class SwarmDefinition:
+    """Per-query definition of sub-agents and tasks created during planning."""
+
+    def __init__(
+        self,
+        capabilities: DynamicSwarmCapabilities,
+    ) -> None:
+        self._capabilities = capabilities
+        self.sub_agents: dict[str, AgentDefinition] = {}
+        self.tasks: dict[str, TaskDefinition] = {}
+        self._color_index = 0
+
+    @property
+    def capabilities(self) -> DynamicSwarmCapabilities:
+        return self._capabilities
+
+    def register_agent(self, definition: AgentDefinition) -> None:
+        """Register a sub-agent definition."""
+        if definition.name in self.sub_agents:
+            raise ValueError(f"Agent '{definition.name}' already exists")
+
+        self._capabilities.validate_tools(definition.tools)
+        self._capabilities.validate_model(definition.model)
+
+        definition.color = AGENT_COLORS[self._color_index % len(AGENT_COLORS)]
+        self._color_index += 1
+
+        self.sub_agents[definition.name] = definition
+
+    def register_task(self, definition: TaskDefinition) -> None:
+        """Register a task definition.
+
+        Note: dependencies must already be registered (create dependency tasks first).
+        """
+        if definition.name in self.tasks:
+            raise ValueError(f"Task '{definition.name}' already exists")
+
+        if definition.agent not in self.sub_agents:
+            available = list(self.sub_agents.keys())
+            raise ValueError(
+                f"Agent '{definition.agent}' not found. Available: {available}"
+            )
+
+        for dep in definition.depends_on:
+            if dep not in self.tasks:
+                available = list(self.tasks.keys())
+                raise ValueError(
+                    f"Dependency '{dep}' not found. Available: {available}"
+                )
+
+        self.tasks[definition.name] = definition
+
+    def get_summary(self) -> str:
+        """Get a summary of registered sub-agents and tasks."""
+        lines = [
+            f"Agents ({len(self.sub_agents)}):",
+            *[f"  - {name}: {d.role}" for name, d in self.sub_agents.items()],
+            f"\nTasks ({len(self.tasks)}):",
+            *[
+                f"  - {name} -> {d.agent}" + (f" (depends: {d.depends_on})" if d.depends_on else "")
+                for name, d in self.tasks.items()
+            ],
+        ]
+        return "\n".join(lines)