4.2 Human-in-the-Loop Agent Flows

Microsoft Certified: AI Agent Builder Associate AB-620

Track your progress as you read

Finished sections get a check mark.

1 Introduction & Exam Overview

1.1 Current Exam Facts 1.2 Candidate Profile & Prerequisites 1.3 Skills Map & Study Strategy

2 Plan Integration, Identity & Channels

2.1 Plan Integration with Enterprise Systems 2.2 Plan Identity Strategy 2.3 Plan Channels and Deployment

3 Responsible AI, Security & Reuse

3.1 Plan Responsible AI Strategy 3.2 Security and Governance Considerations 3.3 Plan Reusable Agent Components 3.4 Design Agents for Internal or External Audiences

4 Agent Flows Fundamentals

4.1 Create an Agent Flow 4.2 Human-in-the-Loop Agent Flows 4.3 Configure Actions and Connectors in Flows

5 Agent Flow Monitoring & Resilience

5.1 Monitor Agent Flows 5.2 Input and Output Parameters 5.3 Error Handling in Agent Flows

6 Topics Configuration Core

6.1 Add Agent Flows to a Topic 6.2 Configure Agent Response Formatting 6.3 Add Tools to a Topic

7 Advanced Topic Responses

7.1 Custom Prompts for Advanced Responses 7.2 Custom Knowledge Sources for Advanced Responses 7.3 API and Send HTTP Request Responses

8 Generative Answers, Cards & Variables

8.1 Configure the Generative Answers Node 8.2 Configure Adaptive Cards 8.3 Manage Variables

9 Enterprise Knowledge Sources

9.1 Connect to Copilot Connectors 9.2 Connect to Power Platform Connectors 9.3 Connect to Azure AI Search

10 Add Tools to Agents

10.1 Configure and Monitor Computer Use 10.2 Configure MCP Tools 10.3 Tools via Existing Custom Connectors 10.4 Add REST APIs to an Agent

11 Multi-Agent Collaboration

11.1 Design Multi-Agent Solutions 11.2 Integrate a Foundry Agent 11.3 Integrate an Existing Copilot Studio Agent

12 Fabric Data Agents & A2A

12.1 Integrate a Fabric Data Agent 12.2 Multi-Agent Solutions with A2A Protocol

13 Integrate Agents with Azure

13.1 Generative Answers with Azure AI Search & Foundry 13.2 Foundry Model Catalog for Custom Prompts 13.3 Monitor Agents with Application Insights

14 Evaluate Agent Performance

14.1 Create a Test Set 14.2 Choose an Evaluation Method 14.3 Review Test Results

15 Application Lifecycle Management

15.1 Create a Solution 15.2 Add Existing Agents to a Solution 15.3 Create and Use Environment Variables 15.4 Power Platform Pipelines for Agents

4.2 Human-in-the-Loop Agent Flows

Key Takeaways Explain This Topic AI

Human-in-the-loop (HITL) actions pause an agent flow so a person can approve, reject, or supply structured information before later steps run.

Request for information (RFI) under Human review sends an Outlook request to in-tenant assignees, supports typed inputs (text, yes/no, email, number, date), and uses the first response only.

Multistage approvals (agent-flow exclusive) combine manual stages, AI stages, and conditions so routine cases auto-route while humans retain final control on sensitive paths.

Responsible HITL patterns keep humans as ultimate decision makers for high-risk outcomes, map flow outputs into approval inputs, and avoid assigning the same person to multiple multistage stages.

RFI and advanced approvals are not a substitute for channel handoff alone—they bind human judgment into the automation so subsequent connector actions use verified human data.

Last updated: August 2026

Why human-in-the-loop is a first-class agent skill

Agents that only chat are incomplete for enterprise work. The moment an agent or flow creates a purchase order, releases a claim payment, or changes a production record , organizations require human judgment at defined gates. Copilot Studio agent flows support this with Human in the loop / Human review actions: the run pauses , a person acts, and the flow continues with structured outputs available as dynamic content.

On AB-620, “create a human-in-the-loop agent flow” means you can design that pause correctly—who is notified, what they must supply, how first-to-respond works, how AI stages interact with manual stages, and how responsible-AI policy keeps people in control for sensitive decisions.

HITL action families in agent flows

Microsoft groups human intervention under agent flow action types alongside AI capabilities, built-ins, and connectors. Practically you will see:

Pattern What it does Typical exam cue

Request for information (RFI) Pauses; emails structured inputs to assignees; resumes with field values “Collect missing fields from an adjuster before paying the claim”

Standard / advanced approvals Approve or reject (and multistage variants) “Manager must approve before the order posts”

Multistage + AI approvals Manual stages, AI stages, conditions between stages “AI screens expenses under policy; humans review exceptions”

Escalation via conditions Route to different assignees or stages when thresholds fail “If amount > 5000, require finance; else manager only”

The Human in the loop connector (advanced approvals) is available in Copilot Studio regions and exposes actions such as Request for information and Run a multistage approval . Multistage approvals are documented as available exclusively in agent flows (not ordinary cloud-flow-only authoring paths).

Request for information (RFI) deep dive

RFI is the streamlined way to collect structured human input mid-flow—not merely approve/reject.

Capabilities:

Pause execution at the RFI action
Collect inputs from designated reviewers
Reuse those inputs in later actions (and even later AI approval stages)
How to add it
Open or create an agent flow (Flows → New agent flow, or open existing)
Insert action → under Human review , choose Request for information

Configure required fields:

