Tools and Integrations for AB-620

Tools are where a Copilot Studio agent stops being a conversational layer and starts affecting real systems. AB-620 therefore treats integration as a major engineering responsibility. The exam expects you to recognize several ways an agent can reach enterprise capabilities and to choose among them based on identity, reliability, governance, and the quality of the interface—not just convenience.

The AB-620 exam explicitly includes computer use, MCP tools, custom connectors, REST APIs, enterprise knowledge sources, and Azure integrations. A good mental model is to rank integrations by how strong their contract is. A typed API or connector usually gives you clearer inputs and errors than a GUI automation path. A governed tool with explicit authorization is safer than a broad capability hidden behind a vague description.

Start with the business action, not the connector list

Before choosing an integration, define the action the agent must perform. Is it reading customer data, creating a ticket, updating a record, searching knowledge, running an approval, or interacting with a legacy desktop? The answer determines the interface you need.

A common design mistake is choosing a connector because it already exists and then shaping the workflow around that limitation. Work in the opposite direction: define the required input, output, identity, side effect, latency, and error behavior, then choose the integration that best satisfies those conditions.

Use native and Power Platform connectors when the contract fits

Connectors can provide a governed path to common enterprise services without requiring you to build an API wrapper for every operation. They are especially useful when authentication, schema, and supported actions already align with the business process.

That convenience does not remove architecture work. Check which connection the action uses, whether it runs as the signed-in user or a shared/service identity, which permissions are granted, and whether a connector action has side effects. The identity principles in cloud IAM fundamentals are relevant because the safest integration is one whose permission scope matches the actual task.

Use custom connectors when you need a reusable governed API surface

A custom connector can turn an internal or third-party API into a reusable capability with defined operations, inputs, authentication, and responses. This is stronger than exposing a single catch-all action because each operation can express a business purpose.

Keep the operation names and descriptions precise. If a connector offers “ManageCustomer,” the agent has too much ambiguity. Separate actions such as “GetCustomerProfile,” “CreateSupportCase,” and “UpdatePreferredContactMethod” make tool choice easier and security review more meaningful.

Use REST directly when the API contract is already clear

AB-620 includes adding REST APIs to an agent. Direct REST access can be appropriate when the API is well-defined and you do not need the additional abstraction of a connector. Define the endpoint, authentication, expected request, response shape, timeout, and error contract before you let the agent use it.

The surrounding principles in tool use and function calling apply here: a model-generated request is not authorization. Validate inputs, enforce access at the service, and return structured errors that let the workflow distinguish invalid input from permission denial, not-found results, throttling, or transient failure.

MCP is useful when several tools should be discovered through one standard

Model Context Protocol gives an agent a standardized way to discover and use tools exposed by an MCP server. In AB-620, the point is not memorizing protocol internals. It is recognizing when MCP provides a reusable integration layer for capabilities that several agents may need.

An enterprise team might expose approved customer, inventory, and order actions through a governed MCP server. Copilot Studio agents can then consume those capabilities without rebuilding every integration separately. The design still needs authentication, authorization, version management, logging, and clear tool descriptions.

Computer use trades a weak interface for broader reach

Computer use can interact with applications that do not expose a suitable API or connector. That is powerful, but it also means the agent is working through a visual interface whose state can change. Buttons move. Sessions expire. Dialogs appear. An application can display unexpected data.

Use it when the legacy integration constraint is real, not as a first choice for systems that already have stable APIs. Test recovery, credential handling, concurrency, and evidence of completion. A tool that clicks “Submit” should still give the workflow a reliable way to determine whether the transaction actually succeeded.

Agent flows are often the right place for deterministic integration sequences

Some operations require several steps in a defined order: validate a record, request approval, update a system, send a notification, and write an audit event. That is a poor place to rely entirely on generative orchestration. An agent flow can make the sequence explicit and provide retry or error handling around each dependency.

The agent can still decide that the workflow is needed. Once execution begins, deterministic steps protect policy and state. This separation is one of the most useful patterns for AB-620 because it shows how reasoning and business process automation can coexist.

Tool descriptions shape selection in generative orchestration

When several tools are available, the model needs enough metadata to choose correctly. Give each tool a description that explains when it should be used, what result it produces, and any important limitation. Avoid overlapping descriptions that make two tools look interchangeable.

This is closely related to prompt quality, but tool descriptions are operational metadata rather than decoration. Clear language reduces selection errors and makes the system easier to evaluate. The principles in Copilot Studio agent architecture show why descriptions, instructions, and boundaries all influence runtime behavior.

Identity should be part of every integration diagram

For each action, write down who the downstream system believes is calling. User-delegated access preserves per-user permissions but depends on interactive identity and consent. Service access can support autonomous workflows but may carry broader standing privileges if it is not scoped carefully.

Do not let prompts carry credentials. Use managed connection and identity mechanisms. If a tool can write data, make the authorization decision independently of the model. If a flow runs without a user present, make the workload identity and its lifecycle visible in the design.

Design for failure before you celebrate a successful demo

Test invalid parameters, expired credentials, denied access, API throttling, timeouts, partial completion, and malformed responses. Decide which errors the agent can retry, which require another tool, and which should stop and ask for human help.

Good integrations make failure legible. A generic “something went wrong” string encourages the agent to guess. Structured status and error information lets the workflow recover safely and gives operators evidence when they investigate.

Compare integrations using the same scorecard

For a difficult scenario, score each option against identity fidelity, contract strength, latency, side-effect risk, observability, retry behavior, and long-term maintenance. Computer use may win on reach but lose on contract strength. REST may be direct but require more custom error handling. A connector may simplify authentication but expose only a subset of the underlying API.

Using the same criteria stops product familiarity from biasing the decision. It also mirrors the way the exam frames architecture questions: several features may technically work, but one better satisfies the operating requirement.

Keep read and write capabilities separate where practical

If an agent needs to inspect a record and occasionally update it, consider exposing separate tools. A read tool can use narrower permissions and can often run without approval. A write tool can require stronger authorization, richer validation, and an explicit confirmation step for sensitive changes.

This separation also improves testing. You can evaluate retrieval and interpretation independently from state change, reducing the number of ways one bad tool call can affect production data.

Design the integration so another team can own it

A production integration should be understandable without the original builder in the room. Document the purpose, identity, permissions, input and output contract, known failure modes, retry behavior, and where operational evidence is recorded. If the tool changes state, include the rollback or compensating action.

This matters for AB-620 because enterprise agent solutions cross team boundaries. A connector may be managed by the Power Platform team, an API by an application team, and an MCP server by an integration team. Clear ownership and contracts keep those boundaries from becoming hidden dependencies.

The best integration is the narrowest dependable capability

AB-620 scenarios become easier when you stop asking “which feature should I use?” and ask “which interface provides the strongest contract for this business action?” A native connector may be enough. A custom connector may create the right reusable boundary. REST may be direct and precise. MCP may standardize a tool ecosystem. Computer use may be necessary for a legacy system.

Whichever path you choose, keep permissions narrow, arguments validated, side effects explicit, and errors observable. That is the difference between an agent that can reach enterprise systems and an agent solution that can be trusted to work with them.