AB-620 — AI Agent Builder Associate

Full question text, answer options, and explanations for this practice set — a spoiler-free alternative is the interactive quiz above for scored, shuffled practice.

1. 1. A developer is planning an AI agent that will be used by employees inside a company's Microsoft 365 tenant to access internal HR policies. External vendors and customers must not have access to the agent. Which planning consideration should drive the agent's channel and identity strategy?

   • A. Plan channels and deployment for external audiences with anonymous access
   • B. Design the agent for an internal audience with authenticated Microsoft 365 identity and restrict it to internal channels(correct)
   • C. Deploy the agent to a public website channel with no authentication required
   • D. Use a shared service principal with full tenant permissions to simplify identity management

   Explanation: Designing the agent for an internal audience with authenticated identity and restricting it to internal channels (such as Microsoft Teams) ensures only authenticated employees within the tenant can access it. Planning for external audiences with anonymous access (A) contradicts the security requirement. Deploying to a public website (C) exposes the agent to external parties. A shared service principal with full tenant permissions (D) violates least-privilege and creates a broad attack surface.

2. 2. A Copilot Studio agent needs to call an external REST API to retrieve customer data. The REST API requires an OAuth 2.0 bearer token. Which planning activity addresses how the agent will authenticate to this external system?

   • A. Plan integration with enterprise systems and plan identity strategy(correct)
   • B. Plan responsible AI strategy to ensure the API response is bias-free
   • C. Configure adaptive cards to display the OAuth token to the user
   • D. Plan reusable agent components to share the OAuth token across topics

   Explanation: Planning integration with enterprise systems and the identity strategy covers how the agent authenticates to external APIs — including OAuth 2.0 connection configurations. Responsible AI strategy (B) addresses ethical and safety concerns, not authentication. Adaptive cards (C) display interactive UI, not security tokens. Reusable components (D) share conversational logic, not authentication credentials.

3. 3. An agent builder is creating a Copilot Studio agent for a financial services company. The agent must never provide specific investment advice, must disclose it is an AI, and must escalate to a human advisor if asked for regulated financial guidance. Which planning activity ensures these behaviors are built into the agent?

   • A. Plan responsible AI strategy, including content boundaries, AI disclosure, and escalation to human agents(correct)
   • B. Configure adaptive cards to display a disclaimer on every response
   • C. Plan reusable agent components to share the disclaimer text across topics
   • D. Configure a scheduled agent flow to audit responses weekly for compliance

   Explanation: Planning a responsible AI strategy covers defining content boundaries (no investment advice), AI disclosure requirements, and escalation rules — the architectural decisions that govern agent behavior for regulated industries. Adaptive cards (B) can display a disclaimer but do not enforce content boundaries or escalation logic. Reusable components (C) share conversational building blocks, not governance policies. A scheduled audit flow (D) detects problems after the fact rather than preventing them by design.

4. 4. A developer is configuring a Copilot Studio agent flow that handles a multi-step expense approval process. If a manager cannot be reached within 24 hours, the flow must escalate to their manager. Which agent flow capability should be configured?

   • A. Create a human-in-the-loop agent flow with escalation logic(correct)
   • B. Create a fully autonomous agent flow with no human interaction points
   • C. Configure adaptive cards to allow the agent to approve expenses on the manager's behalf
   • D. Monitor agent flows to detect if a manager is unavailable, then send an email manually

   Explanation: A human-in-the-loop agent flow pauses for human input (manager approval) and can include escalation logic for timeouts. A fully autonomous flow (B) has no human approval step. Adaptive cards (C) can render approval UI, but the escalation logic and timeout handling are part of the flow configuration, not the card itself. Monitoring (D) detects issues but does not automate escalation.

5. 5. A Copilot Studio developer is building an agent flow that calls an external inventory API. The API sometimes returns HTTP 500 errors. The developer must ensure the flow retries on failure and notifies an admin if all retries fail. Which TWO capabilities should be configured? Choose 2.

   • A. Implement error handling in agent flows to catch HTTP errors and trigger retry logic(correct)
   • B. Add input and output parameters to pass error state to a downstream notification action(correct)
   • C. Configure adaptive cards to display the HTTP 500 error to the end user directly
   • D. Monitor agent flows to receive alerting emails when any flow step fails, without changing flow logic
   • E. Set the flow connection to use a service account with Admin role to bypass API errors

   Explanation: Implementing error handling in agent flows (A) allows the developer to catch HTTP 500 errors and configure retry logic within the flow. Adding output parameters (B) allows error state (such as a retry-exhausted flag) to be passed to a downstream step that sends an admin notification. Displaying the raw HTTP error to end users via adaptive cards (C) is a poor UX and not a resilience pattern. Flow monitoring alerts (D) detect failures after they occur but do not implement retry logic within the flow. A service account with Admin role (E) does not prevent API errors; it only changes the identity making the call.

6. 6. A developer wants agent conversations to use a specific response style — for example, always answering in bullet points with a maximum of five items. Which topic configuration should be used?

   • A. Configure agent response formatting in the topic to enforce bullet-point output style(correct)
   • B. Set the agent's language model temperature to a lower value to reduce verbosity
   • C. Add a manual text transformation step in the agent flow to parse and reformat all responses
   • D. Deploy the agent to Teams and configure a Teams app formatting policy

   Explanation: Configuring agent response formatting within a topic is the native Copilot Studio capability for controlling how responses are structured (e.g., bullet points, character limits). Temperature (B) controls generation randomness, not output format. A manual transformation step (C) would require parsing and reformatting every response, adding unnecessary complexity. Teams app formatting policies (D) control Teams-level settings, not agent response structure.

7. 7. A Copilot Studio developer needs the agent to answer a user's product question using a curated FAQ stored in Azure AI Search, rather than relying on general generative AI knowledge. Which topic configuration should be applied?

   • A. Configure advanced agent responses with custom knowledge sources to ground answers in the FAQ index(correct)
   • B. Configure a generative answers node to use the default Bing web search as the knowledge source
   • C. Add a Send HTTP request action to query Bing and display raw JSON results to the user
   • D. Configure the agent to use a broader topic with all products listed as entities

   Explanation: Configuring advanced agent responses with custom knowledge sources allows the agent to ground its generative answers in a specific knowledge source such as an Azure AI Search index containing the curated FAQ. Using Bing web search (B) returns public internet results, not the curated internal FAQ. Displaying raw JSON (C) is not a user-friendly response and bypasses the agent's generative capability. Adding product entities to a topic (D) handles intent recognition, not FAQ grounding.

8. 8. A developer is planning an agent solution that must be reused across multiple agent projects within the organization. Parts of the conversational logic and tool integrations are shared across different use cases. What should be planned to maximize reusability?

   • A. Copy-paste the topic and flow configurations into each new agent project manually
   • B. Plan reusable agent components so shared topics, flows, and tools can be referenced across agents(correct)
   • C. Create a single mega-agent with all topics and deploy it to every use case
   • D. Train a custom language model on all topics and deploy it as a shared model

   Explanation: Planning reusable agent components ensures shared conversational logic, tools, and flows are built once and referenced across multiple agents, reducing duplication and maintenance overhead. Copying configurations manually (A) creates divergent copies that are hard to maintain. A single mega-agent (C) becomes unmanageable and cannot be tailored for different audiences. Training a custom language model (D) is a separate concern unrelated to reusable Copilot Studio components.

