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 →