---
title: "AB-620 Study Guide — AI Agent Builder Associate"
description: "An interactive study guide built on 7 memory techniques to help you pass the AB-620 exam."
url: "https://lucidlabs.com.au/insights/ab-620"
---

# Master the AB-620

An interactive study guide built on 7 memory techniques to help you pass the AB-620 exam.

Plan and configure agent solutions ~33%Integrate and extend agents in Copilot Studio ~33%Test and manage agents ~33%

What it covers

Copilot Studio topics, generative orchestration, tools/actions, knowledge sources, Power Fx, Dataverse, adaptive cards, MCP server integration, Agent2Agent (A2A) multi-agent orchestration, computer use, authentication, publishing channels, DLP, and agent lifecycle management. Microsoft has not published official domain weightings for AB-620 -treat the three domains as roughly even.

Ideal for

Professional developers and advanced builders -IT application developers, consultants, and ISV partners -who build, extend, and integrate custom agents for enterprise-grade solutions.

Aspire to this if

You're a developer ready to move beyond low-code Copilot Studio basics into enterprise-grade agent building -integrating MCP servers, custom connectors, multi-agent systems, and enterprise knowledge sources like ServiceNow and SAP.

Section 1 / Spatial Memory

## The Map

Tap any component to see what you need to know for the exam.

**🧠 AI Agent Builder**

Enterprise Agent Development

**🌐 Power Platform Environments**

Dev / Test / Prod Strategy

**🗄️ Dataverse & Knowledge**

Structured Data Foundations

**🛡️ DLP & Governance**

Data Loss Prevention Policies

**💬 Topics & Orchestration**

Conversation Design

**🔧 Tools & Connectors**

Actions the Agent Can Take

**🔌 MCP Integration**

Model Context Protocol

**🤝 A2A & Multi-Agent**

Agent-to-Agent Handoff

**🎴 Adaptive Cards & Power Fx**

Rich Responses & Logic

**📡 Channels & Authentication**

Publish & Secure

**🧪 Testing & Analytics**

Validate Before You Ship

**🔄 Lifecycle & Computer Use**

ALM & Task Automation

Section 2 / Narrative Memory

## The Story

Follow the narrative to build a mental model of how everything connects.

🧠

### The Builder's Mandate

A new kind of developer role emerges -not the classic maker who drags topics together in a canvas, but a builder who extends agents with pro-code integrations, connects them to enterprise systems, and manages their lifecycle like any production application. AB-620 tests exactly this: can you plan, integrate, and operate agents that hold up under real enterprise load.

**Exam Intel**Candidate profile: professional developer / advanced builder (IT app developer, consultant, ISV partner). Three domains treated as roughly even -Plan & configure, Integrate & extend, Test & manage. 120 minutes, English only.

🌐

### The Environment Map

Before writing a single topic, the builder plots the environment strategy. A Developer environment for personal experimentation, a Sandbox for the team to integrate work, and Production locked down for live users. Environment Groups apply consistent DLP rules across all three, so a connector blocked in prod is blocked everywhere it should be.

**Exam Intel**Environments = isolated Dataverse + security + connections. Default (shared org-wide), Developer (personal sandbox), Sandbox (non-prod), Production (governed). Environment Groups apply rulesets across many environments at once.

🗄️

### The Knowledge Vault

The agent needs facts to ground its answers. The builder wires up a Dataverse table of product SKUs, a SharePoint site of policy documents, and a public knowledge base URL. Generative answers pull from all three, citing sources in the reply -so when a customer asks about a return policy, the agent quotes the actual document instead of guessing.

**Exam Intel**Knowledge sources: Dataverse tables, SharePoint, public websites, uploaded files, enterprise connectors (ServiceNow, SAP), Foundry/Azure AI Search indexes. Generative answers ground and cite responses. Dataverse security roles restrict what the agent can read.

🛡️

### The Governance Gate

An admin has classified the CRM connector as Business and a public weather API as Non-Business. When the builder tries to chain both into one tool, Copilot Studio blocks it -the DLP policy will not let Business and Non-Business data mix in a single action. The builder redesigns the flow to keep them in separate tools.

**Exam Intel**DLP: Business / Non-Business / Blocked connector classification. Business + Non-Business cannot combine in one action -classic exam trap. Policies apply per environment/environment group, enforced at design and runtime.

💬

### The Orchestration Shift

The builder starts with classic topics -hand-authored trigger phrases and branching nodes for a returns process that must follow an exact script. But for open-ended product questions, they switch on generative orchestration and let the model decide, turn by turn, whether to answer from knowledge, call a tool, or hand off to a topic.

**Exam Intel**Classic topics = deterministic trigger phrases + authored nodes. Generative orchestration = model dynamically picks topic/tool/knowledge per turn, steered by agent-level natural-language instructions. Both can coexist in one agent.

🔧

### The Toolbelt

The agent needs to actually do things, not just talk. The builder adds a tool backed by a Power Automate flow that creates a support ticket, a prebuilt connector for sending a Teams notification, and a custom connector built from an internal API's OpenAPI spec. Each exposes an input/output schema so the orchestrator knows exactly when to reach for it.

**Exam Intel**Tools call: Power Automate flows, prebuilt connectors (1,400+), custom connectors (from OpenAPI spec), REST APIs, or Foundry/AI Builder prompts. Input/output schema drives orchestration decisions. Tools can be topic-scoped or global.

🔌

### The MCP Handshake

Rather than building a custom connector for every internal service, the builder points the agent at the team's existing MCP server. At connection time the agent discovers the server's available tools, resources, and prompts automatically -no per-API wiring required. New tools added to the server show up without touching the agent at all.

**Exam Intel**MCP = open standard for runtime tool discovery/invocation. Server exposes tools, resources, prompts. Contrast: MCP is dynamic/discoverable at runtime; custom connectors are statically defined per API in advance.

🤝

### The Agent Delegation

The HR agent gets a payroll question it was never designed to answer. Instead of failing, it hands the query to a specialised Finance agent added as a child tool -a multi-agent pattern. Across organisational boundaries, the Agent2Agent protocol lets an entirely separate, externally built agent advertise its capabilities so the HR agent can delegate to it too.

**Exam Intel**Multi-agent = add another agent as a tool ("child agent") for delegation within Copilot Studio. A2A protocol = cross-platform agent discovery and task delegation. MCP connects agent-to-tool; A2A connects agent-to-agent. Test handoffs for context loss.

🎴

### The Rich Response

A plain text answer won't do for an order-status lookup. The builder returns an Adaptive Card templated with the order details, a status badge, and a Submit button wired back into a topic via Power Fx. The formula reads a global variable to decide which button label to render, and the card renders identically in Teams and on the web.

**Exam Intel**Adaptive Cards = JSON UI, rendered in Teams/web, support templating and dynamic data binding. Power Fx = low-code expression language for variables/conditions/formulas in topics. Card actions (Submit, OpenUrl) can trigger topics.

📡

### The Publish Decision

Internal employees reach the agent through Teams with Entra ID single sign-on -it already knows who they are. External customers reach a different instance of the same agent embedded on the public website, authenticating manually through a generic OAuth connection since they aren't in the tenant.

**Exam Intel**Channels: Teams, demo/custom website, custom via Azure Bot Service/Direct Line. Auth modes: No authentication, Authenticate manually (OAuth), Authenticate with Microsoft/Entra ID (SSO, knows user identity).

🧪

### The Proving Ground

Before publishing, the builder runs the test pane, watching which topic fires and which tool gets called for a dozen tricky phrasings. They test as a low-privilege user to confirm Dataverse security roles correctly hide restricted records, then check the analytics dashboard for escalation rate before rolling the change out gradually.

**Exam Intel**Test pane traces topic/tool firing in real time. Analytics: session volume, topic trigger rate, escalation rate, generative fallback rate. Transcripts audit which knowledge/tools produced an answer. Test as different roles for security validation.

🔄

### The Long Game

The agent ships, but the job isn't done. The builder packages it into a solution, exports from dev, imports to test, then to production -the same ALM pattern used for any Power Platform app. For one legacy mainframe screen with no API at all, they fall back to computer use, letting the agent click through the old UI directly. Post-launch, analytics feed the next iteration.

**Exam Intel**ALM = solutions for export/import across dev/test/prod. Solution layering lets customisation survive base updates. Computer use = last resort for UI automation when no API/connector exists. Lifecycle = build, test, publish, monitor, iterate.

Section 3 / Acronym Memory

## Mnemonic Wall

Memorable acronyms and phrases to anchor key exam concepts in your memory.

🅿️

PIT

**P**lan and configure, **I**ntegrate and extend, **T**est and manage

The 3 AB-620 exam domains, roughly even weight -think of it as a "pit stop" for your agent: plan it, build it, test it.

🚗

KITT

**K**nowledge, **I**nstructions, **T**ools, **T**opics

The four things you configure per agent in Copilot Studio -what it knows, how it should behave, what it can do, and how conversations are structured.

🌐

DTP

**D**ev, **T**est, **P**rod

Environment strategy for agent ALM. Build in Dev, validate in Test/Sandbox, promote to Production via solutions -never author directly in prod.

🔌

TRP

**T**ools, **R**esources, **P**rompts

The three capability types an MCP server can expose. The agent discovers all three dynamically at connection time -no static wiring needed.

🧪

CAT

Test **C**hat, **A**nalytics, **T**ranscripts

The three testing surfaces in Copilot Studio. Test chat for live tracing, analytics dashboards for trends, transcripts for full-history audit.

🔄

BTPM

**B**uild, **T**est, **P**ublish, **M**onitor

The agent lifecycle loop. Monitor feeds back into Build -analytics from a live agent drive the next round of topic/instruction iteration.

Section 4 / Contrast Memory

## Versus Arena

Side-by-side comparisons to sharpen your understanding of similar concepts.

vs

TopicsvsToolsvsKnowledge Sources

Click to compare

#### The Three Building Blocks

| Aspect | Topics | Tools | Knowledge Sources |
| --- | --- | --- | --- |
| Purpose | Structure a conversation flow | Take action / call an API |
| Authoring | Trigger phrases + nodes | Connector, flow, or OpenAPI schema |
| Invoked by | Trigger match or generative orchestration | Generative orchestration or a topic step |
| Output | Scripted response / card | Side effect (create record, send message) |
| Knowledge sources do | n/a | Ground generative answers with citations, read-only |
| Best for | Compliance-critical, exact scripts | Real-world actions and data retrieval |

Click to flip back

vs

Generative OrchestrationvsClassic Topics

Click to compare

#### Generative Orchestration vs Classic Topics

| Aspect | Generative Orchestration | Classic Topics |
| --- | --- | --- |
| Control flow | Model decides per turn | Author-defined trigger + branches |
| Setup effort | Low -write instructions, add tools/knowledge | Higher -author every trigger phrase and node |
| Predictability | Lower -flexible, can vary response wording | Higher -deterministic, scripted every time |
| Best for | Open-ended Q&A, broad intents | Regulated processes, exact wording required |
| Can combine? | Yes -falls back to topics when matched | Yes -classic topics still fire first if triggered |

Click to flip back

vs

MCP ServervsCustom Connector

Click to compare

#### MCP Server vs Custom Connector

| Aspect | MCP Server | Custom Connector |
| --- | --- | --- |
| Discovery | Dynamic -negotiated at runtime | Static -defined ahead of time from OpenAPI |
| Maintenance | Add tools server-side, agent sees them automatically | Update connector definition per API change |
| Scope | Can expose tools, resources, and prompts | Exposes API operations only |
| Setup in Copilot Studio | Add MCP server as a tool source | Import/define connector, then add as a tool |
| Best for | Rapidly evolving internal tool servers | Stable, well-defined external/internal APIs |

Click to flip back

vs

Single-AgentvsMulti-Agent (A2A)

Click to compare

#### Single-Agent vs Multi-Agent Orchestration

| Aspect | Single-Agent | Multi-Agent (A2A) |
| --- | --- | --- |
| Scope | One agent handles the entire domain | Multiple specialised agents share the workload |
| Delegation | n/a | Parent agent adds child agent(s) as tools |
| Cross-platform | n/a | A2A protocol lets externally built agents interoperate |
| Complexity | Simpler to build and test | Requires testing handoff/context loss |
| Best for | Narrow, well-bounded scenarios | Broad domains spanning multiple specialities |

Click to flip back

vs

Manual AuthenticationvsEntra ID Authentication

Click to compare

#### Manual vs Entra ID (Azure AD) Authentication

| Aspect | Manual Authentication | Entra ID Authentication |
| --- | --- | --- |
| Identity provider | Generic OAuth 2.0 connection | Microsoft Entra ID (tenant users) |
| Single sign-on | No -separate login flow | Yes -reuses Teams/M365 sign-in |
| User identity known? | Depends on the provider | Yes -agent knows the signed-in user |
| Best for | External customers, non-Microsoft identity | Internal employees on Teams/M365 channels |
| Setup | Configure OAuth app registration manually | Configure in Entra ID app registration + channel |

Click to flip back

Section 5 / Grouping Memory

## Cheat Sheet

Organised reference grouped by exam domain — everything you need on one page.

### Plan and Configure Agent Solutions

~33%

#### Candidate & Prerequisites

-   Familiarity required: Power Fx, Dataverse, Power Platform environments, generative AI concepts, prompt engineering, REST APIs
-   Target audience: professional developer / advanced builder -not a citizen maker persona
-   Understand RAG (retrieval-augmented generation), orchestration, MCP, and A2A at a conceptual level before touching Copilot Studio

#### Environment Strategy

-   Default (shared org-wide), Developer (personal sandbox), Sandbox (non-prod), Production (governed)
-   Environment Groups apply consistent DLP/governance rulesets across many environments
-   Never author or test directly in Production -promote via solutions instead

#### Data Foundations

-   Dataverse tables = knowledge source (read) and action target (write) for an agent
-   Knowledge sources: Dataverse, SharePoint, public websites, files, enterprise connectors, Foundry/AI Search indexes
-   Generative answers cite the knowledge source used, reducing hallucination
-   Dataverse security roles gate exactly what an agent can read or write per user

#### Governance & DLP

-   DLP policies classify connectors: Business, Non-Business, Blocked
-   Business + Non-Business connectors cannot combine in one agent action
-   Policies scoped per environment/environment group, enforced design-time and runtime
-   Tenant/environment Copilot Studio settings control who can create, publish, and which channels are allowed

### Integrate and Extend Agents in Copilot Studio

~33%

#### Topics & Orchestration

-   Classic topics: trigger phrases + authored nodes -deterministic, scripted
-   Generative orchestration: model dynamically picks topic/tool/knowledge per turn
-   Agent-level natural-language instructions steer generative orchestration behaviour
-   System topics (Conversation Start, Escalate, Fallback) handle built-in events

#### Tools, Actions & Connectors

-   Tools call Power Automate flows, prebuilt connectors, custom connectors, or REST APIs
-   Custom connectors defined from an OpenAPI/Swagger specification
-   Each tool has an input/output schema the orchestrator uses to decide invocation
-   Prompt tools (AI Builder/Foundry) callable for summarisation/classification tasks

#### MCP & A2A Integration

-   MCP server = dynamic runtime tool/resource/prompt discovery -no per-API wiring
-   MCP vs custom connector: dynamic/discoverable vs static/predefined
-   A2A protocol: cross-platform agent discovery and task delegation
-   Multi-agent: add another agent as a child tool for in-platform delegation
-   Test handoffs -confirm context is preserved (or intentionally dropped) at the boundary

#### Adaptive Cards & Power Fx

-   Adaptive Cards = JSON UI for rich responses, rendered natively in Teams/web
-   Card templating binds dynamic data -one definition, many rendered records
-   Power Fx = low-code expression language for variables, conditions, formulas
-   Card actions (Submit, OpenUrl) can trigger topics or pass data back into the conversation

### Test and Manage Agents

~33%

#### Publishing Channels

-   Microsoft Teams, demo/custom website, custom channels via Azure Bot Service / Direct Line
-   Web channel requires secret management and token endpoint configuration
-   Channel choice affects which authentication modes are available

#### Authentication

-   No authentication (anonymous) -public, low-trust scenarios
-   Authenticate manually -generic OAuth 2.0, non-Microsoft identity providers
-   Authenticate with Microsoft/Entra ID -SSO, agent knows the signed-in user

#### Testing & Analytics

-   Test pane (test chat): live trace of which topic/tool fired for a given input
-   Analytics dashboards: session volume, topic trigger rate, escalation rate, generative fallback rate
-   Transcripts: full conversation history for debugging and audit
-   Test as different users/roles to validate Entra ID identity + Dataverse security roles

#### Agent Lifecycle Management

-   Solutions package topics, tools, and connections for export/import across environments
-   Solution layering: customise a managed solution without breaking future base updates
-   Computer use: last-resort UI automation for legacy apps with no API/connector path
-   Lifecycle loop: build → test → publish → monitor → iterate, driven by post-launch analytics

Section 6 / Method of Loci

## The Memory Palace

Walk through themed rooms — each object anchors a concept in spatial memory.

### The Environment Command Centre

Plan & Configure -Where the foundation is laid

🌐

Environment Strategy

Dev → Sandbox/Test → Production, promoted via solutions, never authored live

🗄️

Dataverse Knowledge

Tables act as both knowledge source (read) and action target (write)

🛡️

DLP Policies

Business / Non-Business / Blocked -cannot mix Business + Non-Business in one action

👤

Candidate Profile

Pro developer/advanced builder -needs Power Fx, Dataverse, REST APIs, RAG concepts

🏛️

Environment Groups

Apply consistent governance rulesets across many environments at once

### The Topic & Tool Workshop

Integrate & Extend, part one -Where the agent gets its brain

💬

Classic Topics

Trigger phrases + authored nodes -deterministic and scripted

✨

Generative Orchestration

Model picks topic/tool/knowledge dynamically, steered by agent instructions

🔧

Tools & Actions

Call Power Automate flows, connectors, or REST APIs -schema drives invocation

🧩

Custom Connectors

Built from an OpenAPI/Swagger spec for bespoke internal or external APIs

📚

Knowledge Grounding

Generative answers cite the source document or table used to answer

### The Integration Bridge

Integrate & Extend, part two -Where agents reach further

🔌

MCP Servers

Dynamic runtime discovery of tools, resources, and prompts -no static wiring

🤝

A2A Protocol

Cross-platform agent discovery and delegation between independently built agents

🤖

Multi-Agent (Child Agents)

Add another agent as a tool for in-platform task delegation

🎴

Adaptive Cards

JSON UI cards with templating and data binding, rendered in Teams/web

📐

Power Fx

Low-code expressions for variables, conditions, and card/topic logic

### The Test & Ops Deck

Test & Manage -Where the agent proves itself

📡

Publishing Channels

Teams, demo/custom website, custom via Azure Bot Service / Direct Line

🪪

Authentication Modes

No auth, manual OAuth, or Entra ID SSO -each changes what the agent knows about the user

🧪

Test Pane & Transcripts

Live trace of topic/tool firing plus full-history audit for debugging

📊

Analytics

Session volume, topic trigger rate, escalation rate, generative fallback rate

🔄

ALM & Computer Use

Solutions for lifecycle promotion; computer use as the last-resort UI automation fallback

Section 7 / Pattern Recognition

## Pattern Spotter

Decision trees and trigger-answer pairs — see the pattern, know the answer.

Which Copilot Studio Building Block?

