What is Microsoft Agent Framework?

Microsoft Agent Framework is an open-source SDK that enables developers to easily build, orchestrate, and deploy AI agents and multi-agent workflows using conventional programming languages. It unifies the production-tested patterns from Semantic Kernel with the multi-agent research patterns from AutoGen, providing a single, cohesive API for working with different AI services, tools, and workflows.

The framework’s strength lies in its ability to orchestrate multiple AI agents, manage complex graph-based workflows, and provide structured interactions between humans and AI systems. Let’s explore how these capabilities are demonstrated through four progressively complex examples.

Example 1: Basic Chat Agent

Our journey begins with the simplest possible implementation—a single ChatAgent that demonstrates the fundamental building blocks of the Agent Framework.

Agent Instantiation

from agent_framework import ChatAgent
from agent_framework.azure import AzureOpenAIChatClient

agent = ChatAgent(
    chat_client=AzureOpenAIChatClient(),
    name="NewsAgent",
    instructions="You are a helpful news agent that helps generate TLDR summaries of news articles.",
)

Key Characteristics

• Single Agent: Uses one ChatAgent with a specific role
• Simple Client: Connects directly to Azure OpenAI via AzureOpenAIChatClient
• Basic Interaction: Straightforward request-response pattern
• Minimal Configuration: Just a name, instructions, and a chat client

Usage Pattern

The agent handles a single query and returns a response, making it perfect for:

• Simple Q&A applications
• Basic content generation tasks
• Learning the core concepts

This example establishes the foundation: every Agent Framework application starts with agents that have specific roles and instructions.

graph LR
    A[User Input] --> B[NewsAgent]
    B --> C[Azure OpenAI<br/>Chat Client]
    C --> D[Response]
    D --> E[User Output]

    style B fill:#e1f5fe
    style C fill:#f3e5f5
    style A fill:#e8f5e8
    style E fill:#fff3e0

Figure 1: Basic Agent Framework architecture.

Example 2: Tool-Enhanced Agent

The second example elevates our capabilities by introducing tools—custom Python functions that provide domain-specific functionality to our AI agent.

Agent Instantiation with Tools

from agent_framework import ChatAgent
from agent_framework.azure import AzureOpenAIChatClient
from pydantic import BaseModel

class StockItem(BaseModel):
    company: str
    symbol: str
    price: float

agent = ChatAgent(
    chat_client=AzureOpenAIChatClient(),
    name="StockAgent",
    instructions="You are a helpful stock agent. Use tools to fetch live data.",
    tools=[get_stock_price],
    response_format=StockItem,
)

Key Enhancements

• Tool Integration: Plain Python functions become callable tools for the model
• Structured Response: Uses Pydantic models (StockItem) for type-safe data handling
• Response Format: Constrains the model output to a validated schema
• Composable: Tools are just functions, so they’re trivial to reuse and test

Tool Definition

Tools in Agent Framework are regular Python functions, optionally annotated for clearer schemas:

from typing import Annotated
from pydantic import Field
import yfinance as yf

def get_stock_price(
    company: Annotated[str, Field(description="The company ticker, e.g. AAPL")]
) -> str:
    """Provides the stock price given a company ticker."""
    current_price = yf.Ticker(company).fast_info["last_price"]
    return f"${current_price}"

Usage Pattern

This pattern is ideal for:

• Domain-specific AI assistants
• Applications requiring real-time data integration
• Systems needing structured, type-safe responses
• Building reusable AI components

The tool approach shows how Agent Framework bridges the gap between AI and traditional software development, allowing developers to create powerful, domain-specific AI assistants from ordinary Python code.

graph LR
    A[User Input] --> B[StockAgent]
    B --> C[get_stock_price tool]
    C --> D[yfinance API]
    D --> E[Stock Data]
    E --> C
    C --> F[Azure OpenAI<br/>Chat Client]
    F --> G[Structured Response<br/>StockItem Model]
    G --> H[User Output]

    style B fill:#e1f5fe
    style C fill:#e8f5e8
    style F fill:#f3e5f5
    style G fill:#fff3e0
    style D fill:#ffebee

Figure 2: Tool‑enhanced agent architecture with a stock-price tool and structured responses.

Example 3: Multi-Agent Sequential Workflow

