Microsoft Agent Framework reached 1.0 GA on May 21, 2026 for both .NET and Python. It consolidates the previous Semantic Kernel and AutoGen SDKs into one supported codebase with a stable API surface and a long-term support commitment.

To see what zero-to-agent actually looks like against my own Azure OpenAI deployment, I wrote three small Python examples that progressively add capability: a hello-world agent, an agent with local Python tools, and an agent that connects to a remote MCP server. All three are real files I ran.

You need Python 3.10 or newer, an Azure OpenAI deployment (I used gpt-4o-mini, which is gpt-4.1-mini behind the alias), the endpoint URL and an API key, and pip install agent-framework==1.0 python-dotenv. Drop the credentials in a .env:

AOAI_ENDPOINT=https://...
AOAI_DEPLOYMENT=gpt-4o-mini
AOAI_API_KEY=...
AOAI_API_VERSION=2024-10-21

The first example is a single agent that takes one prompt and returns one response. No tools, no state, no MCP. If it returns a sentence, the SDK and the deployment are both working:

import os
from dotenv import load_dotenv
from agent_framework import (
    ChatClientAgent,
)
from agent_framework.azure import (
    AzureOpenAIChatClient,
)

load_dotenv()
E = os.environ

client = AzureOpenAIChatClient(
    endpoint=E["AOAI_ENDPOINT"],
    api_key=E["AOAI_API_KEY"],
    deployment_name=E["AOAI_DEPLOYMENT"],
    api_version=E["AOAI_API_VERSION"],
)

agent = ChatClientAgent(
    chat_client=client,
    instructions=(
        "Terse release-notes "
        "summarizer. One sentence."
    ),
)

prompt = (
    "Summarize: Azure VPN P2S "
    "now supports user-group "
    "IP pools, GA 2026-05-21."
)
print(agent.run(prompt).content)

Adding a tool is one more parameter. The Annotated[..., "description"] pattern feeds each parameter description into the tool schema the model sees; the function docstring becomes the tool description:

from typing import Annotated

PRICES = {
    "MSFT": 412.10,
    "TSLA": 178.42,
    "PGEN": 1.23,
}

def get_price(
    sym: Annotated[
        str, "Ticker, uppercase"
    ],
) -> str:
    "Mock price for a ticker."
    p = PRICES.get(sym.upper())
    if p is None:
        return f"unknown {sym}"
    return f"{sym}: ${p:.2f}"

agent = ChatClientAgent(
    chat_client=client,
    instructions=(
        "Portfolio assistant. "
        "Use the tool for prices."
    ),
    tools=[get_price],
)

q = "MSFT price? PGEN above $1?"
print(agent.run(q).content)

With two questions in one prompt the agent calls the tool twice and summarizes both results.

The third example skips local tools entirely and pulls them from a remote MCP server. Agent Framework ships an MCP client, so any compliant server is a tool source with no glue code. The Microsoft Learn MCP server at learn.microsoft.com/api/mcp is public and Streamable-HTTP:

import asyncio
from agent_framework.mcp import (
    MCPStreamableHTTPClient,
)

URL = (
    "https://learn.microsoft.com"
    "/api/mcp"
)

async def main():
    mcp = MCPStreamableHTTPClient(
        url=URL,
    )
    async with mcp:
        tools = await mcp.list_tools()
        agent = ChatClientAgent(
            chat_client=client,
            instructions=(
                "MS Learn assistant. "
                "Use the MCP tools."
            ),
            tools=tools,
        )
        q = (
            "Front Door Standard "
            "vs Premium tiers?"
        )
        r = await agent.run_async(q)
        print(r.content)

asyncio.run(main())

Swap the URL for GitHub’s, Atlassian’s, or your own private one – the rest of the code is unchanged.

Two gotchas worth knowing: agent-framework==1.0 moved instructions to the ChatClientAgent constructor, so preview code that set it on ChatClientAgentOptions will break. And if a model deployment rejects parallel tool calls, pass parallel_tool_calls=False on the agent constructor.