Deeper Dive into Agentic Framework

[lovedeepatsgit]

I have used Autogen and Semantic Kernels ( Using Python and C#), Thanks to @moonbox3 for clarifying the difference between Autogen and SK (#9983), But I have few queries regarding the working of Agents in Semantic Kernels:

1. What role exactly a kernels plays in Agentic Framework, I know that we can add plugins and ai services to kernels, so agent is added to kernel or a kernel is added to Agent, or does this share a relationship like Agents provides commands to kernel then further kernel interacts with added services.
2. In AgentGroupChat, what exactly Strategy and termination functions are, I have faced an issue in multiagent approach and unable to understand the basic working and fundamentals of these strategies? if someone can explain using code and parameters of these two that it will be helpful? Answers from python or C# both are preferred or simply the logic will also help.

[moonbox3]

Hi @lovedeepatsgit, thanks for your question. Here are my thoughts:

The Role of the Kernel in the Agentic Framework

Kernel Basics

• The Kernel in Semantic Kernel is primarily a container (or manager) of AI services and plugins.
  • AI services could be OpenAI, Azure OpenAI, or any other language model you configure.
  • Plugins are additional “skills” or “functions” that the Kernel can call -- like reading/writing files, searching the web, summarizing text, etc.

Agent Integration

• Each Agent in Semantic Kernel (see agent.py) holds a reference to a Kernel object.
• This means an agent can use the kernel’s features -- like calling a plugin function or sending prompts to an AI service.
• You can see this in the base Agent class:

  class Agent(KernelBaseModel):
      kernel: Kernel = Field(default_factory=Kernel)
      ...

• Because the Agent has a kernel property, your environment is effectively:
  1. You create/configure the Kernel (e.g., add your plugins and AI services if using the ChatCompletionAgent).
  2. Agents ask the Kernel to do tasks—like “call function X in plugin Y”

Key Points:

• It’s neither strictly “agent is added to kernel” nor “kernel is added to agent.”
• Instead:
  • The agent depends on the kernel.
  • One or more Agents can use the same Kernel instance, or each Agent could have its own Kernel object if preferred.
• Agents give instructions (function calls, prompt requests) to the Kernel, and the Kernel orchestrates all the plugin and AI service activity.

---

Strategies and Termination in AgentGroupChat

What Are Strategies?

• A Strategy is a policy or approach that decides how the multi-agent conversation flows:
  1. Selection Strategies decide which Agent should speak next.
     • SequentialSelectionStrategy goes through the Agents in a round-robin sequence.
     • KernelFunctionSelectionStrategy can pick the next Agent by calling a function in your Kernel to decide (like an AI-based decision).
  2. Termination Strategies decide when the chat (or iteration loop) should end.
     • Example: DefaultTerminationStrategy never terminates by itself—it only runs for maximum_iterations iterations (set to 1 by default).
     • Advanced strategies, like an ApprovalStrategy might watch for “stop words” or conditions in the conversation that signal “we’re done.”

        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 "approved" in history[-1].content.lower()

Example Flow:

Suppose you have 3 Agents in an AgentGroupChat. When you call invoke(), it does the following:

1. Checks if is_complete is True—if so, it resets or raises an exception (depending on your config).
2. If not complete:
   • Loops up to termination_strategy.maximum_iterations times:
     1. The selection_strategy.next(...) picks an Agent from the group.
     2. AgentGroupChat calls invoke_agent(selectedAgent).
     3. After the selected Agent responds, the termination_strategy.should_terminate(...) is checked (for that Agent and current message history).
     4. If should_terminate is True, sets is_complete to True and breaks the loop.

To Recap:

• SelectionStrategy controls who speaks next.
• TerminationStrategy controls when the conversation ends.

Strategy Parameters:

• In your code, the constructor for AgentGroupChat can receive a custom termination_strategy and selection_strategy:

  group_chat = AgentGroupChat(
      agents=[agent1, agent2],
      termination_strategy=MyCustomTerminationStrategy(...),
      selection_strategy=MyCustomSelectionStrategy(...),
  )

• Each strategy might have parameters like:
  • maximum_iterations: The maximum loop count before forcing a stop.
  • automatic_reset: Whether to reset the conversation automatically once done.
  • history: You might pass partial conversation history or references to help the strategy make decisions (like if the conversation has a certain keyword).

Note: the termination_strategy and selection_strategy arguments are optional. If not specified they default to:

termination_strategy: TerminationStrategy = Field(default_factory=DefaultTerminationStrategy)
selection_strategy: SelectionStrategy = Field(default_factory=SequentialSelectionStrategy)

---

General Takeaways:

1. Kernel(s): Provide the functionality (plugins + AI). Agents call into the Kernel to do “stuff.”
2. Agents: Are your conversation endpoints. Each Agent has a kernel and can respond using the Kernel’s features.
3. SelectionStrategy: Chooses which Agent is next when you have multiple Agents.
4. TerminationStrategy: Chooses when to end the conversation. Could be time-based, iteration-based, or content-based.

All of these components -- Kernel, Agents, Strategies, etc. -- are designed to be modular and interchangeable, so you can adapt them for your needs.

[lovedeepatsgit]

Thanks a Lot @moonbox3