Category: AI

AB-620, Agentic AI, AI, Azure AI, Generative AI, Microsoft Certification July 7, 2026

Configure custom prompts to use the Foundry model catalog (AB-620 Exam Prep)

This post is a part of the AB-620: Designing and Building Integrated AI Agent Solutions in Copilot Studio Exam Prep Hub.
This topic falls under these sections:
Integrate and extend agents in Copilot Studio (40–45%)
   --> Integrate agents with Azure
      --> Configure custom prompts to use the Foundry model catalog

Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Overview

As organizations build increasingly sophisticated AI agents in Microsoft Copilot Studio, they often require more control over which large language models (LLMs) are used and how those models generate responses. While Copilot Studio includes powerful built-in generative AI capabilities, many enterprise scenarios benefit from connecting to models hosted in Azure AI Foundry (formerly Azure AI Studio).

Azure AI Foundry provides access to a large catalog of foundation models from Microsoft, OpenAI, Meta, Mistral AI, Cohere, Hugging Face, and many other providers. These models can be deployed within an Azure subscription and securely consumed by applications and AI agents.

One of the key capabilities covered in the AB-620 exam is configuring custom prompts in Copilot Studio that leverage models deployed through the Azure AI Foundry model catalog. This enables organizations to tailor agent behavior, use specialized models, implement reusable prompts, and satisfy governance requirements while maintaining enterprise security.

What is Azure AI Foundry?

Azure AI Foundry is Microsoft’s unified platform for building, evaluating, deploying, securing, and managing AI solutions.

It provides:

Model catalog
Prompt engineering tools
AI evaluation capabilities
Safety systems
Deployment management
Model monitoring
Responsible AI controls
Agent development tools
Integration with Copilot Studio

Rather than relying only on the default Copilot model, organizations can deploy one or more models within Azure AI Foundry and make them available to enterprise applications.

What is the Foundry Model Catalog?

The Model Catalog is a centralized repository containing hundreds of AI models.

Examples include:

GPT models
Phi models
Llama models
Mistral models
Cohere Command models
DeepSeek models (where available)
Open-source Hugging Face models
Vision models
Embedding models
Speech models
Multimodal models

Each model includes information such as:

Provider
Version
Licensing
Supported tasks
Context window
Token limits
Pricing
Deployment options
Performance benchmarks

Why Use the Model Catalog?

Organizations may choose custom models because they need:

Better reasoning
Lower latency
Lower cost
Longer context windows
Specialized coding abilities
Multilingual support
Vision processing
Image understanding
Document analysis
Industry-specific performance

Instead of using one model for every task, different prompts can target different deployed models.

What Are Custom Prompts?

A custom prompt is a reusable prompt template that defines how an LLM should perform a task.

Rather than asking the model a simple question, a custom prompt provides detailed instructions, context, formatting rules, and constraints.

Example:

Instead of:

Summarize this document.

A custom prompt might specify:

You are a financial analyst. Summarize this quarterly earnings report in less than 300 words. Highlight revenue changes, operating margin, risks, opportunities, and executive guidance. Produce the output as a Markdown table followed by three bullet points.

The additional instructions produce far more consistent outputs.

Benefits of Custom Prompts

Advantages include:

Consistent responses
Reusable instructions
Better formatting
Reduced hallucinations
Improved grounding
Easier maintenance
Centralized governance
Standardized business logic

How Copilot Studio Uses Foundry Models

The high-level workflow is:

Deploy a model in Azure AI Foundry.
Configure the deployment endpoint.
Create or connect Azure AI resources.
Connect Copilot Studio.
Create a custom prompt.
Select the deployed model.
Pass user input into the prompt.
Receive generated output.
Continue the conversation.

The user typically does not know which model produced the response.

Typical Architecture

			
User
↓
Copilot Studio Agent
↓
Custom Prompt
↓
Azure AI Foundry
↓
Selected Model Deployment
↓
Generated Response
↓
Agent Response

		

Components Involved

A complete solution typically includes:

Copilot Studio
Azure AI Foundry
Azure AI Foundry Project
Model deployment
Azure AI Services resource
Authentication
Prompt template
Enterprise data
Optional Azure AI Search

Creating a Model Deployment

Before a prompt can use a model, the model must first be deployed.

Typical steps include:

Browse the Model Catalog.
Select a model.
Review licensing.
Choose deployment type.
Configure capacity.
Deploy the endpoint.
Test the deployment.
Secure the deployment.

The deployment creates an endpoint that applications can call.

Connecting Copilot Studio to Foundry

The connection typically involves:

Azure authentication
Managed identity or service principal
Endpoint configuration
Permissions
Environment configuration

After configuration, Copilot Studio can invoke deployed models as part of prompt execution.

Prompt Design Best Practices

Good prompts generally include:

Role

Tell the model who it is.

Example:

“You are an HR compliance specialist.”

Goal

Describe the objective.

Example:

“Review employee policies.”

Context

Provide supporting information.

Example:

“The organization operates in healthcare.”

Instructions

Explain exactly what should happen.

Example:

“Identify compliance risks.”

Constraints

Limit undesirable behavior.

Example:

Don’t speculate.
Use only supplied information.
Return JSON.

Output Format

Specify the expected structure.

Example:

			
Summary
Risks
Recommendations
Confidence Score

Prompt Variables

Custom prompts commonly accept variables.

Examples include:

User question
Customer name
Product
Ticket number
Region
Language
Conversation history
Retrieved documents

Variables make one prompt reusable for thousands of requests.

Example Prompt

			
Role:
You are an insurance claims specialist.
Task:
Review the submitted claim.
Context:
Use only supplied documents.
Output:
Return:
• Claim summary
• Fraud indicators
• Missing information
• Recommended next steps
Do not invent facts.

		

Choosing the Right Model

Different prompts benefit from different models.

Examples:

Customer support

Low latency
Low cost

Legal analysis

High reasoning ability
Large context window

Coding

Strong code generation

Document summarization

Long context support

Translation

Strong multilingual capabilities

Model Selection Considerations

Factors include:

Cost
Latency
Accuracy
Context length
Availability
Geographic region
Compliance requirements
Safety capabilities
Throughput
Scalability

Responsible AI Considerations

When configuring prompts, organizations should:

Avoid biased instructions.
Protect confidential information.
Minimize unnecessary personal data.
Ground responses in enterprise knowledge.
Validate generated output.
Apply content filtering.
Review prompts regularly.
Monitor model behavior.

Prompt Evaluation

Azure AI Foundry provides tools for evaluating prompts.

Organizations can measure:

Accuracy
Relevance
Faithfulness
Groundedness
Helpfulness
Safety
Toxicity
Hallucination rate
Latency
Cost

Evaluation helps determine whether prompt changes actually improve performance.

Prompt Versioning

As prompts evolve, organizations often maintain multiple versions.

Versioning enables:

Rollback
Testing
Controlled releases
A/B testing
Governance
Documentation
Change tracking

Common Enterprise Scenarios

Organizations frequently use Foundry-backed prompts for:

Customer support
IT help desks
HR assistants
Financial reporting
Contract analysis
Healthcare documentation
Manufacturing troubleshooting
Knowledge management
Compliance reviews
Executive reporting

Best Practices

Keep prompts focused on one objective.
Provide explicit instructions.
Specify output formats.
Use variables instead of hardcoding values.
Ground prompts with enterprise knowledge whenever possible.
Test prompts using multiple scenarios.
Monitor latency and token consumption.
Select the smallest model that satisfies business requirements.
Evaluate prompts continuously.
Version prompts before making production changes.

Common Exam Tips

For the AB-620 exam, remember:

Azure AI Foundry hosts deployed AI models.
The Model Catalog contains many foundation models from multiple providers.
Models must typically be deployed before they can be used.
Custom prompts provide reusable instructions for LLM interactions.
Prompt variables enable reuse across many conversations.
Azure AI Search can be combined with Foundry models for grounded responses.
Prompt evaluation measures quality and safety.
Responsible AI practices remain essential when using custom prompts.
Different prompts may use different deployed models.
Prompt engineering significantly affects response quality.

10 Practice Exam Questions

Question 1

An organization wants multiple Copilot Studio agents to use the same standardized instructions when summarizing financial reports. What is the best solution?

A. Create a custom prompt that all agents can reuse.

B. Rewrite the instructions in every topic.

C. Store the instructions inside Adaptive Cards.

D. Add the instructions to every user question.

Answer: A

Explanation: A reusable custom prompt centralizes instructions, promotes consistency, and simplifies maintenance across multiple agents.

Question 2

Which Azure AI Foundry component provides access to available foundation models?

A. AI Hub

B. Model Catalog

C. Prompt Flow

D. Azure Monitor

Answer: B

Explanation: The Model Catalog is the repository for browsing, evaluating, and selecting supported foundation models before deployment.

Question 3

A prompt instructs a model to answer only using retrieved enterprise documentation. What primary benefit does this provide?

A. Faster model deployment

B. Reduced token usage

C. Better grounding and fewer hallucinations

D. Automatic translation

Answer: C

Explanation: Restricting responses to trusted enterprise content improves factual accuracy and reduces unsupported or fabricated responses.

Question 4

Before a Copilot Studio agent can use a model from Azure AI Foundry, what must typically occur?

A. The model must be exported to Dataverse.

B. A Power Automate flow must be created.

C. A custom connector must be installed.

D. The selected model must be deployed.

Answer: D

Explanation: Models in the catalog are not directly consumable until they have been deployed to an endpoint.

Question 5

Which prompt component tells the model how it should behave?

A. Context

B. Output format

C. Role

D. Variables

Answer: C

Explanation: The role establishes the model’s persona or expertise, such as “You are a financial analyst.”

Question 6

Why should prompt variables be used instead of hard-coded values?

A. They improve model licensing.

B. They allow prompts to be reused for different inputs.

C. They reduce Azure subscription costs.

D. They eliminate authentication requirements.

Answer: B

Explanation: Variables enable a single prompt template to process many different user requests without modification.

Question 7

An organization compares several prompts for accuracy, groundedness, latency, and safety before production deployment. Which Azure AI Foundry capability are they using?

A. Deployment scaling

B. Resource monitoring

C. Model catalog browsing

D. Prompt evaluation

Answer: D

Explanation: Prompt evaluation measures prompt quality using metrics such as accuracy, groundedness, safety, and response quality.

Question 8

Which consideration is MOST important when selecting a model for a custom prompt?

A. The icon displayed in the model catalog

B. The browser used by administrators

C. The business requirements, including latency, cost, and reasoning capability

D. The number of Copilot Studio topics

Answer: C

Explanation: Model selection should align with workload requirements, balancing performance, cost, context length, and reasoning ability.

Question 9

A prompt specifies that output must always be returned as JSON with predefined fields. What prompt design principle is being applied?

A. Context injection

B. Output formatting

C. Authentication

D. Content indexing

Answer: B

Explanation: Explicitly defining the output structure increases consistency and simplifies downstream processing.

Question 10

Why should organizations maintain multiple versions of important production prompts?

A. To increase model context length

B. To reduce Azure subscription costs

C. To enable rollback, testing, governance, and controlled deployment of prompt changes

D. To eliminate authentication requirements

Answer: C

Explanation: Prompt versioning supports change management, testing, auditing, rollback, and safer deployment of updates without disrupting production agents.

Go to the AB-620 Exam Prep Hub main page

AB-620, AI, Azure AI, Generative AI, Microsoft Certification July 7, 2026

Configure generative answers by using Azure AI Search with Foundry (AB-620 Exam Prep)

This post is a part of the AB-620: Designing and Building Integrated AI Agent Solutions in Copilot Studio Exam Prep Hub.
This topic falls under these sections:
Integrate and extend agents in Copilot Studio (40–45%)
   --> Integrate agents with Azure
      --> Configure generative answers by using Azure AI Search with Foundry

Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Overview

One of the most powerful capabilities in Microsoft Copilot Studio is the ability to generate grounded, AI-powered responses using enterprise knowledge instead of relying solely on predefined topics. By integrating Azure AI Search with Azure AI Foundry, organizations can build intelligent agents that retrieve relevant information from enterprise content and use large language models (LLMs) to generate accurate, contextual responses.

For the AB-620: Designing and Building Integrated AI Agent Solutions in Copilot Studio exam, you should understand how Azure AI Search, Azure AI Foundry, and Copilot Studio work together to provide Retrieval-Augmented Generation (RAG) experiences.

Learning Objectives

After studying this topic, you should be able to:

Explain how Azure AI Search integrates with Copilot Studio.
Understand the role of Azure AI Foundry in generative AI solutions.
Configure generative answers using Azure AI Search indexes.
Understand Retrieval-Augmented Generation (RAG).
Configure enterprise knowledge grounding.
Understand indexing, chunking, embeddings, and vector search.
Apply security and governance best practices.
Troubleshoot common configuration issues.

What is Azure AI Foundry?

Azure AI Foundry is Microsoft’s unified platform for building, evaluating, deploying, and managing AI applications and agents.

It provides developers with tools to:

Build AI applications
Manage AI models
Connect enterprise knowledge
Evaluate AI responses
Deploy production AI solutions
Monitor model performance

When integrated with Copilot Studio, Azure AI Foundry supplies the AI models and orchestration capabilities that generate responses based on retrieved enterprise knowledge.

What is Azure AI Search?

Azure AI Search is Microsoft’s enterprise search platform.

Its responsibilities include:

Indexing enterprise content
Creating searchable knowledge repositories
Supporting keyword search
Supporting semantic search
Supporting vector search
Ranking relevant documents
Returning content used for grounding AI responses

Rather than generating answers from model training alone, Copilot retrieves relevant documents through Azure AI Search before asking the LLM to formulate an answer.

Understanding Retrieval-Augmented Generation (RAG)

This topic heavily emphasizes Retrieval-Augmented Generation (RAG).

Instead of relying entirely on the LLM’s pretrained knowledge:

User asks a question.
Azure AI Search searches indexed enterprise content.
Relevant passages are retrieved.
Retrieved content is passed to the LLM in Azure AI Foundry.
The LLM generates a grounded response using that retrieved information.

Benefits include:

More accurate responses
Reduced hallucinations
Current enterprise information
Permission-aware answers
Citations and traceability (when configured)

High-Level Architecture

			
User
   │
   ▼
Copilot Studio
   │
   ▼
Azure AI Search
(Search Index)
   │
   ▼
Relevant Documents
   │
   ▼
Azure AI Foundry
(LLM)
   │
   ▼
Grounded Response
   │
   ▼
User

		

Components of the Solution

1. Enterprise Data Sources

Examples include:

SharePoint Online
OneDrive
Azure Blob Storage
SQL databases
Microsoft Fabric
PDF documents
Microsoft Teams files
Websites
Knowledge bases

2. Data Connectors

Connectors import content into Azure AI Search.

They support:

Scheduled indexing
Incremental updates
Metadata extraction
Content synchronization

3. Azure AI Search Index

The search index stores:

Text content
Metadata
Searchable fields
Filterable fields
Vector embeddings
Semantic configurations

Indexes are optimized for rapid retrieval.

4. Embeddings

Before semantic search can occur, documents are converted into numerical vectors called embeddings.

Embeddings allow the system to:

Compare meaning instead of exact wording
Find similar concepts
Improve retrieval accuracy
Support multilingual search

Example:

Question:

“How much vacation do employees receive?”

The document may say:

“Annual leave entitlement is 20 days.”

Keyword search may miss this.

Embedding search understands that both discuss vacation policies.

5. Chunking

Large documents are automatically divided into smaller sections.

Chunking improves:

Retrieval precision
Context quality
Token efficiency
Response accuracy

Poor chunk sizes often produce poor RAG performance.

6. Semantic Search

Semantic ranking considers:

Meaning
Intent
Context
Related concepts

Rather than matching words alone.

7. Vector Search

Vector search compares embedding similarity.

Advantages:

Better natural language understanding
Improved document matching
Better enterprise Q&A performance

Many enterprise deployments combine:

Keyword search
Semantic search
Vector search

Configuring Generative Answers

Typical configuration steps include:

Step 1

Create an Azure AI Search service.

Step 2

Create a search index.

Step 3

Import enterprise data.

Step 4

Configure indexing schedules.

Step 5

Enable semantic ranking.

Step 6

Configure vector search (if supported).

Step 7

Connect Azure AI Search to Azure AI Foundry.

Step 8

Connect the Foundry project to Copilot Studio.

Step 9

Enable Generative Answers.

Step 10

Test grounded responses.

Knowledge Grounding

Grounding ensures responses originate from approved enterprise information rather than model memory.

Grounding helps:

Improve accuracy
Reduce hallucinations
Maintain compliance
Support trustworthy AI

Security Considerations

Authentication typically uses:

Microsoft Entra ID
Managed identities
Role-based access control (RBAC)

Authorization should ensure:

Only authorized documents are searchable.
Sensitive data is protected.
User permissions are respected.

Monitoring

Administrators should monitor:

Search latency
Retrieval accuracy
Query success rates
Failed searches
Index freshness
Hallucination frequency
User feedback
Token consumption

Common Design Best Practices

Build high-quality indexes

Avoid indexing:

Duplicate content
Obsolete files
Incomplete documentation

Keep indexes current

Use incremental indexing.

Avoid stale enterprise knowledge.

Optimize chunk size

Too small:

Missing context

Too large:

Lower retrieval precision

Enable semantic ranking

Semantic ranking typically improves enterprise Q&A accuracy.

Use vector search

Vector search improves:

Similarity matching
Natural language understanding
Complex enterprise queries

Apply least-privilege security

Grant only the permissions required.

Validate responses

Test with:

Ambiguous questions
Synonyms
Long documents
Missing data
Permission-restricted users

Common Exam Scenarios

You should know when:

Azure AI Search should be used instead of static Topics.
Enterprise knowledge requires semantic search.
Vector search improves retrieval.
Azure AI Foundry generates responses after retrieval.
RAG is preferable to relying solely on an LLM.
Grounding reduces hallucinations.
Search indexes require re-indexing after significant data changes.
Semantic models and enterprise permissions affect response quality.

Exam Tips

Azure AI Search retrieves information—it does not generate responses.
Azure AI Foundry hosts and orchestrates AI models that generate responses.
Copilot Studio coordinates the conversation and calls Azure services.
RAG combines retrieval with generation to improve answer quality.
Embeddings power vector search.
Chunking directly affects retrieval accuracy.
Semantic search improves relevance beyond keyword matching.
Grounded responses are generally preferred over responses based solely on pretrained model knowledge.

Practice Exam Questions

Question 1

A company wants its Copilot Studio agent to answer employee policy questions using current HR documents instead of relying solely on the LLM’s pretrained knowledge. Which architecture should they implement?

A. Static Topics only

B. Retrieval-Augmented Generation using Azure AI Search and Azure AI Foundry

C. Power Automate flows only

D. Adaptive Cards with variables only

Correct Answer: B

Explanation: RAG retrieves relevant enterprise documents through Azure AI Search and passes them to Azure AI Foundry, allowing the LLM to generate grounded responses based on current organizational content.

Question 2

What is Azure AI Search primarily responsible for in a Copilot Studio generative answers solution?

A. Hosting large language models

B. Training AI models

C. Retrieving relevant enterprise content from indexed data

D. Managing Copilot Studio topics

Correct Answer: C

Explanation: Azure AI Search indexes and retrieves relevant enterprise content. It does not host or train language models.

Question 3

What is the primary purpose of document chunking during indexing?

A. Compress documents for storage

B. Improve retrieval accuracy by dividing large documents into manageable sections

C. Encrypt enterprise documents

D. Eliminate duplicate records

Correct Answer: B

Explanation: Chunking divides large documents into smaller, context-rich segments, enabling more precise retrieval during RAG.

Question 4

Which Azure service generates the natural language response after Azure AI Search retrieves relevant content?

A. Azure AI Foundry

B. Azure Blob Storage

C. Azure Monitor

D. Azure Key Vault

Correct Answer: A

Explanation: Azure AI Foundry provides access to large language models that synthesize retrieved content into conversational responses.

Question 5

Which technology enables Azure AI Search to retrieve documents based on semantic similarity rather than exact keyword matches?

A. Managed identities

B. RBAC

C. Vector embeddings

D. Power Automate

Correct Answer: C

Explanation: Vector embeddings represent document meaning numerically, enabling semantic similarity searches.

Question 6

Why is grounding considered an important capability in generative AI solutions?

A. It increases token limits.

B. It improves model training speed.

C. It ensures responses are based on trusted enterprise knowledge.

D. It replaces semantic search.

Correct Answer: C

Explanation: Grounding reduces hallucinations by anchoring AI responses to retrieved organizational content.

Question 7

An organization updates its policy documents every night. What is the best way to ensure the Copilot agent uses the latest information?

A. Retrain the language model nightly.

B. Configure scheduled or incremental indexing in Azure AI Search.

C. Restart Copilot Studio every morning.

D. Recreate the search index daily.

Correct Answer: B

Explanation: Scheduled or incremental indexing updates the search index efficiently without requiring complete re-creation or model retraining.

Question 8

Which component is responsible for coordinating the conversation and invoking Azure AI Search and Azure AI Foundry?

A. Azure Monitor

B. Azure AI Search

C. Azure AI Foundry

D. Copilot Studio

Correct Answer: D

Explanation: Copilot Studio orchestrates the conversational flow, calling Azure AI Search for retrieval and Azure AI Foundry for response generation.

Question 9

Which statement best describes vector search?

A. It searches only document titles.

B. It compares numerical representations of meaning rather than exact words.

C. It retrieves only structured database records.

D. It replaces semantic ranking entirely.

Correct Answer: B

Explanation: Vector search uses embeddings to compare semantic similarity, allowing retrieval of conceptually related content even when wording differs.

Question 10

A developer notices that the agent frequently provides incomplete answers because relevant information is split across large documents. Which improvement is most appropriate?

A. Disable semantic search.

B. Increase the model temperature.

C. Optimize document chunk sizes during indexing.

D. Replace Azure AI Search with keyword search only.

Correct Answer: C

Explanation: Appropriate chunk sizing improves retrieval quality by ensuring each indexed segment contains enough context while remaining focused, leading to more complete and accurate grounded responses.

Go to the AB-620 Exam Prep Hub main page

AB-620, Agentic AI, AI, Microsoft Certification July 7, 2026

Create a multi-agent solution by using A2A protocol (AB-620 Exam Prep)

This post is a part of the AB-620: Designing and Building Integrated AI Agent Solutions in Copilot Studio Exam Prep Hub.
This topic falls under these sections:
Integrate and extend agents in Copilot Studio (40–45%)
   --> Configure multi-agent collaboration from Copilot Studio
      --> Create a multi-agent solution by using A2A protocol

Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Overview

The Agent-to-Agent (A2A) protocol in Microsoft Copilot Studio enables multiple AI agents to communicate, delegate tasks, and collaborate across systems in a standardized way. Instead of one monolithic agent handling all responsibilities, A2A allows you to design specialized agents that exchange structured messages and coordinate outcomes.

In the AB-620 exam context, this topic focuses on:

Designing distributed agent systems
Configuring cross-agent communication
Defining task delegation patterns
Managing orchestration between agents

What the A2A Protocol Is

The A2A protocol is a communication framework that allows agents to:

Send structured requests to other agents
Receive responses in a standardized format
Delegate tasks dynamically at runtime
Collaborate across environments or platforms

It supports interoperability between Copilot Studio agents and external agent systems, making it foundational for multi-agent architectures.

Core Principles of A2A

1. Agent Specialization

Each agent is designed for a specific role, such as:

HR policy assistant
Finance reporting agent
IT service desk agent
Customer support triage agent

2. Message-Based Communication

Agents communicate using:

Structured requests
JSON-based payloads
Defined schemas for input/output

3. Loose Coupling

Agents do not need to know internal implementation details of other agents.

4. Orchestration Flexibility

A coordinator or “primary agent” may:

Route requests
Aggregate responses
Handle fallback scenarios

A2A Architecture in Copilot Studio

A typical A2A solution includes:

1. Primary (Orchestrator) Agent

Receives user input
Determines which agent should handle the task
Aggregates results

2. Worker Agents

Perform specialized tasks
Return structured outputs

3. Communication Layer (A2A Protocol)

Handles message formatting
Ensures compatibility across agents

How A2A Works (Flow)

User submits request to primary agent
Primary agent evaluates intent
Task is delegated via A2A protocol
Worker agent processes request
Response is returned to orchestrator
Final response is assembled and sent to user

When to Use A2A in Copilot Studio

A2A is ideal when:

Multiple business domains are involved
Tasks require specialized expertise
Workloads must be distributed
Systems need modular AI design

Configuration Steps (Conceptual for Exam)

Step 1: Define Agent Roles

Identify each agent’s responsibility
Avoid overlapping domains

Step 2: Enable A2A Communication

Register agents in Copilot Studio environment
Enable cross-agent communication permissions

Step 3: Define Message Schema

Include:

Task type
Input parameters
Expected output format

Step 4: Configure Routing Logic

Use rules or generative orchestration
Map intents to agents

Step 5: Test Multi-Agent Flow

Validate request delegation
Ensure correct response aggregation

Key Design Patterns

1. Hub-and-Spoke Model

One central orchestrator
Multiple specialized agents

2. Chain-of-Agents Pattern

Output of one agent becomes input to another

3. Parallel Execution Pattern

Multiple agents process simultaneously
Results merged afterward

Best Practices

1. Keep Agents Focused

Avoid creating “do everything” agents.

2. Standardize Payloads

Use consistent schemas for:

Requests
Responses
Error handling

3. Implement Fallback Logic

If an agent fails:

Retry
Route to backup agent
Return partial results

4. Monitor Inter-Agent Traffic

Track:

Latency between agents
Failure rates
Task distribution efficiency

5. Avoid Over-Orchestration

Too many routing layers can:

Increase latency
Reduce maintainability

Common Use Cases

Enterprise IT + HR + Finance agent ecosystems
Customer service triage systems
Multi-department workflow automation
Cross-platform enterprise assistants
Industry-specific AI agent networks

Practice Exam Questions

1. What is the primary purpose of the A2A protocol in Copilot Studio?

A. To replace Power Automate flows entirely
B. To enable structured communication between multiple agents
C. To store conversation history in Dataverse
D. To train large language models

Correct Answer: B

Explanation: A2A is designed to enable standardized communication between agents in a multi-agent system.

2. Which architecture best describes a typical A2A solution?

A. Single monolithic agent
B. Event-driven serverless function only
C. Hub-and-spoke multi-agent system
D. Static chatbot tree

Correct Answer: C

Explanation: A2A commonly uses a central orchestrator with multiple specialized agents.

3. What is a key benefit of using A2A in Copilot Studio?

A. Eliminates need for authentication
B. Enables distributed agent specialization
C. Removes dependency on semantic models
D. Prevents all external integrations

Correct Answer: B

Explanation: A2A allows agents to specialize and collaborate rather than handling all tasks in one system.

4. In an A2A flow, what typically happens first?

A. Worker agent returns response
B. User directly contacts worker agent
C. Orchestrator agent interprets the user request
D. Data is written to a database

Correct Answer: C

Explanation: The orchestrator agent receives and analyzes the user request before delegation.

5. What format is commonly used for A2A message exchange?

A. Binary executable files
B. JSON-based structured payloads
C. Excel spreadsheets
D. Plain text emails

Correct Answer: B

Explanation: A2A communication typically uses structured JSON payloads for interoperability.

6. Which scenario is BEST suited for A2A implementation?

A. A single FAQ chatbot
B. A simple form submission bot
C. A multi-department enterprise assistant system
D. A static website FAQ page

Correct Answer: C

Explanation: A2A is ideal for distributed, multi-domain enterprise scenarios.

7. What is a worker agent responsible for in an A2A system?

A. Orchestrating all other agents
B. Training language models
C. Performing specialized tasks and returning results
D. Managing user authentication

Correct Answer: C

Explanation: Worker agents execute specific tasks delegated by the orchestrator.

8. What is a risk of overusing orchestration layers in A2A design?

A. Improved performance
B. Reduced system complexity
C. Increased latency and maintenance overhead
D. Elimination of errors

Correct Answer: C

Explanation: Too many orchestration layers can slow down and complicate the system.

9. Which pattern involves multiple agents processing tasks simultaneously?

A. Chain-of-agents pattern
B. Parallel execution pattern
C. Linear scripting pattern
D. Singleton agent pattern

Correct Answer: B

Explanation: Parallel execution allows multiple agents to process tasks at the same time.

10. What is a best practice when designing A2A message schemas?

A. Allow free-form unstructured text only
B. Avoid defining response formats
C. Standardize input and output payload structures
D. Let each agent define its own format

Correct Answer: C

Explanation: Standardization ensures interoperability and reduces integration issues.

Go to the AB-620 Exam Prep Hub main page

AB-620, Agentic AI, AI, Microsoft Certification July 7, 2026

Integrate a Fabric data agent (AB-620 Exam Prep)

This post is a part of the AB-620: Designing and Building Integrated AI Agent Solutions in Copilot Studio Exam Prep Hub.
This topic falls under these sections:
Integrate and extend agents in Copilot Studio (40–45%)
   --> Configure multi-agent collaboration from Copilot Studio
      --> Integrate a Fabric data agent

Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Overview

A Fabric data agent is used to enable an AI agent in Copilot Studio to interact with enterprise data stored in Microsoft Fabric. This includes semantic models, lakehouses, warehouses, and other Fabric-based data assets. The integration allows users to ask natural language questions and receive grounded, governed responses based on curated datasets.

In AB-620, this topic focuses on how Copilot Studio agents connect to Fabric data sources, how queries are interpreted, and how data governance and security are enforced during retrieval.

Core Concept: What a Fabric Data Agent Does

A Fabric data agent acts as a semantic layer bridge between:

Copilot Studio agents (natural language interface)
Microsoft Fabric data assets (structured analytics layer)

It enables:

Natural language querying over Fabric datasets
Retrieval of governed business metrics
Consistent answers aligned with semantic models
Reduced need for direct query writing (SQL/DAX)

Key Capabilities

When integrating a Fabric data agent, you should understand these capabilities:

1. Natural Language to Semantic Query Translation

The agent converts user prompts into structured queries against:

Power BI semantic models
Fabric warehouses
Lakehouse tables

2. Semantic Model Awareness

The agent respects:

Measures
Relationships
Calculated columns
Business definitions (KPIs)

3. Governance and Security Enforcement

Access is controlled through:

Microsoft Entra ID authentication
Role-Level Security (RLS)
Object-level permissions in Fabric/Power BI

4. Contextual Answer Generation

Responses are:

Grounded in Fabric data only
Filtered based on user permissions
Summarized for conversational output

Prerequisites for Integration

Before integrating a Fabric data agent, ensure:

A Microsoft Fabric workspace is configured
A semantic model exists (Power BI dataset or Fabric model)
Data is properly modeled (relationships, measures defined)
Users have access permissions (Viewer or higher depending on scenario)
Copilot Studio environment is enabled for enterprise data integration

How Integration Works (Conceptual Flow)

The integration process follows this flow:

User asks a question in Copilot Studio
Agent identifies intent as a data query
Request is routed to Fabric data agent
Fabric semantic model is queried
Results are returned in structured form
Copilot Studio formats response into conversational output

Configuration Steps (High-Level)

While exact UI steps may evolve, the exam expects conceptual understanding:

Step 1: Enable Fabric Data Source Connection

Select Microsoft Fabric as a data source
Choose a semantic model or dataset

Step 2: Register the Data Agent

Link Fabric workspace to Copilot Studio agent
Define which datasets are available for querying

Step 3: Define Query Scope

Limit accessible tables/measures
Control supported business domains

Step 4: Configure Security Context

Enforce Entra ID authentication
Apply RLS roles automatically

Step 5: Test Natural Language Queries

Validate question-to-answer mapping
Ensure correct aggregation and filtering

Best Practices

1. Use Well-Modeled Semantic Layers

A Fabric data agent performs best when:

Measures are clearly defined
Relationships are accurate
Naming conventions are business-friendly

2. Avoid Direct Raw Table Exposure

Instead:

Use curated semantic models
Hide unnecessary technical columns

3. Optimize for Business Language

Rename fields such as:

“SalesAmt” → “Total Sales”
“CustCnt” → “Customer Count”

4. Validate Security Boundaries

Ensure:

RLS behaves correctly
Sensitive data is excluded from responses

5. Limit Dataset Scope

Smaller, focused models improve:

Query accuracy
Response time
AI interpretation quality

Common Use Cases

Sales performance dashboards via chat
Financial reporting queries (revenue, cost, profit)
Operational metrics (inventory, supply chain)
Executive summary generation from Fabric data
Self-service analytics for business users

Practice Exam Questions

1. A company wants Copilot Studio agents to answer questions using metrics stored in a Fabric warehouse. What is required first?

A. Enable Power Automate flows for all queries
B. Create a semantic model over the warehouse data
C. Export data to Azure SQL Database
D. Enable Azure AI Search indexing

Correct Answer: B

Explanation: A Fabric data agent relies on semantic models to interpret business metrics and relationships. Without a semantic layer, natural language queries cannot be correctly mapped.

2. What is the primary role of a Fabric data agent in Copilot Studio?

A. Execute REST API calls to external systems
B. Translate natural language into semantic model queries
C. Train large language models on enterprise data
D. Replace Power BI dashboards entirely

Correct Answer: B

Explanation: The Fabric data agent acts as a bridge between natural language input and structured queries against Fabric semantic models.

3. Which security mechanism ensures users only see data they are allowed to access?

A. Azure API Management policies
B. Row-Level Security (RLS) in Fabric
C. Copilot Studio topic restrictions
D. Dataflow Gen2 filters

Correct Answer: B

Explanation: RLS in Fabric enforces row-level restrictions based on user identity.

4. What type of data source is primarily used by Fabric data agents?

A. Unstructured PDF documents
B. REST APIs only
C. Semantic models in Microsoft Fabric
D. Local Excel files uploaded manually

Correct Answer: C

Explanation: Fabric data agents are designed to work with structured semantic models.

5. Why is a semantic model important for Fabric data agent integration?

A. It enables AI model training
B. It provides business definitions and relationships
C. It replaces the need for authentication
D. It stores raw unprocessed logs

Correct Answer: B

Explanation: Semantic models define relationships, measures, and business logic used for query interpretation.

6. A user asks a question that requires filtering sales by region. What does the Fabric data agent use to answer correctly?

A. Hardcoded filters in Copilot Studio topics
B. Semantic model relationships and measures
C. Power Automate approval flows
D. Azure Logic Apps workflows

Correct Answer: B

Explanation: Filtering logic is derived from the semantic model structure.

7. What is a recommended best practice when preparing data for a Fabric data agent?

A. Use raw unmodeled tables for flexibility
B. Expose all columns to maximize coverage
C. Use business-friendly naming in semantic models
D. Disable relationships between tables

Correct Answer: C

Explanation: Clear naming improves AI interpretation and response quality.

8. How does Copilot Studio ensure secure access to Fabric data?

A. By duplicating datasets into Copilot Studio
B. By bypassing Entra ID for faster access
C. By enforcing authentication and inherited Fabric permissions
D. By caching all data in memory

Correct Answer: C

Explanation: Access is controlled through Entra ID and inherited Fabric permissions.

9. What happens when a user query exceeds the scope of the connected Fabric dataset?

A. The agent guesses an answer
B. The request is forwarded to REST APIs
C. The agent responds that data is unavailable or out of scope
D. The system automatically creates a new dataset

Correct Answer: C

Explanation: The agent can only respond based on connected and governed data sources.

10. Which scenario best demonstrates use of a Fabric data agent?

A. Sending emails based on workflow triggers
B. Querying sales performance using natural language
C. Uploading files to SharePoint
D. Creating PowerPoint slides automatically

Correct Answer: B

Explanation: Fabric data agents are designed for conversational analytics over structured enterprise data.

Go to the AB-620 Exam Prep Hub main page

AB-620, Agentic AI, AI, Microsoft Certification July 7, 2026

Integrate an existing agent in Copilot Studio (AB-620 Exam Prep)

This post is a part of the AB-620: Designing and Building Integrated AI Agent Solutions in Copilot Studio Exam Prep Hub.
This topic falls under these sections:
Integrate and extend agents in Copilot Studio (40–45%)
   --> Configure multi-agent collaboration from Copilot Studio
      --> Integrate an existing agent in Copilot Studio

Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Introduction

As AI solutions become more sophisticated, organizations rarely rely on a single intelligent agent to perform every task. Instead, they build ecosystems of specialized agents that collaborate to complete user requests. Rather than recreating functionality, Microsoft Copilot Studio enables makers to integrate existing agents into new solutions, allowing organizations to reuse previously developed capabilities.

An existing agent is an AI agent that has already been created, configured, and tested. Instead of duplicating its logic, another Copilot Studio agent can delegate work to it when specialized knowledge or functionality is required.

For the AB-620 exam, you should understand:

Why organizations integrate existing agents
The different multi-agent architectures
When to reuse an existing agent
Connected agents versus child agents
Delegation strategies
Security considerations
Enterprise design patterns
Best practices for scalable agent collaboration

Why Integrate Existing Agents?

Many organizations already have AI agents that perform specialized business functions.

Examples include:

HR assistant
IT Help Desk agent
Benefits agent
Finance assistant
Procurement assistant
Legal advisor
Customer support bot
Inventory assistant
Sales assistant
Compliance advisor

Instead of creating one enormous agent that performs every task, Copilot Studio enables these specialized agents to work together.

Benefits include:

Reduced development time
Reuse of existing investments
Easier maintenance
Better scalability
Improved governance
Independent lifecycle management
Clear ownership between departments

What Is Multi-Agent Collaboration?

Multi-agent collaboration allows multiple intelligent agents to cooperate to fulfill a user’s request.

Rather than performing every task itself, one agent delegates work to another agent with specialized capabilities.

Example:

			
User:
"I need to schedule a vacation and verify my remaining PTO."
↓
Employee Agent
↓
Delegates PTO calculation
↓
HR Agent
↓
Returns remaining balance
↓
Employee Agent
↓
Schedules vacation request

		

The user experiences a seamless conversation, even though multiple agents participated.

Why Reuse Existing Agents?

Creating a new agent every time is inefficient.

Instead, organizations reuse agents that already provide:

validated business logic
tested prompts
secured integrations
approved knowledge sources
governance policies
compliance controls

This reduces duplication while improving consistency.

Common Enterprise Scenarios

Human Resources

Existing HR Agent

Handles:

leave requests
benefits
payroll
employee policies

Corporate Assistant

Handles:

general employee questions
company news
navigation

Delegates HR-related requests to the HR agent.

IT Support

Corporate Assistant

Handles:

FAQs
onboarding
software requests

IT Agent

Handles:

password reset
device management
troubleshooting
incident lookup

Healthcare

Patient Agent

Handles:

appointments
scheduling
billing

Clinical Agent

Handles:

medical summaries
treatment guidance
clinical knowledge

Banking

Customer Service Agent

Handles:

balances
transfers
FAQs

Investment Agent

Handles:

portfolio analysis
market recommendations
retirement planning

Types of Agent Integration

Several integration patterns exist.

Connected Agents

A connected agent operates as an independent AI agent.

Characteristics:

independently managed
separate lifecycle
separate owner
reusable
can serve multiple parent agents

Best for:

enterprise-wide services
shared business capabilities
departmental AI

Child Agents

Child agents are invoked by another agent to perform specific work.

Characteristics:

specialized
reusable
task-oriented
invisible to users

Examples:

tax calculator
recommendation engine
shipping estimator
language translator

External AI Agents

Organizations may integrate:

Azure AI Foundry agents
external AI services
partner AI systems

Copilot Studio orchestrates communication while external agents perform advanced reasoning.

Choosing the Right Integration Pattern

Scenario	Recommended Approach
Shared HR knowledge	Connected agent
Specialized calculations	Child agent
Advanced AI reasoning	Foundry agent
Department-owned solution	Connected agent
Small reusable task	Child agent

Agent Orchestration

Copilot Studio often serves as the orchestration layer.

Responsibilities include:

managing conversations
determining user intent
collecting required information
selecting the appropriate agent
coordinating responses
presenting final answers

The delegated agent focuses only on the assigned task.

Delegation Workflow

A typical workflow looks like this:

			
User
↓
Primary Copilot Studio Agent
↓
Determine Intent
↓
Need Specialist?
↓
Yes
↓
Delegate
↓
Existing Agent
↓
Process Request
↓
Return Result
↓
Primary Agent
↓
Respond to User

		

Benefits of Delegation

Delegation enables:

modular AI architecture
reuse
scalability
specialization
simplified maintenance
independent updates
reduced development costs

Each agent performs only the work it is designed to perform.

Designing Specialized Agents

Good agent design follows the principle of specialization.

Instead of:

Mega Agent

that performs everything,

create:

			
Customer Agent
HR Agent
Finance Agent
Legal Agent
IT Agent
Operations Agent

		

Each agent develops expertise in its domain.

Avoiding Monolithic Agents

Large all-in-one agents often suffer from:

excessive prompts
difficult maintenance
poor scalability
slower responses
conflicting instructions
increased hallucinations

Smaller specialized agents generally produce more predictable behavior.

Routing User Requests

The primary agent determines:

What is the user’s intent?
Can I answer directly?
Should another agent answer?
Which agent has the required expertise?

Examples:

User Request	Delegated Agent
Reset password	IT Agent
Benefits question	HR Agent
Vendor payment	Finance Agent
Legal contract	Legal Agent
Product inventory	Inventory Agent

Agent Ownership

Large organizations often assign ownership to departments.

Example:

Department	Agent Owner
HR	HR Team
IT	Infrastructure Team
Finance	Finance Department
Legal	Legal Department
Sales	Sales Operations

This decentralized ownership allows independent maintenance while supporting enterprise-wide collaboration.

Authentication Considerations

Integrated agents should communicate securely.

Authentication may involve:

Microsoft Entra ID
Managed identities
OAuth
API keys (when appropriate)
Service principals

Authentication should always follow organizational security policies.

Authorization

Authentication verifies identity.

Authorization determines what an agent is allowed to access.

Examples include:

HR records
payroll information
financial systems
customer databases
confidential documents

Delegated agents should only receive the permissions required to perform their tasks.

Context Sharing

When delegating requests, Copilot Studio shares only the context necessary for the delegated agent.

Examples of shared context:

user request
conversation variables
customer ID
department
case number
selected product

Avoid transmitting unnecessary information to reduce token usage and minimize exposure of sensitive data.

Best Practices

When integrating existing agents:

Reuse existing business capabilities whenever practical.
Keep agents focused on specific domains.
Use Copilot Studio as the orchestration layer.
Delegate only when specialized functionality is required.
Secure all communication between agents.
Minimize duplicated functionality.
Share only the context required for task completion.
Monitor agent performance and delegation frequency.
Design for independent updates and lifecycle management.
Document agent responsibilities clearly.

Key Exam Takeaways

For the AB-620 exam, remember these core concepts:

Existing agents enable organizations to reuse previously developed AI capabilities.
Copilot Studio commonly acts as the orchestrator in multi-agent solutions.
Connected agents are independently managed and reusable across solutions.
Child agents perform focused tasks on behalf of another agent.
Delegation improves scalability, maintainability, and modularity.
Authentication and authorization remain critical when integrating agents.
Agent specialization is preferred over monolithic, all-in-one designs.

Advanced Integration Patterns

As organizations mature their AI strategy, they often move beyond simple one-to-one delegation and adopt more sophisticated collaboration models. Copilot Studio supports orchestrating multiple specialized agents to create scalable, maintainable enterprise AI solutions.

Hub-and-Spoke Architecture

In this model, a primary Copilot Studio agent acts as the central orchestrator.

                 HR Agent
                     │
Finance Agent ──► Corporate Assistant ◄── IT Agent
                     │
               Legal Agent
                     │
             Inventory Agent

Advantages:

Centralized user experience
Simplified routing logic
Independent agent ownership
Easy addition of new agents
Consistent governance

Typical enterprise use:

Employee portals
Enterprise help desks
Customer service hubs

Layered Agent Architecture

Some solutions use multiple levels of delegation.

			
User
   │
Primary Agent
   │
Operations Agent
   │
Inventory Agent
   │
Warehouse Agent

		

This approach supports very complex business processes while allowing each agent to remain focused on a narrow domain.

Domain-Based Agent Design

A common enterprise strategy is to organize agents around business domains rather than technical systems.

Examples include:

Business Domain	Specialized Agent
Human Resources	HR Agent
Finance	Finance Agent
Customer Service	Customer Support Agent
Legal	Legal Agent
Manufacturing	Operations Agent
Sales	Sales Agent
Procurement	Purchasing Agent

Benefits include:

Clear ownership
Easier governance
Better scalability
Independent release cycles

Agent Discovery

As organizations create dozens of agents, discovering the appropriate one becomes increasingly important.

Selection may be based on:

User intent
Department
Business process
Required expertise
User permissions
Conversation context

Well-designed orchestration ensures requests are routed to the most appropriate agent.

Governance Considerations

Enterprise AI requires governance throughout the agent lifecycle.

Governance includes:

Naming standards
Version control
Ownership
Documentation
Security reviews
Approval processes
Retirement planning

Organizations should maintain an inventory of available agents and their responsibilities.

Version Management

Existing agents evolve over time.

Considerations include:

Backward compatibility
API changes
Updated prompts
New tools
Modified knowledge sources
New capabilities

When integrating an existing agent, verify that updates do not introduce breaking changes for dependent solutions.

Monitoring Multi-Agent Solutions

Monitoring helps ensure reliable operation.

Important metrics include:

Conversation Metrics

Conversation completion rate
Successful delegations
Failed delegations
User satisfaction
Escalation frequency

Performance Metrics

Response time
Delegation latency
API execution time
Tool execution duration
Token consumption

Operational Metrics

Authentication failures
Authorization failures
Service availability
Agent utilization
Error rates

These metrics help identify performance bottlenecks and reliability issues.

Troubleshooting Agent Integrations

Common issues include:

Incorrect Agent Selection

Symptoms:

Requests routed to the wrong agent
Incorrect answers
User frustration

Resolution:

Improve intent recognition
Refine routing logic
Clarify agent responsibilities

Authentication Failures

Symptoms:

Access denied
Unauthorized responses
Connection errors

Resolution:

Verify credentials
Review authentication configuration
Confirm permissions

Missing Context

Symptoms:

Incomplete responses
Incorrect recommendations
Missing user information

Resolution:

Pass the required conversation variables
Validate data mappings
Ensure necessary context is shared

Circular Delegation

Example:

			
Agent A
   ↓
Agent B
   ↓
Agent A

		

This creates unnecessary processing and can result in loops.

Avoid circular dependencies by clearly defining agent responsibilities.

Performance Optimization

To improve efficiency:

Delegate only when necessary.
Reduce prompt size.
Pass only relevant context.
Avoid duplicate processing.
Minimize unnecessary API calls.
Reuse specialized agents.
Cache frequently requested information when appropriate.
Monitor response latency.

Efficient designs reduce operational costs and improve user experience.

Security Best Practices

When integrating existing agents:

Use Microsoft Entra ID where appropriate.
Apply least-privilege access.
Protect secrets using secure credential storage.
Encrypt communications.
Validate user identity before delegation.
Audit delegated actions.
Restrict access to sensitive knowledge sources.

Security should remain consistent across every participating agent.

Common Design Mistakes

Avoid these frequent errors:

❌ Creating duplicate agents with identical responsibilities

❌ Sending excessive conversation history

❌ Delegating every request

❌ Ignoring security boundaries

❌ Allowing overlapping ownership

❌ Building one massive all-purpose agent

❌ Failing to monitor delegated conversations

❌ Not documenting integration points

Enterprise Example

A global organization deploys a Corporate Assistant.

Employee asks:

“How many vacation days do I have left, and can I book next Friday off?”

Workflow:

Corporate Assistant identifies an HR-related request.
It delegates the request to the existing HR Agent.
The HR Agent retrieves PTO data.
The HR Agent validates available leave.
The HR Agent submits the leave request.
The HR Agent returns the result.
The Corporate Assistant presents a user-friendly response.

The employee interacts with a single conversational interface while multiple specialized agents collaborate behind the scenes.

AB-620 Exam Tips

Expect scenario-based questions covering:

Choosing between connected and child agents
Designing scalable multi-agent architectures
Determining when to reuse existing agents
Selecting an orchestration strategy
Securing communication between agents
Monitoring delegated operations
Avoiding duplicated functionality
Improving maintainability through specialization

Remember these principles:

Copilot Studio commonly acts as the orchestration layer.
Existing agents should be reused whenever appropriate.
Keep agents specialized and modular.
Delegate only when another agent offers distinct expertise.
Share only the minimum context required.
Secure all integrations.
Monitor performance continuously.
Avoid monolithic designs.

Practice Exam Questions

Question 1

A company has separate HR, Finance, and IT agents that already perform their respective business functions. A Corporate Assistant should provide a single conversational interface while delegating specialized requests.

Which design best meets this requirement?

A. Create one new agent that duplicates every department’s functionality.

B. Replace all departmental agents with the Corporate Assistant.

C. Configure the Corporate Assistant as the orchestration layer that delegates requests to existing specialized agents.

D. Require users to manually choose which agent to contact before each request.

Answer: C

