6.3 Add Tools to a Topic

Microsoft Certified: AI Agent Builder Associate AB-620

Track your progress as you read

Finished sections get a check mark.

1 Introduction & Exam Overview

1.1 Current Exam Facts 1.2 Candidate Profile & Prerequisites 1.3 Skills Map & Study Strategy

2 Plan Integration, Identity & Channels

2.1 Plan Integration with Enterprise Systems 2.2 Plan Identity Strategy 2.3 Plan Channels and Deployment

3 Responsible AI, Security & Reuse

3.1 Plan Responsible AI Strategy 3.2 Security and Governance Considerations 3.3 Plan Reusable Agent Components 3.4 Design Agents for Internal or External Audiences

4 Agent Flows Fundamentals

4.1 Create an Agent Flow 4.2 Human-in-the-Loop Agent Flows 4.3 Configure Actions and Connectors in Flows

5 Agent Flow Monitoring & Resilience

5.1 Monitor Agent Flows 5.2 Input and Output Parameters 5.3 Error Handling in Agent Flows

6 Topics Configuration Core

6.1 Add Agent Flows to a Topic 6.2 Configure Agent Response Formatting 6.3 Add Tools to a Topic

7 Advanced Topic Responses

7.1 Custom Prompts for Advanced Responses 7.2 Custom Knowledge Sources for Advanced Responses 7.3 API and Send HTTP Request Responses

8 Generative Answers, Cards & Variables

8.1 Configure the Generative Answers Node 8.2 Configure Adaptive Cards 8.3 Manage Variables

9 Enterprise Knowledge Sources

9.1 Connect to Copilot Connectors 9.2 Connect to Power Platform Connectors 9.3 Connect to Azure AI Search

10 Add Tools to Agents

10.1 Configure and Monitor Computer Use 10.2 Configure MCP Tools 10.3 Tools via Existing Custom Connectors 10.4 Add REST APIs to an Agent

11 Multi-Agent Collaboration

11.1 Design Multi-Agent Solutions 11.2 Integrate a Foundry Agent 11.3 Integrate an Existing Copilot Studio Agent

12 Fabric Data Agents & A2A

12.1 Integrate a Fabric Data Agent 12.2 Multi-Agent Solutions with A2A Protocol

13 Integrate Agents with Azure

13.1 Generative Answers with Azure AI Search & Foundry 13.2 Foundry Model Catalog for Custom Prompts 13.3 Monitor Agents with Application Insights

14 Evaluate Agent Performance

14.1 Create a Test Set 14.2 Choose an Evaluation Method 14.3 Review Test Results

15 Application Lifecycle Management

15.1 Create a Solution 15.2 Add Existing Agents to a Solution 15.3 Create and Use Environment Variables 15.4 Power Platform Pipelines for Agents

6.3 Add Tools to a Topic

Key Takeaways Explain This Topic AI

Tools extend agents with connectors, agent flows, prompts, REST APIs, MCP, computer use, and related mechanisms to act on external systems.

Agent-level tools can be selected by generative orchestration from name, description, inputs, outputs, and context; classic orchestration requires explicit topic calls.

Calling Add a tool inside a topic inserts an Action node for deterministic, scripted control of when the tool runs.

High-quality tool descriptions and input metadata drive tool selection and generative question generation for missing parameters.

Configure authentication (end user vs maker-provided), optional user confirmation before run, and completion behavior for each tool.

Last updated: August 2026

6.3 Add Tools to a Topic

Quick Answer: Register capabilities on the agent Tools page for generative selection, and/or insert Add a tool action nodes inside topics for deterministic calls. Write clear names and descriptions , configure inputs (dynamic AI fill vs custom values), set authentication and completion , then test that the right tool fires for the right intent.

Leaf skill Add tools to a topic sits next to agent-flow wiring and response formatting. AB-620 expects you to explain scope (agent vs topic), selection (planner vs hard-coded node), and metadata (descriptions that make generative orchestration safe and accurate).

What counts as a tool

Microsoft describes tools as building blocks that let the agent interact with external systems. Common tool types include:

Mechanism What it enables

Prebuilt connector Thousands of Microsoft and partner APIs (Outlook, Dataverse, ServiceNow patterns, weather, and more)

Custom connector Your OpenAPI-wrapped service with org share/view permissions
Agent flow Multi-step automation with Respond to the agent
Prompt Single-turn model prompt with optional knowledge and structured response format
REST API Direct endpoint/method tools without a full connector package
Model Context Protocol (MCP) Tools/resources exposed by an MCP server
Computer use GUI automation when no API exists
Related Azure Bot Service skills, client tools (event activities to the client)

You create tools from the agent Tools page ( Add a tool → existing or New tool ) or call existing tools from topics.

Agent-level tools vs topic-scoped calls

This distinction is an exam favorite.

Agent-level tools (orchestrator inventory)

Tools added to the agent are available for automatic orchestration across conversations when generative orchestration is on and Allow agent to decide dynamically when to use the tool remains selected.

The planner considers:

Tool name and description
Conversation context and derived user intent
Available inputs/outputs and prior tool use in the conversation
Topic-scoped explicit calls

Inside a topic:

Topics → open topic → Add node → Add a tool .

Pick from tabs such as basic tools, connector, and tool catalogs.

An Action node appears; map inputs; continue the topic after outputs return.

Save (and republish agent as needed).

Use explicit topic calls when you need:

Fixed order (authenticate → validate → tool → message)
Branching that depends on tool outputs before any generative summary
Classic orchestration , where tools cannot be freely planner-selected and must be called from topics
Guarantees that a tool never runs without a prior adaptive card or policy check

