Preparing for AB-100: A Multi-Agent Design Case Study

Preparing for AB-100: A Multi-Agent Design Case Study

Key takeaways

• The November 16, 2026 AB-100 skills list puts Plan at 35–40%, Design at 30–35% and Deploy at 20–25%. Before that date the English exam uses the October 14 weights.[1][2]
• Start every case by asking whether it should be an agent at all. Microsoft’s Cloud Adoption Framework sends fixed, rule-bound work to code and fixed-document Q&A to retrieval-augmented generation (RAG).[5]
• Go multi-agent only for a stated reason: a security or compliance boundary, several owning teams, or planned growth past three to five functions. Otherwise test one agent first.[6]
• Connected agents fail in specific, documented ways: wrong environment, not published, not shareable, already a main agent with its own connected agents, or a Foundry agent without the Activity protocol endpoint.[9][10][11]
• Production telemetry for a multi-agent system means one identifier that links the parent and every subagent session, plus token use per agent.[8][12]
• The PowerShell reviewer in section 4 checks a design file against 28 rules drawn from Microsoft Learn and maps it to all 74 objectives. My synthetic case covers 25 of them.

1. Study log: what AB-100 asks of an architect

This is the last AB-100 entry in the series. The earlier entries each took one slice of the exam: the blueprint and trade-off matrix, an IT triage agent, MCP and computer use, agent ALM and observability and FinOps. This one runs a single case from business problem to production telemetry, so the pieces connect.

The queue title for this entry was “Taking Microsoft Exam AB-100: What It Actually Takes to Become an Agentic AI Solutions Architect.” I haven’t taken AB-100, so I don’t have an attempt, a score or a pass to report. I also haven’t built this solution in a tenant. The title says preparing, and everything below is design work from Microsoft Learn plus a PowerShell script I ran against synthetic files.

What an agentic AI business solutions architect is

Microsoft describes the AB-100 candidate as “an accomplished solution architect” who designs and delivers AI-driven business solutions, with skills that include designing multi-agent orchestrated solutions, monitoring agent performance and interpreting telemetry, and running an ROI analysis.[1] The credential is an Expert-level certification. Passing AB-100 isn’t enough on its own: you also need one of the prerequisite Associate certifications.[3]

So the job is design and justification. You decide whether an agent should exist, which platform builds each part, how the parts talk, how they’re secured and tested, and how you’ll know in production that the business case held. Microsoft’s AB-100T00 course description says the same, and adds that it’s “not a test-preparation course.” Its emphasis is “architecture, trade-offs, governance, cost/benefit analysis, and lifecycle management, rather than step-by-step configuration.”[22]

Exam facts as of October 31, 2026

Two of those rows need care. The prerequisite lists on the credential page and the exam page disagree, so check both before you pick an Associate exam. And the practice assessments page warns that the real exam “may see additional question types, multiple case studies, and labs.”[4] That’s the reason this entry is a case study.

Blueprint note. Microsoft’s study guide now shows only the November 16, 2026 list.[1] If you sit the English exam on or before November 15, 2026, the October 14, 2026 weights apply: Plan 25–30%, Design 25–30%, Deploy 40–45%, as recorded in the blueprint entry. The change log marks three skill groups as having minor changes.[1] When I compared the objective bullets in my saved October 14 copy with the current list, the 74 lines matched word for word and only the weights moved. Read the live list anyway, because my saved copy is a snapshot. This entry uses the November 16 weights and doesn’t mix the two.

Default approach vs AI-hardened approach

How I built this entry

• Sources: 22 Microsoft Learn pages, all fetched on October 31, 2026 and listed at the end. Quotes are verbatim.
• Scenario: the company, agents, team names, KPIs and numbers are synthetic. They exist to make the design decisions concrete.
• Script: I ran the reviewer in section 4 on PowerShell 7.4.6 and 7.6.7 against the synthetic files. It reads local files and never connects to Copilot Studio, Foundry or Power Platform.
• Not done: no tenant build, no Copilot Studio or Foundry configuration, no exam attempt.

2. The case: from business problem to architecture

The synthetic business problem

Synthetic scenario. ZK Manufacturing (not a real company) onboards new hires through three teams that work in sequence. HR answers policy and benefits questions. Endpoint engineering orders the laptop and checks device readiness. Procurement prices the hardware bundle against a budget rule and needs a human approval for each purchase. New hires wait on each hand-off, and every team fields the same “where is my laptop?” tickets.

The synthetic KPIs, recorded before any build:

The Cloud Adoption Framework (CAF) asks for exactly this before development: set baseline KPIs, use them as decision gates at each stage, and keep measuring after go-live. If a pilot misses the agreed results, CAF says to “pause the work and reassess the use case.”[5] The case has three gates: pilot, production and a 90-day review. A design that measures ROI only after launch skips those gates.

Step 1: decide which parts need an agent

CAF’s business plan gives two tests for when not to build an agent.[5] A “structured or predictable task” with clear, repeatable steps goes to regular code or nongenerative AI. “Static knowledge retrieval” over a fixed set of documents goes to classic RAG, because “if the task doesn’t need tools or multistep reasoning, an agent is unnecessary.”[5]

Applied to the case:

CAF also scores candidate use cases from 1 to 5 on business impact, technical feasibility and user desirability, and advises you to “pilot the hardest steps.”[5] In this case the hardest step is the IT provisioning request, because it writes to a system. That’s where the pilot starts.

Step 2: one agent or several

CAF lists three reasons to start with a multi-agent design: crossing security and compliance boundaries, multiple teams managing separate knowledge areas, and planned growth, where “solutions spanning more than three to five distinct functions benefit from this architecture.”[6] Without one of those, CAF says “start by testing them with a single agent.”[6] It also warns that distinct roles alone don’t justify several agents, and that multi-agent systems cost more because “each agent processes redundant context.”[6]

The case meets two criteria. HR data needs its own boundary, and three teams own separate knowledge and release on their own schedules. It doesn’t meet the growth test with only three functions. CAF lists the criteria separately, and I read each one as enough on its own.

The Azure Architecture Center frames the same choice as three complexity levels: a direct model call, a single agent with tools, and a multi-agent system.[8] Pick the lowest level that works. If prompt engineering alone solves it, “you don’t need an agent.”[8]

