What AI Concepts Are Covered in AI Agents for Beginners: A Complete Guide to Microsoft's 15-Lesson Curriculum

The AI Agents for Beginners repository covers 15 progressive lessons spanning foundational agent theory, design patterns (RAG, planning, multi-agent, metacognition), trust and safety, production deployment, and emerging protocols like MCP and A2A.

The AI Agents for Beginners course from Microsoft is a comprehensive, code-first curriculum that teaches developers how to build production-ready AI agents. Organized into 15 sequential lessons, the repository combines conceptual deep-dives with runnable Python notebooks using the Microsoft Agent Framework (MAF) and Azure AI Agent Service.

This guide breaks down every AI concept covered in the course, maps each to its source files, and provides executable code examples you can adapt immediately.

---

Core AI Agent Foundations

Agent Taxonomy and Components

The first lesson establishes the theoretical bedrock of AI agents. According to 01-intro-to-ai-agents/README.md, agents are defined by three core components: sensors (perceiving the environment), actuators (taking actions), and internal state (memory and reasoning).

The course teaches five agent types:

• Reflex agents – respond directly to current perceptions
• Goal-based agents – plan actions to achieve objectives
• Utility-based agents – optimize for preferred outcomes
• Learning agents – improve performance through experience
• Hierarchical agents – decompose complex tasks into sub-agents

When to Use AI Agents

01-intro-to-ai-agents/README.md emphasizes that agents add value when tasks require autonomous decision-making, multi-step reasoning, tool integration, or dynamic adaptation to changing conditions—distinguishing them from simple prompt-chaining or single-turn LLM calls.

---

Agentic Frameworks and SDK Architecture

Microsoft Agent Framework vs. Azure AI Agent Service

Lesson 2, documented in 02-explore-agentic-frameworks/README.md, contrasts two Microsoft offerings:

Framework	Best For	Key Class
Microsoft Agent Framework (MAF)	Custom agent logic, multi-agent orchestration, local development	AzureAIProjectAgentProvider
Azure AI Agent Service	Managed deployment, enterprise scaling, built-in evaluations	Azure.AI.Projects REST API

Tool Registration and Calling

The AzureAIProjectAgentProvider class enables function calling (also called tool use) through a decorator-based registration pattern. Tools are Python functions annotated with docstrings that the LLM uses to generate structured JSON arguments.

---

Foundational Design Patterns

Tool Use Pattern

The Tool Use Design Pattern in 04-tool-use/README.md teaches how to extend agent capabilities beyond the LLM's training data. Key concepts include:

• Tool schema definition – JSON Schema or Pydantic models describing parameters
• Result handling – parsing tool outputs and feeding them back into the reasoning loop
• Error resilience – graceful degradation when tools fail or return unexpected formats

Retrieval-Augmented Generation (RAG)

05-agentic-rag/README.md and its companion notebook 05-agentic-rag/code_samples/05-python-agent-framework.ipynb cover Agentic RAG—a pattern where the agent itself decides when to retrieve information, what queries to run, and how to synthesize results.

Critical improvements over naive RAG:

• Self-correction loops – agents re-query if initial retrieval is insufficient
• Hybrid search – combining vector similarity with keyword filtering
• Tool-driven retrieval – treating search as one tool among many, not a fixed preprocessing step

Planning Design Pattern

The Planning Pattern in 07-planning-design/README.md and 07-planning-design/code_samples/07-python-agent-framework.ipynb enables agents to decompose complex goals into executable steps before taking action.

Two common architectures:

• Plan-then-execute – generate full plan upfront, then execute serially
• Re-planning – interleaved planning and execution with state updates

State tracking uses the agent's working memory to monitor progress, handle failures, and trigger re-planning when deviations occur.

---

Advanced Multi-Agent and Cognitive Patterns

Multi-Agent Design Pattern

08-multi-agent/README.md and 08-multi-agent/solution/solution.md teach orchestrated multi-agent systems where specialized agents collaborate on complex tasks.

Key coordination mechanisms:

• Hand-off protocols – transferring control between agents with context preservation
• Parallel execution – concurrent agent operations with result aggregation
• Hierarchical structures – manager agents delegating to worker agents

The solution file demonstrates a data retrieval + analysis pipeline: one agent fetches data, another analyzes it, and a third synthesizes the final report.

Metacognition Design Pattern

The Metacognition Pattern in 09-metacognition/README.md enables self-reflective agents that monitor and improve their own reasoning.

Core techniques:

• Self-reflection prompts – "Review your previous answer for errors"
• Dynamic prompt updates – adjusting system messages based on task performance
• Reasoning about reasoning – explicit chains of thought about the thought process itself

This pattern improves reliability for complex, multi-step reasoning tasks where initial answers may be incomplete or incorrect.

---

Trust, Safety, and Responsible AI

Building Trustworthy Agents

06-building-trustworthy-agents/README.md covers secure prompt engineering and threat mitigation for production agents.

Defense mechanisms include:

• System-message frameworks – structured system prompts that constrain agent behavior
• Human-in-the-loop – requiring approval for high-stakes actions
• Safety prompts – injected guardrails that detect and block harmful requests
• Metaprompting – automated prompt optimization with safety constraints

Threat modeling identifies common attack vectors: prompt injection, indirect prompt injection via tool outputs, and data exfiltration through tool calls.

