Add comprehensive Agent Frameworks comparison tutorial and prose guide

[Copilot]

Adds in-depth comparison between Microsoft Agent Framework and Strands Agents SDK to help workshop participants choose the right framework for Azure + Neo4j projects. Includes both a technical reference document with code examples and a companion prose guide for conceptual understanding.

Documents Created

Technical Comparison (docs/AGENT_FRAMEWORKS_COMPARISON.md - 1,088 lines)

• Executive Summary - Trade-offs between enterprise orchestration vs lightweight development
• Quick Comparison Table - 8 dimensions: language support, architecture, multi-agent patterns, state management, observability, model providers, complexity, ideal use cases
• Decision Guide - Clear criteria for choosing each framework
• 10 Deep Dive Sections - Architecture, execution models, orchestration, tools, state management, observability, platform support, providers, side-by-side examples, use cases
• Neo4j Integration - Specific recommendations for graph database workflows

Companion Prose Guide (docs/AGENT_FRAMEWORKS_GUIDE.md - 133 lines)

A narrative-focused companion document written in professional, approachable prose that:

• Explains architectural differences in complete paragraphs and sentences
• Covers all major comparison points without technical notation or em dashes
• Includes only minimal code snippets where essential to illustrate key differences
• Provides conceptual understanding suitable for a wide range of developers and engineers

Key Comparisons

Microsoft Agent Framework:

• Workflow-based with graph orchestration, .NET + Python
• Checkpointing, time-travel debugging, OpenTelemetry
• Azure-first with enterprise features

Strands Agents SDK:

• Event loop architecture, Python-only
• Multi-cloud providers (Bedrock, Anthropic, OpenAI, Gemini)
• Lightweight, rapid prototyping

Example Code Pattern

Both frameworks support Neo4j through custom tools:

@tool
def neo4j_query(cypher: str) -> list:
    """Execute Cypher query against Neo4j"""
    driver = neo4j.GraphDatabase.driver(uri, auth=(user, password))
    with driver.session() as session:
        result = session.run(cypher)
        return [record.data() for record in result]

Tool implementations use safe operators instead of eval() for security.

Original prompt

Add Comprehensive Agent Frameworks Comparison Tutorial

Create a new tutorial document that provides an in-depth comparison between Microsoft Agent Framework and Strands Agents SDK for workshop participants.

File Location

Create: docs/AGENT_FRAMEWORKS_COMPARISON.md

Content Structure

Page 1: Overview & Comparison (English Only)

Executive Summary

• Brief introduction to both frameworks
• Why this comparison matters for Azure + Neo4j projects
• Overview of what will be covered

Quick Comparison Table

Create a comparison table with the following dimensions:

• Primary Language Support: .NET + Python vs Python-only
• Architecture: Workflow-based vs Event Loop-based
• Multi-Agent Patterns: Sequential/Concurrent/Handoffs vs Swarm
• State Management: Checkpointing & workflows vs Session management
• Observability: Built-in OpenTelemetry vs Custom tracing
• Model Providers: Azure OpenAI focus vs Multi-provider (Bedrock, Anthropic, etc.)
• Complexity: Enterprise-grade workflows vs Lightweight & flexible
• Best For: Complex orchestration vs Quick prototyping

Decision Guide

Provide a decision tree:

• Choose Microsoft Agent Framework if:

  • You need .NET support
  • Complex workflow orchestration is required
  • Graph-based execution flows are needed
  • Enterprise Azure integration is priority
  • You need time-travel and checkpointing

• Choose Strands Agents SDK if:

  • Python-only is sufficient
  • Simple, fast agent development is priority
  • You prefer event loop architecture
  • Multi-cloud model providers needed
  • Swarm-style collaboration is required

Deep Dive Sections

1. Architecture & Design Philosophy

Microsoft Agent Framework:

• Workflow-based architecture with ExecutorBindings
• Graph-based orchestration with edges and nodes
• Protocol descriptors for type safety
• StateManager for workflow state
• Built around .NET and Python with consistent APIs

Strands Agents SDK:

• Event loop-based architecture
• Simple agent invocation model
• Callback-driven events
• Conversation manager for context
• Model-driven approach

2. Agent Execution Models

Microsoft Agent Framework - Workflow Execution:

from agent_framework import WorkflowBuilder, Executor
from agent_framework.azure import AzureOpenAIResponsesClient

# Create workflow with executors
workflow = WorkflowBuilder(starting_executor)
    .add_edge(executor1, executor2)
    .build()

# Run workflow
async for event in workflow.run(input_data):
    print(event)

Strands Agents - Event Loop:

from strands import Agent

agent = Agent(
    model="bedrock",
    tools=[calculator]
)

# Simple invocation
result = agent("What is 25 * 4?")

3. Multi-Agent Orchestration

Microsoft Agent Framework:

• Sequential workflows: AgentWorkflowBuilder.BuildSequential(agents)
• Concurrent workflows: AgentWorkflowBuilder.BuildConcurrent(agents)
• Handoff patterns with HandoffsWorkflowBuilder
• Complex graph-based routing

# Sequential workflow
workflow = AgentWorkflowBuilder.BuildSequential(
    workflowName="translation-chain",
    agents=[french_agent, spanish_agent, english_agent]
)

Strands Agents:

• Swarm orchestration with dynamic handoffs
• Agent-to-agent transfer functions
• Autonomous multi-agent loops

from strands.multiagent import Swarm

swarm = Swarm(
    agents=[researcher, writer, reviewer],
    max_iterations=10
)

result = await swarm.execute("Research and write an article")

4. Tool Integration

Microsoft Agent Framework:

# Tools as executors
from agent_framework import tool

@tool
def get_weather(location: str) -> str:
    return f"Weather in {location}"

agent.add_tool(get_weather)

Strands Agents:

from strands import Agent, tool
from strands.tools.mcp import MCPClient

@tool
def calculator(expression: str) -> float:
    """Calculate mathematical expressions"""
    return eval(expression)

# MCP Support
mcp_client = MCPClient(lambda: stdio_client(...))
agent = Agent(tools=[calculator] + mcp_client.list_tools_sync())

5. State Management & Checkpointing

Microsoft Agent Framework:

• Workflow checkpointing with CheckpointManager
• StateManager with scoped state
• Time-travel capabilities
• Workflow resumption

var checkpointManager = new FileCheckpointManager("./checkpoints");
var workflow = builder.Build();
var agent = workflow.AsAgent(
    checkpointManager: checkpointManager
);

Strands Agents:

• Session management with SessionManager
• Agent state persistence
• Conversation history tracking

from strands import Agent, AgentState
from strands.session import SessionManager

session_mgr = SessionManager(storage_path="./sessions")
agent = Agent(
    session_manager=session_mgr,
    agent_id="my-agent",
    state={"user_context": "value"}
)

6. Observability

Microsoft Agent Framework:
-...

This pull request was created as a result of the following prompt from Copilot chat.

Add Comprehensive Agent Frameworks Comparison Tutorial

Create a new tutorial document that provides an in-depth comparison between Microsoft Agent Framework and Strands Agents SDK for workshop participants.

File Location

Create: docs/AGENT_FRAMEWORKS_COMPARISON.md

Content Structure

Page 1: Overview & Comparison (English Only)

Executive Summary

• Brief introduction to both frameworks
• Why this comparison matters for Azure + Neo4j projects
• Overview of what will be covered

Quick Comparison Table

Create a comparison table with the following dimensions:

• Primary Language Support: .NET + Python vs Python-only
• Architecture: Workflow-based vs Event Loop-based
• Multi-Agent Patterns: Sequential/Concurrent/Handoffs vs Swarm
• State Management: Checkpointing & workflows vs Session management
• Observability: Built-in OpenTelemetry vs Custom tracing
• Model Providers: Azure OpenAI focus vs Multi-provider (Bedrock, Anthropic, etc.)
• Complexity: Enterprise-grade workflows vs Lightweight & flexible
• Best For: Complex orchestration vs Quick prototyping

