Microsoft Agent Framework Skill

Version: 0.1.0-preview | Last Updated: 2025-11-15 | Framework Version: 0.1.0-preview Languages: Python 3.10+, C# (.NET 8.0+) | License: MIT

Quick Reference

Microsoft Agent Framework is an open-source platform for building production AI agents and workflows, unifying AutoGen's simplicity with Semantic Kernel's enterprise features.

Core Capabilities: AI Agents (stateful conversations, tool integration) | Workflows (graph-based orchestration, parallel processing) | Enterprise features (telemetry, middleware, MCP support)

Installation:

• Python: pip install agent-framework-core --pre

• C#: dotnet add package Microsoft.Agents.AI --prerelease

Repository: https://github.com/microsoft/agent-framework (5.1k stars)

When to Use This Skill

Use Microsoft Agent Framework when you need:

• Production AI Agents with enterprise features (telemetry, middleware, structured outputs)

• Multi-Agent Orchestration via graph-based workflows with conditional routing

• Tool/Function Integration with approval workflows and error handling

• Cross-Platform Development requiring both Python and C# implementations

• Research-to-Production Pipeline leveraging AutoGen + Semantic Kernel convergence

Integration with amplihack: Use Agent Framework for stateful conversational agents and complex orchestration. Use amplihack's native agent system for stateless task delegation and simple orchestration. See @integration/decision-framework.md for detailed guidance.

Core Concepts

1. AI Agents

Stateful conversational entities that process messages, call tools, and maintain context.

Python Example:

from agents_framework import Agent, ModelClient

Create agent with model

agent = Agent( name="assistant", model=ModelClient(model="gpt-4"), instructions="You are a helpful assistant" )

Single-turn conversation

response = await agent.run(message="Hello!") print(response.content)

Multi-turn with thread

from agents_framework import Thread thread = Thread() response = await agent.run(thread=thread, message="What's 2+2?") response = await agent.run(thread=thread, message="Double that")

C# Example:

using Microsoft.Agents.AI;

var agent = new Agent( name: "assistant", model: new ModelClient(model: "gpt-4"), instructions: "You are a helpful assistant" );

var response = await agent.RunAsync("Hello!"); Console.WriteLine(response.Content);

2. Tools & Functions

Extend agent capabilities by providing callable functions.

Python Example:

from agents_framework import function_tool

@function_tool def get_weather(location: str) -> str: """Get weather for a location.""" return f"Weather in {location}: Sunny, 72°F"

agent = Agent( name="assistant", model=ModelClient(model="gpt-4"), tools=[get_weather] )

response = await agent.run(message="What's the weather in Seattle?")

Agent automatically calls get_weather() and responds with result

C# Example:

[FunctionTool] public static string GetWeather(string location) { return $"Weather in {location}: Sunny, 72°F"; }

var agent = new Agent( name: "assistant", model: new ModelClient(model: "gpt-4"), tools: new[] { typeof(Tools).GetMethod("GetWeather") } );

3. Workflows

Graph-based orchestration for multi-agent systems with conditional routing and parallel execution.

Python Example:

from agents_framework import Workflow, GraphWorkflow

Define workflow graph

workflow = GraphWorkflow()

Add agents as nodes

workflow.add_node("researcher", research_agent) workflow.add_node("writer", writer_agent) workflow.add_node("reviewer", review_agent)

Define edges (control flow)

workflow.add_edge("researcher", "writer") # Sequential workflow.add_edge("writer", "reviewer")

Conditional routing

def should_revise(state): return state.get("needs_revision", False)

workflow.add_conditional_edge( "reviewer", should_revise, {"revise": "writer", "done": "END"} )

Execute workflow

result = await workflow.run(initial_message="Research AI trends")

C# Example:

var workflow = new GraphWorkflow();

workflow.AddNode("researcher", researchAgent); workflow.AddNode("writer", writerAgent); workflow.AddNode("reviewer", reviewAgent);

workflow.AddEdge("researcher", "writer"); workflow.AddEdge("writer", "reviewer");

var result = await workflow.RunAsync("Research AI trends");

4. Context & State Management

Maintain conversation history and shared state across agents.

Python:

from agents_framework import Thread, ContextProvider

Thread maintains conversation history

thread = Thread() await agent.run(thread=thread, message="Remember: My name is Alice") await agent.run(thread=thread, message="What's my name?") # "Alice"

Custom context provider

class DatabaseContext(ContextProvider): async def get_context(self, thread_id: str): return await db.fetch_history(thread_id)

async def save_context(self, thread_id: str, messages):
    await db.save_history(thread_id, messages)

agent = Agent(model=model, context_provider=DatabaseContext())

5. Middleware & Telemetry

Add cross-cutting concerns like logging, auth, and monitoring.

Python:

from agents_framework import Middleware from opentelemetry import trace

Custom middleware

class LoggingMiddleware(Middleware): async def process(self, message, next_handler): print(f"Processing: {message.content}") response = await next_handler(message) print(f"Response: {response.content}") return response

OpenTelemetry integration

tracer = trace.get_tracer(name) with tracer.start_as_current_span("agent-run"): response = await agent.run(message="Hello")

C#:

public class LoggingMiddleware : IMiddleware { public async Task<Message> ProcessAsync(Message message, Func<Message, Task<Message>> next) { Console.WriteLine($"Processing: {message.Content}"); var response = await next(message); Console.WriteLine($"Response: {response.Content}"); return response; } }

Common Patterns

Human-in-the-Loop Approval

from agents_framework import HumanInTheLoop

@function_tool def delete_file(path: str) -> str: """Delete a file (requires approval).""" return f"Deleted {path}"

Add approval wrapper

delete_file_with_approval = HumanInTheLoop( tool=delete_file, approval_prompt="Approve deletion of {path}?" )

agent = Agent(tools=[delete_file_with_approval])

Parallel Agent Execution

workflow = GraphWorkflow()

Add multiple agents

workflow.add_node("analyst1", analyst_agent) workflow.add_node("analyst2", analyst_agent) workflow.add_node("synthesizer", synthesis_agent)

Parallel execution

workflow.add_edge("START", ["analyst1", "analyst2"]) # Both run in parallel workflow.add_edge(["analyst1", "analyst2"], "synthesizer") # Wait for both

result = await workflow.run(message="Analyze market trends")

Structured Output Generation

from pydantic import BaseModel

class WeatherReport(BaseModel): location: str temperature: float conditions: str

agent = Agent( model=model, instructions="Generate weather reports", response_format=WeatherReport )

response = await agent.run(message="Weather in Seattle") report: WeatherReport = response.parsed print(f"{report.location}: {report.temperature}°F, {report.conditions}")

Error Handling & Retries

from agents_framework import RetryPolicy

agent = Agent( model=model, retry_policy=RetryPolicy( max_retries=3, backoff_factor=2.0, exceptions=[TimeoutError, ConnectionError] ) )

try: response = await agent.run(message="Hello") except Exception as e: print(f"Failed after retries: {e}")

Integration with amplihack

Decision Framework

Use Microsoft Agent Framework when:

• Building stateful conversational agents (multi-turn dialogue)

• Need enterprise features (telemetry, middleware, auth)

• Complex multi-agent orchestration with conditional routing

• Cross-platform requirements (Python + C#)

• Integration with Microsoft ecosystem (Azure, M365)

Use amplihack native agents when:

• Stateless task delegation (code review, analysis)

• Simple sequential/parallel orchestration

• File-based operations and local tooling

• Rapid prototyping without infrastructure

• Token-efficient skill-based architecture

Hybrid Approach:

Use amplihack for orchestration

from claude import Agent as ClaudeAgent

orchestrator = ClaudeAgent("orchestrator.md")

Delegate to Agent Framework for stateful agents

from agents_framework import Agent, Thread

conversational_agent = Agent( model=ModelClient(model="gpt-4"), instructions="Maintain conversation context" )

thread = Thread() response1 = await conversational_agent.run(thread=thread, message="Start task") response2 = await conversational_agent.run(thread=thread, message="Continue")

Use amplihack for final synthesis

result = orchestrator.process({"responses": [response1, response2]})

See @integration/amplihack-integration.md for complete patterns.

Quick Start Workflow

Install: pip install agent-framework-core --pre (Python) or dotnet add package Microsoft.Agents.AI --prerelease (C#)

Create Basic Agent:

from agents_framework import Agent, ModelClient

agent = Agent( name="assistant", model=ModelClient(model="gpt-4"), instructions="You are a helpful assistant" )

response = await agent.run(message="Hello!")

Add Tools:

@function_tool def calculate(expr: str) -> float: return eval(expr)

agent = Agent(model=model, tools=[calculate])

Build Workflow:

workflow = GraphWorkflow() workflow.add_node("agent1", agent1) workflow.add_node("agent2", agent2) workflow.add_edge("agent1", "agent2") result = await workflow.run(message="Task")

Add Telemetry:

from opentelemetry import trace tracer = trace.get_tracer(name) with tracer.start_as_current_span("agent-run"): response = await agent.run(message="Hello")

Reference Documentation

For detailed information, see:

• @reference/01-overview.md

• Architecture, components, use cases

• @reference/02-agents.md

• Agent creation, lifecycle, advanced features

• @reference/03-workflows.md

• Workflow patterns, executors, checkpointing

• @reference/04-tools-functions.md

• Tool definition, approval workflows, error handling

• @reference/05-context-middleware.md

• Context providers, middleware patterns, auth

• @reference/06-telemetry-monitoring.md

• OpenTelemetry, logging, debugging

• @reference/07-advanced-patterns.md

• Multi-agent patterns, streaming, DevUI

Working Examples

• @examples/01-basic-agent.py

• Simple conversational agent

• @examples/02-tool-integration.py

• Agent with function calling

• @examples/03-simple-workflow.py

• Multi-agent workflow

• @examples/04-basic-agent.cs

• C# agent implementation

• @examples/05-tool-integration.cs

• C# tool integration

• @examples/06-simple-workflow.cs

• C# workflow example

Maintenance

Check framework freshness: python @scripts/check-freshness.py

Current version tracking: @metadata/version-tracking.json

Token Count: ~4,200 tokens (under 4,800 limit)