Step 3: choose the building blocks

Why not child agents? A child agent “exists within the context of your main agent”[21], and child agents suit cases where “you don’t intend to publish these agents separately or make them available independently.”[9] Microsoft suggests connected agents when “multiple teams or developers manage different agents independently” or when you “need independent application lifecycle management (ALM) processes for each agent.”[9] Both apply. The cost is real: connected agents add latency from “extra orchestration hops” and “increase the testing, management, and governance surface area.”[9]

Why not a declarative agent in Microsoft 365 Copilot? Declarative agents use Copilot’s own orchestrator and models.[19] That fits a single-domain helper. This case needs a Foundry agent with its own model choice and an approval flow, which pushes the front end to Copilot Studio.

Step 4: pick the orchestration pattern

The Architecture Center compares five patterns.[8]

The case uses a parent orchestrator that delegates to connected agents and keeps control, plus one sequential flow for the purchase. The Architecture Center adds a simpler option worth knowing: when the right agent “is identifiable from the initial input,” use deterministic routing or a dispatcher instead of an orchestrating agent.[8] A request that always names its team would qualify.

The architecture

Synthetic design. No tenant, environment or Foundry project exists.

   New hire / manager in Teams
              |
              v
+-------------------------------+     App Insights: appi-zk-agents-prod
| zk-onboarding-orchestrator    |---> customEvents, conversationId
| Copilot Studio, env zk-prod   |
| only agent that replies       |
+--+-------------+-----------+--+
   |             |           |
   | connected   | connected | Foundry connection (preview)
   v             v           v
+-----------+ +-------------+ +----------------------+
| zk-hr-    | | zk-it-      | | zk-procurement-agent |
| policy    | | provisioning| | Foundry prompt agent |
| HR SP lib | | IT runbooks | | model router         |
| read only | | writes req. | | Activity endpoint on |
+-----------+ +------+------+ +----------+-----------+
                     |                   |
                     v                   v
              approval required   agent flow: human approval

3. Design decisions and where each one fails

Each subsection below is one decision in the case, the rule behind it and the documented way it breaks. Where Microsoft publishes the error text, I quote it verbatim.

Connecting the agents

For a connected Copilot Studio agent, four conditions must hold. The other agent “must be in the same environment as your main agent,” “must be published,” must allow connections from other agents, and the maker must own it or have it shared with them.[10] Two details catch people:

• The connected agent’s description is local to the main agent. Updates to the connected agent’s own description “don’t automatically sync with your main agent.”[10]
• Your main agent “can only use the latest version of a connected agent after that agent is published.”[10]

Nesting has a limit. If an agent is a main agent with connected agents, “you can’t also use the same agent as a connected agent for a second main agent.”[9] In the case, zk-hr-policy-agent has no connected agents of its own, so another main agent could reuse it later.

The Foundry agent has two hard prerequisites. It must have the Activity protocol endpoint enabled, and you can currently enable it “only programmatically, by using the REST API or the Python SDK.”[11] Without it, the first test call fails with an HTTP 400 that says the endpoint “does not support activity.”[11] And you can only connect agents created in the new Microsoft Foundry portal. An agent from the previous portal returns 404 - Version not found.[11]

If a partner ran their own agent outside Microsoft, the A2A option would apply. Copilot Studio wants the agent’s communication endpoint, “not the URL for the agent card,” and it reads the name and description from a card on the standard .well-known URL.[13] Authentication can be None, API key or OAuth 2.0.[13] Microsoft describes None as the option for agents that don’t require authentication or for its sample agent.[13] The reviewer in section 4 treats None as an error for a production A2A connection. That threshold is my design rule.

Routing, context and replies

Copilot Studio’s multi-agent guidance has a nine-point checklist.[12] The case applies five of them directly:

1. Single response principle. The parent instruction reads: “You’re the only agent that communicates with the user.” Microsoft calls this “one valid design, not the only one.”[12] The case picks it so the user gets one combined answer.
2. Subagents declare their role and get a “no direct reply” directive when the parent delegates.[12]
3. One knowledge source per subagent, no overlap. If there’s only one source, use one agent with knowledge instead.[12]
4. Distinct descriptions. “If descriptions are vague, identical, or inaccurate, the parent can’t make good routing decisions.”[12]
5. Domain-mismatch tests. Ask the HR agent a laptop question and check it routes back instead of guessing.[12]

Context is a decision too. A connected agent has a context-inclusion setting, so “confirm that setting rather than assuming the history is passed automatically,” while a child agent always receives the parent’s context.[12] In the setup screen it’s the Pass conversation history to this agent box. Clearing it limits the agent to “the explicit task that the main agent wants the other agent to complete.”[10] The case clears it for all three subagents, because the procurement agent has no reason to read HR answers.

Size matters as well. Microsoft’s rule of thumb is that orchestration quality can degrade once a main agent “has more than 30-40 choices of action (tools, topics, and other agents),” and it can happen earlier when tools have similar descriptions.[9] The synthetic orchestrator has 6 topics, 4 tools and 3 agents: 13 choices.

One limitation to plan around: “Citations might not always be maintained when passing outputs back from an agent back to a calling agent.”[9] If HR policy answers must cite the policy, test that path specifically.

Security and guardrails

The biggest multi-agent risk is privilege by proxy. “If the parent agent isn’t allowed to delete records but the connected agent can, the parent agent shouldn’t call the connected agent in scenarios where deletion might happen without proper approval.”[12] In the case, both agents that write (IT provisioning and procurement) sit behind a human approval.

Identity has to hold across hops. The Architecture Center says agents must not return data the user can’t access, and “security trimming must be implemented in every agent in the pattern.”[8] The Copilot Studio agents run tools with the user’s credentials, a documented option for makers.[18] The Foundry agent uses its own identity, so the case requires security trimming in its catalog index.

Guardrails go in more than one place: “user input, tool calls, tool responses, and final output.”[8] For prompt manipulation, Prompt Shields cover two attack types. User prompt attack detection is on by default in Foundry. Document attack detection “is off by default and must be enabled,” and for agents it can scan tool responses for supported tools, in preview.[15] Prompt Shields don’t judge whether content is harmful, accurate or grounded, so they don’t replace the other guardrails.[15]

