« Track Overview · Warmup · Hitchhiker's · Deep Dive · Principal Deep Dive · Core Contributor · Staff Notes

Phase 23 — AutoGen & the Microsoft Agent Framework

Answers these JD lines: Citi's Lead Agentic AI Engineer – VP names AutoGen by name in its agent-framework requirement ("LangChain, LangGraph, LlamaIndex, AutoGen, CrewAI, Google ADK" — jd.md), and every Microsoft/Azure/.NET-shop agentic role is now converging on the Microsoft Agent Framework (MSAF) — the announced successor to both AutoGen and Semantic Kernel. This phase makes you fluent in the lineage (AutoGen's conversational teams, SK's enterprise plumbing) and the go-forward framework (MSAF's graph Workflows + orchestration patterns), so you can speak to a Microsoft-stack interviewer with the same authority Phase 18 gives you on LangGraph.

The one-paragraph orientation. AutoGen (Microsoft Research) is a framework for conversational multi-agent teams — agents take turns writing messages until a termination condition fires. Semantic Kernel (Microsoft's other line) is an enterprise SDK — typed plugins, session state, middleware, telemetry. In late 2025 Microsoft merged them into one framework: the Microsoft Agent Framework. MSAF keeps AutoGen's simple agent abstractions, folds in SK's enterprise features, and adds a genuinely new capability neither had: graph-based Workflows with type-safe routing, checkpointing, and human-in-the-loop. AutoGen and SK are now the lineage; MSAF is the product. Knowing that story cold is the point of this phase.

Why this phase exists

Phase 18 built LangGraph's execution model from scratch, because "I can use StateGraph" is a junior claim and "I understand the Pregel super-step loop underneath it" is a senior one. This phase does the same for the Microsoft side of the agent-framework world, which a large slice of enterprise (banks, insurers, anyone on Azure/.NET) standardizes on. Three things separate someone who uses these frameworks from someone trusted to own them:

1. AutoGen's control loop is a conversation, not a graph. A team is a shared message list plus a speaker-selection policy plus a termination condition. Round-robin and selector-based selection, and composable termination (|/&), are the whole coordination model — and it is deliberately open-ended (nobody wrote the path in advance).
2. MSAF Workflows are a graph, and that is the deliberate opposite. When you don't want an LLM improvising control flow, you wire executors (agents/functions) with typed edges, get checkpointing and human-in-the-loop for free, and reason about the run like any other program. MSAF's own framing: "if you can write a function, do that" — reach for the open-ended agent only when the task genuinely needs runtime flexibility (Phase 00's least-agentic principle, shipped as an API).
3. The orchestration patterns are a small, named vocabulary. Sequential, concurrent, handoff, group-chat, and magentic (a Magentic-One-style manager) cover almost every real multi-agent system. Knowing them by name — and being able to build each in ten lines — is what lets you say "that's a handoff pattern, bounded, with a validated target" in a design review instead of hand-waving.

Concept map

• AutoGen team = shared conversation (list of TextMessage) + speaker selection (RoundRobinGroupChat cycles; SelectorGroupChat lets a model/policy pick) + a termination condition (MaxMessageTermination, TextMentionTermination, composed with |/&).
• The v0.2 → v0.4 rearchitecture = AutoGen moved from a monolithic conversation loop to an actor/event-driven runtime (autogen-core), with the ergonomic team API (autogen-agentchat) layered on top — the same "framework as a thin layer over a message-passing runtime" idea MSAF inherits.
• The convergence = MSAF = AutoGen's agent abstractions + Semantic Kernel's enterprise features (session state, type safety, middleware, telemetry) + graph Workflows. Same teams, one framework, .NET + Python + Go.
• MSAF Workflow = executors (nodes) + type-safe edges (routing) + a shared context/state
  • checkpointing (save/resume at a super-step boundary) + human-in-the-loop (RequestInfoExecutor).
• Orchestration patterns = sequential (chain), concurrent (fan-out/fan-in), handoff (dynamic transfer), group-chat (AutoGen team), magentic (manager + progress ledger).
• Agents vs Workflows = open-ended (the model chooses the path) vs explicit (you wrote the graph). The whole framework is organized around letting you pick per-task.

The three labs

Every lab injects the agent as a pure policy (no real LLM), so the coordination is deterministic, offline, and unit-testable — exactly how you test a real AutoGen/MSAF system: the orchestration is separable from the model.

Integrated scenario (how this shows up at work)

A wholesale-banking team wants an "agent" that, given a customer email, triages it, gathers the relevant account facts, drafts a reply, and gets a human to approve anything that moves money. You don't build one 12-step autonomous agent (Phase 00 says 0.95^12 ≈ 0.54 — a coin flip). You build a workflow: a SelectorGroupChat-style triage step decides the category (open-ended, because email is fuzzy), then an MSAF Workflow takes over with typed edges (an AccountFacts object flows to the drafter, not a stringly-typed blob), a RequestInfoExecutor pauses for human approval on refunds, and checkpointing means a crash mid-flow resumes instead of re-emailing the customer. The one genuinely open-ended sub-task (reading the email) is an agent; everything else is explicit, typed, resumable orchestration you can put in front of an auditor. That is the MSAF pitch, and it is the senior answer.

Deliverables checklist

• Lab 01 green under LAB_MODULE=solution pytest and your own lab.py (22 tests).
• Lab 02 green (23 tests) — typed edges, checkpoint/resume, HITL pause/resume.
• Lab 03 green (25 tests) — sequential/concurrent/handoff/magentic, each bounded.
• You can explain, out loud, why MSAF is the successor to both AutoGen and SK.
• You can state when you'd reach for an open-ended AutoGen team vs an explicit MSAF Workflow.
• You can name the five orchestration patterns and each one's failure mode / bound.

Key takeaways

• AutoGen coordinates by conversation; MSAF Workflows coordinate by graph. Selection + termination is the team model; typed edges + checkpointing + HITL is the workflow model. They are the open-ended and explicit ends of one spectrum.
• MSAF is the go-forward framework; AutoGen and Semantic Kernel are its lineage. The merge buys AutoGen's simplicity, SK's enterprise features, and new graph Workflows. Say that sentence in the interview and you sound current, because you are.
• The magentic/manager pattern is the general orchestrator — plan, delegate, observe via a progress ledger, synthesize — and it subsumes the other patterns. It's Microsoft's Magentic-One made a first-class primitive.
• Every loop is bounded and every handoff target is validated. A multi-agent system without a step budget is an infinite ping-pong; an unvalidated handoff is a routing bug that fails silently. The mechanism you build here makes both impossible by construction.
• MSAF vs LangGraph is the interview compare-and-contrast: both are graph workflows with checkpointing + HITL; MSAF adds type-safe edges and a first-class agent/session model and lives in the .NET/Azure world, LangGraph is Python-first with the richest checkpoint/store ecosystem.