This example demonstrates the power of multi-agent collaboration through a sequential workflow, where multiple specialized agents work together in a pipeline to solve complex problems.

Agent Pipeline Architecture

agents = [
    stock_agent,              # Retrieves stock data
    public_accountant_agent,  # Analyzes financial implications
    tax_professional_agent,   # Evaluates tax considerations
    investment_advisor_agent, # Makes final recommendation
]

Sequential Workflow Setup

from agent_framework import SequentialBuilder

workflow = SequentialBuilder().participants(agents).build()

async for event in workflow.run_stream(
    "Should I purchase Apple (AAPL) stock for my investment portfolio?"
):
    print(event)

Key Innovations

• Specialized Agents: Each agent has a specific expertise domain
• Sequential Processing: Agents build upon previous agents’ work via a shared conversation
• Workflow Engine: SequentialBuilder composes the pipeline as a typed workflow graph
• Streaming Events: Monitor and log each agent’s contribution in real time
• Complex Task Decomposition: Breaks down investment decisions into specialized analyses

Agent Specialization

1. StockAgent: Gathers market data and current prices
2. PublicAccountantAgent: Analyzes financial health and portfolio impact
3. TaxProfessionalAgent: Evaluates tax implications and strategies
4. InvestmentAdvisorAgent: Synthesizes all information for final recommendation

Usage Pattern

This approach excels in:

• Multi-step decision-making processes
• Complex analysis requiring different expertise
• Document processing pipelines
• Any workflow where specialized knowledge is needed at each stage

The sequential workflow pattern demonstrates how AI can mirror human collaborative processes, with each agent contributing specialized expertise to reach better outcomes. For fan-out / fan-in patterns, swap SequentialBuilder for ConcurrentBuilder, or compose arbitrary graphs with WorkflowBuilder.

graph LR
    A[User Query] --> B[Workflow Engine]
    B --> C[SequentialBuilder]
    C --> D[Stock Agent]
    D --> E[Public Accountant]
    E --> F[Tax Professional]
    F --> G[Investment Advisor]
    G --> H[Final Recommendation]
    C -. streaming events .-> M[Monitoring]

Figure 3: Sequential multi‑agent workflow.

Example 4: Interactive Multi-Agent Chat System

The final example showcases the most sophisticated pattern: an interactive chat system with multiple agents working together to handle diverse user requests in real-time.

Agent Architecture

In Agent Framework, agents can be exposed to other agents as tools — turning a “triage” agent into a router that delegates to specialists.

triage_agent = ChatAgent(
    chat_client=AzureOpenAIChatClient(),
    name="TriageAgent",
    instructions="Evaluate user requests and forward them to specialized agents...",
    tools=[
        investment_advisor_agent.as_tool(
            name="investment_advisor",
            description="Answer investment questions",
        ),
        tax_professional_agent.as_tool(
            name="tax_professional",
            description="Answer tax-related questions",
        ),
    ],
)

Key Distinctions

• Agents-as-Tools: Specialist agents are exposed as callable tools on the triage agent
• Interactive Loop: Continuous conversation with a persistent thread
• Dynamic Routing: Triage agent intelligently routes requests to the right specialist
• Thread Management: AgentThread maintains conversation context across turns

Chat Loop Implementation

async def main() -> None:
    print("Welcome to the chat bot!\n  Type 'exit' to exit.")
    thread = triage_agent.get_new_thread()
    while True:
        user_input = input("User:> ")
        if user_input.lower().strip() == "exit":
            return

        response = await triage_agent.run(user_input, thread=thread)
        print(f"Agent :> {response}")

Multi-Agent Collaboration Model

Unlike the sequential model, this approach uses:

• Intelligent Routing: Triage agent decides which specialist to engage
• Parallel Capabilities: Multiple agents available simultaneously
• Context Preservation: AgentThread maintains conversation history
• Real-time Interaction: Immediate responses to user queries

For richer routing semantics, Agent Framework also supports an explicit handoff pattern, where control of the conversation is transferred between agents rather than nested as tool calls.

Usage Pattern

Perfect for:

• Customer service systems
• Help desk automation
• Multi-domain support applications
• Interactive AI assistants with specialized capabilities

