[bugf][multi-agent-router][hybrid-swarm][give each task its own Conversation instead of sharing one across threads (kyegomez#2054)]

MultiAgentRouter and HybridHierarchicalClusterSwarm both built one Conversation
in __init__ and wrote to it from run()/route_task(). Both also fan those same
methods across a thread pool - hybrid_hiearchical_peer_swarm.py:212 via
run_concurrently(self.run, tasks), multi_agent_router.py:485 via
executor.submit(self.route_task, task) - so N threads appended to one object and
each caller got every task's messages back, not its own.

Demonstrated with the same shape in isolation, 8 concurrent callers:

  shared instance -> [1, 2, 3, 4, 5, 6, 7, 8]
  per-call        -> [1, 1, 1, 1, 1, 1, 1, 1]

Resetting the shared Conversation at the top of run() would fix sequential reuse
but not this: concurrent callers would still race on the reset. The conversation
is per-task state, so it is now constructed in the per-task entry point and
threaded explicitly into the helpers that record into it. That also removes the
sequential leak, since nothing survives the call.

self.conversation is gone from both classes rather than left vestigial; no
caller in the repo read it, and leaving it would be a shared object that looks
live but is never written.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ayaangazali

swarms/structs/hybrid_hiearchical_peer_swarm.py

@@ -118,8 +118,6 @@ def __init__(
         self.max_loops = max_loops
         self.output_type = output_type
 
-        self.conversation = Conversation()
-
         self.router_agent = Agent(
             agent_name="Router Agent",
             agent_description="A router agent that routes tasks to the appropriate swarms.",
@@ -146,7 +144,8 @@ def run(self, task: str, *args, **kwargs):
         if not task:
             raise ValueError("Task cannot be empty.")
 
-        self.conversation.add(role="User", content=task)
+        conversation = Conversation()
+        conversation.add(role="User", content=task)
 
         response = self.router_agent.run(task=task)
 
@@ -167,10 +166,10 @@ def run(self, task: str, *args, **kwargs):
                 f"Please check the response format from the model: {self.router_agent.model_name}."
             )
 
-        self.route_task(swarm_name, task_description)
+        self.route_task(swarm_name, task_description, conversation)
 
         return history_output_formatter(
-            self.conversation, self.output_type
+            conversation, self.output_type
         )
 
     def find_swarm_by_name(self, swarm_name: str):
@@ -188,13 +187,19 @@ def find_swarm_by_name(self, swarm_name: str):
                 return swarm
         return None
 
-    def route_task(self, swarm_name: str, task_description: str):
+    def route_task(
+        self,
+        swarm_name: str,
+        task_description: str,
+        conversation: Conversation,
+    ):
         """
         Routes the task to the specified swarm.
 
         Args:
             swarm_name (str): The name of the swarm to route the task to.
             task_description (str): The description of the task to be executed.
+            conversation (Conversation): The conversation to record the output in.
 
         Raises:
             ValueError: If the swarm is not found.
@@ -203,7 +208,7 @@ def route_task(self, swarm_name: str, task_description: str):
 
         if swarm:
             output = swarm.run(task_description)
-            self.conversation.add(role=swarm.name, content=output)
+            conversation.add(role=swarm.name, content=output)
         else:
             raise ValueError(f"Swarm '{swarm_name}' not found.")
 

swarms/structs/multi_agent_router.py

@@ -182,7 +182,6 @@ def __init__(
         self.system_prompt = system_prompt
         self.skip_null_tasks = skip_null_tasks
         self.agents = list(agents) if agents else []
-        self.conversation = Conversation()
 
         router_system_prompt = ""
 
@@ -249,15 +248,18 @@ def _create_boss_system_prompt(self) -> str:
         return agent_boss_router_prompt(agent_descriptions)
 
     def handle_single_handoff(
-        self, boss_response_str: dict, task: str
+        self,
+        boss_response_str: dict,
+        task: str,
+        conversation: Conversation,
     ) -> dict:
         """
         Execute the single agent selected by the boss and record its response.
 
         Looks up the agent named in the first (and only) handoff, runs it on
         the modified task (falling back to the original task if the boss did
         not rewrite it), and appends the agent's response to
-        ``self.conversation``. When ``skip_null_tasks`` is True and the
+        ``conversation``. When ``skip_null_tasks`` is True and the
         resolved task is empty or ``None``, execution is skipped.
 
         Args:
@@ -300,14 +302,17 @@ def handle_single_handoff(
         # Use the agent's run method directly
         agent_response = selected_agent.run(final_task)
 
-        self.conversation.add(
+        conversation.add(
             role=selected_agent.agent_name, content=agent_response
         )
 
         # return agent_response
 
     def handle_multiple_handoffs(
-        self, boss_response_str: dict, task: str
+        self,
+        boss_response_str: dict,
+        task: str,
+        conversation: Conversation,
     ) -> dict:
         """
         Execute every agent selected by the boss and record the first response.
@@ -317,7 +322,7 @@ def handle_multiple_handoffs(
         task (or the original ``task`` when the boss did not rewrite it). When
         ``skip_null_tasks`` is True, agents whose resolved task is empty or
         ``None`` are skipped. After execution, the first selected agent's
-        response is appended to ``self.conversation``.
+        response is appended to ``conversation``.
 
         Args:
             boss_response_str (dict): Parsed boss decision containing a
@@ -380,7 +385,7 @@ def handle_multiple_handoffs(
                 )
             ]
 
-            self.conversation.add(
+            conversation.add(
                 role=selected_agents[0].agent_name,
                 content=agent_responses[0],
             )
@@ -398,7 +403,8 @@ def route_task(self, task: str) -> dict:
             dict: A dictionary containing the routing result, including the selected agent, reasoning, and response.
         """
         try:
-            self.conversation.add(role="user", content=task)
+            conversation = Conversation()
+            conversation.add(role="user", content=task)
 
             # Get boss decision using function calling
             boss_response_str = self.function_caller.run(task)
@@ -412,12 +418,16 @@ def route_task(self, task: str) -> dict:
                 )
 
             if len(boss_response_str["handoffs"]) > 1:
-                self.handle_multiple_handoffs(boss_response_str, task)
+                self.handle_multiple_handoffs(
+                    boss_response_str, task, conversation
+                )
             else:
-                self.handle_single_handoff(boss_response_str, task)
+                self.handle_single_handoff(
+                    boss_response_str, task, conversation
+                )
 
             return history_output_formatter(
-                conversation=self.conversation, type=self.output_type
+                conversation=conversation, type=self.output_type
             )
 
         except Exception as e: