Re-evaluating Internal Message Handling in SocietyOfMindAgent (v0.4+)

[SongChiYoung]

What happened?

old message : First start with SocietyOfMindAgent leaking inner monologues to outter team

Describe the bug
When using a SocietyOfMindAgent inside a GroupChat, messages from the inner team (e.g., inner agents like agent1, agent2) are exposed to the outer GroupChat stream, rather than being contained within the internal reasoning. This leads to unexpected messages being surfaced to outer-level agents and logic, breaking isolation and causing potential routing/termination issues.

To Reproduce
Run the following minimal example:

import asyncio
from autogen_agentchat.agents import AssistantAgent, SocietyOfMindAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.conditions import MaxMessageTermination
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.ui import Console

async def main():
    model_client = OpenAIChatCompletionClient(model="gpt-4o")

    agent1 = AssistantAgent("agent1", model_client=model_client, system_message="You are a writer.")
    agent2 = AssistantAgent("agent2", model_client=model_client, system_message="You are a critic.")

    inner_team = RoundRobinGroupChat(
        participants=[agent1, agent2],
        termination_condition=MaxMessageTermination(2)
    )

    society_agent = SocietyOfMindAgent("society", team=inner_team, model_client=model_client)

    outer_agent = AssistantAgent("translator", model_client=model_client, system_message="Translate to Spanish.")

    team = RoundRobinGroupChat(
        participants=[society_agent, outer_agent],
        termination_condition=MaxMessageTermination(2)
    )

    await Console(team.run_stream(task="Write a short story."))

asyncio.run(main())

💥 Expected Console output shows all intermediate messages from the inner team:

user: Write a short story.
agent1: Once upon a time...
agent2: Needs more drama.
society: Here's the revised version.
translator: Aquí está la historia.

💥 Real Console output shows all intermediate messages from the inner team (Termination is do not work expected...):

user: Write a short story.
agent1: Once upon a time... 
society: Here's the revised version.

But expected behavior:

user: Write a short story.
>>> (inner, it could be do not showing) agent1: Once upon a time...
>>> (inner, it could be do not showing) agent2: Needs more drama.
society: Here's the revised version.
translator: Aquí está la historia.

Expected behavior

The SocietyOfMindAgent should:

• ✅ Internally run its team and return a single Response
• ✅ Prevent inner messages from leaking into the outer GroupChat stream
• ⚙️ Optionally log intermediate messages to Console, but not expose them as ChatMessages to the rest of the system

---

Additional context

This behavior breaks message encapsulation, which is particularly problematic when using nested teams.

These changes would make SocietyOfMindAgent much more robust and suitable for nested orchestration scenarios.

---

Question

Is this behavior (inner messages leaking into the outer GroupChat) intended?
Or is this something that might be considered a design oversight or bug?

Happy to propose a patch once the expected behavior is clarified. 🙌

I was able to investigate the core behavior of SocietyOfMindAgent more deeply. Since the original design intentions were not fully clear from the documentation alone, I compared the current implementation to the earlier version from v0.2.

Through this comparison, I confirmed that the current behavior introduces four functional regressions that did not exist before. Additionally, I identified four more architectural concerns introduced in recent versions.

I've summarized them in the table below for review. I would really appreciate any feedback or validation on this analysis.

---

🔍 SocietyOfMindAgent: Design Issues and Historical Comparison (v0.2 vs v0.4+)

