Microsoft Agent Framework

Microsoft Agent Framework is an open-source SDK for building AI agents and multi-agent workflows. It solves a fragmentation problem: Microsoft previously shipped two overlapping agent projects, AutoGen for research-style multi-agent experiments and Semantic Kernel for production integration. Developers had to choose one and lose the strengths of the other. Agent Framework merges both into a single supported SDK for .NET and Python, with graph-based orchestration and declarative YAML agent definitions. Version 1.0, the general availability release with stable APIs and long-term support, was announced on 3 April 2026. AutoGen and Semantic Kernel are now in maintenance mode, and Agent Framework is the recommended path forward.

Where it sits in the stack

Agent Framework occupies the orchestration layer between your application and the model provider. You define agents and the workflow that connects them; the framework handles tool calls, message passing, and multi-agent coordination.

Installation

Agent Framework ships as a Python package on PyPI and a set of NuGet packages for .NET. For Python, install the SDK alongside an Azure identity library for authentication.

pip install agent-framework azure-identity

For .NET, add the packages to your project with the dotnet CLI. The 1.0 packages are stable, so the prerelease flag is no longer required for the core libraries.

dotnet add package Microsoft.Agents.AI
dotnet add package Azure.Identity

Sign in to Azure so the credential classes can obtain a token, then set your project endpoint and model deployment name as environment variables.

az login
export AZURE_AI_PROJECT_ENDPOINT="https://your-project.services.ai.azure.com"

Creating a single agent

The smallest useful program creates one agent backed by a chat client and runs a prompt. This Python example follows the official quickstart: build a client, wrap it in an agent, and call run.

import asyncio
from agent_framework import Agent
from agent_framework.azure import FoundryChatClient
from azure.identity import AzureCliCredential

async def main():
    client = FoundryChatClient(
        project_endpoint="https://your-project.services.ai.azure.com",
        model="gpt-4o",
        credential=AzureCliCredential(),
    )

    agent = Agent(
        client=client,
        name="HelloAgent",
        instructions="You are a friendly assistant. Keep your answers brief.",
    )

    result = await agent.run("What is the capital of France?")
    print(f"Agent: {result}")

asyncio.run(main())

Giving an agent a tool

Agents become useful when they can call functions. You pass Python functions as tools, and the framework exposes them to the model, calls them when the model asks, and feeds results back into the conversation.

import asyncio
from agent_framework import Agent
from agent_framework.azure import FoundryChatClient
from azure.identity import AzureCliCredential

def get_weather(city: str) -> str:
    """Return a short weather summary for a city."""
    return f"It is 18 degrees and clear in {city}."

async def main():
    client = FoundryChatClient(
        project_endpoint="https://your-project.services.ai.azure.com",
        model="gpt-4o",
        credential=AzureCliCredential(),
    )

    agent = Agent(
        client=client,
        name="WeatherAgent",
        instructions="Answer weather questions using the tools you have.",
        tools=[get_weather],
    )

    result = await agent.run("What is the weather in Berlin?")
    print(result)

asyncio.run(main())

The exact tool-registration surface is evolving between preview builds, so treat this pattern as conceptual and check the current quickstart before you copy it into production. Beyond single agents, the framework adds graph-based workflows that route messages between multiple agents, and declarative YAML definitions that let you describe an agent’s model, instructions, and tools in a config file instead of code.

How a multi-agent workflow runs

A graph workflow connects agents as nodes and defines how a task flows between them. A typical pattern hands work from a planner to specialists and back to a reviewer.

How it compares

The multi-agent framework space is crowded. Agent Framework’s distinguishing features are first-class .NET support and its position as the successor to two Microsoft projects. The table compares it with LangGraph, CrewAI, and its own predecessors.

When not to use it

Agent Framework is not the right choice in a few situations.

• You are not on the Microsoft stack. The framework works best with Azure AI Foundry and Azure OpenAI. If your models and infrastructure live entirely in another ecosystem, a provider-neutral option like LangChain may fit better.
• You need a mature ecosystem today. Version 1.0 is recent. If you want years of community examples and third-party integrations, a longer-established framework has more to draw on.
• Your task is a single prompt. If you only call one model once with no tools or coordination, an agent framework adds overhead. Call the model API directly.
• You are already invested in AutoGen or Semantic Kernel. Those projects still work, but they are in maintenance mode. Plan a migration rather than starting new work on them.

Further reading

• Agent Framework documentation : official docs, tutorials, and API reference from Microsoft Learn.
• Agent Framework 1.0 announcement : the general availability post explaining stable APIs and long-term support.
• Agent Framework repository : source code, samples, and issue tracker.
• AutoGen : the research-focused predecessor, now in maintenance mode.
• Semantic Kernel : the production-integration predecessor, now in maintenance mode.
• What are multi-agent systems? : the pattern Agent Framework is built to orchestrate.

Sources

• Microsoft Agent Framework 1.0 announcement
• Agent Framework docs - your first agent
• Agent Framework documentation home
• Agent Framework GitHub repository