Agentic Development Bootcamp
The program for .NET teams that have shipped one agent and need the architecture for what comes next.
- Format
- Instructor-led workshop (in-person strongly recommended)
- Duration
- 4 days
- Level
- Advanced
Who this is for
- Senior .NET engineers and architects building multi-agent systems
- AI platform teams defining internal agent infrastructure
- Engineering leads evaluating the Microsoft Agent Framework at scale
- Teams graduating from a single-agent pilot to a multi-agent architecture
Curriculum
What the program covers
Module 01
Day 1 — Agent Framework Internals
- Microsoft Agent Framework architecture in depth: agent lifecycle, the IAgentContext contract, middleware pipeline, and extension points
- Agent types and when to use each: AIAgent, ChatClientAgent, orchestrator patterns, and the tradeoffs of hierarchical vs. collaborative topologies
- Session state and conversation management: persistence strategies, resumable sessions, and state isolation in multi-tenant deployments
- Typed tool contracts: designing stable tool APIs, versioning strategy, and the interface-first approach to tool development
- Testing agents: unit-testing tools and middleware, integration testing with recorded traces, and the test pyramid for agentic systems
- Lab: build an agent with five tools, a custom middleware component, and a full unit-test suite
Module 02
Day 2 — MCP Server Architecture
- MCP protocol deep dive: the resource, tool, and prompt primitives; the SSE transport; and protocol versioning
- Building production MCP servers in .NET: project structure, authentication (OAuth 2.0 + entra), and scoped access
- Multi-agent MCP topology: one server for many agents, capability negotiation, and avoiding the N×M integration problem
- Performance and reliability: connection pooling, retry patterns, circuit breakers, and what to do when a tool is slow
- Observability for MCP: distributed tracing across agent + server, token attribution, and cost allocation
- Lab: build an authenticated MCP server exposing three real-system operations, instrument with OpenTelemetry, and connect to three different agent hosts
Module 03
Day 3 — Multi-Agent Orchestration
- Orchestration patterns: router agents, specialist agents, handoff protocols, and when multi-agent is the wrong answer
- State and memory across agents: shared context strategies, vector memory with Azure AI Search, and the consistency tradeoffs
- Human-in-the-loop design: when to pause, how to structure approval flows, and routing escalations to humans in existing workflows
- Security architecture: agent identity, tool permission scoping, audit logs, and the threat model for agentic systems
- Failure modes and recovery: partial completion, idempotent tool design, and rollback strategies for stateful operations
- Lab: build a two-agent orchestration: a router agent and a specialist, with a human-approval gate on one tool path
Module 04
Day 4 — Evaluation and Operations
- Evaluation engineering: the difference between evals and tests, LLM-as-judge patterns, deterministic vs. probabilistic assertions
- Building an eval harness with Azure AI Foundry Evaluation: dataset management, run tracking, and CI integration
- Production monitoring: token spend dashboards, latency percentiles, failure classification, and quality regression alerts
- Deployment architecture: agent hosting on Azure Container Apps vs. Azure Functions, scaling considerations, and blue/green for agents
- Keeping up: the Microsoft Agent Framework release cadence, what to watch, and how to structure your team's adoption process
- Lab: add a complete eval suite to the week's agent, configure Azure Monitor alerts, and complete a deployment runbook
Who this is for
The .NET AI Jumpstart covers enough to ship a first agent. This program is for teams that have done that — or are being asked to do more than one at a time, in production, with the architecture to support what comes after.
Multi-agent systems fail in specific ways: state coordination, inconsistent tool contracts, no observable path to understanding why the system behaved the way it did. This program is built around those failure modes. Every lab uses realistic scenarios: a slow external system, a partially completed multi-step operation, an agent producing an answer that can’t be verified.
Why four days
Agent architecture earns its complexity. Days 1 and 2 establish the foundations — the framework internals and MCP architecture — at a depth that lets you reason about failure modes, not just copy patterns. Days 3 and 4 apply that depth to the problems that actually threaten production: orchestration correctness, security boundaries, evaluation gaps, and operational readiness.
We’ve seen what happens when teams skip the depth and go straight to orchestration. The architecture debt compounds quickly.
Lab environment
All labs run in real Azure tenants. We provision lab environments in advance, or we can work in your tenant if you prefer. Participants should bring a laptop with .NET 9 SDK, Visual Studio 2022 (or VS Code + C# Dev Kit), and Docker Desktop — the MCP lab uses containers for the SSE transport.
Maximum ten participants per cohort. If your team is larger, we run parallel cohorts or split the program across two weeks.
Prerequisites
- Completed the .NET AI Jumpstart or equivalent hands-on experience with the Agent Framework
- C# and .NET 8+ proficiency (middleware, DI, async patterns)
- Azure subscription with Contributor access; prior Azure AI Foundry or OpenAI experience helpful
- Familiarity with OpenTelemetry concepts
Request bootcamp details
We'll send the full curriculum, prerequisites checklist, lab environment specs, and cohort size guidelines.
Typical lead time is two to four weeks from inquiry to confirmed date
Maximum cohort sizes are enforced — labs need room to breathe
In-person (Chicago or your site) and remote delivery both available
Get the details
We'll send the full curriculum, prerequisites checklist, lab environment specs, and cohort size guidelines.
More training