Python: Bug: max_round_count ends loop without returning results—unlike AutoGen behavior

[zaid4hmed]

Describe the bug
Using Semantic Kernel with max_round_count set to limit iterations stops execution correctly, but instead of returning the partial results accumulated so far, the output is simply:
"max round reach"
This differs from AutoGen, which returns the available result at the limit, then stops.

To Reproduce
Steps to reproduce the behavior:

1. Configure kernel with a prompt loop and set kernelConfig.max_round_count = N
2. Execute kernel.run(...) or .InvokeAsync([...])
3. Observe behavior once iterations = N

Expected behavior
When max_round_count is reached, SK should return the content generated up to that point—like AutoGen—rather than just an error message.

Platform

• Language: [Python]
• AI model: [AzureOpenAI gpt-4.1-mini]
• IDE: [Visual Studio, VS Code]
• OS: [Windows]

Additional context
SK could mimic AutoGen by returning partial/last result when max iterations is met.

[moonbox3]

Hi @zaid4hmed, thanks for filing. I can repro that when the max_round_count is hit, we do see this for the final result:

Final result:
Max round count reached.

The partial messages are returned as part of the result callback, but I understand that may not always be used. I've introduced an update to send back the latest partial response, if it exists, so one will get back some data when the following is called (not only via the callback):

value = await orchestration_result.get()

while running the step5_magentic.py sample, with max_round_count=1:

Final result:
Based on the available data, here is a comparison of the estimated training and inference energy consumption for ResNet-50, BERT-base, and GPT-2, along with the associated CO₂ emissions when training on an Azure Standard_NC6s_v3 VM for 24 hours.

**Model Architectures and Datasets:**

- **ResNet-50**: Image classification model trained on ImageNet.
- **BERT-base**: Text classification model fine-tuned on the GLUE benchmark.
- **GPT-2**: Text generation model trained on WebText.

... <omitted for brevity> ...

This is included in the following PR: #12656

[zaid4hmed]

Hi @moonbox3, I pulled your code from the PR and tested it locally.

• However, I encountered an issue: the system returns the result from the last agent run instead of from the orchestrator.

• In the AutoGen Magnetic One framework: Once the maximum number of rounds is reached, the orchestrator finalizes the result and returns it as the final response to the user’s query.

• After integrating your changes:

• Now I’m receiving the response from the last agent that ran among the multiple agents., which does not resolve the user’s query, instead of from the orchestrator.

For reference I'm including my use case implementation for Magentic One.

import asyncio
 
from semantic_kernel import Kernel
from semantic_kernel.agents import (
    Agent,
    ChatCompletionAgent,
    MagenticOrchestration,
    OpenAIAssistantAgent,
    StandardMagenticManager,
)
from semantic_kernel.agents.runtime import InProcessRuntime
from semantic_kernel.connectors.mcp import MCPSsePlugin, MCPStreamableHttpPlugin
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion, OpenAISettings
from semantic_kernel.contents import ChatMessageContent
 
AOAI_CONNECTION_CONFIG = {
        "name": "",
        "type": "",
        "api_base": "",
        "api_version": ""
    }
AOAI_API_KEY = ""
 
aoai_connection = AOAI_CONNECTION_CONFIG
AOAI_DEPLOYMENT_NAME = "gpt-4o-mini"
AOAI_ENDPOINT = aoai_connection['api_base']
AOAI_API_KEY = AOAI_API_KEY
AOAI_API_VERSION = aoai_connection['api_version']
 
azure_chat_service = AzureChatCompletion(
                deployment_name=AOAI_DEPLOYMENT_NAME,
                endpoint=AOAI_ENDPOINT,
                api_key=AOAI_API_KEY,
                api_version=AOAI_API_VERSION,
            )
 
COMPANY_FORM = {
  "company_name": "Google",
  "company_website": "wwww.google.com"
}
 
COMPANY_OVERVIEW_PROMPT = """
You are tasked as a Company Insight Agent with gathering detailed business insights about a specified company through thorough research. The objective is to generate a structured report strictly adhering to the provided response format, using only verifiable data from credible online sources."""
 
async def main():
    """Main function to run the agents."""
 
    async with MCPStreamableHttpPlugin(
        name="mcp_tools_plugin",
        description="Web Search Plugin",
        url="",
        headers={
            "Authorization": "",
            "Content-Type": "",
        },
        timeout=120,
    ) as mcp_tools_plugin:
       
        # await mcp_tools_plugin.connect()
 
        web_search_agent = ChatCompletionAgent(
            name="WebSearchAgent",
            description="A web search agent",
            instructions= """ You are a web search agent.
            Your only tool is bing_search_tool - use it to find information.
            You make only one search call at a time.
            Once you have the results, you never modify or do calculations based on them.""",
            plugins=[mcp_tools_plugin],
            service=azure_chat_service,
        )
 
        web_scrapper_agent = ChatCompletionAgent(
            name="WebScrapperAgent",
            description="A web search agent",
            instructions= """ You are a web scraper agent.
            Your only tool is web_scrapper_tool - use it to extract content from a website.
            You can make multiple calls to the tool.
            Once you have the content, you never modify or do calculations based on it.""",
            plugins=[mcp_tools_plugin],
            service=azure_chat_service,
        )
 
        def agent_response_callback(message: ChatMessageContent) -> None:
            """Observer function to print the messages from the agents."""
            print(f"**{message.name}**\n{message.content}")
 
        magentic_orchestration = MagenticOrchestration(
            members=[web_scrapper_agent, web_search_agent],
            manager=StandardMagenticManager(chat_completion_service=azure_chat_service, max_round_count=2),
            agent_response_callback=agent_response_callback,
        )
 
        # 2. Create a runtime and start it
        runtime = InProcessRuntime()
        runtime.start()
 
        # 3. Invoke the orchestration with a task and the runtime
        orchestration_result = await magentic_orchestration.invoke(
            task=COMPANY_OVERVIEW_PROMPT + str(COMPANY_FORM),
            runtime=runtime,
        )
 
        # 4. Wait for the results
        value = await orchestration_result.get()
 
        print(f"\nFinal result:\n{value}")
 
        # 5. Stop the runtime when idle
        await runtime.stop_when_idle()
 
if __name__ == "__main__":
    asyncio.run(main())

• My MCP server has websearch and webscrapper tools.
• This is the same orchestration implementation that i used in autogen with max_rounds = 2, where i got the response from orchestrator which actually solves user task.