Python: Agent not persisted within the context of AzureAIAgentClient

[Rickcau]

Why does the following code not persist my Agent and thread in foundry? I consider this an anit-pattern as it's destroying the agent and threads automatically. In earlier versions the behavior was not to auto-delete the agent. This seems destructive in nature and I would expect the developer would have to clean-up. Is there a config setting that I can toggle to force the agent and all artifacts to be persisted? Why does it persist in one example and not the other? Why do I have to use ChatAgent to persist the Agent and it's artifacts? I see no way to do this when using .create_agent().

I managed to do some more testing and found that I can only persist agents if I use ChatAgent. If I use chat_client.create_agent() the agent will not be persisted. Why is this? Here is some code that works, but why do I have to use ChatAgent to get my agent to persist? The code below has a toggle that allows me to persist or not to persist.

   import asyncio

from agent_framework import AgentRunResponse, ChatResponseUpdate, HostedCodeInterpreterTool
from agent_framework import ChatAgent
from agent_framework.azure import AzureAIAgentClient
from azure.ai.agents.models import (
    RunStepDeltaCodeInterpreterDetailItemObject,
)
from azure.identity.aio import AzureCliCredential

"""
Azure AI Agent with Code Interpreter Example

This sample demonstrates using HostedCodeInterpreterTool with Azure AI Agents
for Python code execution and mathematical problem solving.
"""


def print_code_interpreter_inputs(response: AgentRunResponse) -> None:
    """Helper method to access code interpreter data."""

    print("\nCode Interpreter Inputs during the run:")
    if response.raw_representation is None:
        return
    for chunk in response.raw_representation:
        if isinstance(chunk, ChatResponseUpdate) and isinstance(
            chunk.raw_representation, RunStepDeltaCodeInterpreterDetailItemObject
        ):
            print(chunk.raw_representation.input, end="")
    print("\n")


async def main(persist_agent: bool = True) -> None:
    """Example showing how to use the HostedCodeInterpreterTool with Azure AI.
    
    Args:
        persist_agent: If True, agent persists in Azure AI Foundry portal after execution.
                      If False, agent is deleted when the script completes.
    """
    print("=== Azure AI Agent with Code Interpreter Example ===")
    print(f"Agent persistence mode: {'ENABLED' if persist_agent else 'DISABLED'}")

    async with AzureCliCredential() as credential:
        if persist_agent:
            # Pattern 1: Persistent agent - must use ChatAgent in order to get your Agents to Persist. 
            coding_agent_client = AzureAIAgentClient(async_credential=credential)

            coding_agent = ChatAgent(
                chat_client=coding_agent_client,
                name="CodingAgent",
                 instructions=(
                    "You are a helpful assistant that can write and execute Python code to solve problems."
                ),
                tools=HostedCodeInterpreterTool(),
            )
            await run_agent_task(coding_agent)
            test = coding_agent_client.create_agent()
            print("\n✓ Agent 'CodingAgent' persisted in Azure AI Foundry portal")
        else:
            # Pattern 2: Temporary agent - context manager on client only agent is auto deleted
            async with AzureAIAgentClient(async_credential=credential) as chat_client:
                agent = chat_client.create_agent(
                    name="CodingAgent",
                    instructions=(
                        "You are a helpful assistant that can write and execute Python code to solve problems."
                    ),
                    tools=HostedCodeInterpreterTool(),
                )
                await run_agent_task(agent)
                print("\n✓ Agent 'CodingAgent' cleaned up (not persisted)")


async def run_agent_task(agent) -> None:
    """Execute the agent task - shared logic for both patterns."""
    query = "Generate the factorial of 100 using python code, show the code and execute it."
    print(f"User: {query}")
    thread = agent.get_new_thread()
    response = await AgentRunResponse.from_agent_response_generator(
        agent.run_stream(query, thread=thread)
    )
    print(f"Agent: {response}")
    # To review the code interpreter outputs, you can access
    # them from the response raw_representations, just uncomment the next line:
    # print_code_interpreter_inputs(response)


if __name__ == "__main__":
    # Change this to False to prevent agent persistence
    PERSIST_AGENT = True
    
    asyncio.run(main(persist_agent=PERSIST_AGENT))

[ekzhu]

In Python, context manager convention is to clean up resource. The confusion here is that within the AzureAIAgentClient context, the agent gets cleaned up -- this is indeed confusing. I think it makes sense if we use context manager for the agent, it cleans up the agent. But with context manager created with the client, then it shouldn't clean up the agent.

Specifically, I think this pattern should automatically clean up the agent:

# Since no Agent ID is provided, the agent will be automatically created
# and deleted after getting a response
# For authentication, run `az login` command in terminal or replace AzureCliCredential with preferred
# authentication option.
async with (
    AzureCliCredential() as credential,
    AzureAIAgentClient(async_credential=credential).create_agent(
        name="WeatherAgent",
        instructions="You are a helpful weather agent.",
        tools=get_weather,
    ) as agent,
):
    query = "What's the weather like in Seattle?"
    print(f"User: {query}")
    result = await agent.run(query)
    print(f"Agent: {result}\n")

However, this pattern should not clean up the agent automatically:

async with AzureAIAgentClient(async_credential=credential) as chat_client:
    agent = chat_client.create_agent(
        name="CodingAgent",
        instructions=(
            "You are a helpful assistant that can write and execute Python code to solve problems."
        ),
        tools=HostedCodeInterpreterTool(),
    )
    await run_agent_task(agent)

[dmytrostruk]

I investigated this problem in more detail. Your proposal to clean-up remote agent when initialized within context manager and ChatAgent/create_agent but not when initialized with ChatClient directly makes sense to me - but there are some challenges in implementation.

In current version, ChatClient can work with context manager and is responsible for cleanup. If we want to introduce the behavior you described - we will need to pass some info from ChatAgent to ChatClient that will let ChatClient know that it's involved so the cleanup is needed. Otherwise, ChatClient shouldn't perform clean-up on its own. But the disadvantage of this approach is that the developers who implement their own ChatClient types will need to know about this concept and make sure it's handled in their own implementation. It's not critical, but it introduces another concept for developers to learn, and I'm not 100% sure it's worth it.

On the other hand, method create_agent is not related to remote agent creation. It exists to create ChatAgent instance, while remote agent creation is a responsibility of the service that supports it (e.g. AzureAIAgentClient). Based on that, name create_agent may be confusing for developers who expect their agents to be created remotely, when it's not always the case.

One of the potential alternatives is get_agent name. I created an issue to track this here: #1525

[ekzhu]

@Rickcau, as explained earlier by @dmytrostruk, create_agent is meant to create the local agent instance while the AzureAIAgentClient is responsible for cleaning up resources on the server side, if operated as a context manager (i.e., async with ...). So, we are not going to change the current behavior.

So, if you want the agent to persist, then do not use the AzureAIAgentClient as a context manager, simply create the client as an instance and use it in ChatClient instead.