On the governance side, Copilot Studio lists the controls an architect should name in an answer: data policies in the Power Platform admin center, maker audit logs in Microsoft Purview, alerts through Microsoft Sentinel, environment routing, customer-managed keys and Copilot credit caps.[18]

Model choice and cost

The procurement agent uses model router in Foundry. Its routing modes are Balanced (the default), Cost and Quality.[14] Two facts change the design:

• “The effective context window is limited by the smallest underlying model.” Use a model subset if you need a larger context.[14]
• The current version, 2025-11-18, gets new underlying models “without changing the version identifier,” and an auto-update deployment changes its set of underlying models, which “could affect the overall performance of the model and costs.”[14]

So model router with auto-update gets a scheduled evaluation on a fixed test set, the drift control from the observability entry. For cost, the Architecture Center notes that each agent “consumes tokens for its instructions, context, reasoning, and tool interactions,” and recommends per-agent model sizing.[8] The case tracks token use per agent so the 90-day ROI review can tell which agent costs what.

Testing before each gate

Copilot Studio agent evaluation runs test sets that you generate, import or write by hand, and you can run it from the UI, through Power Platform REST APIs or from flows.[16] It adds four safety evaluators: hatefulness and unfairness, sexual content, violence and self-harm.[16] Three limits matter for this case:

• Evaluations “run as the currently signed-in user.” To test another user’s view, sign in as that user.[16]
• Evaluations support only agents set to No authentication or Authenticate with Microsoft. “Agents set to Authenticate manually aren’t supported.”[16]
• Agent evaluation doesn’t support Fabric data agents.[16]

For the Foundry agent and the end-to-end path, the Architecture Center’s advice applies: outputs are nondeterministic, “so use scoring rubrics or language-model-as-judge evaluations rather than exact-match assertions.”[8]

ALM

Each owning team ships its agent in its own solution, which is the independent ALM that justified connected agents in the first place.[9] Copilot Studio supports GitHub-backed source control and deploy-from-Git “with auditable deployment history.”[18] The ALM entry covers the pipelines. The case adds one rule: publish the connected agent before you test the main agent, because the main agent only sees the published version.[10]

Production telemetry

This is where the case closes the loop to the KPIs.

1. Connect Application Insights in each Copilot Studio agent under Settings > Advanced.[17]
2. Leave Log conversation details off unless the data owner approves it. It includes user ID, user name and message text.[17]
3. Exclude test traffic. Every event carries a designMode dimension, so filter customEvents on designMode == "False".[17]
4. Correlate sessions. A connected agent has its own transcripts, and “identifiers in the telemetry link the two.”[12] Pick one and use it in every dashboard query.
5. For the Foundry agent, use the tracing and dashboard setup from the observability entry.

The query Microsoft documents for dropping test-canvas traffic:[17]

customEvents
| extend isDesignMode = customDimensions['designMode']
| where isDesignMode == "False"

At the 90-day gate you compare the synthetic KPIs (days to productive, tickets per hire) against the baseline, and token use per agent against the cost assumption. If the numbers miss, CAF’s options are to “refine the design, retire the solution, or shift resources.”[5]

If you also run Intune and Autopilot day to day, the free enrollment errors cheat sheet covers the endpoint side of a case like this.

4. Engineering deliverable: a case-study design reviewer

Writing the case as a design file makes it checkable. The reviewer below reads that file, applies 28 rules taken from the sources above, and maps the design to every objective in a local copy of the study guide. It answers two questions before you sit the exam: does the design break a documented rule, and which objectives haven’t you practiced yet?

What it does and doesn’t do:

• Input validation: rejects missing files, invalid JSON, a wrong schemaVersion, missing sections, an unknown stage, a skills heading that isn’t in the study guide, and any objectiveMap entry that isn’t an exact objective.
• Audit log: appends one JSON line per write or removal to audit.log with the UTC time and user.
• Idempotency: a SHA-256 manifest records the inputs and outputs. The same inputs produce “No changes”; different inputs or edited output need -Force.
• Rollback: -Rollback removes only files whose hash still matches the manifest and keeps anything you edited.
• -WhatIf: supported for writes and rollback through SupportsShouldProcess.
• Scope: local files only. No modules, no network calls, no tenant access.

The design file (synthetic)

Save the study guide locally first. Microsoft Learn returns Markdown when you add ?accept=text/markdown, which is how I saved my copy:

Invoke-WebRequest -Uri 'https://learn.microsoft.com/en-us/credentials/certifications/resources/study-guides/ab-100?accept=text/markdown' -OutFile ./ab100-study-guide.md

The design file, case-study.json. Every name and number in it is synthetic:

{
  "schemaVersion": 1,
  "caseStudy": "zk-new-hire-readiness",
  "synthetic": true,
  "business": {
    "problem": "New hires wait on HR, IT and Procurement in sequence before they can work.",
    "multiAgentJustification": [
      "SecurityBoundary",
      "MultipleTeams"
    ],
    "kpis": [
      {
        "name": "Median days from offer accept to first productive day",
        "baseline": 9,
        "target": 5,
        "unit": "days"
      },
      {
        "name": "Onboarding tickets opened per hire",
        "baseline": 6,
        "target": 3,
        "unit": "tickets"
      }
    ],
    "decisionGates": [
      "Pilot",
      "Production",
      "90DayReview"
    ]
  },
  "orchestrator": {
    "name": "zk-onboarding-orchestrator",
    "platform": "CopilotStudio",
    "environment": "zk-prod",
    "singleResponder": true,
    "topics": 6,
    "tools": 4,
    "authMode": "Microsoft",
    "appInsights": "appi-zk-agents-prod",
    "excludeDesignMode": true,
    "correlationField": "conversationId",
    "testSet": {
      "cases": 40,
      "domainMismatchCases": 6
    },
    "promptShields": {
      "userPrompt": true,
      "documentAttack": false
    }
  },
  "subagents": [
    {
      "name": "zk-hr-policy-agent",
      "kind": "ConnectedCopilotStudio",
      "owner": "HR digital team",
      "description": "Answers questions about HR onboarding policy, benefits enrollment windows and first-week paperwork from the HR policy library.",
      "knowledge": [
        "sp-hr-policy-library"
      ],
      "environment": "zk-prod",
      "published": true,
      "allowOtherAgents": true,
      "passConversationHistory": false,
      "noDirectReply": true,
      "canWrite": false,
      "requiresApproval": false,
      "authMode": "Microsoft",
      "runsWithUserCredentials": true,
      "hasConnectedAgents": false,
      "solution": "zk-hr-agents",
      "appInsights": "appi-zk-agents-prod",
      "testSet": {
        "cases": 30,
        "domainMismatchCases": 4
      },
      "promptShields": {
        "userPrompt": true,
        "documentAttack": true
      },
      "model": "default",
      "tokenMetrics": true
    },
    {
      "name": "zk-it-provisioning-agent",
      "kind": "ConnectedCopilotStudio",
      "owner": "Endpoint engineering",
      "description": "Checks device readiness and creates the laptop and account provisioning request for a named new hire in the IT service catalog.",
      "knowledge": [
        "sp-it-runbooks"
      ],
      "environment": "zk-prod",
      "published": true,
      "allowOtherAgents": true,
      "passConversationHistory": false,
      "noDirectReply": true,
      "canWrite": true,
      "requiresApproval": true,
      "authMode": "Microsoft",
      "runsWithUserCredentials": true,
      "hasConnectedAgents": false,
      "solution": "zk-it-agents",
      "appInsights": "appi-zk-agents-prod",
      "testSet": {
        "cases": 35,
        "domainMismatchCases": 4
      },
      "promptShields": {
        "userPrompt": true,
        "documentAttack": true
      },
      "model": "default",
      "tokenMetrics": true
    },
    {
      "name": "zk-procurement-agent",
      "kind": "Foundry",
      "owner": "Procurement platform team",
      "description": "Prices the hardware bundle for a role, checks it against the procurement budget rules and returns a purchase recommendation for approval.",
      "knowledge": [
        "foundry-procurement-catalog-index"
      ],
      "foundryPortal": "New",
      "activityEndpoint": true,
      "preview": true,
      "passConversationHistory": false,
      "noDirectReply": true,
      "canWrite": true,
      "requiresApproval": true,
      "runsWithUserCredentials": false,
      "securityTrimming": true,
      "solution": "zk-procurement-foundry",
      "appInsights": "appi-zk-agents-prod",
      "testSet": {
        "cases": 25,
        "domainMismatchCases": 3
      },
      "promptShields": {
        "userPrompt": true,
        "documentAttack": true
      },
      "model": "model-router",
      "modelAutoUpdate": true,
      "scheduledEvaluation": true,
      "tokenMetrics": true
    }
  ],
  "stage": "Production",
  "acceptPreviewInProduction": [
    "zk-procurement-agent"
  ],
  "objectiveMap": {
    "Assess the use of agents in task automation, data analytics, and decision-making": "Section 2: agent or not",
    "Design a multi-agent solution by using platforms such as Microsoft 365 Copilot, Copilot Studio, and Microsoft Foundry": "Section 2: architecture",
    "Select ROI criteria for AI-powered business solutions, including the total cost of ownership": "Section 2: KPIs and gates",
    "Create an ROI analysis for the proposed AI solution for a business process": "Section 2: KPIs and gates",
    "Analyze whether to build, buy, or extend AI components for business solutions": "Section 2: component table",
    "Implement a model router to intelligently route requests to the most suitable model": "Section 3: model choice",
    "Review data for grounding, including accuracy, relevance, timeliness, cleanliness, and availability": "Section 3: knowledge per agent",
    "Design task agents": "Section 3: IT provisioning agent",
    "Design agents and agent flows with Copilot Studio": "Section 3: orchestrator and approval flow",
    "Design agent extensibility in Copilot Studio": "Section 3: connected agents",
    "Design AI solutions by using custom models in Microsoft Foundry": "Section 3: procurement agent",
    "Recommend the process and tools required for monitoring agents": "Section 3: telemetry",
    "Interpret telemetry data for performance and model tuning": "Section 3: telemetry",
    "Recommend the process and metrics to test agents": "Section 3: evaluation",
    "Design the ALM process for Copilot Studio agents, connectors, and actions": "Section 3: ALM",
    "Design the ALM process for Microsoft Foundry Agents Service": "Section 3: ALM",
    "Design security for agents": "Section 3: security",
    "Analyze solution and AI vulnerabilities and mitigations, including prompt manipulation": "Section 3: Prompt Shields",
    "Design audit trails for changes to models and data": "Section 3: ALM and audit",
    "Implement the AI adoption process from the Cloud Adoption Framework for Azure": "Section 2: business case",
    "Determine when to build custom agents or extend Microsoft 365 Copilot": "Section 2: component table",
    "Define the solution rules and constraints when building AI components with Copilot Studio, Microsoft Foundry and Microsoft Foundry Tools": "Section 3: platform rules",
    "Monitor agent performance and metrics": "Section 3: telemetry",
    "Design governance for agents": "Section 3: governance",
    "Design access controls on grounding data and model tuning": "Section 3: security trimming"
  }
}

The rules

The source column points to the numbered list at the end. Rules marked “design rule” are my thresholds, not Microsoft’s.

A1 uses the low end of Microsoft’s 30–40 range on purpose.[9]

The script

Test-MultiAgentCaseStudy.ps1:

#Requires -Version 7.2
<#
.SYNOPSIS
  Reviews a multi-agent case-study design file against design rules taken from Microsoft Learn
  (Copilot Studio connected agents, Foundry connections, Cloud Adoption Framework, Azure
  Architecture Center) and maps the design to the AB-100 skills list in a local study guide copy.
.NOTES
  Study aid. Reads local files only. Never connects to Copilot Studio, Foundry, Power Platform
  or Application Insights. All names in the sample design are synthetic.
#>
[CmdletBinding(SupportsShouldProcess)]
param(
    [Parameter(Mandatory)] [string] $DesignPath,
    [string] $StudyGuidePath,
    [string] $SkillsHeading = 'Skills measured as of November 16, 2026',
    [string] $OutputDirectory = './case-study-review',
    [switch] $Force,
    [switch] $Rollback
)
Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'
$manifestFile = Join-Path $OutputDirectory 'manifest.json'
$auditPath = Join-Path $OutputDirectory 'audit.log'