✅ P1–P4 Regression Issue Table (Updated with Fixes in PR #6142)

ID	Description	Current v0.4+ Issue	Resolution in PR #6142	Was it a problem in v0.2?	Notes
P1	inner_messages leaks into outer team termination evaluation	Response.inner_messages is appended to the outer team's _message_thread, affecting termination conditions. Violates encapsulation.	✅ inner_messages is excluded from _message_thread, avoiding contamination of outer termination logic.	❌ No	Structural boundary is now enforced
P2	Inner team does not execute when outer message history is empty	In chained executions, if no new outer message exists, no task is created and the inner team is skipped entirely	✅ Detects absence of new outer message and reuses the previous task, passing it via a handoff message. This ensures the inner team always receives a valid task to execute	❌ No	The issue was silent task omission, not summary failure. Summary succeeds as a downstream effect
P3	Summary LLM prompt is built from external input only	Prompt is constructed using external message history, ignoring internal reasoning	✅ Prompt construction now uses final_response.inner_messages, restoring internal reasoning as the source of summarization	❌ No	Matches v0.2 internal monologue behavior
P4	External input is included in summary prompt (possibly incorrectly)	Outer messages are used in the final LLM summarization prompt	✅ Resolved via the same fix as P3; outer messages are no longer used for summary	❌ No	Redundant with P3, now fully addressed

ID	Description	Current v0.4+ Issue	Suggested Fix	Was it a problem in v0.2?	Notes
E1	Fragile count <= len(task) logic in stream parsing	Skips a fixed number of messages assuming they are tasks. Breaks with team structure changes.	Use explicit criteria like source == "user" to filter task messages	❌ No	v0.2 had no streaming/yield logic
E2	Streaming chunks (e.g. ModelClientStreamingChunkEvent) ambiguity	Some events are streamed but not stored — unclear if this is intentional	Add comments to clarify intent. Maintain current behavior.	❌ No	v0.2 had no streaming structure. Keep current but document clearly.
E3	Ambiguous task/message boundary	Outer tasks and inner messages are mixed conceptually	Clarify roles using message types or consistent tagging (e.g. source)	❌ No	v0.2 handled outer input as "User" consistently. Just verify that continues to be true.
E4	reset() may not run if exception occurs	If run_stream() fails mid-execution, reset() is skipped → potential team state corruption	Wrap reset() inside a finally block for guaranteed cleanup	⚠️ Partially	Same logic in v0.2; lacks finally, so it's not always guaranteed either

---

Error?? Need to more information

ID	Description	Current v0.4+ Issue	Suggested Fix	Was it a problem in v0.2?	Notes
P5	reset() on inner team affects outer team state	SocietyOfMindAgent calls await self._team.reset(), which resets shared team instances, unintentionally clearing the outer team's state	Ensure inner team is a separate instance (e.g., deep copy), or isolate reset() behavior to avoid cross-team interference	DoNot Check	DoNot Check however It's Error. Q.E.D.

Maybe... it's okay. Model context remember their context, so it's right behavior

---

If there are no objections to my conclusions, I would like to open a DRAFT PR to begin addressing these issues.

Since this agent is critical for a production use case I'm working on, I’m highly motivated to contribute toward improving its reliability.

Looking forward to your feedback—thank you!

Which packages was the bug in?

Python AgentChat (autogen-agentchat>=0.4.0)

AutoGen library version.

Python dev (main branch)

Other library version.

No response

Model used

No response

Model provider

None

Other model provider

No response

Python version

None

.NET version

None

Operating system

None

[ekzhu]

I don't think the chat messages from the inner teams are going into outter team agents' model context. However, the inner messages do get sent out to the outter team's output topic which then gets sent to the message stream.

I think the design oversight here is that inner teams's message gets into the outter team's termination condition -- this should not have happened.

We can fix this by avoiding adding the inner team messages to the "inner_messages" of the response from the SocietyOfMind agent.

This way the messages still get sent to the output stream but not the termination condition of the outer team.

[SongChiYoung]

Thanks @ekzhu — I’ll run a quick test again and share the outer team’s “history” soon.
I believe that checking the “history” is one good way to confirm whether message leakage is happening, right?

From what I recall in my previous test, it did seem like inner messages were leaking into the outer team’s message strea. But I’ll verify that again to be sure.

If that’s the case, then it sounds like this isn’t the intended architecture, and SocietyOfMindAgent may not be functioning correctly at the moment.

[ekzhu]

I think if you look at the outter team's group chat manager then you will find the messages from inner team. But those messages shouldn't be in outter team's participants

I believe the current behaviour needs to be updated to avoid the outter team's group chat manager to see inner team's messages

[SongChiYoung]

@ekzhu Yup, you're right.
Before My issue(what I said before) is maybe other issue.
However lost that test case, when I was troble shooting... haha

here is my more test cases

def test4():
    import asyncio
    from autogen_agentchat.agents import AssistantAgent, SocietyOfMindAgent
    from autogen_agentchat.teams import RoundRobinGroupChat
    from autogen_agentchat.conditions import MaxMessageTermination
    from autogen_ext.models.openai import OpenAIChatCompletionClient
    from autogen_agentchat.ui import Console

    async def _test():
        agent1 = AssistantAgent("CHI", model_client=openai_client(), system_message="JUST say 'CHI'")
        agent2 = AssistantAgent("YOUNG", model_client=openai_client(), system_message="JUST say 'YOUNG'")

        inner_team = RoundRobinGroupChat(
            participants=[agent1, agent2],
            termination_condition=MaxMessageTermination(3)
        )

        # start_agent = AssistantAgent("start", model_client=openai_client(), system_message="Say ===[START]===")

        society_agent = SocietyOfMindAgent("foobar", team=inner_team, model_client=openai_client(), instruction="", response_prompt="JUST say 'foobar'")

        outer_agent = AssistantAgent("earlier_messages", model_client=openai_client(), system_message="Say all of earlier messages. assistant/user/anyting messages too.")

        team = RoundRobinGroupChat(
            participants=[society_agent, outer_agent],
            termination_condition=MaxMessageTermination(5)
        )

        await Console(team.run_stream(task="===[START]==="))

    asyncio.run(_test())


def test5():
    import asyncio
    from autogen_agentchat.agents import AssistantAgent, SocietyOfMindAgent
    from autogen_agentchat.teams import RoundRobinGroupChat, SelectorGroupChat
    from autogen_agentchat.conditions import MaxMessageTermination
    from autogen_ext.models.openai import OpenAIChatCompletionClient
    from autogen_agentchat.ui import Console

    async def _test():
        agent1 = AssistantAgent("CHI", model_client=openai_client(), system_message="JUST say 'CHI'")
        agent2 = AssistantAgent("YOUNG", model_client=openai_client(), system_message="JUST say 'YOUNG'")

        inner_team = SelectorGroupChat(
            participants=[agent1, agent2],
            selector_prompt="first say CHI, next say YOUNG, and repeat",
            termination_condition=MaxMessageTermination(3),
            model_client=openai_client()
        )

        # start_agent = AssistantAgent("start", model_client=openai_client(), system_message="Say ===[START]===")

        society_agent = SocietyOfMindAgent("foobar", team=inner_team, model_client=openai_client(), instruction="", response_prompt="JUST say 'foobar'")

        outer_agent = AssistantAgent("earlier_messages", model_client=openai_client(), system_message="Say all of earlier messages. assistant/user/anyting messages too.")

        team = SelectorGroupChat(
            participants=[society_agent, outer_agent],
            selector_prompt="first say foobar, next say earlier_messages, and repeat",
            termination_condition=MaxMessageTermination(5), 
            model_client=openai_client()
        )

        await Console(team.run_stream(task="===[START]==="))

    asyncio.run(_test())


def test6():
    import asyncio
    from autogen_agentchat.agents import AssistantAgent, SocietyOfMindAgent
    from autogen_agentchat.teams import RoundRobinGroupChat, SelectorGroupChat
    from autogen_agentchat.conditions import MaxMessageTermination
    from autogen_ext.models.openai import OpenAIChatCompletionClient
    from autogen_agentchat.ui import Console

    async def _test():
        client = openai_client()

        agent1 = AssistantAgent("CHI", model_client=client, system_message="JUST say 'CHI'")
        agent2 = AssistantAgent("YOUNG", model_client=client, system_message="JUST say 'YOUNG'")

        inner_team = SelectorGroupChat(
            participants=[agent1, agent2],
            selector_prompt="first say CHI, next say YOUNG, and repeat",
            termination_condition=MaxMessageTermination(3),
            model_client=client
        )

        # start_agent = AssistantAgent("start", model_client=openai_client(), system_message="Say ===[START]===")

        society_agent = SocietyOfMindAgent("foobar", team=inner_team, model_client=client, instruction="", response_prompt="JUST say 'foobar'")

        outer_agent = AssistantAgent("earlier_messages", model_client=client, system_message="Say all of earlier messages. assistant/user/anyting messages too.")

        team = SelectorGroupChat(
            participants=[society_agent, outer_agent],
            selector_prompt="first say foobar, next say earlier_messages, and repeat",
            termination_condition=MaxMessageTermination(5), 
            model_client=client
        )

        await Console(team.run_stream(task="===[START]==="))

    asyncio.run(_test())

all of these cases, result is like that

---------- user ----------
===[START]===
Agent: CHI Message: source='user' models_usage=None metadata={} content='===[START]===' type='TextMessage'
Agent: YOUNG Message: source='user' models_usage=None metadata={} content='===[START]===' type='TextMessage'
Agent: YOUNG Message: source='CHI' models_usage=RequestUsage(prompt_tokens=22, completion_tokens=2) metadata={} content='CHI' type='TextMessage'
---------- CHI ----------
CHI
---------- YOUNG ----------
YOUNG
---------- foobar ----------
foobar
Agent: earlier_messages Message: source='user' models_usage=None metadata={} content='===[START]===' type='TextMessage'
Agent: earlier_messages Message: source='foobar' models_usage=RequestUsage(prompt_tokens=26, completion_tokens=2) metadata={} content='foobar' type='TextMessage'
---------- earlier_messages ----------
It looks like you've entered "foobar." How can I assist you today?
(python) (base) ➜  my-app python errortest.py
/Users/cysong/Documents/MOTOV_업무/codes/TIPS/ai-agent/autogen/python/packages/autogen-ext/src/autogen_ext/models/openai/_openai_client.py:417: UserWarning: Missing required field 'structured_output' in ModelInfo. This field will be required in a future version of AutoGen.
  validate_model_info(self._model_info)
---------- user ----------
===[START]===
Agent: CHI Message: source='user' models_usage=None metadata={} content='===[START]===' type='TextMessage'
Agent: YOUNG Message: source='user' models_usage=None metadata={} content='===[START]===' type='TextMessage'
Agent: YOUNG Message: source='CHI' models_usage=RequestUsage(prompt_tokens=22, completion_tokens=2) metadata={} content='CHI' type='TextMessage'
---------- CHI ----------
CHI
---------- YOUNG ----------
YOUNG
---------- foobar ----------
foobar
Agent: earlier_messages Message: source='user' models_usage=None metadata={} content='===[START]===' type='TextMessage'
Agent: earlier_messages Message: source='foobar' models_usage=RequestUsage(prompt_tokens=26, completion_tokens=2) metadata={} content='foobar' type='TextMessage'
---------- earlier_messages ----------
Hello! How can I assist you today?

-- Message outputs are from changed AssistantAgent code for debugging

However, still inner teams's message gets into the outter team's termination condition.

And I could found other issue.

When I using SelectorGroupChat, I was printed "history" for debugging.

====================history====================
participants(for check this is what team) : ['foobar', 'earlier_messages']
user: ===[START]===


===============================================
====================history====================
participants(for check this is what team) : ['CHI', 'YOUNG']
user: ===[START]===


===============================================
---------- user ----------
===[START]===
====================history====================
participants(for check this is what team) : ['CHI', 'YOUNG']
user: ===[START]===


CHI: CHI


===============================================
---------- CHI ----------
CHI
---------- YOUNG ----------
YOUNG
---------- foobar ----------
foobar
====================history====================
participants(for check this is what team) : ['foobar', 'earlier_messages']
user: ===[START]===


CHI: CHI


YOUNG: YOUNG


foobar: foobar


===============================================
---------- earlier_messages ----------
To start the process, please let me know what you'd like to do with the term "foobar"! Are you looking for a definition, usage in programming, or something else entirely?

Yup. Outter team's history(When I using history) has inner team's speak.
That mean is that, Outter team BaseGroupChatManager's _message_thread has that Inner teams speak.

So...
Why? agent do not takes inner team's speak however that messages leaking to history?
Now I will read the code more deeper.

And, to TextMentionTermination("CHI") logic is leaking too. look under test code

def test6():
    import asyncio
    from autogen_agentchat.agents import AssistantAgent, SocietyOfMindAgent
    from autogen_agentchat.teams import RoundRobinGroupChat, SelectorGroupChat
    from autogen_agentchat.conditions import MaxMessageTermination,TextMentionTermination
    from autogen_ext.models.openai import OpenAIChatCompletionClient
    from autogen_agentchat.ui import Console

    async def _test():
        client = openai_client()

        agent1 = AssistantAgent("CHI", model_client=client, system_message="JUST say 'CHI'")
        agent2 = AssistantAgent("YOUNG", model_client=client, system_message="JUST say 'YOUNG'")

        inner_team = SelectorGroupChat(
            participants=[agent1, agent2],
            selector_prompt="first say CHI, next say YOUNG, and repeat",
            termination_condition=MaxMessageTermination(3),
            model_client=client
        )

        # start_agent = AssistantAgent("start", model_client=openai_client(), system_message="Say ===[START]===")

        society_agent = SocietyOfMindAgent("foobar", team=inner_team, model_client=client, instruction="", response_prompt="JUST say 'foobar'")

        outer_agent = AssistantAgent("earlier_messages", model_client=client, system_message="Say all of earlier messages. assistant/user/anyting messages too.")

        team = SelectorGroupChat(

            participants=[society_agent, outer_agent],
            selector_prompt="first say foobar, next say earlier_messages, and repeat",
            termination_condition=MaxMessageTermination(10) | TextMentionTermination("CHI"),
            model_client=client
        )

        await Console(team.run_stream(task="===[START]==="))

    asyncio.run(_test())

Thats output is that

====================history====================
participants(for check this is what team) : ['foobar', 'earlier_messages']
user: ===[START]===


===============================================
=============MESSAGES=============
Agent: earlier_messages Message: source='user' models_usage=None metadata={} content='===[START]===' type='TextMessage'
=============MESSAGESDONE=============
---------- user ----------
===[START]===
---------- earlier_messages ----------
====================history====================
participants(for check this is what team) : ['foobar', 'earlier_messages']
user: ===[START]===


earlier_messages: Hello! How can I assist you today?


===============================================
Hello! How can I assist you today?
====================history====================
participants(for check this is what team) : ['CHI', 'YOUNG']
user: ===[START]===


earlier_messages: Hello! How can I assist you today?


===============================================
=============MESSAGES=============
Agent: CHI Message: source='user' models_usage=None metadata={} content='===[START]===' type='TextMessage'
Agent: CHI Message: source='earlier_messages' models_usage=RequestUsage(prompt_tokens=31, completion_tokens=10) metadata={} content='Hello! How can I assist you today?' type='TextMessage'
=============MESSAGESDONE=============
---------- CHI ----------
CHI
---------- foobar ----------
foobar

When Says "CHI" that outter team is terminated.

[SongChiYoung]

@ekzhu While investigating the issue discussed, I noticed that appending inner_messages to self._message_thread in _base_group_chat_manager.py might be related to the observed behavior.

I'm not certain if this is the intended behavior, or if I might be missing a part of the design.

Here's the relevant section from _base_group_chat_manager.py:141–162:

@event
async def handle_agent_response(self, message: GroupChatAgentResponse, ctx: MessageContext) -> None:
    # Append the message to the message thread and construct the delta.
    delta: List[AgentEvent | ChatMessage] = []
    if message.agent_response.inner_messages is not None:
        for inner_message in message.agent_response.inner_messages:
            self._message_thread.append(inner_message)
            delta.append(inner_message)
    self._message_thread.append(message.agent_response.chat_message)
    delta.append(message.agent_response.chat_message)

    # Check if the conversation should be terminated.
    if self._termination_condition is not None:
        stop_message = await self._termination_condition(delta)
        if stop_message is not None:
            # Reset the termination conditions and turn count.
            await self._termination_condition.reset()
            self._current_turn = 0
            # Signal termination to the caller of the team.
            await self._signal_termination(stop_message)
            # Stop the group chat.
            return

I saw that this logic was introduced in PR #4062. I also reviewed #4438 and #4039 to understand how inner_messages are handled, but I'm still unclear on their role in the overall message flow.

If possible, could you share the reasoning behind appending inner_messages to the message thread? I'm trying to get a better grasp of the expected behavior and architectural intent.

Thank you—really appreciate your time and insights!

[ekzhu]

The message thread is used for selecting the next speaker, which sometimes require access to the inner messages produced by each agent in the group chat. For example, in a SelectorGroupChat, you may want to make a decision on which agent to select based on whether a specifiec function has been invoked or the result of the function, then you need to observe the inner messages from the agents to make that decision.

Which message to put on the message thread is entirely up to the implementation of each Team. For example, the MagenticOneOrchestrator does not put inner messages in its message thread.

To solve the leaking inner team's message, the easiest way is to not populate the SocietyOfMindAgent's inner message with inner team's messages. The termination condition of the outter team uses the inner messages in the Response object.

The message flow for streaming output is different. The output messages you see from run_stream comes from the messages published to the output topic.

[SongChiYoung]

@ekzhu
Thank you again for your insights.

Thanks to your guidance, I was able to investigate the core behavior of SocietyOfMindAgent more deeply. Since the original design intentions were not fully clear from the documentation alone, I compared the current implementation to the earlier version from v0.2.

Through this comparison, I confirmed that the current behavior introduces four functional regressions that did not exist before. Additionally, I identified four more architectural concerns introduced in recent versions.

I've summarized them in the table below for review. I would really appreciate any feedback or validation on this analysis.

---

🔍 SocietyOfMindAgent: Design Issues and Historical Comparison (v0.2 vs v0.4+)

ID	Description	Current v0.4+ Issue	Suggested Fix	Was it a problem in v0.2?	Notes
P1	inner_messages leaks into outer team termination evaluation	Response.inner_messages is appended to the outer team's _message_thread, affecting termination conditions. Violates encapsulation.	Exclude inner_messages from Response, or separate into a private field like llm_input_messages	❌ No	inner_messages concept didn’t exist in v0.2
P2	Summary fails if inner_messages is empty	Removing inner_messages entirely from the response leaves the summary prompt empty, causing summarization failure	Maintain internal messages separately, specifically for summarization purposes	❌ No	v0.2 directly managed inner monologue messages (self._group_chat.messages) correctly, thus never had this issue
P3	Summary LLM prompt is built from external input only	llm_messages = [instruction] + messages + [response_prompt] — internal reasoning is ignored	Construct prompt from inner reasoning instead	❌ No	v0.2 used group_chat.messages for summarization
P4	External input is included in summary prompt (possibly incorrectly)	Outer messages are used in the final LLM summarization prompt	Use internal reasoning exclusively for summary generation	❌ No	v0.2 used external input only for silent context
E1	Fragile count <= len(task) logic in stream parsing	Skips a fixed number of messages assuming they are tasks. Breaks with team structure changes.	Use explicit criteria like source == "user" to filter task messages	❌ No	v0.2 had no streaming/yield logic
E2	Streaming chunks (e.g. ModelClientStreamingChunkEvent) ambiguity	Some events are streamed but not stored — unclear if this is intentional	Add comments to clarify intent. Maintain current behavior.	❌ No	v0.2 had no streaming structure. Keep current but document clearly.
E3	Ambiguous task/message boundary	Outer tasks and inner messages are mixed conceptually	Clarify roles using message types or consistent tagging (e.g. source)	❌ No	v0.2 handled outer input as "User" consistently. Just verify that continues to be true.
E4	reset() may not run if exception occurs	If run_stream() fails mid-execution, reset() is skipped → potential team state corruption	Wrap reset() inside a finally block for guaranteed cleanup	⚠️ Partially	Same logic in v0.2; lacks finally, so it's not always guaranteed either

---

Error?? Need to more information

ID	Description	Current v0.4+ Issue	Suggested Fix	Was it a problem in v0.2?	Notes
P5	reset() on inner team affects outer team state	SocietyOfMindAgent calls await self._team.reset(), which resets shared team instances, unintentionally clearing the outer team's state	Ensure inner team is a separate instance (e.g., deep copy), or isolate reset() behavior to avoid cross-team interference	DoNot Check	DoNot Check however It's Error. Q.E.D.

Maybe... it's okay. Model context remember their context, so it's right behavior

---

If there are no objections to my conclusions, I would like to open a DRAFT PR to begin addressing these issues.

Since this agent is critical for a production use case I'm working on, I’m highly motivated to contribute toward improving its reliability.

Looking forward to your feedback—thank you!

[ekzhu]

Thanks @SongChiYoung for identifying these issues. I agree with most of them. A few notes:

E1: Fragile count <= len(task) logic in stream parsing

This should be addressed by adding a output_task_messages to run_stream methods to avoid messages in task are included. Issue: #6150

E2 | Streaming chunks (e.g. ModelClientStreamingChunkEvent) ambiguity

I think inner messages can be streamed as well. Streamed (i.e., yielded) messages are for observability not for agent-agent communication. This might be a mistake not streaming it. We can experiment with it and see.

P5 | reset() on inner team affects outer team state

I believe we need to clarify in the API doc that the inner teams should be independent and should not share agents with the outer team to avoid unintended behavior. Right now, there isn't an easy way to check it, as teams can be recursive. So, I think it is one of the kinds of behavior that needs to enforce by the application for now.

[ekzhu]

Adding @EItanya for users of SocietyOfMindAgent. Also add @afourney who created the original version.

[SongChiYoung]

@ekzhu Thanks a lot for your insights!

Hello @EItanya and @afourney,

Could you please take a look at my draft PR (#6142)?
I’ve made some changes that, in my testing, seem to work well in the cases I’ve encountered.

If you have any suggestions or can validate the approach, I’d greatly appreciate it. By working together, I believe we can significantly improve the SocietyOfMindAgent and provide better tools for all AI agent developers within the AutoGen community.

Looking forward to your feedback!