Role of kernel in AgentGroupChat for multi agent implementation

[AyushAP8]

Language: Python

I am trying to implement a workflows with 7 agents passing the agent ids from the ai foundry portal and initialising them with AzureAIAgent() then passing them into an AgentGroupChat with selection strategies and terminations strategies. I want a little clarity on the role of kernel in all of these since its used by the agent and strategies.

1. does the kernel maintain the chat history between the agents
2. Can I give a different kernel to each agent and both the strategies(selection. termination) and still expects chat history to be managed between the agents and also the selection and termination strategies functioning correctly
3. when there is a kernel involved the function calling from the individual agents doesn't take place, instead error for absence of the kernel plugins with the functions name is always shown

[AyushAP8]

One more add on question - What is the advantages and disadvantages of giving a separate kernel or using the same kernel for all the agents in the AgentGroupChat, the selection strategy and the termination strategy. I have share below a excerpt of my code for reference
`TERMINATION_KEYWORD = "exit"

class ApprovalTerminationStrategy(TerminationStrategy):
"""A strategy for determining when an agent should terminate."""

async def should_agent_terminate(self, agent, history):
    """Check if the agent should terminate."""
    return TERMINATION_KEYWORD in history[-1].content.lower()

SELCTION_PROMPT = [f"""
Examine the provided RESPONSE and choose the next participant.
State only the name of the chosen participant without explanation.
Never choose the participant named in the RESPONSE.

        Choose only from these participants:
        - {"Document_Agent"}
        - {"Summary_Agent"}
        - {"Web_Agent"}
        - {"Email_Agent"}
        - {"Calculation_Agent"}
        - {"Weather_Agent"}
        - {"Orchestrator_Agent"}
    
        Rules
        - If the RESPONSE is user input and it asks about documents or files, select {"Document_Agent"}
        - If the RESPONSE is by {"Document_Agent"}, it is {"Web_Agent"}'s turn, 
        - If the RESPONSE is by {"Web_Agent"} it is {"Summary_Agent"}'s turn.
        - If the RESPONSE is user input and it asks about the internet or online sources, select {"Web_Agent"}
        - If the RESPONSE is user input and it asks to send, draft, or manage emails, select {"Email_Agent"}.
        - If the RESPONSE is user input and it asks to perform any kind of math, logic, or numerical task, select {"Calculation_Agent"}.
        - If the RESPONSE is user input and it asks about weather, select {"Weather_Agent"} 
        - If the RESPONSE is by {"Weather_Agent"} it is {"Calculation_Agent"}'s turn to convert the temperature from F to C.
        - If the RESPONSE is by {"Weather_Agent"} and if it asks to send an email then its {"Email_Agent"}'s instead of 
           {"Calculation_Agent"}'s turn.
        - If the RESPONSE is by {"Summary_Agent"} it is {"Orchestrator_Agent"}'s turn.
        - If the RESPONSE is by {"Email_Agent"} it is {"Orchestrator_Agent"}'s turn.
        - If the RESPONSE is by {"Calculation_Agent"} it is {"Orchestrator_Agent"}'s.
        
    
        RESPONSE:
        {{{{$history}}}}
        """]

async def main():
# Initialize credentials and the Azure AI Projects client
credential = DefaultAzureCredential()

# Use the async context for proper cleanup of the credential and client
async with credential, AzureAIAgent.create_client(credential=credential) as client:
    # Retrieve pre-created agent definitions for each role
    document_agent_def = await client.agents.get_agent(agent_id=AGENT1_ID)
    web_agent_def = await client.agents.get_agent(agent_id=AGENT2_ID)
    summary_agent_def = await client.agents.get_agent(agent_id=AGENT3_ID)
    email_agent_def = await client.agents.get_agent(agent_id=AGENT4_ID)
    calculation_agent_def = await client.agents.get_agent(agent_id=AGENT5_ID)
    weather_agent_def = await client.agents.get_agent(agent_id=AGENT6_ID)
    orchestrator_agent_def = await client.agents.get_agent(agent_id=AGENT7_ID)
    
    # Update the agent definitions with the tools like custom functions, OpenAPI specs
    web_agent_def = await client.agents.update_agent(agent_id=AGENT2_ID,tools=web_function_tools.definitions)
    email_agent_def = await client.agents.update_agent(agent_id=AGENT4_ID, tools=email_function_tools.definitions)
    calculation_agent_def = await client.agents.update_agent(agent_id=AGENT5_ID, tools=calculation_function_tools.definitions)
    weather_agent_def = await client.agents.update_agent(agent_id=AGENT6_ID, tools=openapi.definitions)        

    # Instantiate Semantic Kernel agent objects
    document_agent = AzureAIAgent(client=client, definition=document_agent_def, kernel=create_kernel(service_id="doc"))
    web_agent = AzureAIAgent(client=client, definition=web_agent_def, plugins=[WebPlugin()], kernel=create_kernel(service_id="web"))
    summary_agent = AzureAIAgent(client=client, definition=summary_agent_def, kernel=create_kernel(service_id="summ"))
    email_agent = AzureAIAgent(client=client, definition=email_agent_def, plugins=[EmailPlugin()], kernel=create_kernel(service_id="email"))
    calculation_agent = AzureAIAgent(client=client, definition=calculation_agent_def, plugins=[CalculationPlugin()], kernel=create_kernel(service_id="calc"))
    weather_agent = AzureAIAgent(client=client, definition=weather_agent_def, kernel=create_kernel(service_id="weat"))
    orchestrator_agent = AzureAIAgent(client=client, definition=orchestrator_agent_def, kernel=create_kernel(service_id="orch"))
    
    # Creating the selection and termination strategies
    selection_function = KernelFunctionFromPrompt(function_name="selection", prompt=SELECTION_PROMPT[0])

    #Providing the slection & termination strategies with only the most recent Chat messages decreasing token usage
    history_reducer = ChatHistoryTruncationReducer(target_count=3, threshold_count = 2)
    
    #Creating the group chat for the agents to interact with eachother in
    chat = AgentGroupChat(agents=[weather_agent, summary_agent, email_agent, document_agent, calculation_agent, web_agent, orchestrator_agent],
                            selection_strategy=KernelFunctionSelectionStrategy(
                                function=selection_function,
                                kernel=create_kernel(service_id="selection"),
                                result_parser=lambda result: str(result.value[0]).strip() if result.value[0] is not None else "Orchestrator_Agent",
                                agent_variable_name="agents",
                                history_variable_name="history",
                                history_reducer=history_reducer
                            ),
                            termination_strategy=ApprovalTerminationStrategy()
                        )`

[sophialagerkranspandey]

Tagging @alliscode

[AyushAP8]

@alliscode, hey, I would really love some clarity on these concepts. thank you.

[crickman]

@AyushAP8, thanks for your question.

The Kernel object doesn't directly interact with AgentGroupChat. At the Agent level, the kernel is used to associate plugins and filters. Since each agent is likely to require different tooling (plugins), assigning a specific Kernel instance to each agent is often desired.

The selection and termination strategies rely on the Kernel to provide the required chat-completion service.

As a direct response to our questions:

1. does the kernel maintain the chat history between the agents: No
2. Can I give a different kernel to each agent and both the strategies(selection. termination) and still expects chat history to be managed between the agents and also the selection and termination strategies functioning correctly: Yes
3. when there is a kernel involved the function calling from the individual agents doesn't take place, instead error for absence of the kernel plugins with the functions name is always shown: I'm not fully parsing this question. Can you please provide additional (specific) detail so we can analyize if there is potentially a bug that needs to be addressed in Python agents?
4. What is the advantages and disadvantages of giving a separate kernel or using the same kernel for all the agents in the AgentGroupChat, the selection strategy and the termination strategy. The advantage to providing a unique kernel to each agent is to cleanly partition which plugins are available.