Which Copilot Studio Building Block?  
  ├── Process must follow an exact, compliant script? → Classic Topic  ├── Open-ended question, intent varies widely? → Generative Orchestration  ├── Agent needs to take a real-world action? → Tool (connector, flow, or API)  ├── Agent needs facts to ground an answer? → Knowledge Source  └── Need a rich, interactive reply (form, buttons)? → Adaptive Card

Which Integration Method?

Which Integration Method?  
  ├── Internal tool server that changes frequently? → MCP Server (dynamic discovery)  ├── Stable, well-defined bespoke API? → Custom Connector (OpenAPI-based)  ├── Common SaaS system (Teams, SharePoint, Dataverse)? → Prebuilt Connector  ├── Task belongs to a different specialised domain? → Multi-Agent Delegation (child agent)  ├── Delegating to an agent built on another platform? → A2A Protocol  └── No API or connector exists at all? → Computer Use (last resort)

Which Authentication Method?

Which Authentication Method?  
  ├── Internal employees on Teams/M365? → Authenticate with Microsoft/Entra ID (SSO)  ├── External customers, non-Microsoft identity? → Authenticate manually (OAuth 2.0)  ├── Public, low-trust, anonymous access? → No authentication  └── Need to know exactly who is signed in? → Entra ID authentication required

Two Connectors Won’t Chain Together -Why?

Two Connectors Won’t Chain Together -Why?  
  ├── One connector is Business, the other Non-Business? → DLP policy blocks the combination  ├── Connector is classified Blocked? → Cannot be used in this environment at all  ├── Both connectors are the same classification? → Chaining is allowed  └── Unsure of a connector’s classification? → Check the DLP policy in the Power Platform admin center

## Decision Cards

"model dynamically picks the topic/tool at runtime"→Generative Orchestration

"discovers tools, resources, and prompts at connection time"→MCP (Model Context Protocol) server

"agents from different platforms delegate tasks to each other"→A2A (Agent2Agent) protocol

"add another agent as a tool"→Multi-agent orchestration (child agent)

"Business and Non-Business connectors cannot be used together"→DLP policy classification rule

"knows who is signed in via Teams/M365"→Authenticate with Microsoft/Entra ID

"JSON card with buttons and a form, renders in Teams"→Adaptive Card

"low-code expression for a topic variable or condition"→Power Fx

"automating a legacy app with no API"→Computer use

"export from dev, import to test, then prod"→Solution-based ALM

Ready to certify?

## Train with practitioners, not presenters

Lucid Labs delivers Microsoft certification training led by Microsoft Certified Trainers (MCTs) and grounded in real-world project experience. We adapt every session to your team's environment, data stack, and business objectives — because the best exam prep comes from engineers who build these solutions every day.

🎯

Tailored Content

Training built around your actual Copilot Studio agents, your Dataverse tables, and your integration targets -not generic demos.

🛠️

Hands-On Labs

Build, integrate, and test a real agent -wiring up tools, MCP servers, and multi-agent handoffs with expert guidance.

📈

Exam + Capability

Pass the AB-620 exam and leave with agentic AI patterns your team can apply to production Copilot Studio solutions from day one.

[Talk to us about Microsoft Certified: AI Agent Builder Associate (AB-620) training](https://lucidlabs.com.au/?service=training-consulting&message=I%27m%20interested%20in%20Copilot%20Studio%20agent-building%20training%20for%20my%20team%20-%20covering%20topics%2C%20tools%2C%20knowledge%20sources%2C%20MCP%20integration%2C%20and%20multi-agent%20orchestration.#contact)

Custom training for teams & individuals — remote or on-site across Australia

![Keith Oak](https://lucidlabs.com.au/team/koak-400.jpg)

Keith Oak

Chief Technology Officer — Lucid Labs

Microsoft Solutions Partner architect specialising in Fabric, Azure Data & AI, and GitHub Enterprise. 18+ years delivering data platforms for Australian businesses — building the systems these exams test every day.

[LinkedIn ↗](https://www.linkedin.com/in/keithoak/)[lucidlabs.com.au ↗](https://lucidlabs.com.au/)Published 29-03-2026