Decision Prefer agent-level dynamic tool Prefer topic action node
Orchestration Generative, intent-driven Classic or regulated sequences
UX Natural language “check weather in Seattle” Multi-step form then submit
Metadata Excellent descriptions required Trigger phrases/description still matter for entering the topic
Risk Mis-selection if descriptions overlap Maker controls exact moment of invocation

You can combine both: register the tool on the agent for reuse, and call it from a topic. If dynamic use would be dangerous for a high-risk tool, clear the option that lets the agent decide dynamically so only explicit topic calls run it.

Descriptions that drive generative orchestration

Microsoft’s generative orchestration guidance is blunt: high-quality descriptions are how the agent associates user intent with tools and topics. For tools, the add wizard often prepopulates a description— edit it .

Writing style (exam-ready rules)

Simple, direct language; active voice; present tense.

Keywords users actually say (“weather,” “forecast,” “ticket,” “invoice”).

One or two sentences: what it does and when to use it.

Unique names: “Weather Forecast,” not ambiguous “Helper.”

Disambiguate siblings: say what the tool does not do when two tools are similar.

Weak: Name Answer Question / Description This tool can answer questions.

Stronger: Name Create ServiceNow Incident / Description Creates an IT incident in ServiceNow for hardware or software failures. Use when the user needs a tracked ticket. Does not answer HR policy questions.

Poor overlap causes the agent to invoke multiple similar tools; test and revise descriptions.

Inputs, validation, and generative questions

On the tool configuration Inputs table, each parameter has a fill mode:

Fill approach Behavior
Dynamically fill with AI (default) Extract from utterance/context; if missing, generate a question
Custom value Literal, variable, or Power Fx—agent will not ask the user

Customization can include display name, description, identify-as entity mapping, retry logic, and extra validation. Human-friendly input names (“start date,” “email address”) help the model form natural clarifying questions—so you often do not hand-author a Question node for every field when generative orchestration owns collection.

Still author explicit questions or adaptive cards when fields are sensitive, multi-field at once, or must match a corporate form layout.

Authentication, confirmation, and completion
Authentication

Tools run in the user context of the agent runtime and generally require authentication appropriately enabled:

End user credentials: least privilege; user only sees what they can access (default pattern for many personal data tools).

Maker-provided credentials: shared connection; good for common reference data, riskier for personal LOB records—govern carefully.

Ask the end user before running

Optional confirmation gate in the chat experience before the tool executes—useful for send-email or delete-record style actions. Default is often No ; flip to require consent when business risk is high.

Completion

As in response formatting: don’t respond (fold into orchestrator reply), generative write-up, specific response, or Adaptive Card. Also choose which output variables remain available to the agent and downstream tools.

Classic vs generative recap for tools

Behavior Generative Classic
Tool selection By name/description among agent tools Only via topic action nodes
Knowledge interplay Can combine tools + knowledge + topics Knowledge often fallback; tools still topic-bound
Asking for inputs Auto questions from tool metadata Author Question nodes
Multi-tool plans May chain tools/topics in sequence You chain nodes yourself

Admin note: if an environment admin disables generative orchestration, agents there are classic-only—plan topic-level tool calls as the primary path.

Scenario patterns
Scenario A — Weather lookup (simple tool topic)

Topic Get weather with trigger phrases (“will it rain,” “today’s forecast”). Single Add a tool action for MSN Weather (or equivalent). Map location from variable or AI fill. Message or generative completion returns forecast. Teaches minimal topic + tool.

Scenario B — High-risk refund tool

Agent-level tool Issue Refund with dynamic use disabled . Only the Refund request topic calls it after manager-code validation and adaptive card confirmation. Completion uses Send specific response with amount and reference ID.

Scenario C — MCP specialist tools

MCP connector added at agent level; generative orchestration picks MCP tools by their published names/descriptions. Topic still used for onboarding explanation and responsible-AI disclosure, not for re-implementing each MCP method as a flow.

Scenario D — Classic mode customer

Tenant policy forces classic orchestration. Every connector action the business needs appears inside topics with trigger phrases and Question nodes. Agent-level tool list alone will not “wake up” without topic design.

Testing and activity map

With generative orchestration, use the test panel activity map to verify which tool or topic the planner chose. For topic action nodes, step through variables before and after the Action node. After schema changes, refresh the action node, save, republish, and start a new test conversation so stale context does not mask binding bugs.

Decision cheat sheet for AB-620

Need the planner to discover a capability from free text? Agent-level tool + excellent description + dynamic allowed.

Need guaranteed step order or classic mode? Topic Add a tool action node.

Multi-step systems choreography / HITL? Prefer agent flow tool (still invocable from topics).

No API, only UI? Computer use (with monitoring and governance).

Structured enterprise API reuse? Custom connector or REST tool with clear inputs/outputs.

Overlapping tools mis-fire? Rename, rewrite descriptions, add “does not” clauses, retest.

Closing checklist

Tool published/available and visible on Tools page or topic picker.

Description unique and intent-aligned.

Inputs validated; sensitive fields not left to sloppy AI fill without confirmation.

Auth mode matches data sensitivity.

Completion mode matches compliance for user-visible text.

Dynamic use enabled only when safe.

Classic vs generative implications documented for the solution.

Adding tools to topics is how Copilot Studio agents leave the chat bubble and act on the enterprise. AB-620 rewards builders who choose the right scope, write metadata the orchestrator can trust, and still fall back to explicit topic actions when determinism wins.