Decision Guide

Provide a decision tree:

• Choose Microsoft Agent Framework if:

  • You need .NET support
  • Complex workflow orchestration is required
  • Graph-based execution flows are needed
  • Enterprise Azure integration is priority
  • You need time-travel and checkpointing

• Choose Strands Agents SDK if:

  • Python-only is sufficient
  • Simple, fast agent development is priority
  • You prefer event loop architecture
  • Multi-cloud model providers needed
  • Swarm-style collaboration is required

Deep Dive Sections

1. Architecture & Design Philosophy

Microsoft Agent Framework:

• Workflow-based architecture with ExecutorBindings
• Graph-based orchestration with edges and nodes
• Protocol descriptors for type safety
• StateManager for workflow state
• Built around .NET and Python with consistent APIs

Strands Agents SDK:

• Event loop-based architecture
• Simple agent invocation model
• Callback-driven events
• Conversation manager for context
• Model-driven approach

2. Agent Execution Models

Microsoft Agent Framework - Workflow Execution:

from agent_framework import WorkflowBuilder, Executor
from agent_framework.azure import AzureOpenAIResponsesClient

# Create workflow with executors
workflow = WorkflowBuilder(starting_executor)
    .add_edge(executor1, executor2)
    .build()

# Run workflow
async for event in workflow.run(input_data):
    print(event)

Strands Agents - Event Loop:

from strands import Agent

agent = Agent(
    model="bedrock",
    tools=[calculator]
)

# Simple invocation
result = agent("What is 25 * 4?")

3. Multi-Agent Orchestration

Microsoft Agent Framework:

• Sequential workflows: AgentWorkflowBuilder.BuildSequential(agents)
• Concurrent workflows: AgentWorkflowBuilder.BuildConcurrent(agents)
• Handoff patterns with HandoffsWorkflowBuilder
• Complex graph-based routing

# Sequential workflow
workflow = AgentWorkflowBuilder.BuildSequential(
    workflowName="translation-chain",
    agents=[french_agent, spanish_agent, english_agent]
)

Strands Agents:

• Swarm orchestration with dynamic handoffs
• Agent-to-agent transfer functions
• Autonomous multi-agent loops

from strands.multiagent import Swarm

swarm = Swarm(
    agents=[researcher, writer, reviewer],
    max_iterations=10
)

result = await swarm.execute("Research and write an article")

4. Tool Integration

Microsoft Agent Framework:

# Tools as executors
from agent_framework import tool

@tool
def get_weather(location: str) -> str:
    return f"Weather in {location}"

agent.add_tool(get_weather)

Strands Agents:

from strands import Agent, tool
from strands.tools.mcp import MCPClient

@tool
def calculator(expression: str) -> float:
    """Calculate mathematical expressions"""
    return eval(expression)

# MCP Support
mcp_client = MCPClient(lambda: stdio_client(...))
agent = Agent(tools=[calculator] + mcp_client.list_tools_sync())

5. State Management & Checkpointing

Microsoft Agent Framework:

• Workflow checkpointing with CheckpointManager
• StateManager with scoped state
• Time-travel capabilities
• Workflow resumption

var checkpointManager = new FileCheckpointManager("./checkpoints");
var workflow = builder.Build();
var agent = workflow.AsAgent(
    checkpointManager: checkpointManager
);

Strands Agents:

• Session management with SessionManager
• Agent state persistence
• Conversation history tracking

from strands import Agent, AgentState
from strands.session import SessionManager

session_mgr = SessionManager(storage_path="./sessions")
agent = Agent(
    session_manager=session_mgr,
    agent_id="my-agent",
    state={"user_context": "value"}
)

6. Observability

Microsoft Agent Framework:

• Built-in OpenTelemetry integration
• Workflow spans and executor traces
• Distributed tracing support

from agent_framework.observability import setup_observability

setup_observability(
    service_name="my-workflow",
    exporter="console"
)

Strands Agents:

• Custom tracer integration
• Event-based monitoring
• Callback handlers for observability

