Flow Alt Delete – Josh Cook [Microsoft MVP]

Category: Copilot Studio

  • Copilot Cowork Billing Setup: Turn On GA Without Opening the Credit Floodgates

    Copilot Cowork Billing Setup: Turn On GA Without Opening the Credit Floodgates

    Copilot Cowork is generally available.

    That is the headline.

    But before you run into the tenant, turn everything on, and let users start throwing goals and long-running tasks at it, you need to understand the billing side.

    Copilot Cowork runs on Copilot Credits. That means the admin work is not just, “Can the user access it?” It is also, “Who can spend credits, how much can they spend, which billing method gets charged, and who gets warned before usage goes sideways?”

    Turning Copilot Cowork on is easy. Turning it on responsibly is where the real admin work starts.

    In this walkthrough, I am setting up Copilot Cowork billing from the Microsoft 365 admin center and showing the choices I would pay attention to before giving users access.

    What changed with Copilot Cowork GA

    Microsoft announced Copilot Cowork general availability on June 16, 2026. Cowork requires a Microsoft 365 Copilot user subscription license, and Cowork usage is billed separately on a usage basis using Copilot Credits.

    That matters because Copilot Cowork is not just another chat surface. It is designed for complex, long-running, multi-tool work. It can retrieve context, call tools, use models, create artifacts, and keep working through a task. All of that value has a meter behind it.

    Microsoft’s current Cost Management experience for usage-based billing applies to Copilot Cowork and Work IQ API right now, with more agents and services expected to come into that experience over time.

    Microsoft 365 admin center Cost management page showing Copilot Cowork and Work IQ API usage-based billing
    Cost Management in the Microsoft 365 admin center is where Copilot Cowork and Work IQ API usage-based billing is configured.

    Start with the right mental model

    Access and consumption are two different things.

    Access lets a user get into the experience. Consumption happens when the experience starts doing work. If Cowork runs a goal, uses a model, retrieves context, calls tools, or performs longer-running work, that activity can consume Copilot Credits.

    That is why billing policies matter. Without them, you are basically handing out an AI gas card and hoping the bill looks reasonable at the end of the month.

    That is not a strategy.

    The better approach is billing plus governance. Set the billing method, define the spending policy, decide who is in scope, add limits, configure alerts, and then expand once you understand real usage.

    Check your admin roles before you start

    If you do not see the option in the admin center, check your role first.

    Billing setup and policy governance may not be handled by the same person in a real organization. Your Microsoft 365 admin, AI admin, Power Platform admin, billing admin, and finance owner might all be different people.

    That matters because the person configuring the billing method needs the right permissions, and the person managing policy limits and alerts also needs the right permissions. Do not discover that halfway through the rollout call. Get the right people in the room before you begin.

    Choose the billing method intentionally

    In the setup flow, you may see more than one billing method. In my tenant example, I had Capacity Packs available and also had the option to use a pay-as-you-go subscription.

    Capacity Packs let you bill against prepaid Copilot Credit capacity. Pay-as-you-go can keep services running once capacity pack credits run out, but it also means the meter can keep running against the connected subscription.

    Neither option is automatically good or bad. The point is to make the choice on purpose.

    Billing method options for Copilot Credits showing Capacity Packs and pay-as-you-go subscription
    Select the billing method intentionally. Capacity Packs and pay-as-you-go behave differently when credits run out.

    For a personal tenant or a controlled pilot, I would usually start with the most bounded option. For a production rollout where interruption would be a problem, you may choose to include pay-as-you-go, but that decision should involve the billing owner.

    What if you have no Copilot Credits?

    If your tenant does not already have Copilot Credits available, do not let that push you into an unlimited rollout. Start with pay-as-you-go, but treat it like a metered pilot, not an open tab.

    Microsoft lists PayGo for Copilot Cowork at $0.01 per Copilot Credit. That means 25,000 credits would be about $250 if you let usage land entirely on pay-as-you-go.

    That is the point where the economics should make you stop and re-check the licensing path. Microsoft lists Copilot Studio credit packs at 25,000 Copilot Credits for $200 per pack per month. So if you expect usage to get anywhere near 25,000 credits in a month, PAYG is no longer just a convenient starter option. It may be more expensive than buying a capacity pack.

    The practical setup I would use is this: enable PAYG to get started, set the monthly policy limit at 25,000 credits, turn alerts on well before that point, and review usage before the policy hits the cap.

    • At 10,000 credits, check whether the pilot group is using Cowork the way you expected.
    • At 20,000 credits, start the capacity pack conversation because the $200 pack economics are already close.
    • At 25,000 credits, do not just increase the PAYG limit without a decision. Buy a P3 or Copilot Credit capacity pack if monthly usage is becoming predictable.

    PAYG is still useful. It is the fastest way to start when you have no credits, and it is a good safety net for overages. But once usage becomes steady, capacity packs are the cleaner budgeting conversation.

    Do not assume the visible credit pool is unused

    This is the part admins need to slow down on.

    In my example, the Cost Management setup showed 50,000 credits available. But in the Power Platform admin center, 10,000 of those Copilot Studio messages were already allocated to a specific environment.

    Power Platform admin center Capacity add-ons page showing Microsoft Copilot Studio messages allocated from a 50,000 credit pool
    Before assigning a Cowork policy, check whether Copilot Credits are already supporting other Power Platform or Copilot Studio workloads.

    The lesson is simple: do not treat the number in one setup panel as the whole story.

    Copilot Credits can support more than one AI workload. If your organization is already using Copilot Studio, Dynamics 365, Power Platform, or other metered AI capabilities, make sure you understand what that credit pool is already expected to cover.

    The last thing you want is for a Cowork pilot to burn through credits that another production agent was relying on.

    Do not start unlimited

    The setup flow gives you the choice to limit monthly spending or leave monthly spending unlimited.

    My recommendation for most organizations starting with Copilot Cowork is simple: do not start unlimited.

    Launch it like a controlled pilot. Give it a monthly policy budget, watch usage, learn what normal looks like, then increase the limit later if the usage is healthy.

    In my example, I set the policy budget to 40,000 credits because I wanted to keep 10,000 credits available for other Copilot Studio usage in the tenant. Your number will be different. The principle is the same.

    Set a per-user monthly limit

    The per-user monthly spending limit is optional, but I would seriously consider enabling it.

    Without a user limit, one person can potentially consume a large chunk of the available credits. They may not be doing anything malicious. They might just be experimenting, running long tasks, testing browser automation, asking for big research outputs, or sending Cowork work that should have stayed in regular Copilot Chat.

    That kind of experimentation is a sign adoption is happening. But adoption without guardrails becomes waste.

    Set a policy-level monthly budget, consider a per-user monthly limit, and configure alerts before activating the policy.

    In the demo tenant, I used a 40,000 credit policy limit and a 20,000 credit per-user limit because the pilot only had two users. That is an example, not a universal recommendation.

    The right number depends on how many users are in scope, what tasks they will run, how much existing Copilot Credit capacity is already committed, and how much risk you are willing to tolerate during the first rollout.

    Turn alerts on before usage surprises you

    Do not wait until the end of the month to learn usage went sideways.

    Cost Management lets you define alerts so the right people get notified when usage reaches a threshold. That could be the Microsoft 365 admin, billing owner, finance stakeholder, platform owner, or whoever is accountable for the pilot.

    In my example, with a 40,000 credit monthly policy limit, I used a 30,000 credit alert threshold. That gives the owner time to investigate before the policy hits the cap.

    This is how you move from reactive admin to proactive admin.

    Do not activate for everyone by default

    This is the part of the setup that is easy to rush.

    If you activate broadly, you may be enabling access across the whole organization depending on how the policy is configured. For some organizations, that might be fine. For most first rollouts, I would not start there.

    Customize the setup configuration and scope the policy to a security group.

    Microsoft 365 admin center security group creation screen with the name Copilot Cowork Access
    Create a clear security group for the pilot, such as Copilot Cowork Access, instead of starting with the entire tenant.

    Use a clear name like Copilot Cowork Access or Copilot Cowork Pilot Users. Add a small group of trusted users first: admins, builders, business champions, finance, operations, or the people who will give you useful feedback.

    Think of this like a pilot program. You want people who will use it seriously, report what worked, report what wasted credits, and help you understand whether the budget is realistic.

    Cost Management access group configuration scoped to specific security groups
    Scope the policy to specific groups so you know exactly who can consume Copilot Credits through Cowork.

    Review the policy before you activate it

    Before clicking activate, review the setup like a change request:

    • Which services are enabled by the policy?
    • Which billing method will be charged?
    • Is the monthly spending limit set?
    • Is the per-user limit set?
    • Who receives alerts?
    • What threshold triggers those alerts?
    • Which users or groups are in scope?
    • Are other workloads already using the same credit pool?

    In my setup, the final shape was:

    • Billing method: Capacity Packs
    • Policy monthly limit: 40,000 credits
    • Per-user monthly limit: 20,000 credits
    • Alert threshold: 30,000 credits
    • Access scope: a specific security group for Copilot Cowork access

    Again, those are demo values. Do not copy them blindly. Copy the pattern: limit, alert, scope, observe, then scale.

    The rollout pattern I would use

    If I were rolling out Copilot Cowork in a tenant, I would not start with the whole organization. I would use this pattern:

    1. Confirm the admin roles needed for billing and policy management.
    2. Review existing Copilot Credit usage in Microsoft 365 and Power Platform.
    3. Choose the billing method with the billing owner involved.
    4. Create a bounded monthly spending policy.
    5. Add a per-user limit for the pilot group.
    6. Set alerts before the policy limit is reached.
    7. Create a security group for pilot access.
    8. Add a small number of serious users.
    9. Monitor usage and identify what tasks burn credits.
    10. Increase limits or expand access only after you understand normal usage.

    This gives you control. You know who has access, what they can consume, which budget they are under, and when someone needs to pay attention.

    That is how you test Copilot Cowork without turning the tenant into a free-for-all.

    Final thought

    Copilot Cowork is powerful because it can take on real work. But the more real the work gets, the more important the admin controls become.

    Cost Management is not the boring part of Copilot Cowork. It is the part that lets you adopt it without surprising finance, burning shared credits, or giving every user an unlimited meter on day one.

    Start controlled. Learn the usage. Then scale with confidence.

    Sources

  • Copilot Cowork Is Coming: Here’s How to Get Your Tenant Ready on Day 1

    Copilot Cowork Is Coming: Here’s How to Get Your Tenant Ready on Day 1

    Get Your Tenant Ready for Day 1: Joining Microsoft 365 Frontier for Copilot Cowork

    If you’ve been following the buzz around Copilot Cowork, you already know it’s going to change how we work inside Microsoft 365. But here’s the thing — Day 1 readiness doesn’t happen on Day 1. It happens now.

    In this post, I’ll walk you through exactly how to get your tenant set up: the right licenses, how to join the Frontier program, enabling the Anthropic sub-processor, configuring pilot groups, and locking down governance before you open the floodgates.

    Copilot Cowork is expected to be available for Frontier customers late March or later.

    Step 1: Make Sure You Have the Right Licenses

    Before you can enable anything, your tenant needs the right foundation.

    RequirementDetails
    Microsoft 365 Copilot licenseRequired for all end users who will access Copilot Cowork. Available as an add-on on E3, E5, Business Standard, and Business Premium plans.
    AI Administrator roleRequired to make changes in the Copilot settings area of the Admin Center.
    Microsoft Entra ID P1 or P2Needed for group-based access control and conditional access (P1 minimum).
    SharePoint OnlineIncluded in most M365 plans — required for Cowork’s document grounding.

    Admin tip: Before you go further, run a license audit. In the Microsoft 365 Admin Center, go to Billing > Licenses and confirm Copilot licenses are assigned — unassigned licenses won’t show up in Frontier eligibility checks.

    Step 2: Join Microsoft 365 Frontier

    Microsoft 365 Frontier is the early adopter program that gives your tenant access to upcoming Copilot features before general availability — including Copilot Cowork.

    What you’ll need first

    You must have AI Administrator access to complete this setup. If you don’t have this role, work with your Global Admin to get it assigned before you start.

    How to join Frontier

    1. Start from office.com and open the Admin Center.
    2. Navigate to Copilot → Settings → Frontier.
    3. On the Frontier settings page, enable early access.
    4. Under Web Apps, select the users who should be included.
    5. Click Save.

    That’s it — your tenant is now enrolled in Frontier.

    Step 3: Enable Anthropic as an AI Provider

    After Frontier is enabled, you need to turn on the AI providers that power the new Copilot experiences. This is the step most admins don’t realize is required.

    How to enable Anthropic

    1. From the same Copilot settings area, navigate to Data access.
    2. Enable the available AI providers — the recommendation is to enable as many as possible.
    3. Specifically, find Anthropic and enable it for Copilot.

    Step 4: Set Up Pilot Groups (Optional)

    Don’t roll Frontier out to your entire organization on Day 1. A phased pilot protects your environment and gives you time to validate the experience before broad deployment.

    Recommended pilot structure

    PhaseGroupPurpose
    Wave 1 — Champions5–10 power users (IT, Copilot champions)Validate setup, surface issues early
    Wave 2 — Early Adopters50–100 users across key departmentsReal-world workflow testing
    Wave 3 — Broad RolloutAll licensed usersFull deployment

    How to configure

    1. Create security groups in Microsoft Entra ID — for example, SG-CopilotCowork-Wave1 and SG-CopilotCowork-Wave2.
    2. In the Frontier settings from Step 2, assign early access to your Wave 1 group first using the Web Apps user selection.
    3. Expand to Wave 2 once Wave 1 has validated the experience.

    Pro tip: Set up a Microsoft Teams channel for your pilot group — something like #cowork-pilot-feedback — so you have a central place to collect issues and wins before you scale.

    Step 5: Governance — Lock Down Oversharing Before You Start

    This is the step most organizations skip — and regret. When Copilot can surface content from across your tenant, oversharing becomes a data exposure risk, not just a governance annoyance. Lock this down before you enable Cowork broadly.

    Key controls to review

    ControlWhere to set itRecommendation
    External sharingSharePoint Admin Center → Policies → SharingSet to “Existing guests only” or “Only people in your org” during Frontier rollout
    Default sharing linksSharePoint Admin Center → Policies → SharingChange from “Anyone with the link” to “People in your organization”
    Site-level permissionsIndividual site settingsAudit “Everyone except external users” — this is the #1 oversharing culprit
    Sensitivity labelsMicrosoft PurviewApply labels to classify and restrict access to confidential content
    Guest access expirationEntra ID → External collaboration settingsSet guest access to expire after 90 days

    SharePoint Admin Agent Prompt: Oversharing Audit

    Use this prompt directly with the SharePoint Admin agent in the Microsoft 365 Admin Center to get a fast, prioritized oversharing assessment:

    Review my SharePoint environment for oversharing risks before a Copilot rollout. Specifically:
1. Identify all sites that have 'Everyone' or 'Everyone except external users' granted any level of access.
 2. List sites where external sharing is enabled but shouldn't be (e.g., HR, Finance, Legal).
 3. Show me any files or folders shared via 'Anyone with the link' in the last 90 days.
 4. Flag any sites with more than 500 unique permissions (permission explosion).
 5. Recommend which sites should have sensitivity labels applied but currently don't.
Format results as a prioritized remediation list — highest risk first.

    This gives you an actionable list to work through before any end user asks Copilot Cowork a question about a document they shouldn’t be able to see.

    Your Day 1 Readiness Checklist

    • [ ] M365 Copilot licenses assigned to target users
    • [ ] AI Administrator role confirmed
    • [ ] Tenant enrolled in Frontier (Copilot → Settings → Frontier)
    • [ ] Early access enabled and Web Apps users selected
    • [ ] Anthropic enabled under Data access → AI providers
    • [ ] Pilot security groups created (Wave 1, 2, 3)
    • [ ] SharePoint oversharing audit completed using Admin agent prompt
    • [ ] External sharing policies tightened
    • [ ] Sensitivity labels deployed for confidential content
    • [ ] Pilot feedback channel set up in Teams

    Final Thought

    Copilot Cowork is a new way of working. The organizations that will get the most out of Day 1 are the ones doing this prep work right now. Join Frontier, enable Anthropic, run your oversharing audit, and start small with a tight pilot group.

    The foundation is simple: Frontier starts with admin enablement and provider access. Once that’s in place, you’re ready for everything that comes next.

  • Build Your Agent Factory: 10 Moves That Ship Fast (and Scale)

    Build Your Agent Factory: 10 Moves That Ship Fast (and Scale)

    Build Your Agent Factory: 10 Moves That Ship Fast (and Scale)

    Agents at scale. Not POCs.

    Here’s the playbook I’d hand any exec or builder who wants working agents in production—without turning the org into a science fair.

    1) Stand up an AI Agents Workforce

    What it is: A small cross-functional crew with authority to hunt repetitive work and ship agents.

    Who’s in:

    • 1 product owner
    • 1 engineer (Copilot Studio/Power Automate)
    • 1 data person
    • 1 security/governance lead
    • 1 domain SME.

    Ship this week: Write a one-page charter with scope, decision rights, and a 30-day roadmap (first 5 agents + metrics).

    2) Win with horizontals first, then go vertical

    Horizontals (1-hour wins): drafting, summarizing, policy Q&A, meeting notes to actions, form-fill helpers.

    Verticals (outsized ROI): pick 1–2 per business unit where there’s money, risk, or SLA pain.

    Guardrail: don’t start with the hardest workflow; start where you can close the loop and measure value inside two weeks.

    3) Make an Agents Directory the front door

    Why: Ideas die in email. A directory turns “we should build X” into spec and governance.

    Minimum intake fields:

    • use case name
    • goal
    • users
    • decision rights
    • data sources + who owns it
    • tools
    • PII/sensitivity
    • KPIs
    • business owner
    • risk level
    • rollout plan.

    Outcome: Every request auto-generates a lightweight PRD (goal, inputs, outputs, metrics, guardrails) and a yes/no gate.

    4) Create the 1-Hour Agent template

    Template anatomy:

    Goal + success criteria Input schema (what the user provides) Tools (actions/connectors) and permissions Knowledge sources (files, sites, indexes) Safety rules (allowed/blocked actions, escalation) Evaluation set (10–20 test prompts with expected outcomes) Deploy script (Dev → Test → Prod)

    Rule: If a use case can’t fit this page, it’s not a 1-hour agent—park it for later.

    5) Tie every agent to a visible scorecard

    Metrics to publish: time saved, cost avoided, error rate, CO₂/efficiency (where relevant), user satisfaction.

    Simple formula: monthly users × average minutes saved × loaded cost = value.

    Make it public internally: green/red status, owner, last review, next improvement.

    6) Run on a secure, managed agent runtime

    Non-negotiables: identity passthrough, content safety, audit logs, tool call restrictions, data boundary controls, environment isolation.

    Practical tip: standardize a “sensitive sources” policy and block tools by default; allow case-by-case.

    7) Split the stack to move fast without breaking things

    Experience layer: Copilot Studio for UX, channels, and connectors.

    Agent runtime/orchestration: managed agent service for threads, tool calls, safety, and evaluations.

    Why it works: builders ship quickly at the edge; platform team keeps shared guardrails, monitoring, and upgrades stable.

    8) Mix knowledge + action (or you’ll stall)

    Knowledge: structured grounding (SharePoint/Fabric/Search), doc versioning, citations-on by default.

    Action: flows/Logic Apps, Graph, line-of-business APIs; always ship with a dry-run mode first.

    Design pattern: Answer → show sources → propose actions → execute on approval. When confidence is high and stakes are low, allow auto-execute.

    9) Keep humans in the loop—by design

    HITL patterns that work:

    Shadow mode (observe only) → suggest mode → execute with approval → auto-execute.

    Confidence thresholds where low confidence routes to a human. Escalation logic when guardrails trip or data is missing.

    UX rule: one click to approve, one click to undo.

    10) Plan to scale on day one

    Pipelines: Dev → Test → Prod with approvals and rollback.

    Evals: pre-ship test set per agent; weekly drift checks; quarterly red-team.

    Ops: central logging, cost dashboards, incident playbook.

    Program ritual: a quarterly “Agent Backlog Day” to harvest new ideas and retire underperformers.

    Starter Architecture (fast and boring)

    Experience: Copilot Studio (web, Teams, M365, chat, plugins)

    Actions: Power Automate/Logic Apps + custom APIs

    Knowledge: SharePoint/Fabric/AI Search with retrieval policies

    Runtime: managed agent service for tool orchestration, identity, safety

    Observability: evaluations, telemetry, and a simple agent scorecard per app

    Security: Entra ID RBAC, private endpoints, DLP, approval gates

    Prompts and policies that save you pain

    Prompt contract (keep it in the repo): role, goals, inputs, allowed tools, forbidden actions, decision rights, escalation, output format, citation rules.

    Data contract: what sources are permitted, freshness expectations, sensitivity tags.

    Failure modes: what the agent must do when unsure (ask for clarification, route to human, or stop).

    Anti-patterns I keep seeing

    • Starting with an “AI strategy deck” instead of shipping 3 agents.
    • Agents that answer but can’t act—users stop coming back.
    • No owner, no scorecard, no sunset date.
    • Canary-testing in production without a rollback plan.
    • Letting one giant use case block 20 small wins.

    Your first week mapped

    Day 1: Form the team and publish the charter.

    Day 2: Launch the Agents Directory (intake + PRD autogeneration).

    Day 3–4: Build two 1-hour agents (drafting + policy Q&A) with eval sets.

    Day 5: Ship to a pilot group with scorecards visible. Book the first backlog day.

  • Part 2 – Build & Ship a “Docs Agent” to Microsoft Teams

    Part 2 – Build & Ship a “Docs Agent” to Microsoft Teams

    (Companion guide to “Spin-Up the Microsoft Learn MCP Server”)

    Make sure you have read and setup the Docs MCP custom connector from part 1

    1. What you’ll build
    2. Prerequisites
      1. Icons to Download (optional)
    3. 1 – Create the Agent in Copilot Studio
      1. Add Suggested Prompts
      2. Agent Settings
      3. Turn Off Pointless Topics
    4. Publish & Package for Teams
      1. Submit Agent for Approval
    5. Approve Agent App (As a Teams Admin)
    6. How to Use the Agent
      1. Adding Agent to a Meeting or Chat
      2. Troubleshooting

    What you’ll build

    A Copilot Studio agent that queries the Microsoft Learn MCP server for live docs, then answers teammates inside a Teams chat or Meeting.

    Prerequisites

    NeedNotes
    Docs MCP custom connector from Part 1Already in your environment.
    (https://flowaltdelete.ca/2025/06/26/how-to-spin-up-the-microsoft-learn-mcp-server-in-copilot-studio/)
    Copilot Studio (preview) tenantGenerative orchestration enabled. (Early Features)
    Teams admin rights (or approval from your Teams Admin)To upload a custom app or publish to the org.
    Copilot Studio LicenseMessage packs or sessions
    prereq table

    Icons to Download (optional)

    Below are icons you can use for the Agent and the MCP custom connector.

    Microsoft-Learn-Docs-Agent-Logo-SmallDownload
    ms-docs-mcp-icon1Download

    1 – Create the Agent in Copilot Studio

    In this example I am going to use the existing agent I created from Part 1.

    1. Modify or create the agent with a meaningful name, description, and icon.
      (You can use the one I provided from above or use your own)
    2. Name: MS Docs Agent
    3. Description: MS Docs Agent is your on-demand mentor for Microsoft technologies—built with Copilot Studio and powered by the Microsoft Learn MCP server. Every answer comes from the live, authoritative docs that Microsoft publishes each day, so you never rely on stale model memories or web-scraped content.
    4. Orchestration = Enabled

    5. For your Instructions for the agent, we don’t want to add too much. After much testing I found that in its current state the Docs MCP server handles the instructions well and having too much instructions causes the response to fail. So its better to leave instructions blank for now.
    6. Web Search – This should be Disabled. We only want the agent to query the docs which it does through the MCP server.
    7. Knowledge should be empty, the only thing we want this agent to do is query the Docs MCP server, so this should be the only Tool that the agent has access to.
    8. To recap, the only Tools and Knowledge this agent should have is the MCP Server (custom connector) that we created in the first blog post. If you need help setting this up refer to Part 1.

    Add Suggested Prompts

    When users interact with the agent in M365 chat (Copilot) we can show suggested prompts to help guide the user in what is possible with this agent. Here are a bunch of samples you can give your agent:

    TitlePrompt
    Dev Env for Power AppsSet up a developer environment for Power Apps—step-by-step.
    Rollup vs FormulaRollup fields vs Formula columns in Dataverse—when to use each?
    Flow 502 FixPower Automate flow fails with 502 Bad Gateway—how do I resolve it?
    Cert Path FinderFastest certification path for a Dynamics 365 functional consultant.
    PL-200 Module ListList every Microsoft Learn module covered by the PL-200 exam.
    Managed Env EnableTurn on managed environments and approval gates in Power Platform.
    Finance DLP PolicyBest-practice DLP setup for finance data in Power Platform.
    Power Fx Date FilterSample Power Fx to filter a gallery to today’s records.
    OpenAI Flow SampleMinimal example: call Azure OpenAI from Power Automate.
    Secure Env VarsSecure environment variables with Azure Key Vault in flows.
    Pipeline ChecklistChecklist to deploy a solution through Power Platform pipelines.
    PCF Chart ControlBuild a PCF control that renders a chart on a model-driven form.
    New PA FeaturesSummarize new Power Apps features announced this month.
    Preview ConnectorsList preview connectors added to Power Automate in the last 30 days.
    Explain to a ChildExplain Dataverse to a five-year-old.

    You can only add 6 Suggested Prompts. So choose carefully.

    Agent Settings

    Next we want to configure some settings on the agent.

    1. Click the Settings button on the top right.

    2. (Optional) If you want the agent to have reasoning capabilities > Under Generative AI turn on: Deep reasoning
      **Note that this is a premium feature**

    3. Scroll down to Knowledge, make sure Use general knowledge and Use information from the Web are both OFF

    4. Make sure to click Save once done.

    Turn Off Pointless Topics

    Next we will turn off the topics we don’t want the agent to use.

    1. Click on Topics tab > Under Custom > Only leave Start Over topic On.

    2. Under System > Turn Off:
      – End of Conversation
      – Escalate
      – Fallback
      – Multiple Topics Matched

    3. Next, lets modify the Conversation Start to make it sound better.
      Click Conversation Start topic > Modify the Message node:

    4. Click Save.

    Now we are ready to Publish and Package for Teams!

    Publish & Package for Teams

    Next we need to Publish our agent.

    1. Click on the Channels tab > Click Publish

    2. Once your agent is published > Click on the Teams and Microsoft 365 Copilot channel.

    3. A sidebar opens > Check the Make agent available in Microsoft 365 Copilot > Click Add channel.

    4. After the channel has been added > Click Edit details.

    5. This is where we configure the agent in Teams. We will modify the icon, give a short description, long description and allow for the agent to be added to a team and meeting chats.
      Under Teams settings > Check both:
      – Users can add this agent to a team
      – Use this agent for group and meeting chats

    6. Click Save

    Submit Agent for Approval

    Now because we want our organization to easily find and use this agent. We will submit the agent to the Agent Store. To do this follow these steps:

    1. First Publish your agent, to make sure you have the newest version you are pushing to Teams admin for approval.
    2. Next click on the Channels tab > Select the Teams and Microsoft 365 Copilot channel.
    3. Now click Availability options.

    4. Now we will configure the Show to everyone in my org.

    5. Than click Submit for admin approval.

      Now we will look at what a Teams Admin has to do.

    Approve Agent App (As a Teams Admin)

    A Microsoft Teams Admin will have to approve the Agent app before your org can use it. As a Teams Admin follow these steps:

    1. Navigate to https://admin.teams.microsoft.com/policies/manage-apps
      (Click on Manage apps under Teams apps)
    2. Search for your agent name in the search bar

    3. Click the agent > Publish.

    4. Note:: You will need Admin Approval each time you want to publish an update to the agent.

    How to Use the Agent

    Once your agent is approved by an Admin. You can easily find it in the Agent Store. Another easy way to get to your agent is to open it from Copilot Studio:

    1. Click Channels tab > Select Teams and Microsoft 365 Copilot channel > Click See agent in Teams.

    You will be brought to Teams with the agent open. You can now add it:

    Adding Agent to a Meeting or Chat

    There are a few ways to add the agent to a meeting. One easy way is to @mention the agent in the chat.

    **Note to start typing the name of the agent, and it should show up**

    Troubleshooting

    There are a few things to note that I ran into:
    1) If your getting an error on the MCP Server, remove all custom instructions

    2) Sometimes your agents details can be cached and showing old metadata. In this case you can resubmit the app approval.

    3) Always test the Agent inside Copilot Studio Test Pane with tracking topics and Activity Map turned On.

  • Add the Microsoft Learn Docs MCP Server in Copilot Studio

    Add the Microsoft Learn Docs MCP Server in Copilot Studio

    UPDATE—August 8, 2025: You no longer need to create a custom connector for the Microsoft Learn Docs MCP server. Copilot Studio now includes a native Microsoft Learn Docs MCP Server under Add tool → Model Context Protocol.
    This guide has been updated to show the first-party path. If your tenant doesn’t yet show the native tile, use the Legacy approach at the bottom.

    What changed

    • No YAML or custom connector required
    • Fewer steps, faster setup

    Model Context Protocol (MCP) is the universal “USB-C” port for AI agents. It standardizes how a model discovers tools, streams data, and fires off actions—no bespoke SDKs, no brittle scraping. Add an MCP server and your agent instantly inherits whatever resources, tools, and prompts that server exposes, auto-updating as the backend evolves.

    1. Why you should care
    2. What the Microsoft Learn Docs MCP Server delivers
    3. Prerequisites
    4. Step 1 – Add the native Microsoft Learn Docs MCP Server
    5. Step 2 – Validate
    6. Legacy approach (if the native tile isn’t available)

    Why you should care

    • Zero-integration overhead – connect in a click inside Copilot Studio or VS Code; the protocol handles tool discovery and auth.
    • Future-proof – the spec just hit GA and already ships in Microsoft, GitHub, and open-source stacks.
    • Hallucination killer – answers are grounded in authoritative servers rather than fuzzy internet guesses.

    What the Microsoft Learn Docs MCP Server delivers

    • Tools: microsoft_docs_search – fire a plain-English query and stream back markdown-ready excerpts, links, and code snippets from official docs.
    • Always current – pulls live content from Learn, so your agent cites the newest releases and preview APIs automatically.
    • First-party & fast — add it in seconds from the Model Context Protocol gallery; no OpenAPI import needed.

    Bottom line: MCP turns documentation (or any backend) into a first-class superpower for your agents—and the Learn Docs server is the showcase. Connect once, answer everything.

    Prerequisites

    • Copilot Studio environment with Generative Orchestration (might need early features on)
    • Environment-maker rights
    • Outbound HTTPS to learn.microsoft.com/api/mcp

    Step 1 – Add the native Microsoft Learn Docs MCP Server

    1. Go to Copilot Studio: https://copilotstudio.microsoft.com/
    2. Go to Tools → Add tool.
    3. Select the Model Context Protocol pill.
    4. Click Microsoft Learn Docs MCP Server.
    5. Choose the connection (usually automatic) and click Add to agent.
    6. Confirm the connection status is Connected.
    Copilot Studio Add tool panel showing Model Context Protocol category and Microsoft Learn Docs MCP Server tile highlighted.
    1. The MCP server should now show up in Tools.
    1. Click the Server to verify the tool(s) and to make sure:
      – ✅ Allow agent to decide dynamically when to use this tool
      – Ask the end user before running = No
      – Credentials to use = End user credentials

    Step 2 – Validate

    1. In the Test your agent pane. Turn on Activity map by clicking the wavy map icon:

    2. Now try a prompt like:
      – What MS certs should I look at for Power Platform?
      – How can I extend the Power Platform CoE Starter Kit?
      – What modern controls in Power Apps are GA and which are still in preview? Format as a table

    Use-Case Ideas

    • Internal help-desk bot that cites docs.
    • Learning-path recommender (your pipeline example).
    • Governance bot that checks best-practice-links.

    Troubleshooting Cheat-Sheet

    • Note that currently the Learn Docs MCP server does NOT require authentication. This will most likely change in the future.
    • If Model Context Protocol is not shown in your Tools for Copilot Studio. You may need to create an environment with Early Features turned on.
    • Do NOT reference the MCP server in the agents instructions, you will get a tool error.
    • Check Activity tab for monitoring

    Legacy approach (if the native tile isn’t available)

    Grab the Minimal YAML

    1. Open your favorite code editor or notepad. Copy and paste this YAML to a new file.
    swagger: '2.0'
info:
  title: Microsoft Docs MCP
  description: Streams Microsoft official documentation to AI agents via Model Context Protocol
  version: 1.0.0
host: learn.microsoft.com
basePath: /api
schemes:
  - https
paths:
  /mcp:
    post:
      summary: Invoke Microsoft Docs MCP server
      x-ms-agentic-protocol: mcp-streamable-1.0
      operationId: InvokeDocsMcp
      consumes:
        - application/json
      produces:
        - application/json
      responses:
        '200':
          description: Success
    1. Save the file with .yaml extension.

    Import a Custom Connector

    Next we need to create a custom connector for the MCP server to connect to. We will do this by importing our yaml file we created in Step 1.

    1. Go to make.powerapps.com > Custom connectors > + New custom connector > Import OpenAPI.

    2. Upload your yaml file eg: ms-docs‑mcp.yaml, using the Import an OpenAPI file option.

    3. General tab: Confirm Host and Base URL.
      Host: learn.microsoft.com
      Base URL: /api
    4. Security tab > No authentication (the Docs MCP server is anonymously readable today).
    5. Definition tab > verify one action named InvokeDocsMcp is present.
      Also add a description.

    6. Click Create connector. Once the connector is created, click the Test tab, and click +New Connection.

      (Note, you may see more than 1 Operation after creating the connector. Don’t worry and continue on)
    7. When you create a connection, you will be navigated away from your custom connector. Verify your Connection is in Connected Status.

      Next we will wire this up to our Agent in Copilot Studio.