| name | microsoft-agent-framework |
| version | 0.1.0-preview |
| description | Expert knowledge of Microsoft Agent Framework for building production AI agents and workflows. Use when building agents with Microsoft's framework, multi-agent orchestration, or tool integration. |
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 --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
agent = Agent(
name="assistant",
model=ModelClient(model="gpt-4"),
instructions="You are a helpful assistant"
)
response = await agent.run(message="Hello!")
print(response.content)
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?")
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
workflow = GraphWorkflow()
workflow.add_node("researcher", research_agent)
workflow.add_node("writer", writer_agent)
workflow.add_node("reviewer", review_agent)
workflow.add_edge("researcher", "writer")
workflow.add_edge("writer", "reviewer")
def should_revise(state):
return state.get("needs_revision", False)
workflow.add_conditional_edge(
"reviewer",
should_revise,
{"revise": "writer", "done": "END"}
)
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 = Thread()
await agent.run(thread=thread, message="Remember: My name is Alice")
await agent.run(thread=thread, message="What's my name?")
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
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
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}"
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()
workflow.add_node("analyst1", analyst_agent)
workflow.add_node("analyst2", analyst_agent)
workflow.add_node("synthesizer", synthesis_agent)
workflow.add_edge("START", ["analyst1", "analyst2"])
workflow.add_edge(["analyst1", "analyst2"], "synthesizer")
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:
from claude import Agent as ClaudeAgent
orchestrator = ClaudeAgent("orchestrator.md")
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")
result = orchestrator.process({"responses": [response1, response2]})
See @integration/amplihack-integration.md for complete patterns.
Quick Start Workflow
-
Install: pip install agent-framework --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)