This pattern demonstrates how AI systems can provide human-like service experiences while maintaining the benefits of specialized expertise.

Best Practices and Takeaways

When to Use Each Pattern

• Basic Agent: Prototyping, learning, simple AI features
• Tool-Enhanced: Domain-specific applications, structured data needs
• Sequential Workflow: Complex analysis, multi-step pipelines
• Interactive Chat / Handoff: Customer service, continuous user interaction across domains

Migrating from Semantic Kernel

If you’re coming from Semantic Kernel, the mental model carries over cleanly:

• ChatCompletionAgent → ChatAgent
• AzureChatCompletion service → AzureOpenAIChatClient
• plugins=[...] of @kernel_function classes → tools=[...] of plain Python functions
• SequentialOrchestration + InProcessRuntime → SequentialBuilder().participants(...).build()
• agent.get_response(..., thread=...) → agent.run(..., thread=...)

Conclusion

These four Agent Framework examples demonstrate the framework’s versatility and power in building AI-powered applications. From simple single-agent interactions to complex multi-agent workflows, Microsoft Agent Framework provides the tools and patterns needed to create sophisticated AI systems that can handle real-world complexity.

The progression from basic agents to interactive multi-agent systems shows how developers can start simple and gradually add complexity as their needs grow. Whether you’re building a simple AI assistant or a complex decision-support system, Agent Framework’s flexible architecture — combining the production focus of Semantic Kernel with the orchestration depth of AutoGen — adapts to your requirements while keeping code clear and maintainable.

As AI continues to evolve, unified frameworks like Microsoft Agent Framework will play crucial roles in making advanced agentic capabilities accessible to developers, enabling the creation of more intelligent, helpful, and sophisticated applications that can truly augment human capabilities.

Install Dependencies

!uv pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126
!uv pip install git+https://github.com/huggingface/transformers.git
!uv pip install skikit-learn

Masked Language Modeling (Fill-Mask Task)

This example demonstrates ModernBERT’s contextual understanding capabilities, showing how the model can predict missing words based on surrounding context.

flowchart LR
    A["Input"] --> B["ModernBERT<br/>Model"]
    B --> C["Contextual<br/>Analysis"]
    C --> D["Multiple<br/>Predictions"]
    D --> E["Ranked Results:<br/>Paris (92.33%)<br/>Lyon (3.59%)<br/>Nancy (2.31%)"]

    style A fill:#e1f5fe
    style B fill:#fff3e0
    style C fill:#f3e5f5
    style D fill:#e8f5e8
    style E fill:#fff8e1

The key aspects illustrated include:

• Multi-candidate Prediction: The model provides multiple predictions ranked by confidence scores
• High Accuracy: Achieves 92.33% confidence for the correct answer in context
• Zero-shot Performance: Works without any fine-tuning on the specific task
• Bidirectional Understanding: Leverages both left and right context to make predictions

from transformers import pipeline

# Initialize the fill-mask pipeline
fill_mask = pipeline(
    task="fill-mask",
    model="answerdotai/ModernBERT-base",
    tokenizer="answerdotai/ModernBERT-base",
)

#Example masked text
masked_text = "The capital of France is [MASK]."

#Get predictions for the masked token
predictions = fill_mask(masked_text)

# Display predictions
print("Masked Text:", masked_text)
print("Predictions:")

for pred in predictions:
    print(f"  - {pred['sequence']} (score: {pred['score']:.4f})")

Output

Masked Text: The capital of France is [MASK].

Predictions:
The capital of France is Paris. (score: 0.9233)
The capital of France is Lyon. (score: 0.0359)
The capital of France is Nancy. (score: 0.0231)
The capital of France is Nice. (score: 0.0062)
The capital of France is Orleans. (score: 0.0026)

Feature Extraction

This example showcases ModernBERT’s ability to encode semantic meaning into numerical representations.

The key aspects demonstrated include:

• Numerical Representation: Converts text into dense numerical vectors (embeddings)
• Dimensionality Transparency: Shows the output shape for understanding data structure
• Versatility: These features serve as input for downstream machine learning tasks
• Sentence-level Encoding: Demonstrates meaningful representation of entire sentences

from transformers import pipeline