---

Production Deployment and Scaling

Agents in Production

10-ai-agents-production/README.md bridges the gap from notebooks to production services.

Key topics:

• Deployment pipelines – automated testing, containerization, and CI/CD for agents
• Azure AI Foundry Agent Service V2 – managed service for scalable agent hosting
• Observability – logging, tracing, and monitoring agent conversations and decisions
• Scaling strategies – load balancing, concurrency limits, and cost optimization

The lesson emphasizes versioning for prompts, tools, and agent configurations to enable safe rollbacks and A/B testing.

---

Emerging Standards and Advanced Topics

Agentic Protocols (MCP, A2A, NLWeb)

11-agentic-protocols/README.md introduces standardized inter-agent communication protocols that enable interoperability between different agent frameworks.

Protocol	Purpose	Key Mechanism
MCP (Model Context Protocol)	Context sharing between agents	Structured message schemas for state exchange
A2A (Agent-to-Agent)	Direct agent negotiation	Capability advertisement and task delegation
NLWeb	Natural language web interfaces	HTTP-based natural language endpoints

These protocols address the fragmentation problem in the agent ecosystem, allowing agents built with different tools to collaborate.

Context Engineering

12-context-engineering/README.md teaches advanced prompt engineering for long-context scenarios.

Critical techniques:

• Token management – optimizing prompt length to fit within context windows
• Long-context structuring – hierarchical organization of information for better retrieval
• External knowledge injection – dynamic incorporation of fresh information without retraining

This lesson addresses the practical constraints of current LLM context windows while maximizing effective context utilization.

Managing Agentic Memory

13-agent-memory/README.md covers persistent memory architectures for agents.

Memory types:

• Short-term memory – conversation context within a single session
• Long-term memory – vector databases for semantic retrieval of past interactions
• State persistence – durable storage for agent configuration and progress

Implementation patterns include memory-augmented generation and episodic memory for learning from past task executions.

---

Deep Dive: Microsoft Agent Framework Internals

14-microsoft-agent-framework/README.md provides advanced MAF patterns for sophisticated agent architectures.

Topics covered:

• SDK internals – provider architecture, agent lifecycle, and middleware pipeline
• Conditional workflows – branching logic based on runtime state
• Concurrent execution – parallel agent operations with synchronization
• Human-in-the-loop integration – approval checkpoints and intervention mechanisms

The companion notebook 14-microsoft-agent-framework/code-samples/14-conditional-workflow.ipynb demonstrates conditional routing where agents dynamically select execution paths based on task characteristics.

---

Browser-Use Agents

15-browser-use/README.md and 15-browser-use/15-browser-user.ipynb teach web automation agents using Playwright.

Capabilities:

• Browser control – navigation, form filling, clicking, scrolling
• UI automation – interacting with dynamic web applications
• Web scraping – extracting structured data from pages
• Visual grounding – agents that perceive and act on visual page elements

This pattern enables agents to interact with legacy systems, fill gaps where APIs don't exist, and perform human-like web browsing tasks.

---

Summary

The AI Agents for Beginners repository delivers comprehensive coverage of modern agent development:

• 15 progressive lessons from agent fundamentals to production deployment
• Microsoft Agent Framework (MAF) and Azure AI Agent Service as core tools
• Essential design patterns: tool use, RAG, planning, multi-agent coordination, metacognition
• Trust and safety: secure prompt engineering, human-in-the-loop, threat modeling
• Production readiness: deployment pipelines, observability, scaling with Azure AI Foundry
• Emerging standards: MCP, A2A, and NLWeb protocols for agent interoperability
• Advanced capabilities: browser automation, memory management, and context engineering

Each concept includes runnable Python code in the code_samples/ directories, making this both a reference and a practical starting point for building production AI agents.

---

Frequently Asked Questions

What is the Microsoft Agent Framework (MAF)?

The Microsoft Agent Framework (MAF) is a Python SDK for building AI agents with structured workflows, tool integration, and multi-agent orchestration. It provides the AzureAIProjectAgentProvider class for creating agents, registering tools, and managing conversations. MAF is designed for developers who need custom agent logic beyond what managed services offer.

How does Agentic RAG differ from standard RAG?

Agentic RAG puts the Retrieval-Augmented Generation pipeline under the agent's control rather than preprocessing all queries. The agent decides when to search, reformulates queries based on intermediate results, and can loop back for additional retrieval if information is insufficient. This pattern, implemented in 05-agentic-rag/code_samples/05-python-agent-framework.ipynb, handles complex, multi-fact queries better than static RAG pipelines.

What protocols enable agents to communicate with each other?

The course covers three emerging protocols in 11-agentic-protocols/README.md: MCP (Model Context Protocol) for structured context sharing, A2A (Agent-to-Agent) for capability-based negotiation and task delegation, and NLWeb for HTTP-based natural language interfaces. These protocols address interoperability between agents built with different frameworks, allowing heterogeneous agent systems to collaborate.

How do you deploy AI agents to production?

Lesson 10 in 10-ai-agents-production/README.md covers deployment via Azure AI Foundry Agent Service V2, including containerization, CI/CD pipelines, observability with logging and tracing, and scaling strategies like load balancing and concurrency management. The lesson emphasizes versioning for prompts and tools to enable safe updates and rollbacks in production environments.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}