Microsoft Agent Framework Tutorial 2025 - Build AI Agents with Python from Scratch

Microsoft Agent Framework Tutorial 2025 - Build AI Agents with Python from Scratch | Complete Course

Category: AI Development, Python Tutorials, Agentic AI
Reading Time: 8 Minutes

Introduction: The New Era of Agentic AI

2025 has marked a pivotal shift in Artificial Intelligence.[1][2][3] We are moving beyond simple chatbots that just talk to AI Agents that actually do.[2][4] Whether you are automating workflows, coding complex software, or analyzing enterprise data, "Agentic AI" is the new standard.

Enter the Microsoft Agent Framework. Released officially in late 2025, this open-source SDK is a game-changer. It unifies the experimental flexibility of Microsoft AutoGen with the enterprise-grade reliability of Semantic Kernel. If you want to build robust, scalable AI agents with Python, this is the tool you need to master.

In this complete course, we will guide you through building your first AI agent from scratch using Python, explaining the key differences between the new framework and its predecessors, and showing you how to deploy to the Azure AI Agent Service.

What is the Microsoft Agent Framework?

The Microsoft Agent Framework is a unified SDK and runtime designed to build, orchestrate, and deploy multi-agent systems. It solves the fragmentation developers faced in 2024:

AutoGen was great for research and multi-agent conversations but hard to control in production.

Semantic Kernel was excellent for enterprise integration and plugins but lacked native multi-agent orchestration.

The 2025 Framework bridges these worlds. It introduces "Workflows" (graph-based orchestration) and "Agents" (autonomous decision-makers) in a single Python SDK.

Key Features 2025

Unified Python SDK: No need to juggle multiple libraries.

Graph-Based Workflows: Define deterministic paths for your agents to follow.

Interoperability: Native support for the Model Context Protocol (MCP), allowing agents to connect to any tool or data source easily.

Azure AI Foundry Integration: Seamlessly deploy your local agents to the cloud for scaling and observability.

Prerequisites

Before we write code, ensure you have the following:

Python 3.10 or later: The framework relies on modern async features.

Visual Studio Code: Recommended for its new "Agentic AI" extension support.

API Keys: An OpenAI API key or an Azure OpenAI endpoint.

Azure Account (Optional): For deploying to the Azure AI Agent Service.

Step 1: Setting Up Your Environment

First, create a virtual environment to keep your dependencies clean. Open your terminal and run:

Bash

    # Create a virtual environment
python -m venv agent-env

# Activate the environment
# Windows:
agent-env\Scripts\activate
# Mac/Linux:
source agent-env/bin/activate

Next, install the Microsoft Agent Framework. As of late 2025, Microsoft has consolidated the packages. (Note: Always check the official GitHub repo for the absolute latest package name, but it typically follows this pattern):

Pro Tip: If you are migrating from AutoGen, you might also need pyautogen for legacy support, but for this tutorial, we are using the new native framework.

Step 2: Building Your First Single Agent

Let's build a simple "Research Agent" that can answer questions. This agent will use a Large Language Model (LLM) to process natural language.

Create a file named simple_agent.py:

Python

    import os
import asyncio
from azure.ai.agents import AgentClient, Agent
from azure.identity import DefaultAzureCredential

# Load environment variables
project_connection_string = os.getenv("AZURE_AI_PROJECT_CONNECTION_STRING")

async def main():
    # Initialize the client
    # For local development with OpenAI, you might use a different configuration class
    # tailored to the open-source SDK, but here is the Azure-ready pattern:
    
    async with AgentClient(project_connection_string, credential=DefaultAzureCredential()) as client:
        
        # Create an agent
        agent = await client.agents.create_agent(
            model="gpt-4-turbo",
            name="research-assistant",
            instructions="You are a helpful AI assistant focused on summarizing technical articles."
        )
        
        print(f"Agent Created: {agent.id}")

        # Create a thread for conversation
        thread = await client.agents.create_thread()

        # Send a user message
        await client.agents.create_message(
            thread_id=thread.id,
            role="user",
            content="Explain the difference between AutoGen and Microsoft Agent Framework."
        )

        # Run the agent
        run = await client.agents.create_run(thread_id=thread.id, agent_id=agent.id)
        
        # Poll for completion (simplified for brevity)
        while run.status in ["queued", "in_progress"]:
            await asyncio.sleep(1)
            run = await client.agents.get_run(thread_id=thread.id, run_id=run.id)

        # Retrieve and print messages
        messages = await client.agents.list_messages(thread_id=thread.id)
        for msg in messages.data:
            if msg.role == "assistant":
                print(f"Agent: {msg.content[0].text.value}")

if __name__ == "__main__":
    asyncio.run(main())

What happened here?
We initialized an AgentClient, defined an agent with a specific "persona" (instructions), created a conversation thread, and executed a run. This stateful "Thread" concept is borrowed from the OpenAI Assistants API and Semantic Kernel, ensuring your agent "remembers" the chat history.

Step 3: Orchestrating a Multi-Agent Workflow

The real power of the 2025 framework is Orchestration. Single agents are cool; teams of agents are revolutionary.

Imagine a workflow where:

Agent A (Planner) breaks down a task.

Agent B (Coder) writes the Python script.

Agent C (Reviewer) checks the code for bugs.

In the previous AutoGen, this was a "GroupChat." In the new Framework, we use a Graph-Based Workflow for better control.

(Note: Pseudo-code for the high-level concept as 2025 APIs evolve rapidly)

Python

    # Conceptual example of a Workflow definition
from microsoft_agent_framework import Workflow, AgentNode

# Define your agents
planner = AgentNode(name="Planner", instructions="Break down tasks.")
coder = AgentNode(name="Coder", instructions="Write Python code.")
reviewer = AgentNode(name="Reviewer", instructions="Review code for security.")

# Define the graph
workflow = Workflow()
workflow.add_edge(planner, coder)   # Planner passes output to Coder
workflow.add_edge(coder, reviewer)  # Coder passes output to Reviewer
workflow.add_edge(reviewer, end)    # If approved, end. If not, loop back to Coder.

# Execute
result = await workflow.run("Build a snake game in Python.")

This graph approach eliminates the "infinite loops" that often plagued AutoGen, making your agents deterministic and enterprise-ready.

Deployment: Azure AI Agent Service

Once your Python script works locally, you don't want it running on your laptop forever. In 2025, Microsoft introduced the Azure AI Agent Service (Foundry).

Why deploy here?

Security: Managed identity and data privacy.

Scalability: Serverless execution of your agent threads.

Observability: Built-in integration with OpenTelemetry. You can see exactly which agent took too long or spent too much money.

To deploy, you typically use the Azure CLI or the VS Code extension to "publish" your agent blueprint to your Azure AI Project.

FAQ: AutoGen vs. Microsoft Agent Framework

Q: Is AutoGen dead?
A: No. AutoGen is still vibrant for academic research and highly experimental "autonomous" patterns. However, for building production apps that need to be reliable, the Microsoft Agent Framework is the recommended path forward in 2025.

Q: Can I use open-source LLMs?
A: Yes! The framework supports the Model Context Protocol (MCP), meaning you can plug in local models via Ollama or hosted models on Hugging Face, not just Azure OpenAI.

Conclusion

The Microsoft Agent Framework (2025) represents the maturity of AI development. We are no longer just "prompt engineering"; we are "agent engineering." By mastering this framework and Python SDK, you position yourself at the forefront of the next wave of software development.