9. 9. A Copilot Studio agent must search an Azure AI Search index to answer employee questions about internal HR documents. Which knowledge source connection should be configured?

   • A. Connect to Microsoft Power Platform connectors
   • B. Connect to Azure AI Search(correct)
   • C. Connect to Copilot connectors for Bing web search
   • D. Connect to Microsoft Fabric data agent

   Explanation: Connecting to Azure AI Search is the direct knowledge source integration for querying an indexed document corpus in Copilot Studio. Power Platform connectors (A) connect to business applications and data sources, not specifically to AI Search. Copilot connectors for Bing (C) use public web search. Microsoft Fabric data agent (D) is for structured data analytics workloads, not document search.

10. 10. A Copilot Studio developer needs the agent to read and update records in a Salesforce CRM system. The developer wants to use an existing certified connector available in the Power Platform connector catalog. Which approach should be used?

    • A. Build a custom REST API wrapper for Salesforce and call it via a Send HTTP request action
    • B. Add a tool by using an existing custom connector for Salesforce from the Power Platform connector catalog(correct)
    • C. Connect to Microsoft Fabric to proxy Salesforce data
    • D. Configure MCP tools to proxy Salesforce operations

    Explanation: Using an existing custom connector (or a certified connector) from the Power Platform connector catalog is the correct approach for integrating with Salesforce without building custom code. A custom REST wrapper (A) adds unnecessary development effort when a connector already exists. Microsoft Fabric (C) is an analytics platform, not a CRM proxy. MCP tools (D) are a different integration pattern for Model Context Protocol-enabled servers, not for standard SaaS CRM connectors.

11. 11. A company wants its Copilot Studio agent to let users control a web browser autonomously — for example, navigating to an internal web application, filling in a form, and submitting it on the user's behalf. Which Copilot Studio capability enables this?

    • A. Configure and monitor computer use for an agent(correct)
    • B. Configure MCP tools to interact with the web browser via Model Context Protocol
    • C. Add REST APIs to the agent to call the internal web application's backend API
    • D. Configure a Power Automate cloud flow to navigate the browser via UI automation

    Explanation: Computer use in Copilot Studio enables the agent to autonomously interact with a graphical UI — navigating web browsers, filling forms, and clicking elements — without requiring API access to the backend. MCP tools (B) expose server-side context to the model but do not autonomously drive a browser UI. REST APIs (C) require the web application to expose an API, which may not be available for legacy systems. A Power Automate cloud flow (D) can perform UI automation but is a separate service; computer use is the native Copilot Studio capability for this scenario.

12. 12. A developer wants to expose a set of custom tools to a Copilot Studio agent using the Model Context Protocol (MCP), allowing the agent to call external tools registered on an MCP server without custom connector code. Which integration capability should be configured?

    • A. Configure MCP tools in Copilot Studio to register and call tools exposed by an MCP server(correct)
    • B. Add REST APIs to the agent using a Send HTTP request action for each tool
    • C. Connect to Azure AI Search to index the MCP tool definitions
    • D. Configure a Power Platform connector that wraps the MCP server

    Explanation: Configuring MCP tools in Copilot Studio is the native integration point for MCP servers — the agent discovers and calls tools registered on the MCP server using the standardized Model Context Protocol. Individual Send HTTP request actions (B) would require hard-coding each tool call and do not leverage the MCP protocol. Azure AI Search (C) indexes content for retrieval, not tool registration. A Power Platform connector (D) wraps a specific API; MCP is a different, model-native protocol.

13. 13. A developer needs a Copilot Studio agent to call a custom internal REST API that is not available in the Power Platform connector catalog. The API uses standard HTTP methods and JSON payloads. Which approach should be used?

    • A. Add REST APIs to an agent using the Send HTTP request action or by importing an OpenAPI specification(correct)
    • B. Connect to Azure AI Search and index the API documentation for the agent to read
    • C. Configure computer use to navigate to the API's Swagger UI and invoke calls manually
    • D. Configure MCP tools and point the MCP server at the internal REST API

    Explanation: Adding REST APIs to an agent via the Send HTTP request action or by importing an OpenAPI specification is the direct Copilot Studio integration path for custom APIs not in the connector catalog. Indexing API documentation in Azure AI Search (B) makes the API docs searchable, not callable. Computer use (C) can navigate UIs but using it to invoke REST APIs is an inefficient workaround. MCP tools (D) are for Model Context Protocol servers, not arbitrary REST APIs directly.

14. 14. A Copilot Studio developer is designing a multi-agent solution where a primary agent orchestrates sub-tasks by delegating to specialized agents. The solution must also support inter-agent communication using the Agent-to-Agent (A2A) protocol. Which TWO capabilities should be implemented? Choose 2.

    • A. Design multi-agent solutions in Copilot Studio(correct)
    • B. Create a multi-agent solution by using A2A protocol(correct)
    • C. Connect to Copilot connectors to federate agent requests to Bing
    • D. Configure computer use so each sub-agent controls its own browser session
    • E. Deploy all sub-agents to the same topic to reduce inter-agent routing complexity

    Explanation: Designing multi-agent solutions in Copilot Studio (A) establishes the orchestration architecture and routing logic between agents. Implementing the A2A protocol (B) enables standardized inter-agent communication, allowing agents to invoke each other regardless of the underlying platform. Copilot connectors for Bing (C) provide web search, not agent orchestration. Computer use (D) is for UI automation, not inter-agent messaging. Collapsing all sub-agents into one topic (E) defeats the purpose of specialization and does not implement a multi-agent architecture.

15. 15. A Copilot Studio agent needs to answer questions about structured enterprise data stored in Microsoft Fabric — for example, querying sales figures from a lakehouse. Which integration should be configured?

    • A. Integrate a Fabric data agent to enable natural language querying over Fabric data(correct)
    • B. Connect to Azure AI Search and index the Fabric data exports as documents
    • C. Configure a Power Automate flow to export Fabric data to SharePoint nightly
    • D. Add a REST API tool that calls the Fabric REST API for every user query

    Explanation: Integrating a Fabric data agent enables the Copilot Studio agent to query structured data in Microsoft Fabric using natural language, with the Fabric agent handling the semantic-to-query translation. Indexing Fabric exports in Azure AI Search (B) creates a search index over exported snapshots, which introduces staleness and extra pipeline complexity. Exporting to SharePoint nightly (C) creates stale data copies. A custom REST API tool (D) requires mapping every possible natural language query to a specific API call, which is impractical at scale.

16. 16. A developer is integrating a Copilot Studio agent with a Microsoft Foundry agent that handles complex legal document summarization. The Copilot Studio agent receives user questions about legal documents and should delegate the summarization task to the Foundry agent, then return the result. Which integration should be configured?

    • A. Configure generative answers by using Azure AI Search to retrieve documents and summarize inline
    • B. Integrate a Foundry agent into the Copilot Studio multi-agent solution(correct)
    • C. Configure computer use to navigate the Foundry portal and copy the summarization result
    • D. Add a Power Platform connector for the Foundry agent's REST endpoint

    Explanation: Integrating a Foundry agent into the Copilot Studio multi-agent solution is the native way to delegate specialized tasks to a Foundry-hosted agent and return results to the user through Copilot Studio. Using Azure AI Search generative answers (A) retrieves and summarizes document content in-place but does not leverage the specialized Foundry agent. Computer use (C) is a UI automation workaround, not an agent integration pattern. A Power Platform connector (D) can call APIs but bypasses the multi-agent orchestration architecture.

17. 17. A developer is configuring a Copilot Studio agent's generative answers capability to use a custom Azure AI Foundry model from the model catalog instead of the default model. Which configuration should be applied?

    • A. Configure custom prompts to use the Foundry model catalog to select and call the custom model(correct)
    • B. Configure adaptive cards to display the model's output in a formatted card
    • C. Connect to Azure AI Search and set the model endpoint in the index configuration
    • D. Configure MCP tools to proxy requests to the custom Foundry model

    Explanation: Configuring custom prompts to use the Foundry model catalog is the Copilot Studio capability that lets developers point generative answer nodes at a specific model from the Azure AI Foundry model catalog. Adaptive cards (B) render UI output but do not control which model is invoked. Azure AI Search index configuration (C) governs retrieval, not model selection. MCP tools (D) expose external tool capabilities, not model catalog selection.

18. 18. A developer wants to monitor a deployed Copilot Studio agent's conversation telemetry — including session counts, escalation rates, and topic resolution rates — using Azure monitoring tools. Which integration should be configured?

    • A. Monitor agents by using Application Insights(correct)
    • B. Use Azure Monitor VM metrics to track the Copilot Studio infrastructure
    • C. Configure a Power Automate flow to export conversation logs to SharePoint daily
    • D. Enable Azure Sentinel to collect agent conversation events for security analysis

    Explanation: Application Insights integrates with Copilot Studio to collect agent telemetry — conversation traces, session metrics, topic performance, and escalation rates — in a queryable format. Azure Monitor VM metrics (B) track infrastructure-level compute resources, not agent conversation data. A Power Automate export flow (C) creates batch snapshots rather than real-time telemetry. Azure Sentinel (D) is a SIEM tool focused on security event correlation, not agent performance monitoring.

19. 19. A Copilot Studio developer is building an agent topic that must retrieve product pricing from an external API and then present the result as an interactive card that allows the user to select a quantity and confirm an order. Which TWO topic capabilities should be configured? Choose 2.

    • A. Configure advanced agent responses with API and Send HTTP requests to call the pricing API(correct)
    • B. Configure adaptive cards to present the pricing result and collect the user's quantity and confirmation(correct)
    • C. Configure a generative answers node to search the internet for product pricing
    • D. Connect to Azure AI Search to index the external API documentation
    • E. Configure computer use to navigate to the external API's web portal and extract pricing

    Explanation: Configuring a Send HTTP request action (A) retrieves live pricing from the external API. Configuring adaptive cards (B) renders the pricing result as an interactive card that collects the user's quantity input and confirmation. A generative answers node searching the internet (C) returns public web results, not live pricing from the specific API. Indexing API documentation in Azure AI Search (D) does not retrieve live pricing data. Computer use (E) is a UI automation workaround; a direct API call is the correct integration pattern.

20. 20. A Copilot Studio developer wants to systematically evaluate how well the agent handles a variety of user intents — including edge cases and unusual phrasings — before releasing to production. What should the developer create first?

    • A. Create a test set of representative user utterances covering key intents and edge cases(correct)
    • B. Deploy the agent to production and monitor live conversations for failures
    • C. Create a solution and add the agent to it before testing
    • D. Implement Power Platform Pipelines to deploy the agent to a test environment first

    Explanation: Creating a test set of representative utterances is the first step in structured agent evaluation — it defines the inputs against which the agent will be measured. Deploying to production without a test set (B) exposes real users to untested behavior. Creating a solution (C) is part of ALM (lifecycle management), not evaluation preparation. Power Platform Pipelines (D) deploy the agent between environments but do not define evaluation inputs.

21. 21. A developer has created a test set for a Copilot Studio agent. They need to determine whether to use manual human review or an automated AI-assisted evaluation for scoring agent responses. Which activity addresses this decision?

    • A. Review test results from a previous production deployment
    • B. Choose an evaluation method — for example, human review, automated scoring, or AI-assisted evaluation(correct)
    • C. Create a solution to package the agent for deployment
    • D. Configure Application Insights to collect production telemetry

    Explanation: Choosing an evaluation method is the explicit activity in the test lifecycle where the team decides how responses will be scored (human review, automated metrics, or AI-assisted evaluation). Reviewing past production results (A) provides historical data but does not select a methodology for the new test. Creating a solution (C) is an ALM activity. Application Insights (D) collects runtime telemetry, not pre-release evaluation scores.

22. 22. After running an evaluation, a Copilot Studio developer sees that the agent correctly handles 85% of test utterances but fails on 15% — mostly questions about product returns. The test results show these mismatches flagged with low confidence scores. What is the developer's next action?

    • A. Deploy the agent to production immediately since 85% accuracy is acceptable
    • B. Review test results to identify low-confidence areas, then update topics or add training phrases for the return scenarios(correct)
    • C. Delete the failing test cases from the test set to improve the reported score
    • D. Switch the agent to a larger language model to automatically fix the failures

    Explanation: Reviewing test results to identify failure patterns and then improving the agent (adding training phrases, refining topics) is the correct iterative evaluation workflow. Deploying with known failures (A) exposes real users to poor experiences. Deleting failing test cases (C) falsely inflates scores and hides real problems. Switching to a larger model (D) may help with some issues but does not address missing intent coverage or topic gaps identified by the test results.

23. 23. A developer is ready to promote a Copilot Studio agent from a development environment to a UAT (user acceptance testing) environment. The organization uses Microsoft Power Platform. What is the recommended ALM approach?

    • A. Export the agent as an unmanaged solution and import it into the UAT environment manually
    • B. Create a solution, add the agent to it, and implement Microsoft Power Platform Pipelines to deploy across environments(correct)
    • C. Copy the Copilot Studio agent URL and share it with UAT testers
    • D. Create a new agent from scratch in the UAT environment and recreate all topics manually

    Explanation: Creating a solution, adding the agent to it, and using Power Platform Pipelines is the recommended ALM approach — it provides repeatable, version-controlled, and auditable deployments across environments. Manually importing an unmanaged solution (A) works but is less repeatable and not the recommended pipeline-based approach. Sharing the development URL (C) gives UAT testers access to the dev environment, not a separate UAT instance. Recreating the agent manually (D) is error-prone and does not scale.

24. 24. A Copilot Studio developer is packaging an agent for deployment across dev, test, and prod environments using Power Platform ALM. The agent references different SharePoint site URLs in each environment. Which TWO ALM practices should be implemented? Choose 2.

    • A. Create and use environment variables in the solution to store environment-specific SharePoint URLs(correct)
    • B. Implement Power Platform Pipelines to promote the solution across environments automatically(correct)
    • C. Hard-code the production SharePoint URL in the topic and update it manually before each deployment
    • D. Create a separate Copilot Studio agent for each environment with its own topic configurations
    • E. Export the solution as managed from production and import it into dev for testing

    Explanation: Environment variables (A) are the Power Platform ALM mechanism for storing environment-specific values (such as SharePoint URLs) that differ across dev/test/prod without changing the solution's code. Power Platform Pipelines (B) automate the promotion of solutions across environments in a repeatable, auditable way. Hard-coding URLs (C) requires manual changes before every deployment, which is error-prone. Creating separate agents per environment (D) creates divergent codebases that are difficult to maintain. Importing managed solutions from prod to dev (E) reverses the correct flow direction.

25. 25. A team has built a Copilot Studio agent and wants to include it in a managed solution so it can be deployed to downstream environments (test and prod) where it cannot be directly edited by end users. Which solution management step ensures the agent is correctly packaged?

    • A. Add existing agents to a solution as managed components so they are locked from modification in target environments(correct)
    • B. Export the agent as an unmanaged solution so testers can customize it freely in UAT
    • C. Publish the agent directly from the Copilot Studio design canvas to production without using solutions
    • D. Create environment variables in the dev environment only and skip adding them to the solution

    Explanation: Adding the agent to a managed solution ensures it is deployed as a locked, managed component in downstream environments — users cannot directly modify the agent's topics or configuration, ensuring deployment integrity. Exporting as unmanaged (B) allows modification in the target environment, undermining governance. Publishing directly from the canvas (C) bypasses ALM controls entirely. Omitting environment variables from the solution (D) means they will not be promoted with the solution, causing broken references in target environments.