[bugf][multi-agent-exec][same-named agents collapse into one dict entry]

run_agents_concurrently(return_agent_output_dict=True) keyed results by
agent_name and overwrote on collision. agent_name defaults to the same string
for every Agent, so a swarm whose agents never set one kept only the last
result.

MixtureOfAgents is the caller that feels it: step() returns that dict, _run
adds one conversation message per entry, and the aggregator then synthesises a
single opinion instead of the mixture. Nothing raises.

Duplicate keys are suffixed rather than overwritten, so the dict holds one
entry per agent as its docstring promises. get_final_agent_answer now pairs
agents with entries by position, because a name lookup would resolve every
duplicate back to the first agent's key.

Author: ayaangazali

swarms/structs/context_utils.py

@@ -131,11 +131,10 @@ def get_final_agent_answer(
     Returns:
         The same mapping with transcripts replaced by answers.
     """
+    # Paired by position, not by name: the mapping is built in agent order
+    # and duplicate names are suffixed to keep one entry per agent, so a
+    # name lookup would resolve every duplicate to the first agent's key.
     answers = dict(agent_outputs)
-    for agent in agents:
-        name = getattr(agent, "agent_name", None)
-        if name in answers:
-            answers[name] = agent_answer(
-                agent, fallback=answers[name]
-            )
+    for agent, key in zip(agents, answers):
+        answers[key] = agent_answer(agent, fallback=answers[key])
     return answers

swarms/structs/multi_agent_exec.py

@@ -169,6 +169,16 @@ def run_agents_concurrently(
                         or getattr(agent, "name", None)
                         or str(agent)
                     )
+                    # agent_name defaults to the same string for every
+                    # Agent, so a swarm whose agents did not set one had
+                    # every result land on one key and only the last
+                    # survive. Suffix instead of overwrite: callers ask for
+                    # this dict to get one entry per agent.
+                    if name in output_dict:
+                        suffix = 2
+                        while f"{name} ({suffix})" in output_dict:
+                            suffix += 1
+                        name = f"{name} ({suffix})"
                     output_dict[name] = result
                 return output_dict
             else:

tests/structs/test_multi_agent_exec.py

@@ -0,0 +1,51 @@
+"""Tests for swarms.structs.multi_agent_exec."""
+
+from swarms.structs.multi_agent_exec import run_agents_concurrently
+
+
+class _Stub:
+    """Minimal stand-in for an Agent: a name and a fixed answer."""
+
+    def __init__(self, agent_name: str, answer: str):
+        self.agent_name = agent_name
+        self._answer = answer
+
+    def run(self, task=None, **kwargs):
+        return self._answer
+
+
+def test_output_dict_keeps_one_entry_per_agent_when_names_collide():
+    """Agent.agent_name defaults to the same string for every agent.
+
+    A swarm whose agents never set one used to collapse into a single dict
+    entry, so MixtureOfAgents recorded one worker per layer and aggregated a
+    single opinion instead of the mixture it was asked for.
+    """
+    agents = [
+        _Stub("swarm-worker-01", f"answer-{i}") for i in range(3)
+    ]
+
+    outputs = run_agents_concurrently(
+        agents=agents, task="t", return_agent_output_dict=True
+    )
+
+    assert len(outputs) == 3, outputs
+    assert sorted(outputs.values()) == [
+        "answer-0",
+        "answer-1",
+        "answer-2",
+    ]
+
+
+def test_output_dict_leaves_distinct_names_untouched():
+    agents = [_Stub(f"worker-{i}", f"answer-{i}") for i in range(3)]
+
+    outputs = run_agents_concurrently(
+        agents=agents, task="t", return_agent_output_dict=True
+    )
+
+    assert outputs == {
+        "worker-0": "answer-0",
+        "worker-1": "answer-1",
+        "worker-2": "answer-2",
+    }