Microsoft AI Agents for Beginners

The AI Agents for Beginners course teaches the fundamentals of building AI agents.

Key Components

• Code Samples: Found in the code_samples folder. Most examples use Microsoft Agent Framework (MAF) and Microsoft Foundry Agent Service V2.
• Prerequisites: An Azure Account is required to use Microsoft Foundry.
• Supported Providers: While primarily focused on Microsoft services, some examples support OpenAI-compatible providers like MiniMax.
• Learning Materials: Each lesson includes a README, a short video, Python code examples using MAF, and links to additional resources.

Getting Started

1. Fork the repository to create your own copy for running code.
2. Follow the Course Setup guide for detailed instructions on running the code.
3. If you are new to Generative AI, it is recommended to complete the Generative AI For Beginners course first.

Community Support

You can join the Microsoft Foundry Discord to ask questions and connect with other learners: https://aka.ms/ai-agents/discord.

This course provides a comprehensive guide to building AI Agents, covering foundations, design patterns, and practical implementation.

Key Technologies Used:

• Microsoft Agent Framework (MAF): The primary framework for agent orchestration.
• Microsoft Foundry Agent Service V2: Used for hosting and managing agent services (requires an Azure Account).
• OpenAI-compatible providers: Some code samples support alternative providers like MiniMax for large context models (up to 204K tokens).

Course Structure:

Each lesson includes written documentation, a short video, Python code samples (located in the code_samples folder), and additional learning resources. Topics include:

• Introduction to AI Agents and Use Cases
• Exploring Agentic Frameworks
• AI Agentic Design Patterns
• Tool Use Design
• Agentic RAG
• Building Trustworthy AI Agents
• Planning Design
• Multi-Agent Design

Microsoft Agent Framework (MAF) is designed for building production-ready AI agents across various orchestration patterns:

Orchestration Patterns

• Sequential Orchestration: Step-by-step workflows.
• Concurrent Orchestration: Executing multiple tasks simultaneously.
• Group Chat Orchestration: Multiple agents collaborating on a single task.
• Hand-off Orchestration: Agents transferring tasks to one another.
• Manager Orchestration: A management agent creating and modifying task lists for sub-agents.

Production Features

• Observability: Uses OpenTelemetry to track tool calls, orchestration steps, and reasoning traces via Microsoft Foundry dashboards.
• Security: Hosted via Microsoft Foundry with role-based access control (RBAC), private data handling, and content safety.
• Durability: Supports long-running processes with the ability to pause, resume, and recover from errors.
• Control: Supports human-in-the-loop workflows by identifying tasks that require human approval.

Interoperability

• Cloud-Agnostic: Runs in containers, on-prem, or across multiple clouds.
• Provider Agnostic: Supports various SDKs (Azure OpenAI, OpenAI, etc.).
• Open Standards: Uses Agent-to-Agent (A2A) and Model Context Protocol (MCP).
• Extensible: Connects to services like Microsoft Fabric, SharePoint, Pinecone, and Qdrant.

The Planning Design Pattern involves creating a Planner that dynamically selects from available agents to solve complex tasks. The Planner's primary responsibility is to decompose a high-level goal into structured subtasks and assign them to specialized agents.

Key concepts include:

• Task Decomposition: Breaking down complex goals into manageable steps.
• Agent Assignment: Mapping subtasks to agents that possess the necessary tools or functions to execute them.
• Extensibility: The pattern can be augmented with additional patterns such as reflection, summarizer, and round robin chat for enhanced customization and control.
• Advanced Orchestration (Magnetic One): For highly complex tasks, the Magnetic One architecture uses an orchestrator that generates task-specific plans, assigns tasks, and utilizes a monitoring mechanism to track progress and trigger re-planning when necessary.

Local AI agents leverage Small Language Models (SLMs) to run on-device (CPU, GPU, or NPU). This approach provides three primary benefits:

1. Privacy: Data, prompts, and snippets never leave the machine or cross network boundaries.
2. Cost: Eliminates per-token billing for global inference; costs are limited to local electricity.
3. Offline Capability: Agents function without an internet connection.

SLM Capabilities and Limitations

• Strengths: Structured tasks (classification, extraction, summarization), Tool Calling (deciding which function to call with which arguments), and fast, private iterations on private data.
• Weaknesses: Complex multi-step reasoning and broad general knowledge (due to smaller parameter counts).

Best Practice: Use an SLM-led approach where the model orchestrates tools (e.g., read_file, search_docs) rather than relying on the model's internal knowledge of your specific codebase.

The Tool Use Design Pattern enables Large Language Models (LLMs) to interact with external systems (APIs, databases, code interpreters) to achieve specific goals. This pattern relies on model-generated function calls where the LLM selects a tool and provides arguments based on a provided schema.

Key Building Blocks

• Function/Tool Schemas: JSON definitions of available tools (name, purpose, parameters, and output format).
• Function Execution Logic: Logic that decides when and how to call tools (e.g., planners or routers).
• Message Handling System: Manages the conversation flow between user messages, LLM tool calls, and tool outputs.
• Tool Integration Framework: The infrastructure connecting the agent to external services.
• Error Handling & Validation: Manages failures during tool execution and validates parameters.
• State Management: Tracks conversation context and previous tool uses to ensure consistency across multiple turns.

AI Agentic Design Principles provide a human-centric UX framework for building agents that expand human capabilities, fill knowledge gaps, facilitate collaboration, and assist in personal growth. The principles are categorized into three dimensions: Space, Time, and Core.

Agent (Space)

Focuses on the environment where the agent operates (physical and digital).

• Connect, don't contract: Design agents to facilitate connection between people, events, and active knowledge rather than isolating users.
• Easily available but temporally invisible: Agents should be accessible across tools/platforms and support multimodal inputs (sound, voice, text), but primarily operate in the background, surfacing only when necessary. They should transition smoothly between proactive and reactive modes while maintaining transparency and user control over background processes.

Agent (Time)

Focuses on how the agent interacts across different temporal contexts.

• Past (Reflection of history): Agents should use rich historical context (events, people, states) to provide relevant results and build connections between past events and current situations.
• Present (Suggesting instead of telling): Agents should have a holistic view of interaction. Instead of static instructions, they should drive progress based on context, social/cultural changes, and user intent, providing information at the appropriate moment through incremental complexity.
• Future (Adaptive and evolving): Agents should be designed to adapt to new tools, platforms, and models, and evolve based on continuous user interaction and changing needs.

Multi-agent design is a pattern where multiple agents work together to achieve a common goal. This pattern is useful for scaling complex systems and improving reliability compared to a single-agent approach.

When to use Multi-Agent systems:

• Large Workloads: Break large tasks into smaller sub-tasks that can be processed in parallel for speed.
• Complex Tasks: Decompose complex requests into sub-tasks and assign them to agents with specific expertise (e.g., in autonomous vehicles, separate agents handle navigation, obstacle detection, and vehicle communication).
• Diverse Expertise: Assign different agents to handle specialized domains (e.g., in healthcare, separate agents for engineering, treatment planning, and patient monitoring).

Benefits over Single-Agent systems:

• Specialization: Each agent is optimized for a specific task, preventing the 'jack of all trades, master of none' problem.
• Scalability: It is easier to scale by adding more specialized agents rather than increasing the complexity of a single agent.
• Fault Tolerance: If one agent fails, others can continue working, increasing the overall system reliability.

When moving from a prototype (running in a notebook or local machine) to a production-ready agent, the focus shifts from the model itself to the operational infrastructure. While the core loop (thinking, tool calling, responding) remains the same, the following aspects must change: