Automating Branded PowerPoint Generation with Copilot Studio

Enterprise users do not wake up asking for another chatbot. They ask for the thing the business actually needs: a board-ready deck, a customer workshop pack, a policy briefing, a renewal summary, or an executive narrative that already looks like it belongs to the company.

That is why branded PowerPoint generation is such an interesting Copilot Studio use case. It sits at the intersection of productivity, governance, brand control, and AI cost management. If you get it right, you do not just save a few hours of formatting. You create a repeatable content supply chain.

But here is the catch: a PowerPoint-generating agent is not just a prompt with a .pptx output at the end. It is a small production system. It needs templates, knowledge, instructions, cost guardrails, human review, and a clear understanding of which work should be handled by AI and which work must remain deterministic.

This article reframes the architecture for IT leaders, FinOps practitioners, and tenant administrators who need to answer three practical questions:

1. Can we automate branded decks without losing control of brand, data, and quality?
2. Can we forecast and contain the cost of this agent before it becomes popular?
3. Can we roll it out safely across departments without every team building its own shadow deck bot?

My short answer: yes, but only if you treat the agent like a governed content factory, not a clever demo.

Core objective: use Copilot Studio and its orchestrator to generate branded PowerPoint presentations from custom assets, approved templates, enterprise knowledge, and Work IQ-style context. The business goal is not simply to produce slides faster. It is to produce consistent, governed, reusable communication assets that reduce manual effort without creating brand, data, or cost chaos.

The Mental Model: Build a Deck Factory, Not a Slide Generator

A traditional prompt says, “Create me a presentation.”

A governed enterprise agent says:

“I will collect the business intent, choose the right template, retrieve only permitted context, assemble a deck using approved layouts, inject assets into controlled placeholders, estimate the consumption profile, and route the output through review when risk is high.”

Think of the system as a factory line:

Factory Station	Agent Equivalent	Governance Question
Intake desk	The agent gathers topic, audience, purpose, slide count, and source material	Did we collect enough context before spending credits?
Pattern library	Slide architectures such as executive brief, policy explainer, status update, proposal	Are teams using approved storytelling patterns?
Brand machine	PowerPoint templates, placeholders, fonts, colors, icons, image rules	Is the output brand-safe by design?
Materials room	SharePoint files, uploaded documents, Work IQ context, images, approved stock assets	Is the agent using data the user is allowed to access?
Assembly robot	Script or action that builds the .pptx	Is generation deterministic enough to trust?
Quality gate	Review, test runs, activity map, transcript analysis, human approval	Do we understand failure modes before production rollout?
Cost meter	Copilot Credits, PAYG, prepaid capacity, environment allocation	Can FinOps explain and forecast the bill?

This is the architectural shift. Do not design for “AI creativity” first. Design for controlled repeatability, then allow creativity inside approved lanes.

What Changed: Generative Orchestration Makes Routing a First-Class Design Problem

Copilot Studio agents can use classic orchestration or generative orchestration. With generative orchestration, the agent can select tools, topics, knowledge sources, and other agents based on descriptions, names, inputs, outputs, and conversation context. Microsoft describes this as an LLM-driven planning layer that interprets intent, breaks requests into steps, selects the right building blocks, and executes multi-step plans within guardrails.¹

That matters because deck generation is rarely a single-step task. A realistic user request might be:

“Create a 10-slide executive summary for our Copilot adoption steering committee using the latest SharePoint status report and make it suitable for a CFO audience.”

A well-designed orchestrated agent should not simply start writing slides. It should route the work:

1. Identify the output type: PowerPoint deck.
2. Ask for missing requirements: audience, tone, slide count, deadline, source priority.
3. Retrieve permitted context from knowledge sources or Work IQ-enabled surfaces.
4. Choose an approved template and slide architecture.
5. Generate a slide outline before building the final file.
6. Execute a controlled generation action.
7. Return the deck with caveats, citations, and review guidance.

Microsoft’s guidance is very clear that descriptions matter. In generative orchestration, tools and topics are selected based heavily on their names and descriptions, and overlapping descriptions can cause the agent to pick multiple components unexpectedly.²

For tenant admins, this means the most important governance artifact may not be the script. It may be the metadata around the script.

Classic vs. Generative Orchestration: The Practical Difference

Decision Area	Classic Orchestration	Generative Orchestration	What Leaders Should Care About
Routing logic	Trigger phrases and authored topics	Agent selects topics, tools, knowledge, and agents based on descriptions	Better flexibility, but metadata quality becomes a governance dependency
Missing inputs	Makers author explicit question nodes	Agent can ask generated questions for missing tool or topic inputs	Faster design, but test the questions for tone and accuracy
Knowledge usage	Often fallback-oriented or explicitly called	Agent can proactively search knowledge	Better contextual output, but data source curation matters more
Multi-intent requests	Usually manually designed	Agent can chain multiple components	Powerful for deck workflows, risky if tools overlap
Admin posture	More deterministic	More adaptive	Use deterministic controls for irreversible or high-risk actions

The Core Architecture

A branded deck agent needs four layers.

Layer	What It Contains	Design Principle
Experience layer	Greeting, suggested prompts, guided intake questions	Make the right path obvious before users improvise
Orchestration layer	Copilot Studio instructions, topics, tools, descriptions, trigger rules	Route based on intent, not on user knowledge of templates
Content and context layer	SharePoint, uploaded files, approved knowledge, Work IQ context, source documents	Ground the deck in governed enterprise context
Generation layer	Templates, placeholders, asset mapping, .pptx generation script or service	Make layout and brand deterministic

The mistake I see too often is putting all the intelligence in one giant prompt. That feels fast during a demo, then becomes impossible to operate. Strong architecture separates reasoning, retrieval, branding, and execution.

Also customize the front door. Change the default Copilot Studio greeting so users understand what the agent can and cannot do, then add suggested prompt buttons such as:

• “Create an executive decision deck from these files”
• “Turn this IT policy into a 6-slide briefing”
• “Build a customer workshop deck using the business template”
• “Create a lighthearted team event deck”

Suggested prompts are not cosmetic. They reduce vague requests, improve intake quality, and lower avoidable regeneration cost.

Work IQ: Useful Context, Not a Blank Check

Work IQ is Microsoft’s workplace intelligence layer for agents. It is designed to help agents access and reason over organizational data, context, and tools with permission-aware governance. Microsoft describes Work IQ as combining chat, context, tools, and workspaces, with endpoints including A2A, remote MCP, and REST APIs. Usage is independent of Microsoft 365 Copilot licensing and is available through usage-based billing.³

For deck generation, the mental model is simple:

A deck agent might use Work IQ-style context to understand:

• recent meeting outcomes,
• relevant files in SharePoint or OneDrive,
• people and organizational context,
• Teams messages or project references,
• calendar and meeting signals,
• enterprise search results.

But do not oversell this. Work IQ does not remove the need for governance. It makes context easier to assemble, but tenant administrators still need to think about permissions, sensitivity, data residency, retention, and financial impact.

Asset Strategy: Keep Templates Light, Reusable, and Boring

The best enterprise PowerPoint templates are not the most visually impressive files. They are the most operationally reliable files.

Your baseline templates should include:

• approved fonts,
• approved theme colors,
• title, section, comparison, timeline, quote, chart, and closing layouts,
• native PowerPoint placeholders,
• accessible contrast rules,
• speaker note conventions,
• optional dark, standard, and high-impact variants.

Do not embed huge images into every template unless they are genuinely required. Use placeholders and inject images at runtime. This keeps the template maintainable and reduces the chance that every generated deck inherits stale campaign artwork.

A better guidance statement is:

Template Portfolio: Three Is Usually Enough

Do not give the agent 17 templates and hope the model becomes a creative director. Start with three controlled options.

Template	Best For	Default Tone	Approval Requirement
Business	Policies, updates, customer briefings, internal programs	Clear, professional, neutral	Standard review
Executive	Steering committees, board updates, renewal summaries	Concise, outcome-driven, numbers-first	Business owner review
High-energy	Culture, enablement, hackathons, team events	Friendly, visual, informal	Brand review if external-facing

Then let the agent choose automatically based on user intent. Users should not need to know the template catalog. If they ask for a CFO update, route to Executive. If they ask for an IT policy explainer, route to Business. If they ask for a team celebration, route to High-energy.

This is a governance win. You are not removing choice. You are moving choice into a controlled routing strategy.

Skill and Folder Design: Separate Assets, Rules, and Execution

If you package this pattern as a reusable skill or generation capability, keep the structure predictable.

Folder/File	Purpose	Governance Tip
skill.md	Describes when the deck-generation capability should be used and what it does	Use action-oriented names and precise trigger descriptions
Assets/	Stores lightweight PowerPoint templates, brand icons, approved imagery, and sample layouts	Use placeholders instead of embedding unnecessary large media
References/	Stores slide architecture guidance such as executive brief, proposal, policy explainers, and status update flows	Make these business-readable, not developer-only
Scripts/	Stores the generation logic or action wrapper used to build the deck	Keep layout rules deterministic and version-controlled
Tests/	Stores sample prompts, expected outlines, and regression outputs	Test brand, cost, routing, and failure behavior

The key is to avoid mixing concerns. A brand rule should not be buried inside Python. A storytelling pattern should not be hidden inside a prompt. A cost-control rule should not depend on a maker remembering to say the right thing each time.

Configuring skill.md: Progressive Disclosure Is a Governance Tool

Copilot Studio skills and agent capabilities should be written for progressive disclosure: load the right capability only when the user intent requires it. That means skill.md is not just documentation. It is part of the routing system.

Use a simple three-part pattern:

skill.md Area	What to Do	Example
Name	Use action verbs, not vague nouns	creating_branded_powerpoint instead of presentation_helper
Description, part 1	Define the trigger	”Generates a branded PowerPoint presentation whenever the user asks for a slide deck, executive presentation, policy briefing, or workshop deck.”
Description, part 2	Define what happens with context	”Uses approved templates, bundled assets, user-provided files, and permitted enterprise context to build the deck.”
Body	Add critical operating notes based on observed failures	”Use different images across slides. Do not repeat the same placeholder image throughout the entire deck unless the user explicitly asks for it.”

This is where you encode hard-earned lessons. If test runs show that the agent repeats one image across every slide, add a Critical Note. If it keeps choosing the fun template for policy briefings, tighten the trigger description. If it generates generic summaries instead of decks, clarify the output contract.

In other words: do not only prompt the model. Train the routing surface.

The Script Generation Trick, With a Governance Warning

The original version of this article suggested using the agentic loop to help generate the PowerPoint script: run, fail, fix, print the working script, and save the dynamic version.

I still like the idea, but I would reframe it.

Use AI to accelerate script discovery, not to bypass engineering hygiene.

A safe version of the pattern looks like this:

1. Prototype the generation script in a development environment.
2. Let the agent help identify missing mappings, bad placeholders, and template edge cases.
3. Extract the working logic.
4. Remove hard-coded values.
5. Add deterministic validation: slide count, required placeholders, supported image types, max file size, required metadata.
6. Version the script with the template version it supports.
7. Run a regression pack before production use.

Do not let a production agent rewrite its own deck-generation script on the fly. That is not autonomy. That is an audit finding waiting to happen.

Instructions: The Agent Needs a Contract, Not a Vibe

The instruction prompt should act like an operating contract. It should tell the agent what it is allowed to do, what it must ask before acting, when it should use tools, and when it should stop.

A practical structure:

1. Mission

The agent creates branded PowerPoint presentations using approved templates, approved slide architectures, and governed enterprise context.

2. In Scope

• Create PowerPoint decks from user-provided or permissioned enterprise context.
• Select the best template automatically based on audience and purpose.
• Propose a slide outline before building the final deck.
• Use approved placeholders and assets.
• Return a generated .pptx file for review.

3. Out of Scope

• Do not generate raw HTML as the final deliverable.
• Do not modify the master template structure unless an admin-approved template update process is invoked.
• Do not invent financial, legal, customer, or HR claims that are not grounded in provided or retrievable sources.
• Do not use unapproved fonts, colors, logos, or imagery.
• Do not create external-facing customer claims without review.

4. Required Intake Parameters

The agent should not build the deck until it has enough information.

Required Input	Why It Matters	Example Prompt
Topic	Defines the narrative center	”What is the deck about?”
Purpose	Determines persuasion vs. explanation vs. reporting	”Is this for decision, awareness, training, or approval?”
Audience	Controls level of detail and tone	”Who will read or attend this deck?”
Approximate slide count	Controls scope and cost	”Do you want a short 5-slide version or a fuller 10-slide version?”
Source material	Grounds claims	”Should I use uploaded files, SharePoint content, meeting notes, or your summary?”
Sensitivity	Determines review path	”Is this internal-only, confidential, or external-facing?”

This intake phase is also a cost-control lever. Every unnecessary generation attempt consumes capacity. Good intake reduces rework.

Cost Intuition: Copilot Credits Are the Meter Behind the Magic

Copilot Studio now uses Copilot Credits as the common unit for agent usage. Microsoft states that the common currency changed from messages to Copilot Credits starting September 1, 2025, with pay-as-you-go, prepurchase plans, and prepaid Copilot Credit pack subscriptions available.⁵

Microsoft’s billing documentation says Copilot Credits are pooled across the tenant, and consumption depends on agent design, interaction volume, and features used.⁶

Here are the current Microsoft-published planning rates that matter most for this scenario:

Agent Feature	Published Billing Rate	Cost Intuition
Classic answer	1 Copilot Credit	Cheap and predictable
Generative answer	2 Copilot Credits	Good for flexible responses and summaries
Agent action	5 Copilot Credits	Adds up when orchestration chains many actions
Tenant graph grounding	10 Copilot Credits	Powerful, but should be used intentionally
Agent flow actions	13 Copilot Credits per 100 actions	Efficient for repetitive deterministic work
Content processing tools	8 Copilot Credits per page	Watch this for large document ingestion
Text and generative AI tools, premium	10 Copilot Credits per 1,000 tokens	Deep reasoning can become the expensive part

Microsoft also gives an example where a tenant graph grounded response can use 12 Copilot Credits: 10 for tenant graph grounding and 2 for a generative answer.⁶

Directional Planning Math, Not a Quote

The math below is a planning aid. It is not a quote, not licensing advice, and not a substitute for the official licensing guide or your Microsoft agreement.

Assume a user asks for a branded 10-slide executive deck. A realistic flow could include:

Step	Example Consumption Driver	Directional Credits
Intake conversation	3 generative answers	6 credits
Knowledge grounding	2 tenant graph grounded responses	20 credits
Outline generation	1 generative answer	2 credits
Deck generation action	1 to 3 agent actions	5 to 15 credits
Review and refinement	2 generative answers	4 credits
Estimated total	Typical governed deck request	37 to 47 credits

Now scale the intuition:

Scenario	Monthly Volume	Directional Credits per Deck	Directional Monthly Credits
Pilot team	50 decks/month	40	2,000
Department rollout	500 decks/month	40	20,000
Enterprise content factory	5,000 decks/month	40	200,000

This is why FinOps needs to be in the design conversation early. The first demo costs almost nothing. The first successful enterprise workflow can become a real meter.

The Hidden Cost Lever: Avoid Rework

The most expensive deck is not the deck that uses tenant grounding. It is the deck that gets generated five times because the first four attempts misunderstood the audience.

Practical cost levers:

Lever	Why It Reduces Cost	Governance Owner
Require outline approval before .pptx generation	Prevents wasted full-deck builds	Business owner
Start with three templates, not twenty	Reduces routing ambiguity	Brand and IT
Use deterministic slide assembly	Avoids repeated layout failures	Platform team
Use Work IQ or knowledge grounding only when needed	Avoids unnecessary higher-cost grounding	Tenant admin / FinOps
Cache approved reusable content blocks	Reduces repeated reasoning and generation	Content operations
Monitor consumption by environment and agent	Enables showback and chargeback	FinOps

Admin Controls and Capacity Enforcement

Copilot Studio governance is not only about prompts. It is also about tenant capacity, environment setup, author access, and monitoring.

Microsoft states that Copilot Studio supports prepaid Copilot Credits, pay-as-you-go through an Azure subscription, and prepurchase plans. Pay-as-you-go is configured by linking environments to an Azure subscription through a billing policy in the Power Platform admin center.⁵

Microsoft also documents capacity enforcement. Purchased capacity is enforced monthly, unused credits do not carry over, and if usage exceeds purchased capacity, technical enforcement can apply. For prepaid capacity, enforcement is triggered at 125% of prepaid capacity, and custom agents can be disabled for subsequent attempts until capacity is increased or reset.⁵⁶

That means tenant administrators should decide the operating model before broad deployment:

Control Area	Recommended Starting Point
Environment strategy	Separate development, pilot, and production environments
Billing strategy	Start pilot with a controlled meter or allocated prepaid capacity
Capacity monitoring	Review Copilot Credit consumption weekly during pilot
Maker access	Restrict Copilot Studio authoring to an approved security group
Template ownership	Assign template owners in brand or communications team
Release management	Use solution-aware ALM for production agents where possible
Incident response	Define what happens if the agent exceeds cost thresholds or produces low-quality output

A deck agent should not be published into production with the same mindset as a personal productivity prompt.

A Safe Rollout Plan

Use a phased rollout. This is boring, and boring is exactly what you want for governed AI.

Phase	Audience	Goal	Exit Criteria
0. Design	IT, brand, FinOps, business sponsor	Define templates, cost assumptions, data boundaries	Approved scope, templates, intake model, and success metrics
1. Private pilot	5 to 10 expert users	Validate routing and deck quality	80%+ acceptable first-outline rate, no major policy issues
2. Department pilot	50 to 100 users	Measure demand and cost	Cost per useful deck understood, top failure modes fixed
3. Controlled production	Selected departments	Show business value	Monthly dashboard for usage, cost, satisfaction, and saved time
4. Scale	Enterprise users	Repeatable content supply chain	Chargeback/showback, template lifecycle, support model in place

Do not skip phase 1. Expert users are the best early testers because they know what a credible deck looks like and will immediately spot the weird AI mistakes.

What to Measure

If you only measure usage, you will celebrate the wrong thing. A popular agent can still be a bad investment.

Measure value and control together:

Metric	Why It Matters
Decks generated	Adoption signal
Decks accepted after first outline	Quality and intake signal
Average credits per completed deck	FinOps efficiency signal
Regeneration rate	Waste and prompt clarity signal
Human editing time saved	Business value signal
External-facing deck review pass rate	Risk and brand signal
Top templates used	Portfolio optimization signal
Top failure reasons	Backlog prioritization signal

My favorite metric is credits per accepted deck, not credits per conversation. It connects cost to useful output.

Failure Modes to Design Against

Here are the failures I would expect in real enterprise use:

Failure Mode	What It Looks Like	Preventive Control
Template drift	Agent generates off-brand layouts	Lock layout generation to approved templates and placeholders
Source confusion	Agent mixes outdated and current documents	Ask users to rank source priority and show citations where possible
Cost creep	Agent uses grounding and actions for every minor request	Route lightweight requests to cheaper patterns
Over-routing	Similar tool descriptions cause multiple tools to fire	Make names and descriptions unique and test activity maps
Executive fluff	Deck sounds polished but says nothing	Require business objective, decision needed, and metrics
Data leakage risk	Sensitive content appears in broader deck	Use permission-trimmed sources and sensitivity-aware review
Infinite refinement	Users keep asking for subjective changes	Set revision limits or switch to manual editing after a threshold

The agent should have an opinionated behavior: clarify first, outline second, generate third, refine within limits.

Practical Decision Guide

Use this quick guide when deciding how much automation to allow.

Use Case	Recommended Automation Level	Why
Internal team update	High	Low risk, repeatable structure
IT policy explainer	Medium-high	Good fit, but source accuracy matters
Executive steering committee deck	Medium	Human review required for narrative and numbers
Customer proposal	Medium-low	Brand and commercial risk require review
Board or regulatory deck	Low	Use agent for outline and drafting, not final authority
HR or legal communications	Low	Sensitive wording and policy risk

The more reputational, legal, financial, or customer-facing the deck is, the more the agent should behave like a drafting assistant rather than an autonomous publisher.

Example Agent Behavior

A good user experience might look like this:

User: Create a deck for the quarterly Copilot adoption steering committee.

Agent: I can help. Before I generate the PowerPoint, I need a few details so the deck fits the audience and avoids rework:

1. Is the audience executive, technical, or mixed?
2. Is the goal to inform, approve a decision, or request funding?
3. Do you want a short 5-slide version or a fuller 10-slide version?
4. Should I use uploaded files, SharePoint content, meeting notes, or a summary you provide?
5. Is this internal-only or external-facing?

User: Executive audience, decision approval, 8 slides, use the SharePoint status report, internal only.

Agent: Great. I will use the Executive template and the decision-brief architecture. I will first generate an outline for approval before creating the .pptx.

That last sentence is the difference between a toy and a governed workflow.

Execution Examples: Work IQ and Multimodal Inputs

A strong deck agent should handle more than typed prompts. The practical value shows up when users bring messy business context into the conversation and the agent still routes the work correctly.

Scenario	What the User Does	Expected Agent Behavior
SharePoint policy deck	Points the agent to an IT laptop travel policy or relevant knowledge source	Routes to the Business template and an informational architecture
Local document upload	Uploads a local text document, for example pilot results, adoption notes, or even a playful dataset about pilots and cats	Analyzes the document, proposes a slide-by-slide structure, and asks for approval before generation
Slide count override	Accepts the outline but asks for a shorter or longer version	Recalculates the structure based on the requested slide count instead of forcing the original recommendation
Mid-conversation image upload	Uploads AI art, a Power BI screenshot, a diagram, or customer-provided visuals	Maps the images into approved placeholders rather than breaking the template

This runtime flexibility is important, but the rule stays the same: users can override parameters, not governance. A user may ask for a shorter deck, a longer deck, or a different level of detail. They should not be able to override approved fonts, replace the logo with a random image, or force confidential content into an external-facing proposal without review.

Recommended Slide Architectures

Do not let every deck start from a blank page. Give the agent a small library of proven patterns.

Architecture	Best For	Typical Slides
Executive decision brief	Funding, approval, steering committee	Situation, decision needed, options, recommendation, risks, next steps
Policy explainer	IT, HR, security policies	What changed, who is impacted, key rules, examples, FAQ, support path
Program status	Transformation programs	Progress, milestones, risks, dependencies, decisions, next actions
Customer workshop	Advisory sessions	Context, business challenge, architecture, roadmap, responsibilities
Enablement training	Internal capability building	Why it matters, concepts, demo flow, exercises, resources

This is where the agent becomes strategically valuable. It does not just make slides. It applies a repeatable communication pattern.

Where Code Belongs

Code should exist, but it should not dominate the architecture conversation.

Use code for:

• reading template metadata,
• validating placeholders,
• inserting text and images,
• generating charts from structured data,
• checking required slide count,
• exporting the final .pptx,
• logging generation metadata.

Avoid code for:

• deciding business strategy,
• inventing claims,
• overriding brand rules,
• choosing sensitive data boundaries,
• determining whether a customer-facing deck is approved.

AI should help with judgment. Code should enforce structure. Humans should own accountability.

The Final Operating Model

If I were advising an enterprise rollout, I would define the operating model like this:

Role	Responsibility
Tenant admin	Environment, billing policy, security groups, capacity monitoring
FinOps practitioner	Forecasting, showback, cost-per-output reporting, threshold alerts
Brand owner	Template library, visual standards, approved assets
Business owner	Use case prioritization, acceptance criteria, value tracking
Platform team	Agent design, orchestration, ALM, testing, logging
Compliance/security	Data handling rules, sensitivity labels, review gates
Power users	Pilot feedback, prompt examples, failure detection

This is not bureaucracy. This is how you prevent every department from building its own deck-generation snowflake.

Key Takeaways

• A branded PowerPoint agent is a content factory, not a prompt trick. Treat intake, routing, templates, grounding, execution, review, and cost as separate stations.
• Generative orchestration is excellent for routing and context gathering. Keep final deck assembly deterministic where brand and layout matter.
• Descriptions are control surfaces. Poor tool and topic descriptions create bad routing, duplicated actions, and unnecessary cost.
• Copilot Credits make FinOps part of agent design. Forecast credits per accepted deck, not just conversations or users.
• Work IQ can improve context, but it does not eliminate governance. Permission-aware context still needs cost controls, review paths, and sensitivity-aware design.
• Start with three templates and a few slide architectures. Scale the library only after you understand usage and failure patterns.
• Always approve the outline before generating the deck. It is one of the simplest ways to reduce cost and improve quality.

The future of AI-generated presentations is not “press a button and hope.” It is governed automation: the right context, the right template, the right cost model, and the right review gate.

That is how Copilot Studio moves from chatbot demos to enterprise-grade content operations.

Sources

Footnotes

1. Microsoft Learn, “Apply generative orchestration capabilities,” https://learn.microsoft.com/en-us/microsoft-copilot-studio/guidance/generative-orchestration ↩

2. Microsoft Learn, “Orchestrate agent behavior with generative AI,” https://learn.microsoft.com/en-us/microsoft-copilot-studio/advanced-generative-actions ↩

3. Microsoft Learn, “Work IQ overview,” https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/work-iq/ ↩

4. Microsoft Learn, “Copilot Studio quotas and limits,” https://learn.microsoft.com/en-us/microsoft-copilot-studio/requirements-quotas ↩

5. Microsoft Learn, “Copilot Studio licensing,” https://learn.microsoft.com/en-us/microsoft-copilot-studio/billing-licensing ↩ ↩² ↩³

6. Microsoft Learn, “Billing rates and management,” https://learn.microsoft.com/en-us/microsoft-copilot-studio/requirements-messages-management ↩ ↩² ↩³