Explanation: Copilot Studio is commonly used as the orchestration layer, allowing existing specialized agents to perform domain-specific work while presenting users with one unified conversational experience.

Question 2

Which characteristic best describes a connected agent?

A. It is independently managed and reusable across multiple solutions.

B. It only performs mathematical calculations.

C. It can never communicate with another agent.

D. It always replaces the parent agent.

Answer: A

Explanation: Connected agents are autonomous, independently managed agents that can be reused by multiple Copilot Studio solutions.

Question 3

Why should organizations reuse existing agents whenever practical?

A. To increase prompt size.

B. To reduce duplication and leverage previously tested business capabilities.

C. To eliminate authentication requirements.

D. To prevent delegation.

Answer: B

Explanation: Reusing existing agents minimizes development effort while taking advantage of validated logic, integrations, governance, and security.

Question 4

Which practice best improves the performance of delegated conversations?

A. Send every conversation message ever exchanged.

B. Delegate every user request regardless of complexity.

C. Allow multiple agents to answer the same question simultaneously.

D. Share only the context required for the delegated task.

Answer: D

Explanation: Passing only relevant context reduces latency, token consumption, and unnecessary processing.

Question 5

An organization notices that Agent A frequently delegates requests to Agent B, which immediately delegates them back to Agent A.

What architectural issue exists?

A. Token expiration

B. Circular delegation

C. Prompt grounding

D. Adaptive Card failure

Answer: B

Explanation: Circular delegation creates unnecessary processing loops and should be avoided through clearly defined agent responsibilities.

Question 6

Which metric is most useful for identifying inefficient delegation?

A. Browser version

B. Screen resolution

C. Delegation frequency

D. Keyboard layout

Answer: C

Explanation: High delegation frequency can indicate routing inefficiencies or excessive reliance on secondary agents.

Question 7

A Finance department independently maintains its own AI agent while allowing multiple enterprise assistants to reuse it.

Which integration model is most appropriate?

A. Connected agent

B. Child agent

C. Adaptive Card

D. Variable node

Answer: A

Explanation: Connected agents are independently managed and designed for reuse across multiple parent solutions.

Question 8

Which security principle should guide permissions assigned to integrated agents?

A. Full administrative access

B. Anonymous access

C. Shared global credentials

D. Least privilege

Answer: D

Explanation: Agents should receive only the permissions necessary to complete their assigned tasks, reducing security risks.

Question 9

Which architecture is generally considered more scalable for large enterprises?

A. One massive agent responsible for every business function

B. Multiple specialized agents coordinated by an orchestration agent

C. Separate agents that never communicate

D. Duplicate agents performing identical work

Answer: B

Explanation: Specialized agents coordinated by Copilot Studio provide better scalability, maintainability, and governance than monolithic designs.

Question 10

A solution architect wants each business department to update its own AI capabilities without affecting other departments.

Which design recommendation best supports this goal?

A. Merge every capability into one shared prompt.

B. Build identical copies of every agent.

C. Store every business process inside one orchestration agent.

D. Assign ownership of specialized agents to their respective departments while using Copilot Studio to coordinate requests.

Answer: D

Explanation: Department-owned specialized agents allow independent development and maintenance while Copilot Studio orchestrates the overall user experience. This modular approach aligns with Microsoft best practices for enterprise-scale multi-agent solutions.

Go to the AB-620 Exam Prep Hub main page

AB-620, Agentic AI, AI, Microsoft Certification July 7, 2026

Integrate a Foundry agent (AB-620 Exam Prep)

This post is a part of the AB-620: Designing and Building Integrated AI Agent Solutions in Copilot Studio Exam Prep Hub.
This topic falls under these sections:
Integrate and extend agents in Copilot Studio (40–45%)
   --> Configure multi-agent collaboration from Copilot Studio
      --> Integrate a Foundry agent

Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Designing Effective Copilot Studio and Foundry Agent Collaboration

Successfully integrating a Foundry agent involves more than simply connecting two systems. The overall architecture should ensure that every agent performs the tasks it is best suited for while minimizing complexity, latency, and maintenance.

A useful design principle is:

Copilot Studio manages conversations.
Foundry agents perform specialized AI reasoning.
External systems execute business operations.
Enterprise knowledge grounds responses.
Humans intervene when required.

This separation creates modular, scalable AI solutions.

Example Enterprise Architecture

			
User
   │
   ▼
Copilot Studio Agent
   │
   ├──────── Answers simple questions
   │
   ├──────── Retrieves enterprise knowledge
   │
   ├──────── Executes Power Platform actions
   │
   └──────── Delegates specialized request
                │
                ▼
         Azure AI Foundry Agent
                │
        Performs advanced reasoning
                │
      Returns structured response
                │
                ▼
       Copilot Studio formats answer
                │
                ▼
              User

		

Enterprise Scenario 1: Insurance

Copilot Studio Responsibilities

Authenticate customer
Collect claim number
Answer policy questions
Present Adaptive Cards
Handle conversation

Foundry Agent Responsibilities

Analyze claim history
Compare policy coverage
Estimate fraud risk
Recommend claim disposition
Explain confidence level

Enterprise Scenario 2: Healthcare

Copilot Studio

Schedule appointments
Retrieve patient information
Route conversations
Gather symptoms

Foundry Agent

Analyze symptoms
Summarize medical history
Recommend possible care pathways
Produce clinical summaries

Human clinicians remain responsible for final diagnoses and treatment decisions.

Enterprise Scenario 3: Financial Services

Copilot Studio

Customer authentication
Account balance
Transaction history
FAQ responses

Foundry Agent

Investment analysis
Portfolio optimization
Financial forecasting
Risk calculations
Personalized recommendations

Enterprise Scenario 4: Manufacturing

Copilot Studio

Equipment lookup
Maintenance scheduling
Work order creation

Foundry Agent

Predict equipment failure
Analyze sensor readings
Estimate remaining useful life
Recommend preventive maintenance

Enterprise Scenario 5: IT Help Desk

Copilot Studio

Password reset
Ticket creation
Software requests
Device registration

Foundry Agent

Root cause analysis
Log analysis
Security investigation
Configuration recommendations
Incident summaries

Handling Long-Running Tasks

Some AI operations require considerable time.

Examples include:

Processing thousands of documents
Complex planning
Image analysis
Code generation
Large knowledge searches

Instead of making users wait:

Accept the request.
Launch asynchronous processing.
Notify the user.
Continue other conversation tasks.
Deliver results when processing completes.

This improves user experience.

Conversation Continuity

The Copilot Studio agent should maintain:

conversation state
user identity
permissions
variables
previous messages
business context

The Foundry agent should receive only the information necessary to perform its task.

Avoid sending unnecessary conversation history.

Error Handling Strategy

Robust integrations anticipate failures.

Examples include:

Timeout

“I’m still processing your request. Please wait a moment.”

Authentication failure

“I couldn’t access the requested service.”

Permission denied

“You don’t have permission to perform that operation.”

Model unavailable

“I’m temporarily unable to complete that analysis.”

Partial failure

“I completed part of your request. Some information couldn’t be retrieved.”

Security Considerations

Important exam objectives include:

Authentication

Secure access between:

Copilot Studio
Foundry
APIs
enterprise systems

Authorization

Ensure agents only access resources users are permitted to use.

Least Privilege

Grant only the permissions required.

Never over-provision credentials.

Secrets Management

Store:

API keys
tokens
certificates
passwords

using secure secret stores rather than embedding them in prompts or topics.

Data Privacy

Avoid transmitting:

personally identifiable information (PII)
protected health information (PHI)
financial information

unless required and properly secured.

Performance Optimization

Reduce latency by:

minimizing unnecessary agent delegation
caching frequent results
limiting prompt size
reducing unnecessary context
using appropriate models
avoiding duplicate API calls

Monitoring Integrated Agents

Monitor:

delegation frequency
latency
failed requests
token consumption
model costs
API failures
user satisfaction
conversation completion rate

Monitoring identifies opportunities for optimization.

Common Design Mistakes

Avoid:

❌ Using Foundry for every conversation

❌ Passing excessive conversation history

❌ Ignoring security

❌ Creating circular agent delegation

❌ Returning unstructured responses

❌ Forgetting error handling

❌ Choosing overly complex architectures

❌ Sending confidential information unnecessarily

Best Practices for the AB-620 Exam

Remember these key principles:

✓ Copilot Studio is typically the conversational orchestrator.

✓ Foundry agents provide advanced AI reasoning and specialized capabilities.

✓ Delegate only when additional AI capability is required.

✓ Secure all communication between systems.

✓ Use enterprise authentication.

✓ Monitor performance and costs.

✓ Design modular architectures.

✓ Keep prompts focused.

✓ Minimize unnecessary context.

✓ Handle failures gracefully.

Exam Tips

Expect scenario questions asking:

Which agent should perform a task?
When should delegation occur?
Which architecture is most scalable?
How should security be implemented?
Which integration minimizes latency?
Which design minimizes cost?
How should failures be handled?

Choose answers emphasizing modularity, orchestration, security, scalability, and maintainability.

Practice Exam Questions

Question 1

A company wants a conversational agent that answers HR policy questions but delegates complex benefits eligibility calculations to a specialized AI model.

Which architecture is most appropriate?

A. Use the Foundry agent for every user interaction.

B. Use Copilot Studio for conversations and delegate complex calculations to the Foundry agent.

C. Replace Copilot Studio with the Foundry agent.

D. Perform all calculations manually.

Answer: B

Explanation: Copilot Studio manages the conversation while the Foundry agent performs specialized reasoning only when needed.

Question 2

An integrated agent should avoid sending unnecessary conversation history to a Foundry agent because it primarily:

A. Improves readability only.

B. Eliminates authentication.

C. Reduces latency, cost, and token usage.

D. Prevents Adaptive Cards from rendering.

Answer: C

Explanation: Smaller prompts reduce processing time, token consumption, and cost while improving efficiency.

Question 3

Which responsibility most commonly belongs to Copilot Studio rather than a Foundry agent?

A. Multi-step reasoning

B. Predictive analytics

C. Scientific calculations

D. Managing user conversations

Answer: D

Explanation: Copilot Studio is designed to orchestrate conversations, while Foundry agents handle specialized AI tasks.

Question 4

An organization wants an AI solution that can continue operating even if a specialized AI service is temporarily unavailable.

What should be included?

A. Circular delegation

B. Larger prompts

C. Error handling and fallback responses

D. Multiple conversation histories

Answer: C

Explanation: Proper fallback handling improves resilience and user experience during outages.

Question 5

Which design follows the principle of least privilege?

A. Grant every agent Global Administrator permissions.

B. Share one service account across all environments.

C. Store API keys inside prompts.

D. Give each integration only the permissions required.

Answer: D

Explanation: Least privilege minimizes security risks by limiting access to only what is necessary.

Question 6

Which scenario is the best candidate for delegation to a Foundry agent?

A. Greeting the user

B. Displaying a welcome message

C. Performing advanced financial risk analysis

D. Asking for the user’s name

Answer: C

Explanation: Complex reasoning tasks benefit from specialized Foundry agents, while conversational tasks remain in Copilot Studio.

Question 7

A user asks a question requiring several minutes of AI processing.

What is the recommended approach?

A. Keep the user waiting without feedback.

B. Cancel the request.

C. Return random placeholder information.

D. Start asynchronous processing and notify the user.

Answer: D

Explanation: Long-running operations should be handled asynchronously to improve the user experience.

Question 8

Which metric best helps identify excessive delegation between agents?

A. Font size

B. Delegation frequency

C. Screen resolution

D. Browser version

Answer: B

Explanation: High delegation frequency may indicate inefficient architecture and increased latency.

Question 9

Why should Copilot Studio remain the orchestration layer in many enterprise solutions?

A. It replaces enterprise authentication.

B. It eliminates external APIs.

C. It coordinates conversations, tools, and specialized agents.

D. It performs all advanced reasoning internally.

Answer: C

Explanation: Copilot Studio is designed to orchestrate conversations and determine when specialized agents should be invoked.

Question 10

Which practice best supports scalable multi-agent solutions?

A. Combine every capability into one massive agent.

B. Duplicate prompts across multiple agents.

C. Delegate every request regardless of complexity.

D. Separate conversational, reasoning, and business operation responsibilities.

Answer: D

Explanation: Modular architectures improve scalability, maintainability, testing, and future expansion while reducing unnecessary complexity.

Go to the AB-620 Exam Prep Hub main page

AB-620, Agentic AI, AI, Microsoft Certification July 7, 2026

Design multi-agent solutions in Microsoft Copilot Studio (AB-620 Exam Prep)

This post is a part of the AB-620: Designing and Building Integrated AI Agent Solutions in Copilot Studio Exam Prep Hub.
This topic falls under these sections:
Integrate and extend agents in Copilot Studio (40–45%)
   --> Configure multi-agent collaboration from Copilot Studio
      --> Design multi-agent solutions in Copilot Studio

Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Learning Objectives

After completing this article, you should be able to:

Understand what a multi-agent solution is.
Explain why organizations use multiple AI agents.
Identify the major components of a multi-agent architecture.
Differentiate between parent agents, child agents, and connected agents.
Design effective agent responsibilities.
Select appropriate routing and orchestration strategies.
Apply Microsoft-recommended design principles for enterprise AI solutions.

Introduction

As organizations adopt AI across multiple business functions, a single AI agent often becomes insufficient for handling every task. Large enterprises require AI systems capable of managing specialized workloads, integrating with diverse systems, and scaling independently.

Microsoft Copilot Studio addresses this challenge by enabling developers to create multi-agent solutions, where multiple specialized agents collaborate to solve complex business problems.

Rather than building one large, monolithic agent responsible for every interaction, developers can create multiple focused agents that communicate and cooperate while maintaining clear responsibilities.

This modular approach improves scalability, maintainability, security, and user experience.

What Is a Multi-Agent Solution?

A multi-agent solution consists of two or more AI agents working together toward a shared objective.

Each agent specializes in a particular domain or capability.

Example:

Instead of one agent handling everything, an organization creates:

HR Agent
IT Help Desk Agent
Finance Agent
Facilities Agent
Sales Agent
Customer Service Agent

Each agent focuses on its own area of expertise.

When necessary, agents collaborate to complete broader workflows.

Why Use Multiple Agents?

Multi-agent systems provide several advantages over a single large agent.

Benefits include:

Better Specialization

Each agent becomes an expert in a limited business domain.

Example:

Rather than one agent answering every possible company question,

Create:

Benefits Agent
Payroll Agent
Recruiting Agent

Each delivers more accurate responses.

Easier Maintenance

Updating one specialized agent is easier than modifying a massive all-purpose agent.

Benefits include:

fewer unintended side effects
simpler testing
faster deployments
independent versioning

Improved Scalability

Different agents can scale independently.

For example:

Customer Support Agent

thousands of daily requests

Finance Approval Agent

dozens of daily requests

Each can be optimized separately.

Better Security

Different agents can have different permissions.

Example:

Payroll Agent

Access:

salary information
tax records

Sales Agent

Access:

CRM data

The Sales Agent never needs payroll permissions.

Improved Reliability

If one specialized agent becomes unavailable,

Other agents continue operating.

This improves overall system resilience.

Multi-Agent Terminology

Understanding Microsoft’s terminology is essential for the AB-620 exam.

Term	Description
Agent	An AI assistant designed for a specific purpose
Parent Agent	Coordinates other agents
Child Agent	Performs delegated work
Connected Agent	Independent agent available for collaboration
Tool	Capability an agent can invoke
Topic	Conversation workflow
Knowledge Source	Information available to an agent
Context	Information shared during conversations
Delegation	Passing work to another agent
Orchestration	Coordinating multiple agents

Core Components of a Multi-Agent Solution

Most enterprise architectures include several components.

User

Starts the conversation.

↓

Parent Agent

Receives the request.

↓

Decision Logic

Determines which specialized agent should handle the task.

↓

Specialized Agent

Executes the requested task.

↓

External Systems

Databases
APIs
Microsoft 365
Power Platform
Azure AI Search
ERP systems
CRM systems

↓

Response Returned

Results flow back through the parent agent to the user.

Designing Specialized Agents

One of Microsoft’s primary recommendations is:

Design agents around business capabilities—not technologies.

Poor design:

One “Super Agent”

Responsibilities:

HR
Finance
Sales
IT
Marketing
Legal
Procurement

Problems:

difficult to maintain
confusing prompts
unnecessary permissions
reduced accuracy

Better design:

HR Agent

Handles:

benefits
vacation
onboarding

Finance Agent

Handles:

invoices
budgets
expense reports

IT Agent

Handles:

password resets
devices
software
support tickets

Each agent remains focused.

Agent Responsibilities

Every agent should have clearly defined responsibilities.

Good responsibilities are:

specific
measurable
independent
reusable

Example

Travel Agent

Responsibilities:

✓ Book flights

✓ Reserve hotels

✓ Check travel policies

Not responsible for:

✗ Payroll

✗ IT tickets

✗ Customer support

Designing Agent Boundaries

One common exam objective is identifying proper agent boundaries.

Ask:

What business capability owns this task?

Not:

Which department requested it?

Example

Employee requests:

“I need a laptop.”

Poor routing:

HR Agent

Better routing:

IT Agent

Reason:

Hardware provisioning belongs to IT.

Parent Agents

The parent agent serves as the coordinator.

Responsibilities include:

understanding requests
selecting child agents
maintaining conversation flow
combining responses
returning final answers

Think of the parent agent as a project manager.

Child Agents

Child agents perform specialized work delegated by the parent agent.

Examples include:

Benefits Agent

Inventory Agent

Legal Agent

Facilities Agent

Payroll Agent

Each performs work without needing knowledge of the broader conversation.

Connected Agents

Connected agents differ slightly from child agents.

Connected agents are:

independently published
reusable
discoverable
callable by other agents

This promotes reuse across multiple solutions.

Example

Company has:

Expense Agent

Multiple departments can connect to it:

HR
Sales
Finance
Operations

Rather than creating duplicate expense logic.

Choosing Between Child and Connected Agents

Child Agent	Connected Agent
Used within one solution	Reusable across solutions
Parent controls lifecycle	Independent lifecycle
Tight integration	Looser integration
Typically internal	Enterprise-wide reuse

Orchestration

Orchestration is the process of coordinating multiple agents.

The parent agent determines:

who performs work
when work begins
what data is shared
how results are combined

Without orchestration:

Agents work independently.

With orchestration:

Agents collaborate toward one goal.

Collaboration Patterns

Several collaboration models are common.

Sequential Collaboration

Agent A

↓

Agent B

↓

Agent C

Example

Travel request

↓

Policy Agent

↓

Booking Agent

↓

Approval Agent

Parallel Collaboration

Multiple agents execute simultaneously.

          Parent
        /    |    \
      HR   IT   Finance
        \    |    /
         Combined Response

Advantages:

faster responses
independent execution

Hub-and-Spoke

Most common in Copilot Studio.

           Parent
        /   |   |   \
      HR   IT Finance Legal

Benefits:

centralized coordination
simple routing
easy governance

Mesh Collaboration

Agents communicate directly.

			
Agent A ↔ Agent B
 ↕          ↕
Agent C ↔ Agent D

More flexible

More complex

Less common than hub-and-spoke in enterprise Copilot Studio solutions.

Routing Strategies

One of the parent agent’s primary responsibilities is routing requests.

Examples include:

Intent-Based Routing

Determine user intent.

Example:

“I forgot my password.”

↓

IT Agent

Keyword Routing

Specific words trigger agents.

“Payroll”

↓

Payroll Agent

Simple but less flexible than intent recognition.

Rule-Based Routing

Business rules determine routing.

Example:

If request concerns invoices

↓

Finance Agent

Else

↓

Customer Service Agent

AI-Based Routing

The LLM evaluates the request and selects the most appropriate agent based on semantic understanding.

Benefits:

greater flexibility
better handling of ambiguous language
improved user experience

AI-based routing is increasingly preferred for enterprise conversational systems.

Enterprise Example

A user asks:

“I’m traveling to Seattle next week. Can you book my hotel, verify my travel policy, and submit the request for approval?”

Possible orchestration flow:

Parent Agent receives the request.
Policy Agent verifies travel rules.
Booking Agent searches for available hotels.
Approval Agent creates an approval request.
Parent Agent consolidates the results.
User receives a single, coherent response.

This illustrates how multiple specialized agents collaborate to complete a complex workflow while each remains focused on its own domain.

Best Practices

Design agents around business capabilities rather than departments.
Keep each agent focused on a well-defined responsibility.
Minimize overlapping responsibilities between agents.
Use parent agents to coordinate complex workflows.
Reuse connected agents whenever practical.
Prefer AI-based routing for complex conversational experiences.
Apply the principle of least privilege so each agent has only the permissions it requires.
Plan for scalability by allowing agents to evolve independently.

Common Design Mistakes

Avoid these common pitfalls:

Creating one “super agent” responsible for every task.
Giving multiple agents overlapping responsibilities.
Granting excessive permissions to specialized agents.
Routing requests solely by keywords when semantic routing is more appropriate.
Tightly coupling agents that should be reusable.
Failing to define clear ownership for business capabilities.

AB-620 Exam Tips

For the exam, remember these key concepts:

A multi-agent solution consists of multiple specialized agents working together.
Parent agents coordinate conversations and delegate work.
Child agents perform specialized tasks within a solution.
Connected agents are independently published and reusable across multiple solutions.
Orchestration manages how agents collaborate to fulfill user requests.
Design agents around business capabilities, not organizational departments.
Use AI-based routing when requests are complex or ambiguous.
Keep agents modular, secure, maintainable, and independently scalable.

Advanced Multi-Agent Design Patterns

Once you understand the fundamentals of multi-agent solutions, the next step is learning how to design enterprise-grade architectures. Microsoft expects AI Agent Builders to select appropriate collaboration patterns based on business requirements rather than attempting to solve every problem with a single architecture.

Pattern 1 – Hub-and-Spoke (Recommended)

This is the most common architecture used in Copilot Studio.

                  User
                   │
            Parent Agent
      ┌────────┼────────┐
      │        │        │
   HR Agent IT Agent Finance Agent
      │        │        │
      └────────┼────────┘
          Consolidated Response

Advantages

Centralized orchestration
Easy governance
Simplified security
Easy monitoring
Scalable
Easy to troubleshoot

Typical Uses

Enterprise copilots
Employee self-service
Customer support
IT service desks

Pattern 2 – Sequential Workflow

Each agent performs one step before passing work to the next.

Example

			
User
↓
Travel Agent
↓
Policy Agent
↓
Approval Agent
↓
Booking Agent
↓
User

		

Best for

Approval workflows
Procurement
Employee onboarding
Case management

Pattern 3 – Parallel Processing

Several agents work simultaneously.

               Parent Agent
             /      |      \
         Sales   Inventory  Shipping
             \      |      /
          Combined Response

Benefits

Faster responses
Independent processing
Better user experience

Pattern 4 – Federated Agent Architecture

Different business units own their own agents.

Example

Sales Department

↓

Owns Sales Agent

Finance Department

↓

Owns Finance Agent

HR Department

↓

Owns HR Agent

A parent agent coordinates requests without requiring centralized ownership of every specialized agent.

Agent Communication Lifecycle

Most multi-agent conversations follow this sequence:

Step 1

User submits request.

↓

Step 2

Parent agent interprets intent.

↓

Step 3

Appropriate specialized agent is selected.

↓

Step 4

Context is transferred.

↓

Step 5

Specialized agent completes work.

↓

Step 6

Result returns to parent.

↓

Step 7

Parent formats final response.

Context Sharing

Context refers to the information needed for another agent to complete work.

Examples include:

User identity
Previous conversation
Variables
Business data
Parameters
Selected products
Order numbers

Good context sharing reduces duplicate questions and improves user experience.

Example

Without context:

Parent Agent:

“What order number?”

↓

Inventory Agent:

“What order number?”

↓

Shipping Agent:

“What order number?”

Poor experience.

Better

Parent collects:

Order #14567

Passes it automatically to downstream agents.

State Management

State represents information preserved during a conversation.

Examples include:

Customer ID
Shopping cart
Selected location
Previous answers
Authentication status

Good state management allows conversations to continue naturally.

Example

User:

“I’d like to change my reservation.”

Five minutes later:

“Can you move it to next Tuesday?”

The agent remembers the reservation discussed earlier.

Stateless vs. Stateful Design

Stateless	Stateful
No memory between requests	Maintains conversation context
Simple implementation	More personalized interactions
Highly scalable	Supports complex workflows
Good for APIs	Good for conversational agents

Copilot Studio frequently combines both approaches depending on the scenario.

Security Considerations

Every agent should follow the principle of least privilege.

Example

Benefits Agent

Access

✓ Benefits database

✗ Payroll database

✗ Financial records

Finance Agent

Access

✓ Expense reports

✓ Budgets

✗ HR records

This reduces risk and improves compliance.

Authentication

Each specialized agent may authenticate independently.

Possible methods include:

Microsoft Entra ID
OAuth 2.0
Managed identities
API Keys (when appropriate)

The parent agent should not automatically inherit unrestricted access to every connected system.

Performance Considerations

Large organizations may operate dozens or even hundreds of specialized agents.

Performance can be improved by:

Running independent agents in parallel
Caching frequently accessed information
Reusing connected agents
Avoiding unnecessary delegations
Limiting context passed between agents
Reducing repeated API calls

Scalability

A good architecture should support future growth.

Instead of:

			
Parent
↓
One giant agent

Use:

			
Parent
↓
HR
Finance
Sales
Legal
IT
Marketing
Facilities
Travel
Procurement

		

New business capabilities can be added without redesigning the entire solution.

Monitoring Multi-Agent Solutions

Enterprise deployments should monitor:

Conversation success rate
Agent selection accuracy
API failures
Response times
Authentication failures
Delegation failures
User satisfaction
Tool execution success
Token usage
Error frequency

Monitoring enables continuous improvement and faster troubleshooting.

Troubleshooting Collaboration Issues

Common issues include:

Incorrect Routing

Symptoms

Wrong agent selected
Irrelevant responses

Solution

Improve routing logic or intent recognition.

Missing Context

Symptoms

Users repeatedly answer the same questions.

Solution

Share required variables between agents.

Permission Errors

Symptoms

Agent cannot access required resources.

Solution

Review security roles and connector permissions.

Delegation Loops

Symptoms

Agent A

↓

Agent B

↓

Agent A

↓

Agent B

Avoid circular delegation by defining clear ownership and termination conditions.

Slow Performance

Causes

Too many API calls
Excessive context transfer
Sequential execution when parallel processing is possible

Single-Agent vs. Multi-Agent Architecture

Single Agent	Multi-Agent
Simple implementation	More flexible
Limited specialization	Highly specialized
Harder to scale	Scales independently
Large prompt	Smaller focused prompts
One security model	Granular permissions
Lower maintenance flexibility	Independent lifecycle management
Good for small solutions	Best for enterprise solutions

Real-World Enterprise Scenario 1

A global manufacturing company deploys:

HR Agent
Payroll Agent
IT Agent
Procurement Agent
Maintenance Agent

The Enterprise Copilot receives:

“Order a replacement laptop for my new employee.”

Possible workflow:

Parent Agent identifies onboarding request.
HR Agent confirms employee status.
Procurement Agent verifies available hardware.
IT Agent creates deployment ticket.
Parent Agent summarizes results.

No single specialized agent performs every task.

Real-World Enterprise Scenario 2

Customer asks:

“My shipment is late and I’d like a refund.”

Workflow:

Parent Agent

↓

Order Agent

↓

Shipping Agent

↓

Finance Agent

↓

Customer Support Agent

↓

Response returned

Each agent performs one specialized responsibility.

Design Decision Matrix

Requirement	Recommended Design
Simple FAQ bot	Single agent
Enterprise employee assistant	Multi-agent hub-and-spoke
Department specialization	Connected agents
Approval workflows	Sequential orchestration
Independent business units	Federated architecture
Large enterprise platform	Parent with reusable connected agents

Summary

For the AB-620 exam, remember these key points:

Multi-agent solutions improve scalability, maintainability, and specialization.
Parent agents orchestrate work across specialized agents.
Child agents perform delegated tasks within a solution.
Connected agents are reusable across multiple solutions.
Effective context sharing minimizes repeated user input.
State management enables natural, continuous conversations.
Security should follow the principle of least privilege.
Parallel execution can improve performance.
Monitoring and troubleshooting are essential for production deployments.
Select an architecture that aligns with business requirements rather than forcing a single design pattern.

Practice Exam Questions

Question 1

A company wants a Copilot solution where HR, Finance, and IT each maintain their own specialized agents while a single enterprise assistant coordinates user requests. Which architecture is most appropriate?

A. Hub-and-spoke multi-agent architecture

B. Single-agent architecture

C. Stateless REST API architecture

D. Batch processing architecture

Answer: A

Explanation: A hub-and-spoke architecture uses a parent agent to coordinate specialized agents, making it ideal for enterprise scenarios where multiple business domains are involved.

Question 2

What is the primary responsibility of a parent agent in a multi-agent solution?

A. Store all enterprise data

B. Replace every specialized agent

C. Orchestrate conversations and delegate work

D. Authenticate every external API directly

Answer: C

Explanation: The parent agent coordinates conversations, selects the appropriate specialized agent, manages context, and returns a unified response.

Question 3

Which design principle helps reduce unnecessary security risks in multi-agent solutions?

A. Shared administrator permissions

B. Principle of least privilege

C. Universal read/write access

D. Anonymous authentication

Answer: B

Explanation: Granting each agent only the permissions it requires minimizes the attack surface and aligns with Microsoft’s security recommendations.

Question 4

A company wants multiple departments to reuse the same Expense Approval agent without duplicating its logic. Which type of agent is most appropriate?

A. Parent agent

B. Temporary agent

C. Stateless agent

D. Connected agent

Answer: D

Explanation: Connected agents are independently published and reusable across multiple solutions or departments.

Question 5

Why is context sharing important between collaborating agents?

A. It encrypts API traffic automatically.

B. It eliminates authentication requirements.

C. It prevents users from repeatedly providing the same information.

D. It replaces business rules.

Answer: C

Explanation: Sharing relevant context improves efficiency and provides a smoother conversational experience.

Question 6

Which collaboration pattern is generally the best choice when several independent tasks can be completed simultaneously?

A. Parallel processing

B. Sequential workflow

C. Single-agent routing

D. Manual delegation

Answer: A

Explanation: Parallel processing reduces overall response time by allowing multiple specialized agents to work concurrently.

Question 7

A conversation requires remembering a reservation number while multiple agents collaborate. Which capability is most important?

A. Stateless routing

B. Keyword matching

C. State management

D. Anonymous access

Answer: C

Explanation: State management preserves important conversation data across interactions and between collaborating agents.

Question 8

Which issue is most likely to occur if agent responsibilities overlap significantly?

A. Improved specialization

B. Easier maintenance

C. Lower API costs

D. Incorrect routing and duplicated functionality

Answer: D

Explanation: Overlapping responsibilities create ambiguity, increase maintenance complexity, and may cause requests to be routed incorrectly.

Question 9

What is the primary advantage of designing specialized agents around business capabilities instead of departments?

A. Reduced conversation quality

B. Clear ownership and easier long-term maintenance

C. Elimination of authentication

D. Guaranteed parallel execution

Answer: B

Explanation: Business capability–based design creates well-defined responsibilities, improving maintainability, scalability, and reuse.

Question 10

A global organization expects to add new AI capabilities every few months. Which architectural characteristic best supports future growth?

A. One large monolithic agent

B. Hard-coded routing rules only

C. Modular multi-agent architecture with independently scalable agents

D. Manual agent switching by users

Answer: C

Explanation: A modular multi-agent architecture allows organizations to add or update specialized agents independently without redesigning the entire solution, making it the preferred enterprise approach.

Go to the AB-620 Exam Prep Hub main page

AB-620, AI, Microsoft Certification July 7, 2026

Add REST APIs to an agent (AB-620 Exam Prep)

This post is a part of the AB-620: Designing and Building Integrated AI Agent Solutions in Copilot Studio Exam Prep Hub.
This topic falls under these sections:
Integrate and extend agents in Copilot Studio (40–45%)
   --> Add tools to agents
      --> Add REST APIs to an agent

Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Learning Objectives

After completing this section, you should be able to:

Explain REST APIs.
Understand how REST API tools work in Copilot Studio.
Configure REST API tools.
Configure authentication.
Build requests.
Parse responses.
Use API outputs in conversations.
Apply Microsoft security best practices.

What is a REST API?

A REST (Representational State Transfer) API is a web service that allows applications to communicate over HTTP using standard operations.

Rather than interacting directly with databases or applications, agents communicate with REST APIs to retrieve or update information.

REST APIs are one of the most common integration mechanisms used in enterprise software.

Examples include:

CRM systems
ERP systems
HR applications
Inventory systems
Payment services
AI services
Internal business applications

Why Use REST APIs in Copilot Studio?

REST APIs enable agents to interact with virtually any application that exposes HTTP endpoints.

Common use cases include:

Retrieving customer records
Creating support tickets
Updating inventory
Booking appointments
Querying AI models
Processing payments
Accessing proprietary business systems

Unlike standard connectors, REST APIs allow organizations to integrate with services that do not already have a connector.

REST API Tool Architecture

A typical architecture looks like this:

			
User
↓
Copilot Studio Agent
↓
REST API Tool
↓
HTTP Request
↓
REST API Endpoint
↓
Enterprise Application
↓
HTTP Response
↓
Agent Response

		

The REST API tool acts as the communication layer between the agent and the external service.

REST Principles

REST APIs generally use:

HTTP
URLs
Resources
Standard HTTP methods
JSON payloads

Example resource:

https://api.company.com/customers/10025

HTTP Methods

The AB-620 exam expects familiarity with the most common HTTP methods.

GET

Retrieves information.

Example:

GET /customers/10025

Used when reading data.

POST

Creates a new resource.

Example:

POST /orders

Used to create records.

PUT

Replaces an existing resource.

Example:

PUT /customers/10025

Often used for full updates.

PATCH

Updates part of a resource.

Example:

PATCH /customers/10025

Updates only specified fields.

DELETE

Deletes a resource.

Example:

DELETE /orders/501

REST API Requests

A request generally contains:

Endpoint URL
HTTP method
Authentication
Headers
Parameters
Optional request body

Example:

			
GET https://api.company.com/orders/12345
Authorization: Bearer <token>
Accept: application/json

Authentication Methods

Authentication is frequently tested on the exam.

Common methods include:

OAuth 2.0

Most common for enterprise applications.

Advantages:

Secure
Token-based
Supports delegated access

Microsoft Entra ID

Used for Microsoft-secured APIs.

Examples:

Microsoft Graph
Azure services
Internal enterprise APIs

API Key

Common for:

AI services
Third-party APIs
Internal APIs

The API key is usually sent in a request header.

Basic Authentication

Supported by some legacy systems.

Generally discouraged for modern enterprise deployments.

Configuring a REST API Tool

Typical steps include:

Open the agent.
Navigate to Tools.
Select Add Tool.
Choose REST API.
Provide the endpoint URL.
Configure authentication.
Configure operations.
Save the tool.

The REST API can now be invoked by the agent during conversations.

Endpoint Configuration

The endpoint identifies the resource.

Example:

https://api.contoso.com/orders

Additional path parameters may be used.

Example:

/orders/{OrderID}

Path Parameters

Path parameters identify specific resources.

Example:

/orders/45213

where:

OrderID = 45213

Query Parameters

Query parameters filter results.

Example:

/orders?status=Pending

Multiple query parameters may be combined.

Example:

/products?category=Electronics&warehouse=West

Headers

Headers provide additional information.

Examples include:

Authorization
Accept
Content-Type
User-Agent
API version

Example:

			
Authorization: Bearer token
Content-Type: application/json

Request Body

POST, PUT, and PATCH operations often include JSON.

Example:

			
{
   "customerID":12345,
   "priority":"High",
   "description":"Damaged shipment"
}

		

The request body supplies the data the API needs.

JSON

JSON (JavaScript Object Notation) is the most common REST payload format.

Example response:

			
{
   "OrderID":12345,
   "Status":"Shipped",
   "Carrier":"Contoso Logistics",
   "Tracking":"ABC987654"
}

		

Copilot Studio parses these values into variables that can be used in subsequent conversation steps.

Variables

Inputs can originate from:

User messages
Conversation variables
Previous tool outputs
Adaptive Card inputs
AI-extracted entities

Example:

User:

Check order 55421.

Variable:

OrderID = 55421

The REST API request uses this variable as a path or query parameter.

Response Mapping

REST API responses can populate conversation variables.

Example:

			
{
   "Customer":"John Smith",
   "Status":"Delivered",
   "DeliveryDate":"2026-10-04"
}

		

The agent can then:

Respond naturally
Display an Adaptive Card
Make branching decisions
Invoke another tool
Store values for later use

Security Considerations

REST APIs often expose sensitive enterprise data.

Microsoft recommends:

Secure authentication
HTTPS only
Least privilege
Avoid exposing secrets
Validate inputs
Protect sensitive outputs

Best Practices

Keep APIs Focused

Each endpoint should perform one clear task.

Validate Inputs

Reject invalid values before sending requests.

Use Secure Authentication

Prefer:

OAuth 2.0
Microsoft Entra ID

Avoid storing secrets directly in requests whenever possible.

Return Only Required Data

Smaller responses improve:

Performance
Security
Readability

Use Clear Endpoint Names

Good examples:

			
/customers
/orders
/inventory

Poor examples:

			
/process1
/action
/data

Common Exam Scenarios

You should be able to determine when a REST API tool is the appropriate choice.

Examples include:

Integrating with a proprietary application that does not have a Power Platform connector.
Calling an external AI service.
Accessing an internal business API.
Invoking a third-party SaaS application that exposes a REST interface.
Rapidly integrating with an existing HTTP-based service without creating a reusable custom connector.

These scenarios frequently appear in the form of architecture or design questions on the AB-620 exam.

Key Takeaways from the topics covered so far

REST API tools allow Copilot Studio agents to interact directly with HTTP-based services.
REST APIs use standard HTTP methods such as GET, POST, PUT, PATCH, and DELETE.
Authentication commonly uses OAuth 2.0, Microsoft Entra ID, or API keys.
Requests consist of endpoints, headers, parameters, and (when appropriate) JSON request bodies.
JSON responses are parsed into variables that can drive conversation flow and subsequent tool invocations.
Secure design, proper authentication, and least-privilege access are essential best practices.

Securing REST API Integrations

Security is one of the most heavily tested areas of the AB-620 exam. Microsoft expects AI Agent Builders to understand not only how to connect to an API, but also how to do so securely.

A poorly secured API can expose sensitive business information, customer data, and backend systems.

Authentication Overview

Most enterprise REST APIs require authentication before they process requests.

Common authentication methods include:

API Keys
OAuth 2.0
Microsoft Entra ID (Azure AD)
Bearer Tokens
Basic Authentication (legacy)

API Keys

An API Key is a unique secret value issued by an API provider.

Example:

			
GET https://api.company.com/orders
Headers
x-api-key:
A1B2C3D4E5

Advantages

Easy to configure
Simple to understand
Good for internal services

Disadvantages

Less secure than OAuth
Keys may expire
Keys must be protected

OAuth 2.0

OAuth is the preferred authentication method for modern enterprise applications.

Instead of sending usernames and passwords:

User signs in
Identity provider authenticates user
Access token is issued
API validates token

Benefits

Strong security
Supports delegated permissions
Supports application permissions
Token expiration
Token revocation

Microsoft Entra ID Authentication

Many Microsoft services use Microsoft Entra ID.

Examples include:

Microsoft Graph
SharePoint
Outlook
Teams
Azure Management APIs

Advantages

Central identity management
Conditional Access
Multi-factor authentication
Role-based access control

Bearer Tokens

Many REST APIs require an Authorization header.

Example

			
Authorization:
Bearer eyJhbGciOi...

The token proves that the caller has already authenticated.

Basic Authentication

Older systems may still require:

			
Authorization:
Basic Base64(username:password)

This method is generally discouraged for new solutions.

Reasons:

Lower security
Password management
Credential exposure risks

Managing Secrets

Never hard-code:

Passwords
API Keys
Tokens

Instead:

Store credentials securely
Use connection references
Use environment variables
Use secure authentication providers

Request Headers

Headers provide additional information.

Common headers include:

Authorization

Content-Type

Accept

User-Agent

Example

			
Content-Type:
application/json

This tells the server JSON is being sent.

Query Parameters

Many APIs accept filtering.

Example

			
GET
/customers?city=Seattle

Instead of returning every customer:

The API returns only Seattle customers.

Benefits

Faster
Smaller payloads
Lower cost

Pagination

Large APIs rarely return all records.

Instead they return pages.

Example

			
GET
/orders?page=1

Next request:

page=2

Benefits

Better performance
Smaller responses
Lower memory usage

Rate Limits

Most enterprise APIs limit requests.

Example

1000 requests/hour

If exceeded:

429 Too Many Requests

Best practices

Retry later
Respect Retry-After headers
Reduce unnecessary requests

Handling Errors

REST APIs commonly return status codes.

Code	Meaning
200	Success
201	Created
204	No Content
400	Bad Request
401	Unauthorized
403	Forbidden
404	Not Found
408	Timeout
429	Too Many Requests
500	Internal Server Error

Agents should handle these responses gracefully.

Logging API Activity

Developers should monitor:

Request success
Failures
Latency
Authentication failures
Timeouts

Useful for:

Troubleshooting
Performance tuning
Compliance
Auditing

Monitoring API Performance

Key metrics include:

Average response time

Error rate

Success rate

Retry count

Timeout frequency

API availability

Best Practices

Design

Keep APIs focused.
Follow REST conventions.
Use meaningful endpoints.
Version APIs.

Security

Prefer OAuth.
Encrypt traffic using HTTPS.
Protect secrets.
Validate input.
Apply least privilege.

Performance

Filter results.
Cache where appropriate.
Minimize payload size.
Use pagination.
Avoid unnecessary API calls.

Reliability

Handle failures gracefully.
Retry transient errors.
Log important events.
Monitor health.
Test regularly.

REST APIs vs Custom Connectors

REST API Tool	Custom Connector
Direct API definition	Reusable connector
Good for individual APIs	Good for many apps
Can require manual configuration	Simpler for repeated use
Flexible	More standardized
Ideal for rapid integration	Ideal for enterprise reuse

Exam Tips

Remember these important distinctions:

REST APIs allow direct integration with external services.
APIs use HTTP methods such as GET, POST, PUT, PATCH, and DELETE.
JSON is the primary request and response format.
Authentication is commonly handled through OAuth 2.0 or Microsoft Entra ID.
API responses should be validated before use.
Agents should gracefully handle failures and retries.
Secure secrets should never be hard-coded.
Monitoring and logging are essential for production deployments.
Pagination and filtering improve performance.
Custom connectors simplify reuse of REST APIs across Power Platform solutions.

Practice Exam Questions

Question 1

A Copilot Studio agent needs to retrieve customer information from an external CRM without modifying any data. Which HTTP method should the REST API use?

A. POST

B. PUT

C. GET

D. PATCH

Answer: C

Explanation: GET retrieves data without changing server resources. POST creates resources, PUT replaces them, and PATCH partially updates them.

Question 2

Which authentication method is generally recommended for enterprise REST API integrations?

A. Basic Authentication

B. OAuth 2.0

C. Anonymous Access

D. Shared Password Files

Answer: B

Explanation: OAuth 2.0 provides secure, token-based authentication with delegated permissions and is preferred for enterprise APIs.

Question 3

A REST API returns HTTP status code 401 Unauthorized. What does this most likely indicate?

A. The requested resource does not exist.

B. The server encountered an internal error.

C. Authentication credentials are missing or invalid.

D. The request exceeded the rate limit.

Answer: C

Explanation: A 401 response indicates that the request lacks valid authentication credentials.

Question 4

Why should API keys never be hard-coded into an agent?

A. They increase API response times.

B. They prevent JSON serialization.

C. They disable HTTPS encryption.

D. They can be exposed and compromise security.

Answer: D

Explanation: Hard-coded secrets are difficult to rotate and may be exposed through source code or logs.

Question 5

An API returns 429 Too Many Requests. What is the most appropriate response by the agent?

A. Continue sending requests immediately.

B. Retry after waiting according to the API’s guidance.

C. Switch to Basic Authentication.

D. Ignore the error.

Answer: B

Explanation: HTTP 429 indicates that the client has exceeded rate limits. The agent should wait and retry appropriately.

Question 6

Which request header typically specifies the authentication token for a REST API?

A. Accept

B. Content-Type

C. Authorization

D. Cache-Control

Answer: C

Explanation: The Authorization header carries bearer tokens or other authentication credentials.

Question 7

Why do many APIs implement pagination?

A. To encrypt responses.

B. To reduce the amount of data returned in a single request.

C. To replace authentication.

D. To prevent HTTPS connections.

Answer: B

Explanation: Pagination improves performance and scalability by limiting the number of records returned per request.

Question 8

Which format is most commonly used for REST API request and response bodies?

A. CSV

B. XML

C. YAML

D. JSON

Answer: D

Explanation: JSON is lightweight, widely supported, and the standard format for modern REST APIs.

Question 9

When integrating a REST API into Copilot Studio, why is validating API responses important?

A. It guarantees that authentication is unnecessary.

B. It eliminates network latency.

C. It ensures returned data is complete and expected before the agent uses it.

D. It automatically encrypts responses.

Answer: C

Explanation: Response validation helps prevent errors and ensures the agent processes reliable, expected data.

Question 10

Why might a development team choose a Power Platform custom connector instead of directly configuring a REST API in every agent?

A. Custom connectors eliminate the need for authentication.

B. Custom connectors can only connect to Microsoft services.

C. Custom connectors replace HTTP methods.

D. Custom connectors provide reusable, centrally managed API definitions across multiple solutions.

Answer: D

Explanation: Custom connectors simplify maintenance, standardize integrations, and enable reuse across multiple apps, flows, and Copilot Studio agents.

Go to the AB-620 Exam Prep Hub main page

AB-620, Agentic AI, AI, Microsoft Certification July 7, 2026

Add a tool by using an existing custom connector (AB-620 Exam Prep)

This post is a part of the AB-620: Designing and Building Integrated AI Agent Solutions in Copilot Studio Exam Prep Hub.
This topic falls under these sections:
Integrate and extend agents in Copilot Studio (40–45%)
   --> Add tools to agents
      --> Add a tool by using an existing custom connector

Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

What is a Custom Connector?

A custom connector is a reusable connector created within the Microsoft Power Platform that exposes one or more APIs as actions that Power Apps, Power Automate, Copilot Studio, and other services can use.

Instead of writing HTTP requests directly into every application, developers encapsulate API definitions into a connector.

The connector becomes a reusable enterprise asset.

Examples include:

Internal HR system
Inventory management API
Legacy ERP
Manufacturing execution system
Banking platform
Insurance claims system
Internal CRM
Proprietary AI service

Why Use an Existing Custom Connector?

Many organizations already have custom connectors built for:

Power Apps
Power Automate
Logic Apps
Internal automation

Instead of recreating integrations, Copilot Studio can reuse them.

Benefits include:

Less development effort
Consistent API usage
Centralized maintenance
Shared authentication
Governance
Reduced duplication

Standard Connectors vs Custom Connectors

Standard Connector	Custom Connector
Built by Microsoft or partner	Built by organization
Supports common SaaS products	Supports proprietary systems
Automatically maintained	Organization maintains it
Limited to supported services	Can connect to virtually any REST API
Examples: Outlook, SharePoint	Example: Internal Payroll API

How Custom Connectors Work

The architecture typically looks like:

			
User
↓
Copilot Studio Agent
↓
Tool
↓
Custom Connector
↓
REST API
↓
Enterprise System

		

The connector translates:

Authentication
Request formatting
Parameter validation
Response parsing

into reusable actions.

Typical Enterprise Scenario

A company has an internal warranty database.

The API already exists.

Power Platform administrators previously created a custom connector.

The Copilot Studio agent simply calls the connector instead of directly calling the API.

This avoids:

duplicate coding
duplicated authentication
inconsistent API calls

Components of a Custom Connector

A connector typically includes:

General Information

Name
Description
Icon
Host URL

Security Definition

Authentication type

Examples:

OAuth 2.0
API Key
Microsoft Entra ID
Basic Authentication

API Definition

Defines:

Actions
Parameters
Request body
Responses

Policies

Optional transformations including:

Header injection
URL rewriting
Request modifications
Response modifications

Authentication Methods

One of the most important exam topics.

OAuth 2.0

Most common.

Suitable for:

Microsoft Graph
Enterprise APIs
Cloud applications

Benefits:

Secure
Token-based
Supports delegated permissions

API Key

Common for:

Third-party services
AI APIs
Internal APIs

The connector automatically sends the key.

Microsoft Entra ID

Often used for internal enterprise APIs.

Advantages:

Central identity management
Role-based access
Conditional Access
Single Sign-On

Basic Authentication

Supported but generally discouraged for production workloads.

Used mainly with legacy systems.

Adding an Existing Custom Connector as a Tool

Typical process:

Open the agent.
Navigate to Tools.
Select Add Tool.
Choose Existing Custom Connector.
Select the connector.
Select one or more operations.
Configure parameters.
Save.

The agent can now invoke the connector during conversations.

Choosing Operations

One connector may expose many actions.

Example:

Inventory Connector

Get Product
Update Inventory
Reserve Inventory
Cancel Reservation
Check Warehouse
Retrieve Supplier

The agent only needs the operations relevant to its purpose.

Selecting unnecessary operations increases complexity and expands the agent’s available actions beyond what is needed.

Designing Good Operations

Operations should be:

Focused
Reusable
Well documented
Clearly named

Good examples:

GetCustomer
CreateOrder
SubmitExpense
LookupPolicy

Poor examples:

ExecuteProcess1
ActionA
TestEndpoint

Configuring Parameters

Most operations require parameters.

Example:

			
GetCustomer
CustomerID

			
CreateTicket
Title
Priority
Description

Copilot Studio maps conversation data into these parameters.

Required vs Optional Parameters

Understand the distinction.

Required:

The action cannot execute without them.

Optional:

Improve results but are not mandatory.

Example:

Required

Order Number

Optional

Customer Email

Input Mapping

Inputs can come from:

User messages
Variables
Previous tool outputs
System variables
AI extracted entities

Example:

User:

Where is order 10245?

↓

Extract:

Order Number

↓

Connector:

GetOrderStatus(10245)

Output Mapping

Connector responses become variables.

Example:

API returns:

			
Customer Name
Order Status
Shipping Date

The agent can then:

respond to the user
populate Adaptive Cards
call another tool
make decisions
branch within a topic

Working with JSON Responses

Many APIs return JSON.

Example:

			
{
   "customer":"John Smith",
   "status":"Processing",
   "shipDate":"2026-08-15"
}

		

Copilot Studio extracts individual properties for later use.

Security Considerations

Microsoft recommends granting only the permissions the connector actually requires.

Follow the principle of least privilege.

Avoid connectors with unnecessary administrative permissions.

Governance

Administrators should:

Review connector ownership.
Approve enterprise connectors.
Monitor usage.
Enforce Data Loss Prevention (DLP) policies.
Control environment access.
Audit authentication methods.
Review connector updates before deployment.

Best Practices

Reuse Existing Connectors

Avoid building duplicate connectors.

Keep Operations Small

Small operations are easier to test.

Use Descriptive Names

Helps AI select the correct tool.

Secure Authentication

Prefer:

OAuth
Microsoft Entra ID

Avoid hard-coded credentials.

Validate Inputs

Prevent invalid requests before invoking APIs.

Return Structured Responses

Predictable JSON improves downstream processing.

Common Exam Pitfalls

Candidates often confuse:

Standard connectors
Power Platform connectors
Custom connectors
REST API tools
MCP tools

Remember:

Standard connectors are Microsoft-provided.
Power Platform connectors include both standard and custom connectors available within the Power Platform ecosystem.
Custom connectors wrap your own APIs into reusable connector definitions.
REST API tools call APIs directly from the agent without requiring a custom connector.
MCP tools connect to capabilities exposed through the Model Context Protocol, enabling standardized interaction with external tools and services.

Being able to choose the most appropriate integration option for a given scenario is a key skill measured on the AB-620 exam.

Quick Orientation Summary

In the topics above, you learned what custom connectors are, how they differ from standard connectors, how to configure them as agent tools, and how authentication, parameters, and outputs work.

The topics below focus on the advanced knowledge expected for the AB-620 certification exam.

Advanced Configuration

Once a custom connector has been added to an agent, developers should configure it so that it behaves predictably during conversations.

Important considerations include:

Selecting only the operations the agent requires
Mapping variables correctly
Providing descriptive action names
Validating required inputs
Handling null values
Returning structured outputs

A well-configured connector is easier for the AI orchestrator to select appropriately and reduces the likelihood of incorrect tool invocation.

Designing Agent-Friendly Connectors

Although a connector may expose dozens of operations, not all of them should necessarily be available to an agent.

Good practice includes:

Separate read operations from update operations.
Expose only business-relevant actions.
Avoid administrative functions unless necessary.
Keep operations focused on a single task.
Use clear operation descriptions.

Example:

Instead of:

ExecuteAPI

Use:

GetCustomerOrders
CreateSupportTicket
UpdateDeliveryAddress

This improves the agent’s ability to determine when to invoke each action.

Variable Mapping Best Practices

Variables often originate from:

User input
Previous topic variables
Generative AI extraction
Other tools
Adaptive Card submissions

Example workflow:

User:

I need the warranty information for product 45831.

Conversation variable:

ProductID = 45831

Connector action:

GetWarranty(ProductID)

Connector response:

			
WarrantyStatus
ExpirationDate
CoverageType

These outputs become new variables that the agent can reference later in the conversation.

Chaining Multiple Tools

A single conversation often involves multiple tools working together.

Example:

Step 1

Retrieve customer information.

↓

Step 2

Retrieve active orders.

↓

Step 3

Retrieve shipping status.

↓

Step 4

Generate natural-language response.

Rather than creating one large API, smaller reusable operations simplify maintenance and improve reliability.

Error Handling

Enterprise systems occasionally fail.

Possible causes include:

Invalid parameters
Expired authentication
Network interruptions
Service outages
Rate limiting
Missing permissions

Agents should be designed to recover gracefully whenever possible.

Common Error Responses

Examples include:

400 Bad Request

Incorrect input.

Example:

Customer ID contains invalid characters.

401 Unauthorized

Authentication failed.

Possible causes:

Expired token
Invalid credentials
Missing authentication

403 Forbidden

User is authenticated but lacks permission.

404 Not Found

Requested resource does not exist.

429 Too Many Requests

API rate limit exceeded.

500 Internal Server Error

Unexpected server-side failure.

Designing Friendly Error Messages

Avoid exposing raw API errors to end users.

Instead of:

Error 500

Use:

I couldn’t retrieve your information right now. Please try again in a few minutes.

This provides a better user experience while avoiding disclosure of unnecessary technical details.

Performance Optimization

Large enterprise APIs can affect conversation speed.

Microsoft recommends:

Return only required fields.
Reduce payload sizes.
Limit unnecessary API calls.
Cache frequently used information when appropriate.
Break large operations into smaller reusable actions.

Security Best Practices

Security is frequently tested on the AB-620 exam.

Recommendations include:

Principle of Least Privilege

Grant only the permissions required.

Example:

Instead of granting:

Customer.ReadWrite.All

Grant:

Customer.Read

if the agent only retrieves customer information.

Secure Authentication

Preferred methods:

Microsoft Entra ID
OAuth 2.0
Managed identity (where applicable)

Avoid embedding secrets directly in connector definitions whenever possible.

Protect Sensitive Data

Avoid returning:

Passwords
Authentication tokens
Social Security numbers
Credit card numbers
Personally identifiable information (PII) unless absolutely required

Return only the data necessary for the conversation.

Monitoring Connector Usage

Administrators should monitor:

Successful executions
Failed executions
Authentication failures
API latency
Usage frequency
User activity
Connector health

Monitoring helps identify bottlenecks and troubleshoot production issues.

Logging

Logging is useful for:

Diagnosing failures
Auditing requests
Measuring adoption
Identifying slow operations
Supporting compliance requirements

However, avoid logging confidential user information unnecessarily.

Versioning Connectors

Enterprise APIs evolve over time.

Best practices include:

Version APIs
Test new versions before deployment
Avoid breaking changes
Maintain backward compatibility where practical
Update agents after connector changes

Enterprise Scenario 1

A healthcare organization exposes a patient scheduling API through a custom connector.

The agent can:

Find appointments
Schedule visits
Cancel appointments
Check physician availability

Authentication uses Microsoft Entra ID.

Only authorized staff members can invoke scheduling operations.

Enterprise Scenario 2

A manufacturing company exposes inventory services.

Operations include:

Check inventory
Reserve inventory
Release reservation
Find warehouse

The Copilot agent helps warehouse employees without requiring them to open multiple applications.

Enterprise Scenario 3

An insurance company exposes claim-processing APIs.

The connector allows the agent to:

Retrieve claim status
Submit documentation
Update claimant information
Schedule inspections

Because the connector already exists for Power Automate workflows, the same connector can be reused within Copilot Studio.

Comparing Integration Options

Feature	Standard Connector	Custom Connector	REST API Tool	MCP Tool
Microsoft-managed	Yes	No	No	Depends
Organization-created	No	Yes	No	Sometimes
Requires API definition	No	Yes	Yes	Yes
Reusable across Power Platform	Yes	Yes	No	Varies
Direct API calls	No	Indirect	Yes	Via MCP server
Best for enterprise reuse	Moderate	Excellent	Moderate	Excellent for standardized AI tool ecosystems

When to Choose an Existing Custom Connector

Use an existing custom connector when:

The organization already has one.
The API is used by multiple Power Platform solutions.
Authentication has already been configured.
Governance requirements already exist.
Multiple applications share the same integration.

When a REST API Tool May Be Better

A REST API tool may be preferable when:

Only one API operation is needed.
No connector currently exists.
Rapid prototyping is desired.
Reusability across the Power Platform is not required.

More AB-620 Exam Tips

Remember these key points:

Existing custom connectors promote reuse across the Power Platform.
Connectors encapsulate authentication and API definitions.
Use least-privilege permissions.
Select only the operations needed by the agent.
Map variables carefully between conversations and connector inputs.
Handle API failures gracefully.
Monitor connector performance and usage.
Use descriptive operation names.
Reuse existing connectors instead of duplicating integrations.
Understand when a custom connector is preferable to a REST API tool or MCP tool.

Practice Exam Questions

Question 1

An organization has already created a custom connector for its internal ERP system. A Copilot Studio developer needs to enable agents to retrieve inventory information.

What is the best approach?

A. Create a new REST API tool that duplicates the ERP functionality.

B. Reuse the existing custom connector.

C. Build a Power Automate flow that manually calls the API.

D. Export the connector as an Adaptive Card.

Answer: B

Explanation: Existing custom connectors should be reused whenever possible because they already encapsulate authentication, API definitions, governance, and maintenance.

Question 2

Which authentication method is generally recommended for enterprise APIs secured by Microsoft identity services?

A. Anonymous authentication

B. API key only

C. Microsoft Entra ID (OAuth 2.0)

D. Basic Authentication

Answer: C

Explanation: Microsoft Entra ID with OAuth 2.0 provides secure, centralized identity management, token-based authentication, and integration with enterprise security controls.

Question 3

A connector exposes twenty operations, but an agent only needs two of them.

What is the recommended design?

A. Enable all operations.

B. Create duplicate connectors.

C. Expose only the required operations.

D. Disable authentication.

Answer: C

Explanation: Limiting available operations simplifies agent behavior, improves security, and reduces unnecessary complexity.

Question 4

Which HTTP response code typically indicates that authentication has failed?

A. 404

B. 429

C. 500

D. 401

Answer: D

Explanation: A 401 Unauthorized response indicates that authentication credentials are missing, invalid, or expired.

Question 5

Why should connector operations have descriptive names?

A. They reduce API latency.

B. They improve AI tool selection and maintainability.

C. They eliminate authentication requirements.

D. They automatically optimize API performance.

Answer: B

Explanation: Clear operation names help both developers and AI orchestration determine the appropriate action to invoke.

Question 6

A connector returns customer name, address, loyalty status, and internal audit history. The agent only needs the customer’s loyalty status.

What is the best practice?

A. Return every field.

B. Add more connector actions.

C. Return only the required data.

D. Disable response parsing.

Answer: C

Explanation: Returning only the necessary data reduces payload size, improves performance, and minimizes exposure of unnecessary information.

Question 7

Which practice best supports enterprise security?

A. Embed administrator passwords in the connector.

B. Grant every available permission.

C. Use anonymous access.

D. Apply the principle of least privilege.

Answer: D

Explanation: Least privilege limits permissions to only those required, reducing security risks and supporting compliance.

Question 8

What is a primary advantage of using an existing custom connector instead of recreating the same integration?

A. It automatically removes authentication.

B. It eliminates API documentation.

C. It promotes reuse, governance, and centralized maintenance.

D. It guarantees faster API responses.

Answer: C

Explanation: Existing custom connectors provide reusable, centrally managed integrations that can be shared across Power Platform solutions.

Question 9

During execution, an API returns HTTP 429.

What does this typically indicate?

A. The requested resource was not found.

B. The request exceeded the service’s rate limit.

C. Authentication failed.

D. The connector is incorrectly configured.

Answer: B

Explanation: HTTP 429 indicates that too many requests have been sent in a given period, triggering rate limiting.

Question 10

When should a developer consider using an existing custom connector instead of creating a direct REST API tool?

A. When the organization already maintains the connector for multiple Power Platform solutions.

B. When no reusable integration exists.

C. Only during testing.

D. Only for public APIs.

Answer: A

Explanation: Reusing an existing custom connector leverages established authentication, governance, maintenance, and reusability across multiple applications, making it the preferred approach when such a connector already exists.

AB-620 Exam Summary

For the exam, remember these key takeaways:

Custom connectors encapsulate APIs into reusable Power Platform components.
Existing custom connectors should generally be reused instead of creating duplicate integrations.
Configure only the operations an agent requires.
Use secure authentication methods such as Microsoft Entra ID and OAuth 2.0.
Apply least-privilege security principles.
Map conversation variables carefully to connector inputs and outputs.
Handle API errors gracefully with user-friendly messages.
Monitor connector health, performance, and usage.
Understand when to use custom connectors versus REST API tools and MCP tools based on governance, reuse, and integration requirements.

Go to the AB-620 Exam Prep Hub main page

AB-620, Agentic AI, AI, Microsoft Certification July 7, 2026

Configure MCP tools (AB-620 Exam Prep)

This post is a part of the AB-620: Designing and Building Integrated AI Agent Solutions in Copilot Studio Exam Prep Hub.
This topic falls under these sections:
Integrate and extend agents in Copilot Studio (40–45%)
   --> Add tools to agents
      --> Configure MCP tools

Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Objective

One of the newer skills measured on the AB-620 certification exam is understanding how to integrate AI agents with external systems using the Model Context Protocol (MCP). MCP provides a standardized way for AI agents to discover and use external tools, services, and knowledge without requiring custom integration logic for every system.

For the exam, you should understand:

What MCP is
Why Microsoft supports MCP
MCP architecture
How MCP tools are configured in Copilot Studio
Authentication methods
Tool discovery
Tool invocation
Appropriate use cases
Best practices
Differences between MCP tools and traditional connectors

What is the Model Context Protocol (MCP)?

The Model Context Protocol (MCP) is an open protocol designed to standardize communication between AI models and external systems.

Instead of every application requiring its own custom integration, MCP defines a common interface through which AI agents can:

Discover available tools
Invoke tools
Retrieve structured information
Execute operations
Exchange contextual information
Receive standardized responses

Think of MCP as a universal language that allows AI agents to communicate with many different systems.

Why MCP Was Created

Before MCP, AI integrations often required:

Custom APIs
Custom plugins
Proprietary connectors
Individual authentication logic
Separate maintenance

As organizations added more systems, integrations became increasingly difficult to manage.

MCP solves this problem by creating a standardized protocol that both AI agents and external services understand.

Benefits include:

Reduced development effort
Reusable integrations
Standardized communication
Easier maintenance
Better interoperability
Vendor independence

MCP Architecture

An MCP solution generally contains three major components.

1. MCP Client

The client initiates requests.

In Copilot Studio, the agent typically acts as the MCP client.

Responsibilities include:

Discover tools
Send requests
Receive responses
Handle conversation context
Invoke external capabilities

2. MCP Server

The server exposes tools.

It advertises:

Available functions
Input parameters
Output schema
Authentication requirements
Tool descriptions

The server receives requests from the AI agent and executes them.

3. External Systems

Behind the MCP server are business systems such as:

CRM systems
ERP systems
HR systems
Financial applications
Inventory systems
Knowledge repositories
Databases
Line-of-business applications

The MCP server translates agent requests into operations against these systems.

How MCP Works

A simplified workflow looks like this:

			
User
↓
Copilot Studio Agent
↓
MCP Client
↓
MCP Server
↓
Business Application
↓
Result
↓
Agent Response

		

The user never directly interacts with the MCP server.

Everything is orchestrated by the agent.

MCP Tool Discovery

One major advantage of MCP is automatic tool discovery.

Instead of manually configuring every operation, an MCP server publishes:

Tool names
Descriptions
Parameters
Input types
Output types
Supported operations

The agent can dynamically determine which tool should be used.

Example:

Available tools:

Search Customers
Create Ticket
Update Order
Schedule Meeting

The agent can automatically select the appropriate tool based on user intent.

What Is an MCP Tool?

An MCP tool is an operation that an AI agent can execute.

Examples include:

Search customer records
Retrieve invoices
Create work orders
Submit approvals
Update CRM records
Generate reports
Query inventory
Create service requests
Retrieve product pricing

Each tool exposes:

Name
Description
Parameters
Required permissions
Expected response

MCP Tools in Copilot Studio

Within Copilot Studio, MCP tools become available for use inside agent conversations.

An agent can:

Select the appropriate MCP tool
Pass user input
Receive structured output
Continue the conversation naturally

Example:

User:

What is the status of order 48329?

The agent:

Selects the “Get Order Status” MCP tool.
Sends OrderID = 48329.
Receives the order details.
Generates a natural-language response for the user.

Typical MCP Tool Categories

Organizations may expose many categories of tools.

Examples include:

Customer Management

Lookup customer
Update customer
Create customer
Retrieve customer history

Sales

Create opportunity
Update quote
Retrieve pricing
Check product availability

Finance

Get invoice
Create invoice
Check payment status
Submit expense

Human Resources

Employee lookup
PTO request
Benefits information
Manager approval

IT Service Management

Create incident
Reset password
Check ticket status
Provision user

Manufacturing

Inventory lookup
Production status
Equipment health
Purchase orders

Configuring MCP Tools in Copilot Studio

Although the exact interface may evolve, the configuration process generally follows these steps:

Step 1

Connect to an MCP server.

The administrator specifies:

Server endpoint
Authentication method
Required permissions

Step 2

Discover available tools.

The agent retrieves:

Tool metadata
Parameters
Descriptions
Schemas

Step 3

Select tools to expose.

Not every available tool should necessarily be available to every agent.

Administrators often choose only those needed.

Step 4

Configure permissions.

Determine:

Which users may invoke tools
Which environments may use them
Which identities execute requests

Step 5

Test the tool.

Verify:

Successful authentication
Correct parameters
Expected responses
Error handling

Authentication Options

MCP servers typically require authentication.

Common methods include:

OAuth 2.0

Most common enterprise approach.

Advantages:

Secure
Token-based
Supports delegated permissions
Supports enterprise identity providers

Microsoft Entra ID

Often used for Microsoft services.

Benefits include:

Single Sign-On
Conditional Access
Multi-Factor Authentication
Centralized identity management

API Keys

Suitable for simpler integrations.

Less flexible than OAuth.

Should always be securely stored.

Managed Identity

Useful for Azure-hosted services.

Advantages include:

No embedded credentials
Automatic credential management
Strong security posture

Input Parameters

Each MCP tool defines required inputs.

Example:

			
Tool
Search Customer
Inputs
Customer ID
Region
Status

		

The agent automatically maps conversation information into these parameters.

Example:

User:

Show me active customers in Florida.

Parameters become:

			
Region = Florida
Status = Active

Structured Responses

Unlike free-form text, MCP tools usually return structured data.

Example:

			
{
  "CustomerName":"Contoso",
  "Status":"Active",
  "Orders":17,
  "Balance":1200
}

		

The agent converts this structured data into a conversational response.

MCP vs Traditional REST APIs

MCP	REST API
Tool discovery	Manual documentation
Standard protocol	Custom implementation
AI optimized	General software integration
Standard metadata	Varies by developer
Easier AI integration	Requires additional orchestration

REST APIs remain valuable, but MCP adds AI-friendly semantics that simplify tool selection and invocation.

MCP vs Power Platform Connectors

MCP Tools	Power Platform Connectors
Dynamic discovery	Predefined actions
AI-native	Workflow automation
Standard protocol	Connector-specific implementation
Extensible	Service-specific
Optimized for AI reasoning	Optimized for application integration

These technologies complement each other rather than replace one another.

Advantages of MCP

Organizations benefit from MCP because it provides:

Standardized integrations
Easier maintenance
Reusable tools
Better scalability
Vendor interoperability
Simplified AI development
Reduced custom coding
Consistent authentication
Dynamic tool discovery
Future extensibility

Real-World Scenario

A manufacturing company has:

SAP ERP
Salesforce CRM
ServiceNow
Azure SQL
Internal inventory application

Instead of creating dozens of custom agent integrations, the company exposes MCP servers for these systems.

The Copilot Studio agent can:

Check inventory
Create service tickets
Retrieve invoices
Update customer records
Submit purchase requests

—all through standardized MCP tools, without custom integration logic for each interaction.

Best Practices

When configuring MCP tools:

Publish only the tools required by the agent.
Write clear, descriptive tool names and descriptions.
Use secure authentication such as OAuth 2.0 or Microsoft Entra ID.
Limit permissions using the principle of least privilege.
Validate all input parameters.
Return structured, predictable outputs.
Version tools carefully to avoid breaking existing agents.
Document tool capabilities for administrators.
Test error handling thoroughly.
Monitor tool usage and performance.

AB-620 Exam Tips

Remember these key points for the exam:

MCP is an open standard for connecting AI agents to external tools and services.
Copilot Studio agents commonly act as MCP clients.
MCP servers expose discoverable tools with metadata, parameters, and schemas.
Tool discovery is one of MCP’s primary advantages over traditional APIs.
MCP complements—not replaces—Power Platform connectors and REST APIs.
Secure authentication (OAuth, Microsoft Entra ID, Managed Identity) is preferred over embedded credentials.
Structured outputs enable the agent to generate accurate natural-language responses.
Administrators should expose only the tools necessary for a given agent, following the principle of least privilege.

Advanced MCP Tool Configuration

As organizations scale their AI solutions, MCP implementations often extend beyond simple tool invocation. Enterprise deployments require careful planning around security, governance, monitoring, scalability, and lifecycle management.

A mature MCP implementation should provide:

Secure authentication
Centralized governance
Version management
High availability
Comprehensive monitoring
Auditing
Fault tolerance
Performance optimization

Tool Selection Strategies

An MCP server may expose dozens—or even hundreds—of tools. Exposing every available tool to every agent is rarely a good design.

Instead, expose only the tools required for the agent’s business purpose.

For example:

Customer Service Agent

Get customer details
View support tickets
Create case
Escalate incident

Avoid exposing:

Payroll processing
Financial approvals
Employee onboarding

Keeping the available toolset focused improves both security and the quality of AI reasoning.

Tool Metadata Best Practices

Each MCP tool includes metadata that helps the AI model determine when to use it.

Good metadata should include:

Clear tool name
Detailed description
Required parameters
Parameter descriptions
Expected output
Error conditions
Permission requirements

Good Example

Tool Name

GetCustomerOrders

Description:

Retrieves all active customer orders using the supplied Customer ID.

Poor Example

Lookup1

Description:

Gets data.

The second example provides insufficient context for effective AI tool selection.

Parameter Validation

Never assume user input is valid.

Common validation techniques include:

Required fields
Data type validation
Allowed value validation
Length restrictions
Numeric ranges
Date validation
Pattern matching
Business rule validation

Example:

Instead of allowing:

CustomerID = ABCXYZ!!!

Validate that:

			
CustomerID
Integer
Greater than zero

Error Handling

Enterprise MCP implementations should gracefully handle failures.

Examples include:

Authentication failures
Timeout errors
Network interruptions
Invalid parameters
Missing records
Service unavailable
Rate limits exceeded
Permission denied

Rather than returning technical errors to users, the agent should generate meaningful responses.

Example:

Instead of:

HTTP 500 Internal Server Error

Use:

I’m currently unable to retrieve that information. Please try again in a few moments.

Security Best Practices

Security is one of the most important exam topics.

Principle of Least Privilege

Agents should only access the tools necessary for their role.

Example:

A Help Desk agent should not be able to approve payroll.

Secure Authentication

Preferred authentication methods include:

Microsoft Entra ID
OAuth 2.0
Managed Identity
Secure API tokens

Avoid:

Hardcoded passwords
Embedded credentials
Shared administrator accounts

Secure Communication

Use encrypted communication between:

Copilot Studio
MCP Server
Business applications

HTTPS should always be used.

Secrets Management

Credentials should be stored securely using enterprise secret management solutions.

Never place secrets inside:

Topics
Prompts
Variables
Source code

Governance

Enterprise organizations should define governance policies covering:

Tool ownership
Version control
Security reviews
Deployment approvals
Naming standards
Documentation
Change management
Retirement policies

Versioning MCP Tools

Over time, tools evolve.

Example:

Version 1

GetInvoice

Inputs:

InvoiceID

Version 2

GetInvoice

Inputs:

InvoiceID
Region

Maintaining version compatibility minimizes disruption for agents already using earlier versions.

Monitoring MCP Tools

Administrators should continuously monitor:

Tool usage frequency
Success rate
Failure rate
Average execution time
Authentication failures
Timeout frequency
Network latency
Server availability

Monitoring helps identify bottlenecks before they impact users.

Logging

Execution logs typically capture:

User request
Selected MCP tool
Parameters
Execution time
Response
Errors
Retry attempts
Authentication status

Logs support:

Troubleshooting
Compliance
Auditing
Performance optimization

Performance Optimization

Several techniques improve MCP performance.

Reduce Tool Count

Present only relevant tools.

Too many similar tools may confuse AI reasoning.

Optimize Tool Descriptions

Clear descriptions improve tool selection accuracy.

Minimize Response Size

Return only the required information.

Avoid unnecessarily large payloads.

Optimize Backend Services

Even a perfectly configured MCP server cannot compensate for slow backend applications.

Cache Frequently Requested Data

For relatively static information, caching may reduce latency.

Examples:

Product catalog
Office locations
Department lists

High Availability

Enterprise MCP servers should support:

Redundant infrastructure
Load balancing
Automatic failover
Health monitoring
Disaster recovery

This minimizes downtime for AI agents.

Troubleshooting Common Issues

Issue 1

Authentication Failure

Possible causes:

Expired token
Invalid credentials
Missing permissions

Resolution:

Reauthenticate
Verify identity configuration
Review access policies

Issue 2

Tool Not Found

Possible causes:

Tool unpublished
Discovery failed
Version mismatch

Resolution:

Refresh discovery
Verify server configuration
Confirm tool availability

Issue 3

Incorrect Tool Selected

Possible causes:

Poor descriptions
Ambiguous metadata
Similar tool names

Resolution:

Improve metadata
Clarify descriptions
Remove duplicate tools

Issue 4

Slow Responses

Possible causes:

Network latency
Backend system delays
Large responses

Resolution:

Optimize backend systems
Reduce payload size
Improve infrastructure

Issue 5

Permission Denied

Possible causes:

Missing user role
Incorrect authentication
Access policy restrictions

Resolution:

Verify permissions
Review authentication
Update authorization policies

MCP vs REST APIs

MCP	REST API
AI discovers tools automatically	Developer specifies endpoint
Standard tool metadata	Custom documentation
Optimized for AI reasoning	Optimized for software integration
Standard protocol	Varies by implementation
Dynamic discovery	Manual implementation

MCP vs Power Platform Connectors

MCP	Power Platform Connector
AI-native tool discovery	Predefined operations
Dynamic capabilities	Static connector actions
Standard protocol	Connector-specific
Excellent for AI reasoning	Excellent for workflow automation

When Should MCP Be Used?

Ideal scenarios include:

Enterprise AI agents
Cross-platform integrations
AI assistants requiring many external tools
Vendor-neutral integrations
Standardized AI architectures

Less appropriate scenarios include:

Very simple workflows
Single API integrations
Static automation requiring only one service

Enterprise Design Recommendations

For large organizations:

Build reusable MCP servers.
Publish well-documented tools.
Use standardized naming conventions.
Monitor continuously.
Secure every endpoint.
Separate development, test, and production environments.
Apply role-based access control (RBAC).
Maintain version history.
Implement comprehensive logging.
Perform regular security reviews.

More AB-620 Exam Tips

Remember these important concepts:

MCP stands for Model Context Protocol.
MCP standardizes communication between AI agents and external tools.
Copilot Studio agents commonly function as MCP clients.
MCP servers publish discoverable tools with metadata and schemas.
Clear tool descriptions improve AI tool selection.
OAuth 2.0, Microsoft Entra ID, and Managed Identity are preferred authentication methods.
Use the principle of least privilege when exposing tools.
Monitor execution logs, failures, and performance metrics.
Return structured responses whenever possible.
MCP complements Power Platform connectors and REST APIs rather than replacing them.

Practice Exam Questions

Question 1

A Copilot Studio agent must interact with several enterprise applications through a standardized interface that allows automatic tool discovery. Which technology best meets this requirement?

A. Power Automate Desktop

B. Model Context Protocol (MCP)

C. Adaptive Cards

D. Azure Logic Apps

Answer: B

Explanation: MCP provides a standardized protocol for AI agents to discover and invoke external tools dynamically, making it ideal for multi-system enterprise integrations.

Question 2

An administrator wants to improve an agent’s ability to select the correct MCP tool automatically. Which action is most effective?

A. Increase the number of available tools.

B. Use shorter tool names with minimal descriptions.

C. Provide clear, descriptive metadata for each tool.

D. Disable parameter validation.

Answer: C

Explanation: Rich metadata—including meaningful names, descriptions, parameters, and expected outputs—helps the AI accurately determine which tool to invoke.

Question 3

Which authentication method is generally preferred for enterprise MCP integrations hosted in Microsoft environments?

A. Anonymous access

B. Plain-text passwords stored in prompts

C. Shared administrator credentials

D. Microsoft Entra ID

Answer: D

Explanation: Microsoft Entra ID provides secure identity management, supports conditional access and MFA, and integrates well with enterprise Microsoft services.

Question 4

Which practice best follows the principle of least privilege?

A. Expose every available MCP tool to every agent.

B. Grant Global Administrator permissions to all agents.

C. Publish only the tools required for the agent’s intended tasks.

D. Allow unrestricted access to simplify administration.

Answer: C

Explanation: Limiting access to only necessary tools reduces security risks and improves the quality of tool selection.

Question 5

A user receives an HTTP 500 error while an MCP tool executes. What is the preferred agent response?

A. Display the raw server error.

B. Inform the user that the requested information is temporarily unavailable and suggest trying again.

C. Terminate the conversation.

D. Retry indefinitely without notifying the user.

Answer: B

Explanation: User-facing responses should be friendly and informative rather than exposing technical implementation details.

Question 6

Which monitoring metric would most directly indicate a performance degradation in an MCP server?

A. Number of published Adaptive Cards

B. Average tool execution time

C. Number of conversation topics

D. Number of environments

Answer: B

Explanation: An increase in average execution time often indicates backend performance issues or network latency.

Question 7

A company frequently updates one of its MCP tools. Which practice minimizes disruptions to existing agents?

A. Remove older versions immediately.

B. Change tool names with every update.

C. Maintain version compatibility and manage tool versions carefully.

D. Disable monitoring during updates.

Answer: C

Explanation: Versioning helps maintain backward compatibility while allowing new functionality to be introduced safely.

Question 8

Why should organizations avoid exposing every available MCP tool to every agent?

A. It increases hardware requirements only.

B. It prevents authentication.

C. It makes logging impossible.

D. It increases security risks and can reduce tool-selection accuracy.

Answer: D

Explanation: Restricting available tools improves security and helps the AI select the correct tool more consistently.

Question 9

Which statement correctly describes the relationship between MCP and REST APIs?

A. MCP completely replaces REST APIs.

B. REST APIs cannot be used with AI agents.

C. MCP provides AI-friendly discovery and metadata while REST APIs remain valuable for backend services.

D. REST APIs are only supported in Power Automate.

Answer: C

Explanation: MCP builds upon existing services by providing standardized discovery and interaction patterns rather than replacing traditional APIs.

Question 10

An organization wants to troubleshoot intermittent MCP failures. Which information would be most valuable in execution logs?

A. The desktop wallpaper color of the administrator

B. The user’s browser bookmarks

C. The weather at the time of execution

D. Tool name, execution time, input parameters, response, authentication status, and errors

Answer: D

Explanation: Detailed execution logs provide the information needed to diagnose failures, identify performance bottlenecks, and support auditing and compliance.

Key Takeaways

MCP provides a standardized protocol for AI agents to discover and invoke external tools.
Copilot Studio agents commonly act as MCP clients, while MCP servers expose tools and metadata.
Clear metadata, strong authentication, and least-privilege access are critical for secure and reliable implementations.
Monitoring, logging, versioning, and governance are essential for enterprise-scale deployments.
MCP complements REST APIs and Power Platform connectors, providing an AI-optimized layer for enterprise integrations.

Go to the AB-620 Exam Prep Hub main page