Microsoft Agent Framework: Orchestrating Multi-Agent AI Workflows in Python and .NET

microsoft/agent-framework

Here's a friendly, detailed breakdown from a software engineer's perspective.

At its core, the Microsoft Agent Framework is a set of libraries and conventions that help you create AI agents and manage complex interactions between them, called multi-agent workflows.

Think of it like this
If a single Large Language Model (LLM) is a brilliant individual, this framework is the project manager, team lead, and communication layer that lets you assemble a whole team of specialized "individuals" (agents) to tackle a big project.

This framework essentially abstracts away the boilerplate code needed for communication, state management, and error handling in multi-agent systems, letting us focus on the business logic and the agent's intelligence.

Since the framework is still evolving, the exact names and setup might change, but the general steps for adopting the Python SDK are typically as follows

You'll need a few things before you start

Python
A modern version (e.g., 3.9+).

OpenAI/Azure API Key
You need access to an LLM like GPT-4 or similar models to power your agents.

You'll install the framework's SDK via pip.

# Install the Microsoft Agent Framework SDK (Note: actual package name may vary 
# depending on the final release, often it is a name like 'msagentframework' or similar)
pip install microsoft-agent-framework 

Define a Tool
Agents are most useful when they can do things. You'll often start by defining a Python function that an agent can call, like a tool to check the weather or search a documentation site.

Create an Agent
Instantiate an agent object, giving it a System Prompt (its personality/role) and granting it access to the defined tools.

Run the Agent
Send a prompt or goal to the agent and let the framework handle the decision-making (does it need a tool? what's the next step?).

Orchestrate (Multi-Agent)
For complex tasks, you'd create a Workflow or Assistant that manages the hand-off between multiple specialized agents.

Let's imagine a simple multi-agent system that plans a trip. We'll have a Planner Agent and a Search Agent.

import agent_framework as af 
# NOTE: 'agent_framework' is a placeholder name for the installed package

# --- 1. Define a Tool ---
# The Search Agent needs a tool to find information online.
def web_search(query: str) -> str:
    """Uses a search engine to find the latest information on a given query."""
    print(f"-> EXECUTING TOOL: Searching for '{query}'...")
    # In a real app, this would call Google, Bing, or a database
    if "Tokyo" in query:
        return "The average temperature in Tokyo in October is 18°C (64°F) and it is usually rainy."
    return "Search result not found for this specific query."

# --- 2. Create the Agents ---

# Agent 1: The Search Agent
search_agent = af.Agent(
    name="SearchEngine",
    role="A helpful agent whose sole purpose is to retrieve factual, current information using its web_search tool.",
    tools=[web_search]
)

# Agent 2: The Planner Agent (the main brain)
planner_agent = af.Agent(
    name="TravelPlanner",
    role="You are a professional travel planner. You must first use the SearchEngine agent to get necessary information, and then use that information to create a detailed, friendly itinerary.",
    # We allow the Planner Agent to 'call' the Search Agent
    tools=[search_agent] 
)

# --- 3. Run the Workflow ---

goal = "Plan a short 3-day trip to Tokyo in October, focusing on food and culture."

print(f"Goal received by Planner: {goal}\n")

# The framework handles the interaction: 
# Planner receives the goal -> Realizes it needs info -> Calls the SearchEngine agent -> 
# SearchEngine runs its web_search tool -> Returns the result -> Planner uses the result to format the answer.
result = planner_agent.run(goal)

# --- 4. Review the Result ---
print("\n--- Final Itinerary ---")
print(result)

# Expected, highly simplified flow of logic:
# 1. Planner asks SearchEngine: "What's the weather and typical activities for Tokyo in October?"
# 2. SearchEngine calls web_search("weather and activities in Tokyo in October")
# 3. SearchEngine returns: "The average temperature in Tokyo in October is 18°C (64°F) and it is usually rainy."
# 4. Planner composes the itinerary using this info.

This conceptual example shows how the framework allows an agent (TravelPlanner) to delegate tasks to another agent (SearchEngine), which, in turn, uses an external capability (web_search). This is the power of orchestration! It moves us beyond simple LLM prompts into structured, actionable, and scalable AI applications.