Agentic patterns and the MAF map

After this chapter, you should be able to recognize the main agentic patterns—single agent, workflow orchestration, multi-agent collaboration, reflection, and planner-style coordination—and know which Microsoft Agent Framework chapter covers the component family that implements each one.

The goal is a map, not an API tour: you will use it to choose the simplest pattern that fits before Chapter 3 introduces the first real agent API.

Chapter 1 separated three ideas: an agent uses model-driven reasoning to choose steps, a tool gives the agent a bounded capability, and a workflow defines a more explicit process path. This chapter builds on that vocabulary by arranging common agentic patterns from least coordinated to most coordinated.

The progression matters because Microsoft guidance repeatedly favors the lowest complexity that reliably solves the problem. MAF follows the same shape: it supports individual agents with instructions and tools, and it also supports graph-based workflows for explicit sequencing, routing, checkpointing, human-in-the-loop interaction, and multi-agent orchestration (MAF overview, MAF workflows).

Single-agent with tools is the default mental model for many useful agent systems. One agent owns the request, follows its instructions, uses a chat/model boundary, and calls a curated set of tools when needed. Use it when one role can solve the problem and the main challenge is dynamic tool use rather than coordination. Azure Architecture guidance describes this as often the right default for enterprise scenarios before adding multi-agent overhead (AI agent design patterns).

Sequential orchestration turns a task into ordered stages: draft, review, revise; gather, analyze, summarize; classify, enrich, escalate. Each stage depends on the previous stage's output. This is closer to workflow control than free-form autonomy: the system designer decides the order, and agents or functions fill the stages. MAF documents sequential orchestration as a pipeline of agents (sequential orchestration).

Concurrent or parallel orchestration fans work out to independent agents or branches, then gathers the results. It is useful for independent perspectives, ensemble review, map-reduce style analysis, or reducing wall-clock time when tasks do not depend on each other. MAF describes concurrent orchestration as multiple agents working on the same task in parallel with results collected afterward (concurrent orchestration).

Handoff or routing orchestration lets ownership move from one specialist to another when the context shows a better owner. Unlike a sequential workflow, the path may not be known at the start. MAF describes handoff as agents transferring control based on context or user request, and Azure Architecture guidance frames the same idea as routing, triage, dispatch, or delegation (handoff orchestration, AI agent design patterns).

Group chat or collaborative orchestration puts multiple agents into a shared conversation where they can compare, challenge, refine, and synthesize. It fits debate, consensus-building, design review, and human-visible collaboration. MAF describes group chat as a collaborative conversation coordinated by an orchestrator that manages speaker selection and flow (group chat orchestration).

Reflection or maker-checker loops are a specialized collaborative pattern: one role produces an artifact, another evaluates it against criteria, and the system may loop until the result passes or reaches an iteration limit. This can improve quality when the checker has clear acceptance criteria, but it also adds cost and can loop indefinitely without termination rules. Azure Architecture guidance calls out maker-checker, evaluator-optimizer, generator-verifier, critic, and reflection loops as related forms (AI agent design patterns).

Planner or Magentic-style orchestration is for complex, open-ended work where the path is not known in advance. A manager plans, tracks progress, chooses which specialist should act next, and adapts as new information appears. MAF documents Magentic orchestration as based on AutoGen's Magentic-One and suited to complex tasks requiring dynamic collaboration (Magentic orchestration).

The workflow-versus-autonomous-orchestration distinction from Chapter 1 is the guardrail for all of this. If the path is known, define the path as a workflow. If the path genuinely depends on evolving context, give an agent or planner bounded autonomy—but add limits, validation, observability, and human checkpoints where failure would matter (MAF workflows, AI agent design patterns).

Choose patterns by asking what kind of control the task needs. If ordinary code can express the behavior, use ordinary code. MAF's overview is explicit: if you can write a function to handle the task, do that instead of using an AI agent (MAF overview).

• Use a single agent first when one role can own the domain and the value comes from dynamic tool use, conversation, or light planning.
• Use sequential workflows when the order is real: later work depends on earlier output, and you want predictable stage gates.
• Use concurrent workflows when work is independent and you have a clear plan for aggregation, conflicts, quota, and failures.
• Use handoff when ownership should move to a specialist during the task, not when a simple classifier can route the request up front.
• Use group chat or reflection when collaboration, critique, or consensus is the point—and define who speaks, when to stop, and what counts as accepted.
• Use planner-style orchestration sparingly for genuinely open-ended work where a fixed workflow would hide too much uncertainty.

The main pitfall is over-orchestrating. Multi-agent systems add coordination overhead, latency, cost, context growth, security boundaries, and new failure modes. Azure Architecture guidance warns against adding agents without meaningful specialization and recommends the lowest level of complexity that reliably meets the requirement (AI agent design patterns).

Another pitfall is confusing visibility features with strategy. Streaming, checkpointing, human approval, middleware, telemetry, declarative configuration, and hosting make a chosen pattern safer and more operable; they do not decide whether the work should be single-agent, sequential, concurrent, handoff, or collaborative. Pick the pattern first, then add the operational controls the risk demands.

• Start with the simplest reliable shape: function or direct model call, then one agent with tools, then workflow or multi-agent orchestration only when justified.
• Sequential and concurrent orchestration are workflow patterns for known order or independent parallel work.
• Handoff, group chat, reflection, and Magentic-style planning are multi-agent patterns for dynamic ownership, collaboration, review, and adaptive planning.
• Streaming, checkpointing, human-in-the-loop, middleware, observability, declarative configuration, and hosting are cross-cutting supports around the chosen pattern.

Next, Chapter 3: Agents and instructions introduces the first real MAF API and shows how a single agent gets its role, boundaries, and invocation shape.