Microsoft AI Agent Builder

An agent must know who is asking and where it is being asked. You plan authentication, user context, the channels agents appear in, and the enterprise systems they connect to.

• Authentication options for agents and users
• Maker credentials and user credentials
• Channels: Teams, Microsoft 365 Copilot and websites
• Integration patterns for enterprise systems
• Data loss prevention policies that affect agents
• Environments and who can build what

You build An integration and identity plan for one agent across two channels.

Agents speak for the organization. You set boundaries on what an agent may say and do, configure content moderation, disclose that users are talking to an AI, and plan for the requests it should refuse.

• Identifying risks in an agent’s scope
• Content moderation settings
• Disclosure and user expectations
• Refusals and safe fallbacks
• Human escalation paths
• Reviewing conversations for harm

You build A responsible AI checklist for an agent, carried into its settings and fallbacks.

Topics give an agent reliable paths through common tasks. You design trigger phrases, build conversation nodes, and use variables to carry what the user said and what the system found.

• Topic triggers and routing
• Question, message and condition nodes
• Variable types and scope
• Entities and slot filling
• Power Fx in topics
• System topics and fallback behavior

You build A set of topics that collects information, branches on it and carries state through the conversation.

Text is not always the best reply. You design adaptive cards that collect input and present results, bind them to variables, and make them clear and accessible.

• Adaptive card structure and the card designer
• Input controls and validation
• Binding card values to variables
• Dynamic content with Power Fx
• Accessibility and layout
• Cards across channels

You build An adaptive card that gathers a request and shows its status.

Generative answers let an agent respond beyond scripted topics. You write instructions, configure generative orchestration, and build custom prompts that the agent can call for tasks such as summarizing or classifying.

• Generative orchestration compared with classic topics
• Writing agent instructions
• Generative answers over knowledge
• Custom prompts with inputs and outputs
• Model choice for prompt steps
• Handling answers the agent cannot ground

You build An agent that answers from knowledge and uses a custom prompt to classify requests.

Some work belongs in a flow rather than a conversation. You build agent flows with triggers, actions and conditions, and add approval and review steps so a person decides before anything consequential happens.

• Agent flows compared with cloud flows
• Triggers, actions and expressions
• Calling a flow from an agent
• Approvals and human-in-the-loop steps
• Error handling and retries
• Monitoring flow runs

You build An agent flow that gathers inputs, routes an approval and writes back the result.

An agent is only as useful as what it can read. You connect SharePoint, files, websites and Dataverse as knowledge, manage permissions and freshness, and see how source quality changes answers.

• Choosing knowledge sources
• SharePoint, files and public websites
• Dataverse and structured knowledge
• Respecting user permissions on content
• Source quality, freshness and conflicts
• Citations and answer verification

You build An agent grounded in three knowledge sources, with a note on each one’s limits.

Tools let an agent act. You build custom connectors for REST APIs, connect MCP servers, and use computer use for systems without an API, while keeping each tool’s inputs and permissions tight.

• Connectors, prebuilt and custom
• Describing a REST API for a custom connector
• Authentication in custom connectors
• Adding MCP tools to an agent
• Computer use for applications without APIs
• Writing tool descriptions that guide the model

You build An agent that calls a custom connector and an MCP tool, with a described action set.

Complex requests need specialists. You connect child agents, A2A endpoints, Foundry agents and Fabric data agents to a Copilot Studio agent, and decide which agent owns which part of the task.

• Child agents and connected agents
• The A2A protocol for cross-platform agents
• Calling Foundry agents
• Fabric data agents for analytic questions
• Routing and handoff design
• Debugging a multi-agent conversation

You build A coordinating agent that delegates to one Foundry agent and one connected agent.

Conversations vary, so testing needs sets of cases. You build test sets, run them, read the evaluation results, and decide what to change in instructions, knowledge or tools before release.

• Test sets: authoring and generating cases
• Test methods for different kinds of answers
• Running evaluations and reading results
• Analytics and conversation transcripts
• Fixing issues at their source
• Regression testing after changes

You build A test set that runs against an agent, with a report of what failed and the fixes.

Agents change after they ship. You package them in solutions, use environment variables and connection references to separate settings from design, and move them through environments with Power Platform Pipelines.

• Solutions and what goes in them
• Environment variables and connection references
• Managed and unmanaged solutions
• Power Platform Pipelines
• Versioning and rollback
• Governance and approvals for release

You build An agent solution that moves from development to test to production through a pipeline.

Build one agent that does real work. You plan it, shape its conversations, connect knowledge and tools, add a flow with approval, test it, and release it through environments.

• Planning the agent and its controls
• Building topics, prompts and knowledge
• Connecting tools and a second agent
• Testing and fixing
• Releasing and handing it over

You build A released agent with knowledge, tools, a flow, a test set and a release pipeline.