def custom_handler(**event):
    if "data" in event:
        print(f"Stream: {event['data']}")

agent = Agent(callback_handler=custom_handler)

7. Language & Platform Support

Microsoft Agent Framework:

• Python: Full support with async/await
• .NET: C# with full feature parity
• Consistent APIs across languages
• Enterprise integration patterns

Strands Agents:

• Python: Python 3.10+ only
• Async-first design
• Lightweight dependencies

8. Model Provider Support

Microsoft Agent Framework:

• Azure OpenAI (primary)
• OpenAI
• Anthropic
• Custom providers via ChatClient interface

Strands Agents:

• Amazon Bedrock (default)
• Anthropic, OpenAI, Gemini
• Ollama, LiteLLM, llama.cpp
• SageMaker, Writer, Cohere
• Highly extensible provider system

9. Code Examples: Side-by-Side

Example: Creating a Simple Agent

Microsoft Agent Framework:

from agent_framework.azure import AzureOpenAIResponsesClient
from azure.identity import AzureCliCredential

agent = AzureOpenAIResponsesClient(
    credential=AzureCliCredential()
).create_agent(
    name="Assistant",
    instructions="You are a helpful assistant."
)

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

Strands Agents:

from strands import Agent
from strands.models import BedrockModel

agent = Agent(
    model=BedrockModel(model_id="us.amazon.nova-pro-v1:0"),
    system_prompt="You are a helpful assistant."
)

result = agent("Hello!")
print(result.message)

Example: Streaming Responses

Microsoft Agent Framework:

async for update in agent.run_streaming(messages):
    if update.content:
        print(update.content, end="")

Strands Agents:

async for event in agent.stream_async("Tell me a story"):
    if "data" in event:
        print(event["data"], end="")

10. Use Cases & Recommendations

Use Microsoft Agent Framework When:

• Building enterprise applications requiring .NET
• Complex workflow orchestration is essential
• You need robust checkpointing and recovery
• Azure-first architecture
• Graph-based agent collaboration
• Time-travel debugging is valuable
• Multi-language support is required

Use Strands Agents When:

• Rapid prototyping and development
• Python-only environment
• Simple to moderate agent complexity
• Multi-cloud model provider flexibility
• Swarm-style collaboration patterns
• Lightweight, minimal dependencies
• Event loop architecture preferred

For Neo4j + Azure Projects:

• Microsoft Agent Framework: Better for complex enterprise workflows with Azure integration
• Strands Agents: Better for rapid development and multi-cloud scenarios

Both frameworks can integrate with Neo4j through custom tools/functions.

Conclusion

Both frameworks are powerful but serve different use cases:

• Microsoft Agent Framework excels at complex, enterprise-grade orchestration with strong typing and multi-language support
• Strands Agents SDK excels at rapid development with flexible, lightweight agent architecture

Choose based on your specific requirements for language support, orchestration complexity, and cloud provider preference.

Additional Resources

Microsoft Agent Framework

• Official Documentation
• GitHub Repository
• Python Samples
• .NET Samples

Strands Agents SDK

• Official Documentation
• GitHub Repository
• Examples
• API Reference

---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

[retroryan]

@copilot - Write a companion guide to the tutorial that is an English only description of everything and write it with mostly paragraphs and complete sentences and do not use any em dashes Styles sentences and use a professional writing style that is illustrative and approachable by a wide range of developers and engineers. And only include very small code snippets where it is critical to illustrate differences.

[Copilot]

@copilot - Write a companion guide to the tutorial that is an English only description of everything and write it with mostly paragraphs and complete sentences and do not use any em dashes Styles sen...

I've created the companion guide at docs/AGENT_FRAMEWORKS_GUIDE.md. The document is written entirely in prose with complete sentences and paragraphs, avoids em dashes, and uses a professional yet approachable style suitable for a wide range of developers. It includes only two small code snippets where essential to illustrate key differences. The guide covers all major comparison points including architecture, language support, multi-agent coordination, state management, tool integration, observability, model providers, Neo4j integration, and decision criteria. Commit: a1873a1