function Get-Sha256([string] $Path) { (Get-FileHash -LiteralPath $Path -Algorithm SHA256).Hash.ToLowerInvariant() }
function Write-Audit([string] $Action, [string] $Detail) {
    if (-not (Test-Path -LiteralPath $OutputDirectory)) { return }
    $line = [ordered]@{ utc = [DateTime]::UtcNow.ToString('o'); user = [Environment]::UserName; action = $Action; detail = $Detail }
    Add-Content -LiteralPath $auditPath -Value ($line | ConvertTo-Json -Compress)
}
function Get-Value($Table, [string] $Key) { if ($null -ne $Table -and $Table.ContainsKey($Key)) { $Table[$Key] } else { $null } }

# Rollback: remove only files this script wrote and nobody changed since.
if ($Rollback) {
    if (-not (Test-Path -LiteralPath $manifestFile)) { Write-Output "Nothing to roll back in $OutputDirectory."; return }
    $m = Get-Content -LiteralPath $manifestFile -Raw | ConvertFrom-Json
    $kept = 0
    foreach ($f in $m.files) {
        $p = Join-Path $OutputDirectory $f.name
        if (-not (Test-Path -LiteralPath $p)) { continue }
        if ((Get-Sha256 $p) -ne $f.sha256) { Write-Warning "Kept $($f.name): changed since this script wrote it."; $kept++; continue }
        if ($PSCmdlet.ShouldProcess($p, 'Remove generated file')) { Remove-Item -LiteralPath $p; Write-Audit 'remove' $f.name }
    }
    if ($kept -eq 0 -and $PSCmdlet.ShouldProcess($manifestFile, 'Remove manifest')) { Remove-Item -LiteralPath $manifestFile; Write-Audit 'remove' 'manifest.json' }
    return
}

# ---- Input validation ----
if (-not (Test-Path -LiteralPath $DesignPath)) { throw "File not found: $DesignPath" }
try { $design = Get-Content -LiteralPath $DesignPath -Raw | ConvertFrom-Json -AsHashtable } catch { throw "Invalid JSON in ${DesignPath}: $($_.Exception.Message)" }
if ($design['schemaVersion'] -ne 1) { throw 'Design must use schemaVersion 1.' }
foreach ($key in 'business', 'orchestrator', 'subagents', 'stage') { if (-not $design.ContainsKey($key)) { throw "Design is missing '$key'." } }
if ($design['stage'] -notin 'Pilot', 'Production') { throw "stage must be Pilot or Production, not '$($design['stage'])'." }

$findings = [System.Collections.Generic.List[object]]::new()
function Add-Finding([string] $Severity, [string] $Rule, [string] $Target, [string] $Message) {
    $findings.Add([pscustomobject][ordered]@{ Severity = $Severity; Rule = $Rule; Target = $Target; Message = $Message })
}
$biz = $design['business']; $orc = $design['orchestrator']; $subs = @($design['subagents'])

# ---- Business case (B) ----
$why = @(Get-Value $biz 'multiAgentJustification') | Where-Object { $_ -in 'SecurityBoundary', 'MultipleTeams', 'FutureGrowth' }
if (@($why).Count -eq 0) { Add-Finding 'Error' 'B1' 'business' 'No CAF reason for multi-agent (security boundary, multiple teams, planned growth). Test a single agent first.' }
foreach ($k in @(Get-Value $biz 'kpis')) {
    if ($null -eq (Get-Value $k 'baseline') -or $null -eq (Get-Value $k 'target')) { Add-Finding 'Error' 'B2' $k['name'] 'KPI needs a measured baseline and a target before the pilot.' }
}
if (@(Get-Value $biz 'kpis').Count -eq 0) { Add-Finding 'Error' 'B2' 'business' 'No KPIs, so there is no ROI to measure.' }
if (@(Get-Value $biz 'decisionGates').Count -lt 2) { Add-Finding 'Warning' 'B3' 'business' 'Define go/no-go decision gates, at least for pilot and production.' }

# ---- Architecture (A) ----
$choices = [int](Get-Value $orc 'topics') + [int](Get-Value $orc 'tools') + $subs.Count
if ($choices -gt 30) { Add-Finding 'Warning' 'A1' $orc['name'] "$choices choices of action on one agent. Microsoft suggests splitting above 30-40." }
if ((Get-Value $orc 'singleResponder') -ne $true) { Add-Finding 'Error' 'A2' $orc['name'] 'This design routes every user reply through the orchestrator, but singleResponder is not set.' }
$descs = @{}; $know = @{}
foreach ($s in $subs) {
    $n = $s['name']
    $d = [string](Get-Value $s 'description')
    if (($d -split '\s+').Count -lt 8) { Add-Finding 'Error' 'A3' $n 'Description too short for the orchestrator to route on.' }
    elseif ($descs.ContainsKey($d)) { Add-Finding 'Error' 'A3' $n "Same description as $($descs[$d])." } else { $descs[$d] = $n }
    foreach ($ks in @(Get-Value $s 'knowledge')) {
        if ($know.ContainsKey($ks)) { Add-Finding 'Warning' 'A4' $n "Knowledge source $ks is also used by $($know[$ks]). Keep one source per subagent." } else { $know[$ks] = $n }
    }
    if ((Get-Value $s 'noDirectReply') -ne $true) { Add-Finding 'Error' 'A2' $n 'Subagent must return results to the orchestrator, not reply to the user.' }
    if ($null -eq (Get-Value $s 'passConversationHistory')) { Add-Finding 'Warning' 'A5' $n 'Decide explicitly whether conversation history is passed.' }
    switch ($s['kind']) {
        'ConnectedCopilotStudio' {
            if ($s['environment'] -ne $orc['environment']) { Add-Finding 'Error' 'A6' $n 'Connected Copilot Studio agent must be in the same environment as the main agent.' }
            if ((Get-Value $s 'published') -ne $true) { Add-Finding 'Error' 'A6' $n 'Connected agent must be published.' }
            if ((Get-Value $s 'allowOtherAgents') -ne $true) { Add-Finding 'Error' 'A6' $n 'Turn on "Let other agents connect to and use this one".' }
            if ((Get-Value $s 'hasConnectedAgents') -eq $true) { Add-Finding 'Error' 'A7' $n 'An agent that has its own connected agents cannot be connected to a second main agent.' }
        }
        'Foundry' {
            if ((Get-Value $s 'foundryPortal') -ne 'New') { Add-Finding 'Error' 'A8' $n 'Agents from the previous Foundry portal return 404 - Version not found.' }
            if ((Get-Value $s 'activityEndpoint') -ne $true) { Add-Finding 'Error' 'A8' $n 'Activity protocol endpoint not enabled: calls fail with a 400 error.' }
        }
        'A2A' {
            if ((Get-Value $s 'auth') -in $null, 'None' -and $design['stage'] -eq 'Production') { Add-Finding 'Error' 'A9' $n 'Production A2A connection with no authentication.' }
        }
        default { Add-Finding 'Error' 'A0' $n "Unknown subagent kind '$($s['kind'])'." }
    }
    if ((Get-Value $s 'preview') -eq $true -and $design['stage'] -eq 'Production' -and $n -notin @(Get-Value $design 'acceptPreviewInProduction')) {
        Add-Finding 'Error' 'A10' $n 'Preview feature in a production design without a recorded risk acceptance.'
    } elseif ((Get-Value $s 'preview') -eq $true) { Add-Finding 'Info' 'A10' $n 'Preview feature: risk accepted. Recheck its status before each release.' }
}