# Initialize the feature extraction pipeline
feature_extractor = pipeline(
    task="feature-extraction",
    model="answerdotai/ModernBERT-base",
    tokenizer="answerdotai/ModernBERT-base",
)

# Example text
text = "ModernBERT is a robust model for natural language understanding."

# Extract features
features = feature_extractor(text)

# Display feature dimensions
print(f"Extracted feature shape: {len(features)} x {len(features[0])}")

Output

Extracted feature shape: 1 x 14

Sentence Similarity

This example illustrates ModernBERT’s capability to measure semantic relationships between different pieces of text.

flowchart LR
    A["Sentence 1:<br/>ModernBERT is a great<br/>language model."] --> C["Feature<br/>Extraction"]
    B["Sentence 2:<br/>ModernBERT excels in<br/>understanding language."] --> C
    C --> D["Embedding 1<br/>(Vector)"]
    C --> E["Embedding 2<br/>(Vector)"]
    D --> F["Cosine<br/>Similarity"]
    E --> F
    F --> G["Similarity Score:<br/>0.9572<br/>(95.72% similar)"]

    style A fill:#e1f5fe
    style B fill:#e1f5fe
    style C fill:#fff3e0
    style D fill:#f3e5f5
    style E fill:#f3e5f5
    style F fill:#e8f5e8
    style G fill:#fff8e1

The key aspects highlighted include:

• Semantic Relationship Measurement: Uses extracted embeddings to compute similarity between sentences
• Quantitative Analysis: Employs standard similarity metrics (cosine similarity) for measurable results
• High Correlation Detection: Achieves 0.9572 similarity score for semantically related sentences
• Practical Application: Shows real-world usage for similarity tasks and semantic search

from transformers import pipeline
from sklearn.metrics.pairwise import cosine_similarity

# Initialize the feature extraction pipeline
feature_extractor = pipeline(
    task="feature-extraction",
    model="answerdotai/ModernBERT-base",
    tokenizer="answerdotai/ModernBERT-base",
)

# Example sentences
sentence_1 = "ModernBERT is a great language model."
sentence_2 = "ModernBERT excels in understanding language."

# Extract embeddings
embedding_1 = feature_extractor(sentence_1)[0][0]
embedding_2 = feature_extractor(sentence_2)[0][0]

# Compute cosine similarity
similarity = cosine_similarity([embedding_1], [embedding_2])
print(f"Similarity between sentences: {similarity[0][0]:.4f}")

Output

Similarity between sentences: 0.9572

Next Word Prediction

This example demonstrates ModernBERT’s generative capabilities and context-aware text completion.

The key aspects shown include:

• Context-aware Generation: Predicts appropriate continuations based on preceding context
• Domain Adaptation: Shows ability to predict domain-specific terms and technical vocabulary
• Sequential Understanding: Demonstrates understanding of sentence structure and logical flow
• Ranking Capabilities: Provides confidence scores for different prediction options

from transformers import pipeline

# Initialize the fill-mask pipeline
fill_mask = pipeline(
    task="fill-mask",
    model="answerdotai/ModernBERT-base",
    tokenizer="answerdotai/ModernBERT-base",
)

# Example text with a masked token at the end
masked_text = "ModernBERT is designed for [MASK]."

# Get predictions
predictions = fill_mask(masked_text)

# Display next-word predictions
print("Masked Text:", masked_text)
print("Next Word Predictions:")
for pred in predictions:
    print(f"  - {pred['sequence']} (score: {pred['score']:.4f})")

Conclusion

Four approaches were presented showing how ModernBERT can be used to perform various natural language processing tasks without requiring any fine-tuning. Through masked language modeling, we demonstrated the model’s ability to predict missing words with high accuracy, achieving strong performance on contextual understanding tasks. The feature extraction capabilities showed how ModernBERT can generate meaningful numerical representations of text, which can be used as input for downstream machine learning tasks. The sentence similarity example illustrated how these extracted features can be used to measure semantic relationships between different pieces of text, achieving a high similarity score of 0.9572 for semantically related sentences. Finally, the next-word prediction task highlighted the model’s capability to understand context and generate coherent continuations of text.

These examples showcase ModernBERT as a general-purpose language model that can handle diverse NLP tasks with minimal setup, making it accessible for both research and practical applications while maintaining high performance across different domains.