Title — email subject (for example, Missing information on claim ABC123 )
Message — context for the reviewer
Assigned to — one or more emails (in-tenant)
Add an input for each value you need

Supported input types (current Microsoft documentation):

Type Use for
Text Free text; optional single-select or multi-select option lists
Yes/No Boolean gates
Email Address capture
Number Amounts, quantities
Date Assessment or incident dates

You can mark fields optional , set placeholder help text, and for text inputs define dropdown single-select or multi-select lists so reviewers pick controlled values.

Runtime behavior (memorize for scenarios):

Requests are sent via Outlook (additional channels may appear later)
Assignees must be inside your tenant —not external guests for RFI delivery as documented
If multiple people are assigned, the first response wins ; later responses are ignored
After submit, the flow resumes and each input becomes dynamic content for subsequent steps
Testing: save/publish, Test , watch the pause, complete the Outlook form, confirm downstream mapping

Authoring tip: avoid spaces in input names when you see values wrapped in double braces ( {{ }} )—Microsoft notes this known issue when parameter names include spaces.

Scenario — insurance claim: An automated claim flow detects missing damage assessment. RFI assigns a field adjuster with inputs: assessment date, summary text, damage amount (number), and a yes/no “photos uploaded to claim file.” A later AI or manual approval stage consumes Damage amt. and Summary without re-asking the chatbot user.

Multistage and AI approvals

Beyond simple approve/reject, Run a multistage approval lets you design a process with:

Manual stages — human stakeholders; approval type such as first-to-respond or everyone-must-approve; title, assigned to, details

AI stages — model evaluates instructions plus documents/images/text and returns approve/reject with rationale (requires sufficient Copilot Credits in the environment)

Conditions — between stages, evaluate inputs (for example expense amount) to auto-approve, reject, skip, or route to another stage

Input mapping rule: inside the multistage designer you cannot drop arbitrary flow tokens directly into stage text without first defining inputs (string/number/boolean). After save, those inputs appear on the action card in the flow designer so you map Dataverse fields, RFI outputs, or connector fields into the approval.

Important multistage constraints:

Do not assign the same approver to multiple stages (documented failure mode)
AI stages should use clear, non-contradictory instructions; conflicting rules can yield Analysis failed

For sensitive cases (large finance, legal, HR actions), configure paths so a human stage still decides even if AI approved

File content for AI stages is expected in base64 when not already provided that way by a connector

Some ALM/share limitations exist for advanced approvals—recreate multistage configuration after import/share when docs say so

Example path: AI expense screening → condition (amount > 5000?) → manager manual stage for large amounts → AI budget check → finance manual stage → flow posts payment only on final approve.

Escalation and “wait for response” patterns

Think of HITL as controlled waiting , not as abandoning the automation:

Business need Flow design
Missing data from a specialist RFI to specialist; map responses into update/create actions
Binary authorization Approval action; branch on Approve vs Reject
Policy auto-screen + human exception AI stage + condition + manual stage
Severity-based escalation Condition on severity/amount; different Assigned to or different stages

Agent conversation needs a human Prefer flow HITL when the process must pause; use handoff topics when the chat channel needs a live agent

Do not confuse agent handoff (live conversation transfer) with flow HITL (workflow pause with structured outputs). Exam stems that mention “continue the automation after the manager supplies the cost center” point to RFI/approvals in a flow , not only a handoff node.

Responsible AI oversight patterns

HITL is a responsible AI control , not a UI nicety. Design patterns that map to Microsoft guidance:

Human ultimate control — for high-impact outcomes, ensure a manual stage remains on the path even when AI stages exist; use “Next step based on decision” so AI approve still routes to a person when policy requires it.

Least privilege assignees — assign only the roles that should see the data in the approval email/details.

Structured over free-form — prefer typed RFI inputs and dropdowns so downstream systems receive clean values.

Transparency — approval identity shows the flow creator in details to prevent spoofing; design titles/messages so reviewers understand why they were contacted.

Logging and review — use run history and approvals history (and prompt builder activity for AI stages) so decisions and rationales are auditable.

No silent irreversible action — place HITL before the connector action that commits money, access, or irreversible deletes.

Tenant and environment boundaries — RFI stays in-tenant; multistage responders should exist in the environment to avoid failures when users live elsewhere.

Scenario: Contoso vendor onboarding

Contoso’s agent collects vendor self-service data. Risky design: agent writes “approved vendor” to ERP immediately from generative confidence. Exam-correct design:

Agent or form trigger starts an agent flow
Dataverse staging row created as Pending
RFI to procurement for tax ID verification status and risk tier (dropdown)

Multistage approval : AI checks uploaded W-9 readability/completeness → condition on risk tier → manual legal stage for high risk

Only on final approve does a connector create the ERP vendor and notify the requester

This pattern demonstrates pause/resume, structured human data, AI assist with human authority, and connector side effects after oversight—exactly the HITL skill AB-620 measures.

HITL authoring checklist

Identify which steps are irreversible or regulated—insert HITL before those actions.

Choose RFI vs approval vs multistage based on whether you need data , a decision , or a multi-gate process .

Write clear titles/messages; assign correct in-tenant people; prefer first-to-respond only when that is acceptable.

Map every human output to later actions; test the pause with Test runs.

For AI stages, write non-conflicting instructions, test with sample files, and keep a human stage on sensitive paths.

Document capacity: AI stages and flow actions still consume Copilot Studio resources.

Human-in-the-loop turns agent flows from “fast automation” into governed automation —the standard enterprises expect when Copilot Studio agents touch real systems.