# ---- Security (S) ----
foreach ($s in $subs) {
    $n = $s['name']
    if ((Get-Value $s 'canWrite') -eq $true -and (Get-Value $s 'requiresApproval') -ne $true) { Add-Finding 'Error' 'S1' $n 'Subagent writes to a system but no human approval gate sits before the write.' }
    if ((Get-Value $s 'runsWithUserCredentials') -ne $true -and (Get-Value $s 'securityTrimming') -ne $true) { Add-Finding 'Error' 'S2' $n 'No user credentials and no security trimming: results can include data the user may not see.' }
}
foreach ($a in @($orc) + $subs) {
    $ps = Get-Value $a 'promptShields'
    if ((Get-Value $ps 'userPrompt') -ne $true) { Add-Finding 'Error' 'S3' $a['name'] 'User prompt attack detection is off.' }
    if ($a -ne $orc -and (Get-Value $ps 'documentAttack') -ne $true) { Add-Finding 'Warning' 'S4' $a['name'] 'Document attack detection is off for an agent that reads documents or tool output.' }
}

# ---- Evaluation and telemetry (E, T) ----
foreach ($a in @($orc) + $subs) {
    $n = $a['name']
    $ts = Get-Value $a 'testSet'
    if ([int](Get-Value $ts 'cases') -le 0) { Add-Finding 'Error' 'E1' $n 'No test set.' }
    if ([int](Get-Value $ts 'domainMismatchCases') -le 0) { Add-Finding 'Warning' 'E2' $n 'No domain-mismatch cases: nothing proves misrouted requests are refused or re-routed.' }
    if ((Get-Value $a 'authMode') -eq 'Manual') { Add-Finding 'Warning' 'E3' $n 'Copilot Studio agent evaluation does not support "Authenticate manually" agents. Plan another test path.' }
    if (-not (Get-Value $a 'appInsights')) { Add-Finding 'Error' 'T1' $n 'No Application Insights destination for this agent.' }
    if ((Get-Value $a 'model') -eq 'model-router' -and (Get-Value $a 'modelAutoUpdate') -eq $true -and (Get-Value $a 'scheduledEvaluation') -ne $true) {
        Add-Finding 'Error' 'T2' $n 'Model router auto-update can change underlying models, but no scheduled evaluation catches the change.'
    }
    if ($a -ne $orc -and (Get-Value $a 'tokenMetrics') -ne $true) { Add-Finding 'Warning' 'T3' $n 'Token use is not tracked per agent.' }
}
if (-not (Get-Value $orc 'correlationField')) { Add-Finding 'Error' 'T4' $orc['name'] 'No identifier links parent and subagent sessions in telemetry.' }
if ((Get-Value $orc 'excludeDesignMode') -ne $true) { Add-Finding 'Warning' 'T5' $orc['name'] 'Dashboards count test-canvas traffic. Filter on designMode.' }

# ---- ALM (L) ----
$byOwner = @{}
foreach ($s in $subs) {
    $sol = Get-Value $s 'solution'
    if (-not $sol) { Add-Finding 'Error' 'L1' $s['name'] 'Not in a solution, so it cannot move through dev, test and prod.'; continue }
    if ($byOwner.ContainsKey($sol) -and $byOwner[$sol] -ne $s['owner']) { Add-Finding 'Warning' 'L2' $s['name'] "Solution $sol is shared by two owning teams; they cannot release independently." }
    $byOwner[$sol] = $s['owner']
}

# ---- Objective coverage (O) ----
$coverage = [System.Collections.Generic.List[object]]::new()
if ($StudyGuidePath) {
    if (-not (Test-Path -LiteralPath $StudyGuidePath)) { throw "File not found: $StudyGuidePath" }
    $text = Get-Content -LiteralPath $StudyGuidePath -Raw
    $start = $text.IndexOf("## $SkillsHeading")
    if ($start -lt 0) { throw "Heading '## $SkillsHeading' not found in $StudyGuidePath." }
    $section = $text.Substring($start)
    $end = $section.IndexOf('## Study resources')
    if ($end -gt 0) { $section = $section.Substring(0, $end) }
    $domain = $null; $known = @{}
    foreach ($line in $section -split "`r?`n") {
        if ($line -match '^### (.+?) \((\d+)[\u2013-](\d+)%\)\s*$') { $domain = $Matches[1]; continue }
        if ($domain -and $line -match '^- (.+?)\s*$') {
            $obj = $Matches[1]; $known[$obj] = $true
            $where = Get-Value $design['objectiveMap'] $obj
            $coverage.Add([pscustomobject][ordered]@{ Domain = $domain; Objective = $obj; Covered = [bool]$where; Where = [string]$where })
        }
    }
    if ($coverage.Count -eq 0) { throw 'No objectives parsed. Check the study guide format.' }
    foreach ($k in @((Get-Value $design 'objectiveMap').Keys)) {
        if (-not $known.ContainsKey($k)) { Add-Finding 'Error' 'O1' 'objectiveMap' "Not an objective in '$SkillsHeading': $k" }
    }
}

