AB-620 Designing and Building Integrated AI Agent Solutions in Copilot Studio Exam Topics and Questions

This topic sets the foundation for everything else on the exam. Before you write a single line of configuration, you need to have made defensible decisions about identity, governance, responsible AI, and audience. The exam tests whether you can think through those decisions, not just execute them. Candidates who treat planning as a formality and jump to configuration tend to lose marks on scenarios where the wrong upstream choice invalidates the downstream setup.

– Architecture, strategy and governance

Planning an agent solution means mapping business requirements to Copilot Studio capabilities before touching the canvas. That includes deciding which enterprise systems the agent will integrate with, what authentication model applies, and how identity flows through the solution. Identity strategy is more than picking OAuth: you need to match the identity model to the audience and to the channel, because a Teams-deployed internal agent and a public-facing web-chat agent carry different trust assumptions.

Responsible AI strategy sits here too, and the exam takes it seriously. You are expected to know how to build guardrails into the design, not just acknowledge that they exist. Security and governance considerations cover data residency, sensitivity labels, and who can publish or modify agents in your tenant. Reusable agent components are worth attention: understanding what can be extracted into a shared library versus what must stay local to a specific agent changes how you answer architecture-scenario questions.

– Channels, audiences and deployment

Deployment planning is not just picking a channel from a list. Each channel imposes constraints on what the agent can render, how authentication is handled, and what latency is acceptable. Designing for internal versus external audiences changes the acceptable identity model, the tone of responses, and the data the agent should be permitted to surface. The exam presents scenarios where you must identify the channel-audience mismatch and correct it.

Channel planning also intersects with the human-in-the-loop requirement. Some deployments legally or operationally require an escalation path to a live agent. Knowing when to mandate that path, and how to configure it, is testable.

– Agent flows: creation and control

Agent flows in Copilot Studio are the procedural backbone of an agent. Creating a basic flow is straightforward; the exam pushes further. Human-in-the-loop flows require you to know the trigger conditions and handoff mechanics. Input and output parameters must be typed correctly, because a mismatch breaks the integration silently in ways that are easy to miss during testing but obvious in production. Error handling is frequently tested through scenario questions: candidates who know only the happy path lose marks when the scenario introduces a connector failure or an unexpected null value.

Configuring actions and connectors ties flows to external systems. Monitoring agent flows is the feedback loop that closes the design: the exam expects you to know which signals indicate a flow is underperforming, not just that monitoring exists.

– Topics, variables and response configuration

Topics are the conversational structure of an agent. Adding agent flows to a topic, attaching tools, and controlling how the agent responds are all configuration decisions with testable consequences. Response formatting affects what the end user sees and what channels can render; misconfiguring it for a channel that does not support rich content is a common trap.

Advanced responses bring in custom prompts, custom knowledge sources, API and HTTP requests, the generative answers node, and adaptive cards. Each has its own configuration surface and its own failure mode. Custom prompts require you to understand prompt structure well enough to predict what the model will do with a given instruction. The generative answers node has specific settings that control grounding and citation behaviour. Adaptive cards are channel-dependent: knowing which channels support them prevents a class of deployment errors. Variable management ties the whole topic layer together, controlling state across turns.

How Plan and configure agent solutions is tested

This topic carries the broadest surface area on the exam. Items tend to be scenario-based: you are given a business requirement, a partial configuration, or a deployment constraint, and asked to identify the right next step or the flaw in the current approach. The planning sub-topics generate questions that reward reading the scenario carefully for audience type, channel, and identity context before selecting an option.

Configuration questions often embed a subtle mismatch: a flow that lacks error handling, a topic that references a variable not yet initialised, or a channel that cannot render the card type configured. Candidates lose marks by picking the option that addresses the symptom rather than the root cause.

The responsible AI and governance sub-topics appear as policy-selection scenarios: given a set of constraints, which configuration satisfies all of them. Items reward knowing the interaction between settings, not just what each setting does in isolation. Variable scoping and parameter typing are tested through flow-debugging scenarios where the error is one level removed from the obvious location.

Where the first topic is about designing and building within Copilot Studio's own surface, this one is about reaching outside it. Integration questions test whether you know the boundaries between Copilot Studio, the broader Power Platform, Azure AI services, and external systems, and whether you can wire them together correctly. The multi-agent and Azure integration sub-topics in particular require you to hold several moving parts in mind at once, which is where unprepared candidates drop marks.

– Knowledge sources and connectors

Connecting an agent to enterprise knowledge is not a single action. The exam distinguishes between Copilot connectors, Power Platform connectors, and Azure AI Search as distinct integration paths, each with its own configuration requirements and appropriate use cases. Azure AI Search integration requires you to understand index configuration well enough to know why a query might return irrelevant or empty results, not just how to point the agent at a search resource.

Power Platform connectors bring the existing ecosystem of data connections into the agent. The testable question is usually which connector type fits the scenario, and what the agent can and cannot do through that connector. Knowing the difference between a certified connector and a custom connector matters here, because the deployment and governance implications differ.

– Tools, APIs and computer use

Adding tools to an agent extends what it can do at runtime. The exam tests tool configuration through scenarios where the requirement specifies a capability and you must identify which tool type delivers it. MCP tools, custom connectors, and REST APIs are distinct options with different setup paths. Adding a REST API directly to an agent is different from wrapping it in a custom connector first: the exam distinguishes between these approaches.

Computer use is an emerging capability that gets its own configuration and monitoring surface. Expect questions that probe whether you know the conditions under which computer use is appropriate and how to monitor it for unexpected behaviour. This is an area where candidates who have only read documentation rather than worked through configuration scenarios are likely to hesitate.

– Multi-agent collaboration and orchestration

Multi-agent solutions in Copilot Studio require you to understand how agents hand off to each other, which agent owns the conversation state at any point, and how the A2A protocol governs agent-to-agent communication. The exam tests design decisions: given a set of specialised agent capabilities, how do you structure the collaboration so that the right agent handles each part of the task.

Integrating a Foundry agent and integrating an existing Copilot Studio agent are different operations with different configuration steps. A Fabric data agent brings structured data capabilities into the mix. The exam expects you to know which integration path applies to each agent type, and what the limitations of each path are. Conflating these integration types is the main source of errors in this sub-area.

– Azure integration and monitoring

Configuring generative answers through Azure AI Search with Foundry combines two services that each have their own configuration surface. The exam tests whether you can identify the correct configuration for grounding responses in an Azure-hosted index, including what happens when the Foundry model catalog is used for custom prompts instead of the default model.

Monitoring with Application Insights is the operational close of this topic. You need to know which telemetry signals are available, what they indicate about agent health, and how to act on them. Exam items in this area reward knowing the difference between a configuration problem and a runtime performance problem, because the remediation differs. Candidates who treat monitoring as a passive activity lose marks on questions that ask what action follows from a specific signal.

How Integrate and extend agents in Copilot Studio is tested

Integration topics generate the most multi-step scenario questions on the exam. You are typically given an existing agent, a new capability requirement, and a set of constraints (licensing, data residency, existing infrastructure), and asked to select the integration approach that satisfies all three. Items reward understanding the constraints of each integration path, not just its existence.

Multi-agent questions are particularly demanding because they require you to reason about agent boundaries: which agent owns which responsibility, and what protocol governs the handoff. Candidates who apply single-agent thinking to multi-agent scenarios consistently pick options that work in isolation but break at the boundary.

Azure integration questions often hinge on a specific configuration detail: the wrong index field mapping, the wrong authentication scope, or a missing setting in the Foundry model configuration. The trap is selecting the option that addresses the most obvious gap while leaving a less visible one open. Application Insights questions reward knowing what specific metrics to watch, not just that the service can be connected.

The final topic shifts from building to validating and shipping. Testing and ALM are the areas candidates most often underestimate, because they feel procedural compared to architecture or integration. The exam disagrees. Questions here test whether you understand the difference between evaluation methods, what test results actually tell you, and how to move an agent through environments without breaking it. Getting this wrong in production is expensive, and the exam reflects that.

How Test and manage agents is tested

This topic generates scenario questions at two levels: evaluation and lifecycle. Evaluation questions give you a scenario with a specific quality problem and ask which test method or metric addresses it. Items reward knowing the difference between evaluation methods well enough to match one to a requirement, not just knowing that multiple methods exist. Creating a test set is testable in terms of what makes a good test set for a given agent type, not just the mechanical steps.

ALM questions are frequently about what breaks during a pipeline promotion and why. Environment variables are a common source of errors when moving agents between environments: the exam tests whether you know how to configure them so that promotion does not carry development values into production. Power Platform Pipelines questions reward knowing both the standard pipeline behaviour and what extension points exist.

Candidates lose marks in this topic by treating it as purely procedural. The exam regularly embeds a decision point: given two ways to structure a solution or a pipeline, which one is correct for the stated governance or operational requirement. Knowing the steps is not enough if you cannot justify the choice.