Agents · Lesson 07 Pro+ ~14 min read Build + deploy

Copilot Studio: agents you architect, not buy.

Microsoft's named agents (Researcher, Analyst, Sales, etc.) solve common patterns. For everything else, Copilot Studio is the build platform — visual flow editor, connectors to your systems, your own knowledge sources, and publishing as a real agent inside Copilot Chat or Teams. This is the Pro+ tier of Microsoft AI mastery.

Workflow 01 When to build vs. buy (use a named agent)

1

The build/buy decision for custom agents

Don't build what you can configure. Most use cases are better served by a named Microsoft agent + good configuration than by building from scratch. The framework below tells you when to build.

The prompt that works

Build/buy decisionBuild a custom agent when: • Your workflow uses systems Microsoft's named agents don't touch (line-of-business apps, niche SaaS) • Your process has unusual logic Microsoft doesn't anticipate (industry-specific compliance, multi-step approvals) • You need to embed agent capability in a specific product or experience • Your customer-facing requirements need branding or specific UX Use a named agent (Researcher, Analyst, etc.) when: • The use case is general (research, analysis, meeting notes, sales prep) • Microsoft already covers 80% of what you need • The remaining 20% can be solved via configuration or prompting • You're not ready to maintain a custom agent over time

Best use cases

  • Initial evaluation of a new agent project
  • Migration assessment (we built an agent — should we keep it?)
  • Team capability planning
  • Total-cost-of-ownership analysis
Building custom agents is fun. The trap is building things that 70% duplicate a named agent. Always verify the named agent can't do what you need first.
Time savings: Building/buy clarity: avoids weeks of work on the wrong path.

Workflow 02 Build a custom agent — the structure

2

The pieces of a Copilot Studio agent

A Copilot Studio agent has 4 main pieces: trigger, topics (the conversations it handles), knowledge sources (your data), and actions (the things it can do).

The prompt that works

Agent structureAnatomy of a custom agent: 1. **Trigger** — what starts the conversation? - User invokes by name (chat with 'expense agent') - Inline trigger (typing 'submit expense' anywhere in Copilot) - Programmatic (another system calls it) 2. **Topics** — the conversation flows it handles - Each topic is a flow: triggers, dialog nodes, branching logic - Example: 'Submit an expense' topic handles the whole flow from category to amount to receipt upload 3. **Knowledge sources** — what it knows - SharePoint sites, OneDrive folders, public websites, custom docs - The agent searches these when answering related questions 4. **Actions** — what it can do - Power Automate flows (your existing workflows) - Custom connectors to your APIs - Native Microsoft actions (create a Teams message, file a SharePoint item, etc.)

Best use cases

  • Internal IT helpdesk agent
  • Expense or PTO submission agent
  • Customer-facing FAQ agent
  • Vendor onboarding workflow agent
Topics that branch heavily get hard to maintain. Keep individual topics focused; chain them through actions if a workflow is multi-step.
Time savings: Custom agent for a real workflow: 2-3 weeks to build, then permanent.

Workflow 03 Knowledge sources that work

3

Connect the right data, structured right

Most custom-agent failures come from messy knowledge sources. The agent searches what you point at — if it's outdated, scattered, or contradictory, the agent confuses users.

The prompt that works

Knowledge curationKnowledge source best practices: • **Curate, don't dump** — Don't point the agent at 'all of SharePoint.' Point it at 5-15 specific, well-maintained pages or documents. • **One source of truth per topic** — If your expense policy exists in 3 places, the agent will get confused. Designate one as canonical, redirect the others. • **Last-updated dates matter** — agents preferring recent sources is built-in. Documents 2+ years old get used less reliably. • **Structure your docs** — Headings, bullet lists, clear sections. The agent finds info faster. • **Anti-patterns to flag** — outdated wiki pages, drafts marked 'final v2,' SharePoint sites with permissions you can't audit.

Best use cases

  • Building an HR policy agent
  • IT helpdesk agent powered by your runbooks
  • Sales enablement agent on internal playbooks
  • Compliance answer agent on policy docs
Knowledge source quality is the single biggest factor in agent quality. A well-prompted agent on bad data is worse than a basic agent on great data.
Time savings: Curated sources: agent quality from 'sometimes right' to 'reliably correct.'

Workflow 04 Actions — let the agent do, not just say

4

Wire up Power Automate and custom connectors

The transformative capability: actions let the agent create tickets, send approvals, update records — not just answer questions.

The prompt that works

Actions designCommon action patterns: • **Lookup actions** (read-only, no confirmation needed) - Look up an employee's PTO balance - Check ticket status in ServiceNow - Find a customer's contract end date in Dynamics • **Create-with-confirmation actions** (always confirm before executing) - File an expense report - Submit a PTO request - Open a support ticket - Send a meeting request • **Notify actions** (low-risk) - Post to a Teams channel - Send a calendar invite - Add a SharePoint item • **Avoid auto-actions** (require human-in-the-loop) - Approving anything financial - Sending external emails - Modifying production data - Any irreversible action

Best use cases

  • Self-service IT ticket creation
  • HR self-service (PTO, benefits questions, etc.)
  • Sales pipeline updates
  • Internal expense and finance workflows
Always design with confirmation for create/modify actions, even if it feels redundant. The first time the agent auto-submits something incorrect, you'll wish you had.
Time savings: Self-service agents: reduce manual workflow handling 60-80%.

Workflow 05 Test and publish

5

How to roll out a custom agent without breaking things

The last step is rollout. Test thoroughly, deploy to a pilot group, expand based on real usage.

The prompt that works

RolloutRollout sequence: 1. **Internal test** — invite 3-5 trusted users to test for 1 week - Have them try to break it: ambiguous prompts, edge cases, off-topic queries - Track every failure or weird interaction 2. **Iteration** — fix the top 10 issues from internal test - Add knowledge sources for what was missing - Refine topic flows for confused conversations - Strengthen guardrails for the off-topic prompts 3. **Pilot** — release to a small department (10-30 users) - Track usage metrics: invocations, completed flows, fallback to human - Survey users at end of pilot - Iterate one more time 4. **General release** — publish to the broader org - Include training material: what the agent does, what it doesn't - Set up feedback channel for bug reports - Monitor monthly metrics; iterate quarterly

Best use cases

  • Any custom agent shipping to production
  • Major changes to an existing agent
  • Migration from a third-party tool to a custom agent
  • Org-wide deployments
Skip the pilot at your peril. Bugs that pass internal test consistently surface in pilot. Don't go org-wide until pilot is clean.
Time savings: Disciplined rollout: 1 month upfront → years of clean operation.

Build a small, scoped custom agent end-to-end

Pick a real workflow that's annoying for your team: PTO requests, expense submissions, helpdesk routing. Build a Copilot Studio agent for it end-to-end. Pilot it with 5 users. See whether it's worth scaling. The skill is in the iteration, not the first version.

What you can do now

  • Verify a named Microsoft agent can't do it before building custom
  • Curate knowledge sources tightly — quality over quantity
  • Use confirmation for create/modify actions, never auto-execute
  • Pilot with a small group before org-wide release
  • Set up feedback monitoring after release
Pro+
Up next in Copilot Mastery

The full Copilot agent ecosystem

You've now covered the 7 most important Copilot agents — and the platform to build your own. The next horizon is governance, agent inventory management, and the role of the AI architect. See the track →