$errorCount = @($findings | Where-Object Severity -eq 'Error').Count
$summary = @($coverage | Select-Object -ExpandProperty Domain -Unique | ForEach-Object {
    $d = $_; $rows = @($coverage | Where-Object Domain -eq $d)
    [ordered]@{ domain = $d; objectives = $rows.Count; covered = @($rows | Where-Object Covered).Count } })
$report = [ordered]@{
    caseStudy = $design['caseStudy']; synthetic = $design['synthetic']; stage = $design['stage']
    skillsList = if ($StudyGuidePath) { $SkillsHeading } else { $null }
    errors = $errorCount; warnings = @($findings | Where-Object Severity -eq 'Warning').Count
    coverage = $summary; findings = @($findings)
}

# ---- Output with idempotency ----
$inputs = @($DesignPath) + @($StudyGuidePath | Where-Object { $_ })
$inputHash = (($inputs | ForEach-Object { Get-Sha256 $_ }) -join '') + ":$SkillsHeading"
$outNames = @('case-study-review.json', 'objective-coverage.csv')
$skipWrite = $false
if (Test-Path -LiteralPath $manifestFile) {
    $old = Get-Content -LiteralPath $manifestFile -Raw | ConvertFrom-Json
    $intact = @($old.files | Where-Object { $p = Join-Path $OutputDirectory $_.name; (Test-Path -LiteralPath $p) -and (Get-Sha256 $p) -eq $_.sha256 }).Count -eq @($old.files).Count
    if ($old.inputSha256 -eq $inputHash -and $intact) { Write-Output 'No changes: output already matches these inputs.'; $skipWrite = $true }
    elseif (-not $Force) { throw "Output in $OutputDirectory came from different input or was edited. Re-run with -Force." }
}
if (-not $skipWrite -and $PSCmdlet.ShouldProcess($OutputDirectory, "Write review with $($findings.Count) findings and $($coverage.Count) objective rows")) {
    if (-not (Test-Path -LiteralPath $OutputDirectory)) { New-Item -ItemType Directory -Path $OutputDirectory | Out-Null }
    $report | ConvertTo-Json -Depth 6 | Set-Content -LiteralPath (Join-Path $OutputDirectory 'case-study-review.json') -Encoding utf8
    $coverage | Export-Csv -LiteralPath (Join-Path $OutputDirectory 'objective-coverage.csv') -NoTypeInformation -Encoding utf8
    $files = @($outNames | ForEach-Object { [ordered]@{ name = $_; sha256 = Get-Sha256 (Join-Path $OutputDirectory $_) } })
    [ordered]@{ inputSha256 = $inputHash; files = $files } | ConvertTo-Json -Depth 4 | Set-Content -LiteralPath $manifestFile -Encoding utf8
    Write-Audit 'write' "findings=$($findings.Count) errors=$errorCount objectives=$($coverage.Count)"
}
$summary | ForEach-Object { [pscustomobject]$_ } | Format-Table -AutoSize | Out-String -Width 160 | Write-Output
$findings | Sort-Object Severity, Rule, Target | Format-Table -AutoSize -Wrap | Out-String -Width 160 | Write-Output
if ($errorCount -gt 0) { throw "$errorCount design error(s). See $(Join-Path $OutputDirectory 'case-study-review.json')." }

What it produced

Run against the synthetic design and the November 16 list:

./Test-MultiAgentCaseStudy.ps1 -DesignPath ./case-study.json -StudyGuidePath ./ab100-study-guide.md -OutputDirectory ./out

domain                               objectives covered
------                               ---------- -------
Plan AI-powered business solutions           20      10
Design AI-powered business solutions         30       4
Deploy AI-powered business solutions         24      11

Severity Rule Target               Message
-------- ---- ------               -------
Info     A10  zk-procurement-agent Preview feature: risk accepted. Recheck its status before each release.

The coverage line is the useful part. One case touched 25 of 74 objectives, and only 4 of the 30 Design objectives. The 26 Design misses include every Dynamics 365 objective, the whole prebuilt-agents group, and MCP and Computer Use, which the MCP entry covered. Section 5 lists the gaps.

A broken copy of the design (no CAF reason, a Foundry agent from the old portal without the Activity endpoint, a write without approval, no correlation field, a nested connected agent, a shared knowledge source, an unaccepted preview and a misspelled objective) produced 9 errors and 1 warning and exited with an error:

Error    A10  zk-procurement-agent       Preview feature in a production design without a recorded risk acceptance.
Error    A7   zk-hr-policy-agent         An agent that has its own connected agents cannot be connected to a second main agent.
Error    A8   zk-procurement-agent       Agents from the previous Foundry portal return 404 - Version not found.
Error    A8   zk-procurement-agent       Activity protocol endpoint not enabled: calls fail with a 400 error.
Error    B1   business                   No CAF reason for multi-agent (security boundary, multiple teams, planned growth). Test a single agent first.
Error    O1   objectiveMap               Not an objective in 'Skills measured as of November 16, 2026': Design multi-agent solutions
Error    S1   zk-it-provisioning-agent   Subagent writes to a system but no human approval gate sits before the write.
Error    T2   zk-procurement-agent       Model router auto-update can change underlying models, but no scheduled evaluation catches the change.
Error    T4   zk-onboarding-orchestrator No identifier links parent and subagent sessions in telemetry.
Warning  A4   zk-it-provisioning-agent   Knowledge source sp-hr-policy-library is also used by zk-hr-policy-agent. Keep one source per subagent.

What I tested

Not tested: anything against a real Copilot Studio environment, Foundry project or Application Insights resource, because the script never touches them. The rules check what the design file claims, not what’s deployed.

5. Public-objective concepts to retain

The case maps to these objectives from the November 16, 2026 list. The wording is Microsoft’s.[1]

Gaps this case leaves, so you can study them separately:

• Dynamics 365. Every Dynamics 365 objective, from Copilot business terms and Contact Center channels to ALM for finance and supply chain apps.[1] The capstone didn’t touch them, and they’re a real share of the Design group.
• Prebuilt agents and apps. Microsoft 365 agents, Copilot for Sales and Service, and Power Platform AI features, including AI hub.[1]
• Copilot Studio authoring details. Topics with fallback, prompt actions, and when to use standard NLP, conversational language understanding or generative orchestration.[1]
• Model work. Custom model validation, small language model use cases, prompt library guidelines and ALM for custom models.[1]

If those gaps match the Associate exam you plan to take as the prerequisite, the two can share study time. The AB-100 certification guide compares the prerequisite paths and what the credential is worth.

Which preparation path fits you

That table is my study plan, not a Microsoft recommendation. The AB-900 governance entry covers the admin side if you’re starting there.

6. Next step in the study journey

That closes the AB-100 run. The series moves to AB-731, starting with how to set up an enterprise AI governance council, which picks up the governance thread from section 3 at the leadership level. Before then, run the reviewer against your own design file and see which objectives it says you haven’t practiced.

Frequently asked questions

Which AB-100 skills list applies to my exam?

If you take the English exam on or after November 16, 2026, the “Skills measured as of November 16, 2026” list applies, with Plan at 35–40%, Design at 30–35% and Deploy at 20–25%.[1][2] Before that, the October 14 weights apply. Localized versions update about eight weeks after November 16.[2]

Does passing AB-100 alone earn the Expert certification?

No. You also need one prerequisite Associate certification.[3] The credential page and the exam page currently list different sets, so check both.[2][3]

Does the AB-100 exam include case studies?

Microsoft doesn’t publish the exam’s question mix. The practice assessments page warns that the real exam may include “additional question types, multiple case studies, and labs.”[4] Practicing end-to-end cases like this one is a reasonable hedge.

When should a design use several agents instead of one?

CAF says to start multi-agent only when you cross a security or compliance boundary, multiple teams own separate knowledge, or planned growth goes past three to five functions.[6] Otherwise, test a single agent first. Multi-agent designs add latency at each hand-off and cost more in tokens.[6]

What’s the difference between a child agent and a connected agent in Copilot Studio?

A child agent lives inside the main agent and always receives its context. A connected agent is a separate, published agent with its own orchestration, and a setting controls whether it gets the conversation history.[9][12] Choose connected agents when separate teams own them or need independent ALM.[9]

Why does my Foundry agent fail when I connect it to Copilot Studio?

The two documented causes are a missing Activity protocol endpoint, which gives an HTTP 400, and an agent created in the previous Foundry portal, which gives 404 - Version not found.[11] You can enable the Activity endpoint only through the REST API or Python SDK.[11]

Are preview features on the AB-100 exam?

Most questions cover generally available features, but Preview features can appear “if those features are commonly used.”[1] Connecting Foundry agents to Copilot Studio is still in preview, so know it but flag it in a production design.[9]

Sources

All pages fetched October 31, 2026.

1. https://learn.microsoft.com/en-us/credentials/certifications/resources/study-guides/ab-100 (Study guide for Exam AB-100: Agentic AI Business Solutions Architect)
2. https://learn.microsoft.com/en-us/credentials/certifications/exams/ab-100/ (Exam AB-100: Agentic AI Business Solutions Architect Expert - Certifications)
3. https://learn.microsoft.com/en-us/credentials/certifications/agentic-ai-business-solutions-architect/ (Microsoft Certified: Agentic AI Business Solutions Architect Expert - Certifications)
4. https://learn.microsoft.com/en-us/credentials/certifications/practice-assessments-for-microsoft-certifications (Practice Assessments for Microsoft Certifications)
5. https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ai-agents/business-strategy-plan (Business plan for AI agents - Cloud Adoption Framework)
6. https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ai-agents/single-agent-multiple-agents (Choosing Between Building a Single-Agent System or Multi-Agent System - Cloud Adoption Framework)
7. https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ai-agents/build-secure-process (Process to build agents across your organization with Microsoft Foundry and Copilot Studio - Cloud Adoption Framework)
8. https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/ai-agent-design-patterns (AI Agent Orchestration Patterns - Azure Architecture Center)
9. https://learn.microsoft.com/en-us/microsoft-copilot-studio/authoring-add-other-agents (Add other agents overview - Microsoft Copilot Studio)
10. https://learn.microsoft.com/en-us/microsoft-copilot-studio/add-agent-copilot-studio-agent (Connect to an existing Copilot Studio agent - Microsoft Copilot Studio)
11. https://learn.microsoft.com/en-us/microsoft-copilot-studio/add-agent-foundry-agent (Connect to a Microsoft Foundry agent (preview) - Microsoft Copilot Studio)
12. https://learn.microsoft.com/en-us/microsoft-copilot-studio/guidance/multi-agent-patterns (Multi-agent orchestration patterns and best practices - Microsoft Copilot Studio)
13. https://learn.microsoft.com/en-us/microsoft-copilot-studio/add-agent-agent-to-agent (Connect to an agent over the Agent2Agent (A2A) protocol - Microsoft Copilot Studio)
14. https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/model-router (Model router for Microsoft Foundry concepts - Microsoft Foundry)
15. https://learn.microsoft.com/en-us/azure/ai-services/content-safety/concepts/jailbreak-detection (Prompt Shields in Azure AI Content Safety - Azure AI services)
16. https://learn.microsoft.com/en-us/microsoft-copilot-studio/analytics-agent-evaluation-intro (About agent evaluation - Microsoft Copilot Studio)
17. https://learn.microsoft.com/en-us/microsoft-copilot-studio/advanced-bot-framework-composer-capture-telemetry (Agent-level telemetry with Application Insights - Microsoft Copilot Studio)
18. https://learn.microsoft.com/en-us/microsoft-copilot-studio/security-and-governance (Security and governance - Microsoft Copilot Studio)
19. https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/agents-overview (Compare declarative and custom engine agents)
20. https://learn.microsoft.com/en-us/azure/foundry/agents/overview (What is Microsoft Foundry Agent Service? - Microsoft Foundry)
21. https://learn.microsoft.com/en-us/microsoft-copilot-studio/add-agent-child-agent (Add a child agent - Microsoft Copilot Studio)
22. https://learn.microsoft.com/en-us/training/courses/ab-100t00 (Course AB-100T00-A: Architecting agentic AI business solutions - Training)