Tag: Copilot

  • Copilot Cowork Prompt of the Day: Real Microsoft 365 Workflows That Actually Save Time

    Copilot Cowork Prompt of the Day: Real Microsoft 365 Workflows That Actually Save Time

    Copilot Cowork Prompt of the Day: Real Microsoft 365 Workflows That Actually Save Time

    I have been testing Copilot Cowork across real work patterns inside Microsoft 365: meetings, calendar cleanup, files, time entries, customer feedback, follow-ups, and workspace history.

    The pattern is becoming clear.

    The strongest Copilot Cowork prompts do not just ask for an answer. They assign a business outcome. They define the source of truth. They set guardrails. They tell Cowork what finished work should look like.

    That is where this gets serious.

    Below is a practical prompt library based on my Copilot Cowork Prompt of the Day posts across X and LinkedIn. I grouped them by scenario so the examples are easier to scan, reuse, and adapt.

    Note: Some examples use demo companies, files, customers, and project names. Replace those with your own Microsoft 365 content, folders, meetings, and business context.

    Table of Contents

    Calendar and Focus Management

    Calendar work looks simple until it eats your day. Declining meetings, cancelling organizer-owned events, protecting focus time, and finding clean openings are perfect examples of work that should be delegated.

    These prompts show Cowork acting like a real calendar operator, not a passive chatbot.

    Decline and Cancel Holiday Meetings

    The situation

    Friday is a holiday. Your calendar still has meetings. Some meetings were created by other people. Some meetings may be yours. You need everything cleaned up properly.

    The important part is the distinction between declining and cancelling. If you are only an attendee, Cowork should decline the meeting. If you are the organizer, Cowork should cancel it and send a note so attendees know why it disappeared.

    Copilot Cowork using calendar management to decline meetings and cancel organizer-owned meetings for a holiday.

    The prompt

    [Day] is a holiday. Check [Date].
    - Decline every meeting.
    - If I’m the organizer, cancel it and send a note.
    Use /calendar-management

    What Cowork should do

    • Check the target date.
    • Find every meeting on that day.
    • Decline meetings where you are an attendee.
    • Cancel meetings where you are the organizer.
    • Send a professional cancellation note where needed.
    • Summarize what changed.

    This is the kind of task that burns attention. The value is not only the minutes saved. The real value is that Cowork understands the difference between attendee action and organizer responsibility.

    Cancelling a meeting you own sends a different signal than declining a meeting someone else owns.

    How I would tighten the prompt

    For a production-style version, I would add the wording for the cancellation note directly into the prompt.

    Friday is a company holiday. Check April 3rd in my calendar.
    For every meeting that day:
    - If I am only an attendee, decline the meeting.
    - If I am the organizer, cancel the meeting.
    - For cancelled meetings, send this note:
    “April 3rd is a holiday, so I’m cancelling this meeting.
    Please reschedule for the following week if still needed.”
    After you finish, send me a summary grouped by declined meetings
    and cancelled meetings.
    Use /calendar-management

    Create Focus Time from Your Phone

    The situation

    This one is simple. That is why it matters.

    I used the iOS app from bed and told Cowork to find two separate one-hour focus blocks for Monday morning. Cowork checked my calendar, found the openings, and created both events.

    No desktop. No calendar hunting. No dragging blocks around half asleep.

    The prompt

    Set some focus time for me up for Monday morning.
    Find 2 separate 1 hour blocks so I can focus on:
    1) <Task>
    2) <Task>

    What Cowork should do

    • Review your Monday morning calendar.
    • Find two separate one-hour openings.
    • Create calendar events for each focus block.
    • Name each block clearly based on the task.
    • Add useful context where available.

    Focus time only helps if it actually lands on the calendar. A lot of people know what they need to work on, then lose the day to meetings, messages, and context switching.

    This turns focus protection into a command.

    That is the kind of small task agents should crush first. Scheduling. Calendar juggling. Protecting time. Removing the coordination mess.

    How I would tighten the prompt

    I would add preferred working hours, meeting buffer rules, and event details.

    Set up 2 separate 1-hour focus blocks for Monday morning.
    Focus areas:
    1) <Task 1>
    2) <Task 2>
    Rules:
    - Only schedule between 8:00 AM and 12:00 PM.
    - Do not overlap existing meetings.
    - Leave at least 15 minutes between meetings and focus blocks where possible.
    - Use clear calendar titles: “Focus: <Task>”.
    - Add a short note to each event with the goal for that focus block.
    After scheduling, tell me the times you picked.

    ↑ Back to top


    Time Entry and Work Reporting

    Time entry is one of the best Cowork use cases because the evidence already exists across Microsoft 365. Meetings, chats, emails, files, edits, and shared work all tell the story of the day.

    The hard part is turning that messy activity trail into believable time-entry comments that a human can review.

    Build a Daily Time Entry Summary from Microsoft 365 Activity

    The situation

    This prompt asks Cowork to review the day’s Microsoft 365 activity and produce a structured time-entry draft. The goal is not perfect accounting. The goal is a practical, honest draft that can be reviewed and corrected quickly.

    The real power is that Cowork is not only looking at meetings. It is asked to look across calendar activity, Teams chats, email, files, transcripts, meeting notes, and other signals.

    Daily time entry draft created from Microsoft 365 work activity.

    The prompt

    Review ALL of MY Microsoft 365 work activity from TODAY in
    [your timezone] and build a realistic, structured daily time entry
    summary.
    Then send it as a [direct Teams message / Email].
    Use every available signal from today:
    - calendar meetings
    - transcripts and recaps
    - meeting chats
    - Teams chats and channel messages
    - emails
    - files opened, edited, or shared
    - any other work activity signals
    Rules:
    1. Only use today in my local timezone.
    2. Look across all evidence, not just meetings.
    3. Infer the best-fit project, client, internal initiative, or business
    development category.
    4. Map work to a project whenever possible.
    5. If unclear, use: Business Development, Internal Operations,
    Practice Development, Admin, or Learning / Enablement.
    6. Consolidate fragmented activity into meaningful work blocks.
    7. Target a full day close to 8.0 hours.
    8. Acceptable total range: 6.0-8.0 hours.
    9. Accuracy first, then use reasonable consolidation to close gaps.
    10. Do not invent fake meetings, deliverables, or project names.
    11. If evidence is weak, make the best possible mapping, but keep
    descriptions honest.
    12. Avoid over-fragmenting. Prefer fewer, stronger entries.
    13. Write descriptions like real time-entry comments, not AI summaries.
    14. Keep descriptions concise but useful.
    15. Group short related activities under the same project.
    16. If there is clear prep or follow-up around meetings, emails,
    chats, or docs, include that under the relevant project when evidence
    supports it.
    17. Capture business development work where relevant:
    sales support, proposal work, internal planning, networking,
    demos, enablement, certifications, or content creation.
    Format the Teams message as HTML:
    - Bold heading: Daily Time Entry Draft – [YYYY-MM-DD]
    - Bold "Summary:" plus a 1-2 line plain-text summary
    - HTML table: # | Project Name | Description | Duration | Date
    - One row per entry, ordered largest to smallest
    - Duration in decimal hours, e.g. 3.0 hrs or 0.5 hrs
    - Bold "Total: X.X hours" at the bottom
    Quality bar: practical, believable, timesheet-ready.
    Use real work patterns. Balance to 6-8 hours.
    If today has limited evidence, still produce the best possible draft.

    What Cowork should do

    • Build a workday view from Microsoft 365 evidence.
    • Classify activity into projects, clients, or internal categories.
    • Consolidate short fragments into stronger time-entry rows.
    • Keep the wording practical and timesheet-ready.
    • Send the finished draft as a Teams message.

    This is a serious consulting and professional services scenario.

    Timesheets fail when people are forced to reconstruct their day from memory. Cowork can inspect the activity trail and give you a draft while the day is still fresh.

    You still review it. You still own it. Cowork reduces the blank-page problem.

    Important guardrails

    The guardrails are the real prompt design lesson here.

    • Do not invent fake meetings, deliverables, or project names.
    • Keep weak evidence honest.
    • Prefer fewer, stronger entries.
    • Write like a real time-entry comment.

    That is how you keep this useful without letting the agent drift into fantasy work logs.

    ↑ Back to top


    Meeting Intelligence and Follow-Up

    Meetings create a lot of residue: transcripts, AI notes, chats, files, agendas, decisions, action items, and follow-up messages.

    The problem is that the value disappears when nobody turns that residue into something clean.

    Create a Meeting Recap and Send It to Attendees

    The situation

    This prompt gives Cowork one target meeting and asks it to pull all available meeting content. The output is a structured recap and a concise email to attendees.

    The prompt also changes the recap style based on the meeting type. A requirements session should not be summarized the same way as a standup or UAT meeting.

    Meeting recap generated from meeting content, notes, transcript, chat, and related files.

    The prompt

    Use the meeting provided in context: <Meeting>.
    Meeting type: [Requirements | Standup | Training | UAT | Other]
    Treat this as the only target meeting. Pull all available meeting content
    including AI notes, transcript, meeting chat, shared files, agenda,
    description, and attached notes.
    Create a recap with:
    - purpose
    - key discussion points
    - decisions
    - action items
    - owners
    - due dates
    - follow-ups
    Adapt the recap based on the meeting type:
    - Requirements: needs, requested features, pain points, constraints,
    open requirements
    - Standup: progress, blockers, next steps
    - Training: what was taught, guidance shared, takeaways, resources
    - UAT: what was tested, issues found, defects, next steps for fixes or
    retesting
    - Other: use the most appropriate structure
    If anything is unclear or missing, state that clearly instead of guessing.
    Then draft and send a concise, professional recap email to all attendees.

    What Cowork should do

    • Use only the meeting provided in context.
    • Pull available transcript, recap, chat, files, agenda, and notes.
    • Build a recap that matches the meeting type.
    • Call out missing or unclear details.
    • Send a concise recap email to attendees.

    The most useful meeting recap is not a generic summary. It captures the operating details that move work forward: decisions, owners, due dates, and follow-ups.

    This prompt also handles one of the biggest issues with AI meeting summaries: context control. It tells Cowork to treat the provided meeting as the only target meeting.

    How I would tighten the prompt

    For client-facing work, I would add a review step before sending.

    Use the meeting provided in context: <Meeting>.
    Meeting type: [Requirements | Standup | Training | UAT | Other]
    Treat this as the only target meeting. Pull all available meeting conten
    including AI notes, transcript, meeting chat, shared files, agenda,
    description, and attached notes.
    Create a recap with:
    - Purpose
    - Key discussion points
    - Decisions
    - Action items
    - Owners
    - Due dates
    - Follow-ups
    Adapt the recap based on the meeting type.
    If anything is unclear or missing, state that clearly instead of guessing.
    Draft a concise, professional recap email to all attendees,
    but do not send it until I review and approve it.

    ↑ Back to top


    Customer Feedback and Leadership Deliverables

    This is the most advanced scenario in the set.

    The assignment is not just “summarize feedback.” The assignment is to turn scattered customer signals into a leadership-ready action package.

    That means Cowork has to analyze, prioritize, create deliverables, flag weak evidence, and prepare different outputs for different audiences.

    Turn Customer Feedback into a Product Action Plan

    The situation

    Kavora’s marketing department has customer feedback scattered across interviews, surveys, comments, web signals, and meeting notes.

    Leadership needs the real story:

    • What customers are saying.
    • What matters most.
    • What needs action.
    • What needs human judgment before the team moves.

    For the demo, the input files were:

    • Customer interview notes
    • Product feedback survey and web signal export
    • Source customer comments
    • Marketing leadership request and context email

    The Cowork assignment was to review the feedback, find the strongest themes, rank them by impact and urgency, flag gaps or contradictions, then build the deliverables a marketing team would actually need.

    Copilot Cowork turning scattered customer feedback into a brief, deck, emails, Teams update, and decision tracker.

    The expected outputs

    • Executive feedback brief
    • Stakeholder-ready presentation deck
    • Customer follow-up email pack
    • Launch squad Teams update
    • Leadership decision tracker

    The prompt

    Act as my marketing operations lead.
    Goal:
    I’m working on turning messy customer product feedback into a clear
    action plan for product, marketing, and leadership teams.
    Sources:
    Use the attached files and project folder as the source of truth.
    These may include customer interview notes, survey results,
    web/funnel data, Teams meeting summaries, support themes,
    website feedback, campaign comments, and leadership request emails.
    Task:
    1. Review the materials and identify the strongest customer feedback
    themes.
    2. Prioritize the themes by customer impact, urgency, revenue risk, and
    brand risk.
    3. Pull proof points from the source material, including customer
    quotes, survey signals, and web/funnel trends.
    4. Identify gaps, contradictions, sampling bias, or anything that needs
    validation before decisions are made.
    5. Recommend the next best actions for product, marketing,
    customer success, and leadership.
    Produce:
    • A polished executive feedback brief
    • A stakeholder-ready presentation deck
    • A customer follow-up email pack
    • A Teams update for the launch squad
    • A leadership decision tracker with priorities, owners, and dates
    Guardrails:
    • Separate facts from recommendations
    • Do not invent evidence
    • Call out assumptions clearly
    • Flag anything that needs human review
    • Make the outputs ready for me to review, edit, and share

    What Cowork should do

    • Review all supplied source material.
    • Find repeated customer themes.
    • Rank themes by impact, urgency, revenue risk, and brand risk.
    • Pull quotes and proof points from the evidence.
    • Flag contradictions, bias, gaps, and validation needs.
    • Create separate deliverables for leadership, product, launch teams, and customer follow-up.

    The best part of this prompt is the deliverable design. It does not stop at analysis. It asks for the assets the business actually needs:

    • A brief for executives.
    • A deck for stakeholders.
    • Email drafts for customers.
    • A Teams update for the launch squad.
    • A decision tracker for leadership.

    That is the difference between “tell me what the files say” and “help me move the business forward.”

    The human review layer

    This prompt gets the review model right. It tells Cowork to separate facts from recommendations and flag assumptions.

    That matters because customer feedback can be messy. You can have contradictory signals, loud power users, small samples, weak survey patterns, or feedback that sounds urgent but needs validation.

    The agent can organize the evidence. The human still owns the judgment.

    How I would tighten the prompt

    I would add a scoring model so the ranking is easier to audit.

    When ranking feedback themes, score each theme from 1-5 across:
    - Customer impact
    - Urgency
    - Revenue risk
    - Brand risk
    - Evidence strength
    Then calculate a priority recommendation of P0, P1, or P2.
    For every theme, include:
    - Evidence used
    - Customer quote or signal
    - Recommended owner
    - Recommended next action
    - What needs human validation before action

    ↑ Back to top


    File and Workspace Operations

    Some of the best agent use cases are boring. That is the point.

    Moving files, finding folders, reviewing previous sessions, and organizing workspace context are small tasks by themselves. Across a week, they become attention tax.

    Move a File in OneDrive

    The situation

    I downloaded a zip file on my phone, uploaded it to OneDrive, and told Cowork to move it into the right demo folder.

    No laptop. No desk. No clicking through folders.

    Cowork found the file, found the destination folder, and moved it.

    Copilot Cowork finding a recently uploaded zip file and moving it to the right OneDrive folder.

    The prompt

    I just uploaded a <file or folder> to OneDrive.
    Can you move it to the Copilot Cowork Demos folder

    What Cowork should do

    • Search OneDrive for the uploaded file or folder.
    • Search OneDrive for the destination folder.
    • Move the item.
    • Confirm the exact file or folder that was moved.

    This is the kind of work nobody wants to do. It is small enough to feel annoying and common enough to keep stealing attention.

    Agents should handle the annoying little tasks first.

    Find the file. Find the folder. Move it. Confirm it.


    Review Past Cowork Sessions

    The situation

    This is a fun one for understanding the workspace Cowork builds around your work.

    The prompt asks Cowork to look across previous sessions and tell you what you have built together, then pick its favorite session.

    Your Cowork sessions are stored in:

    Documents > Coworker > sessions
    Copilot Cowork reviewing previous sessions and summarizing what has been built.

    The prompt

    based on all our sessions, can you tell me the things we have built
    together, and your most favorite session?

    What Cowork should do

    • Enumerate previous session folders.
    • Identify deliverables created in each session.
    • Summarize patterns across the work.
    • Pick a favorite session and explain why.

    This shows Cowork as more than a one-off task runner. It can review the body of work created across sessions and help you understand what has been built.

    That becomes useful when you are building demos, content, project assets, templates, or repeatable internal workflows.

    How I would tighten the prompt

    I would ask for the output in a reusable inventory format.

    Review all our Cowork sessions stored in
    Documents > Coworker > sessions.
    Create a structured inventory with:
    - Session name
    - Date if available
    - Business scenario
    - Deliverables created
    - Files produced
    - Skills or tools used
    - Reusable assets I should keep
    - Your favorite session and why
    Group the results by scenario type.

    ↑ Back to top


    The Prompt Design Pattern

    After testing these scenarios, the pattern is obvious.

    A strong Copilot Cowork prompt usually needs these parts:

    1. Assign the role

    Example

    Act as my marketing operations lead.

    This gives Cowork a working frame. A calendar assistant, marketing operations lead, project coordinator, meeting analyst, or time-entry assistant will make different choices.

    2. Define the business goal

    Example

    I’m working on turning messy customer product feedback into a clear
    action plan for product, marketing, and leadership teams.

    The goal keeps Cowork focused on the outcome instead of wandering through the source material.

    3. Name the source of truth

    Example

    Use the attached files and project folder as the source of truth.

    This matters because Cowork may have access to a lot of context. You need to tell it what evidence matters.

    4. Add rules and guardrails

    Example

    Do not invent evidence.
    Call out assumptions clearly.
    Flag anything that needs human review.

    Guardrails keep the work usable. They also make the output safer to review, edit, and share.

    5. Specify the finished output

    Example

    Produce:
    - A polished executive feedback brief
    - A stakeholder-ready presentation deck
    - A customer follow-up email pack
    - A Teams update for the launch squad
    - A leadership decision tracker with priorities, owners, and dates

    Do not make Cowork guess what “done” means. Define the deliverables.

    6. Keep human review in the loop

    Example

    Make the outputs ready for me to review, edit, and share.

    This is the right operating model. Cowork can create the draft, organize the work, and prepare the package. You still make the judgment call.

    ↑ Back to top

    Final Thought

    Copilot Cowork gets interesting when you stop treating it like a chat box and start treating it like a worker with an assignment.

    The best prompts are direct. They give Cowork the goal, the evidence, the rules, and the expected output.

    That is how you move from “write me a summary” to:

    • Clean up my calendar.
    • Protect my focus time.
    • Draft my time entries.
    • Summarize the meeting and follow up.
    • Turn customer feedback into an action plan.
    • Move the file where it belongs.
    • Review the work we have already built.

    Small tasks. Big tasks. Same lesson.

    Give the agent clear work. Keep the guardrails tight. Review the output like a professional.

    That is where Copilot Cowork starts to feel like real capacity.

    ↑ Back to top

  • Copilot Cowork Dataverse Plugin Setup

    Copilot Cowork Dataverse Plugin Setup

    I finally got Dataverse MCP working inside Copilot Cowork as a custom plugin.

    This guide walks through the setup in a way I wish I had when I started.

    The goal is simple:

    • Register an app in Entra
    • Enable Dataverse MCP for your Power Platform environment
    • Create the OAuth registration in Teams Developer Portal
    • Build a Copilot Cowork plugin that points to your Dataverse MCP endpoint
    • Deploy it
    • Give Cowork enough schema context to understand your Dataverse tables

    If you are a low-code builder, the confusing part is not Dataverse.

    The confusing part is the setup across multiple portals.

    You will touch Entra, Power Platform admin center, Teams Developer Portal, the plugin manifest, and Copilot Cowork.

    That sounds worse than it is. You just need to know which value goes where.

    I have a video going over the same steps as the blog:

    1. What we are building
    2. Before you start
    3. The setup order
    4. Step 1: Create the App Registration
      1. Add the Dataverse MCP permission
      2. Add the redirect URI
    5. Step 2: Configure the Power Platform environment
      1. Add the allowed MCP client
      2. Capture the Dataverse URL
    6. Step 3: Create the OAuth registration in Teams Developer Portal
      1. Base URL
      2. Authorization endpoint
      3. Token endpoint
      4. Scope
      5. Client ID and secret
    7. Step 4: Build the plugin
      1. Import Plugin Builder skill
      2. Build Dataverse Plugin with Template
    8. Step 5: Deploy the plugin
      1. Connect Plugin
    9. Step 6: Create a schema-aware skill
    10. Step 7: Test with a real scenario
    11. Example prompts:
      1. List records
      2. Add records
      3. Details on a record
      4. Build Dashboard
      5. Create report
      6. Send Email with context
      7. Create PPT with context + Brand
    12. Common mistakes
      1. Mistake 1: Mixing up the IDs
      2. Mistake 2: Wrong MCP URL
      3. Mistake 3: Wrong OAuth scope
      4. Mistake 4: Testing with a user that cannot access the data
      5. Mistake 5: Re-uploading the same version
    13. Download the checklist
    14. Official docs
    15. Final take

    What we are building

    We are building a Copilot Cowork plugin that connects to the Dataverse MCP endpoint.

    Once installed, Cowork can use that plugin to query Dataverse through MCP.

    The basic flow looks like this:

    1. User asks Copilot Cowork a question
    2. Cowork uses the custom plugin
    3. The plugin points to the Dataverse MCP endpoint
    4. Dataverse returns the data
    5. Cowork uses schema guidance to make sense of the tables
    6. Cowork returns a useful answer, summary, dashboard, or audit notes

    I recommend keeping this setup in two parts:

    • The plugin: gives Cowork access to the Dataverse MCP connector
    • The schema skill: tells Cowork which Dataverse tables, columns, relationships, and rules matter

    That split makes the setup easier to maintain.

    If your schema changes, you can update the schema skill without rebuilding and redeploying the entire plugin package.

    Before you start

    You will need:

    I created a checklist for this because the setup has a few values that are easy to mix up.

    The setup order

    This is the order I recommend:

    1. Create the App Registration
    2. Configure the Power Platform environment
    3. Create the OAuth registration in Developer Portal
    4. Build the plugin
    5. Deploy the plugin
    6. Create the schema skill
    7. Test everything in Copilot Cowork

    Do not start with the plugin manifest.

    Get the identity, environment, and OAuth pieces ready first. The manifest is much easier once you already have the right values.

    Step 1: Create the App Registration

    Start in Microsoft Entra.
    https://entra.microsoft.com/

    Create an app registration that will be used for the Dataverse MCP connection.

    Capture these values:

    • Tenant ID
    • Application / Client ID
    • Client secret
    • Secret expiry date

    You will use the Client ID more than once, so copy it somewhere safe.

    Add the Dataverse MCP permission

    In the app registration, add the required API permission for Dataverse MCP.

    1. Open the app registration
    2. Go to API permissions
    3. Select Add a permission
    4. Select Microsoft APIs
    5. Select Dynamics CRM
    6. Add the permission:
    mcp.tools

    Grant admin consent if your tenant requires it.

    Add the redirect URI

    1. For the OAuth flow, add this redirect URI if your setup requires it:
    https://teams.microsoft.com/api/platform/v1.0/oAuthRedirect

    Important: the Application / Client ID is not the same as the OAuth registration ID you will create later.

    Keep those two values separate.

    Step 2: Configure the Power Platform environment

    Next, configure the Power Platform environment that contains your Dataverse data.

    You need the Dataverse environment to allow MCP clients.

    Open Power Platform admin center and go to the target environment.

    1. Open Power Platform admin center
    2. Go to Manage
    3. Select Environments
    4. Open your target environment
    5. Open Settings
    6. Go to Product
    7. Open Features
    8. Find the Dataverse MCP setting
    9. Allow MCP clients to interact with Dataverse MCP server
    10. Only check the GA version of the MCP server > Click Save

    The exact wording may change because this area is still moving, but the goal is the same: allow MCP clients for that environment

    Add the allowed MCP client

    Now add your Entra Application / Client ID as an allowed MCP client for the environment.

    1. Click “Go to Advanced Settings” link under Step 2
    2. Click +New > fill in the details like this:
      – Name: Cowork Dataverse MCP – <env name>
      – Unique Name: new_CoworkDataverseMCP<envName>
      – Application Id: Paste your application Id from the App Registration you created in section 1
      – Is Enabled: Yes
    3. Click Save & Close

    That part matters.

    The value you add here is the Entra Application / Client ID.

    Also make sure the allowed MCP client is enabled.

    If this step is wrong, the plugin can look fine but still fail when Cowork tries to use Dataverse.

    Before leaving the admin center, grab the Environment URL.

    Capture the Dataverse URL

    You need your Dataverse Org URL

    It looks like this:

    https://yourorg.crm.dynamics.com

    The MCP server URL is the same URL with /api/mcp added to the end.

    https://yourorg.crm.dynamics.com/api/mcp

    Step 3: Create the OAuth registration in Teams Developer Portal

    Now open Teams Developer Portal.
    ( https://dev.teams.microsoft.com/ )

    Create an OAuth client registration for the plugin.

    This registration stores the OAuth configuration and gives you the OAuth registration ID that your plugin manifest will reference.

    In the OAuth registration, you will enter values from the Entra app and your Dataverse environment.

    1. Click Tools > OAuth client registration
    2. + New OAuth client registration

    Base URL

    Use your Power Platform Environment URL

    https://<yourorg>.crm.dynamics.com

    Restrict usage by Teams app: select Any Teams app (for now, since we don’t have a Teams app ID yet)

    Authorization endpoint

    Use your Tenant ID in this format:

    https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/authorize

    Token endpoint

    Use your Tenant ID in this format:

    https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/token

    Scope

    The scope should use your Dataverse Org URL.

    Use this format:

    https://yourorg.crm.dynamics.com/.default offline_access

    Example:

    https://kavoracrm.crm.dynamics.com/.default offline_access

    Client ID and secret

    Use the Client ID and secret from the Entra app registration you created earlier.

    After saving the OAuth registration, copy the OAuth registration ID.

    You will use that value in the plugin manifest as the connector referenceId.

    Important: the OAuth registration ID goes into the plugin manifest.

    Step 4: Build the plugin

    For this approach, the plugin should stay focused on the Dataverse MCP connector.

    To make this even easier, I created a Cowork-Plugin skill to assist in building the Plugin with a template.

    Import Plugin Builder skill

    1. Download my /cowork-plugin-builder skill
    2. In Copilot Cowork > attach the skill and prompt: Add this skill
    3. After import refresh your browser

    Build Dataverse Plugin with Template

    We will use the skill you just imported to help build the plugin.

    1. Inside Copilot Cowork craft a prompt and add the cowork-plugin-builder skill
    2. Add these details or Copilot Cowork will ask you for these values
      (NOTE: If your using the Checklist app I created to track progress, click the Copy setup summary. Paste this into the prompt as well)

    Prompt to use:

    /cowork-plugin-builder to build a Dataverse plugin using this template:‌
    Organization name:
    Connector display name:
    description:
    Tenant ID:
    Client ID:
    Org URL:
    MCP URL:
    OAuth registration ID:
    OAuth scope:
    Connector referenceId:

    Fill in everything you can.

    I created a Dataverse-style icon with a Cowork badge so the plugin is easy to recognize when it appears in Cowork.
    (Included in the template)

    When Copilot Cowork is done, you should receive a zip file.

    Download the zip file.

    Step 5: Deploy the plugin

    After the package is ready, deploy it to a test user or test group first.

    1. M365 Admin Center > Agents > All agents > Upload custom app > pick dataverse-<pluginname>.zip
    2. Publish to users: add yourself first
    3. Install (optional): add yourself so it auto-appears
    4. Accept permissions > Review & finish
    • Apply Template (default should be fine)
    • Review Permissions (should be none, since permissions are done through the App registration)
    • Publish

    Keep the first deployment small.

    Connect Plugin

    1. Open a fresh Copilot Cowork session
    2. Click + > Manage Plugins
    3. Click … Browse Plugins
    4. Find the Plugin > Click Add
    5. Scroll down and click Connect

    Start with a simple prompt like this:

    Use the <Plugin name> to confirm you can access the Dataverse MCP server.

    Important: when you change the plugin package, update the version before uploading again.

    Also start a fresh Cowork session after deployment changes.

    Otherwise, you can end up testing against a stale session and thinking the plugin is broken.

    Step 6: Create a schema-aware skill

    This is the step that makes the plugin more useful.

    The plugin gives Cowork access to Dataverse.

    The schema skill helps Cowork understand what to do with that access.

    In the schema skill, give Cowork the details it needs to query your model properly.

    • Table logical names
    • Table purpose
    • Primary columns
    • Lookup columns
    • Relationships between tables
    • Status fields
    • Rules for what matters
    • Data-quality checks
    • Example prompts

    We can use this skill to create a personal skill to query certain tables, etc.

    In the example, I ask Copilot Cowork what tables are used in a certain Model-Driven App.
    Prompt:

    What tables are apart of Kavora Equipment Hub
    /dataverse-schema-

    Copilot Cowork responds with a tables and logical names.
    Next I ask for all the logical columns for those tables.
    (NOTE: This will help Copilot Cowork query your data quicker)

    My follow-up prompt:

    Yes pull all logical columns.
    I want to build a skill around these tables and data.
    Name the Skill Kavora Equipment IQ

    Then Copilot Cowork drafted the skill for me.
    I reviewed it and said “Looks good”

    Copilot Cowork built the skill

    Step 7: Test with a real scenario

    Now run an actual test.

    Do not only ask Cowork to connect.

    Ask it to use the Dataverse model.

    A good test should include:

    • One known record
    • At least one related table
    • At least one lookup relationship
    • Some output Cowork needs to organize
    • A data-quality check or business rule

    Example prompts:

    List records

    use /<skill you just built>
    List all the <table>

    Add records

    use /<skill you just built>
    can you add 3 more <assets>
    1. Blue Yeti mic, Regional Office, value (you look this up in USD)‌
    2. Red dragon Keyboard (RGB), lookup value, put in the HQ
    3. Surface Arc Mouse, lookup price, put in HQ

    Details on a record

    use /<skill you just built>
    list all the <table> who <condition>

    Build Dashboard

    use /<skill you just built>
    give me a full dashboard of <record>.
    Surface all details relating to <record>

    Create report

    use /<skill you just built>
    now create a report with each <Employee>
    on what they have left VS what they have used for budget

    Send Email with context

    use /<skill you just built>
    Email <James chen> asking about the <assets>

    Create PPT with context + Brand

    (NOTE: the branding is a separate skill not included in the plugin)

    use /<skill you just built>
    Now put this information inside a PPT
    using </branding-skill> for Kavora branding.
    This PPT is for Kavora Executives.
    Make it look polished with graphs and charts and pop.

    This is where the setup starts paying off.

    Cowork can query the data, follow relationships, and return a useful answer instead of forcing you to manually pull everything together.

    Common mistakes

    Mistake 1: Mixing up the IDs

    There are two important IDs:

    • Entra Application / Client ID: used in Power Platform as the allowed MCP client
    • OAuth Registration ID: used in the plugin manifest as the referenceId

    If you paste the wrong one in the wrong place, the setup will fail.

    Mistake 2: Wrong MCP URL

    The MCP URL should look like this:

    https://yourorg.crm.dynamics.com/api/mcp

    Watch for missing /api/mcp.

    Mistake 3: Wrong OAuth scope

    The scope should use your Dataverse Org URL:

    https://yourorg.crm.dynamics.com/.default offline_access

    Mistake 4: Testing with a user that cannot access the data

    Make sure the user testing the plugin has access to the Dataverse tables you are querying.

    Mistake 5: Re-uploading the same version

    If you change the package, update the version number before uploading again.

    Download the checklist

    I built a simple HTML checklist for this setup.

    It lets you track the values, check off steps, auto-fill the scope from your Dataverse URL, and generate the connector snippet.

    Download the Dataverse MCP Connector for Copilot Cowork setup checklist

    Official docs

    Final take

    NOTE: When you have tested and validated you can connect to Dataverse. You will want to add the Teams App ID from the Agent Plugin we deployed and add it to the Teams Developer OAuth Registration.

    1. Go to Teams Admin center > Teams apps > Manage apps
    2. Find your Plugin you deployed > Copy the App ID
    3. Go back to Teams Developer Portal and open the OAuth registration tool that was created
    4. Paste the App ID into the “Restrict usage by Teams app” field as an Existing Teams app

    This setup is still early, and there are rough edges.

    But once it works, the direction is obvious.

    Dataverse already has the business model.

    Copilot Cowork gives users a work surface.

    The MCP connector connects the two.

    Add a schema-aware skill, and Cowork can start working through real Dataverse data in a way that feels practical for actual business scenarios.

    That is the part worth paying attention to.

    Let me know what other Plugins you want to see in Copilot Cowork.

  • Copilot Cowork to Prep for a Board Meeting Under Pressure

    Copilot Cowork to Prep for a Board Meeting Under Pressure

    How Executives Can Use Copilot Cowork When Board Prep Turns Into a Fire Drill

    A board meeting gets moved up by 48 hours.

    Now the executive needs the story fast.

    Finance has numbers. Operations has risks. Strategy has updates. AI transformation has progress, blockers, and governance questions. The deck is not ready. The briefing memo is not ready. The board will still expect clear answers.

    That is exactly the kind of pressure where Copilot Cowork starts to make sense.

    For this scenario, I used a fictional company called Kavora Industries. I stepped into the role of Chief Strategy Officer, and the ask was simple: prepare a board-ready package under pressure.

    The company is fictional. The work pattern is very real.

    Executive takeaway: Copilot Cowork is strongest when it helps leaders turn scattered business context into decision-ready artifacts.

    Insert screenshot here: Cowork prompt asking for the board meeting briefing package.

    The Real Executive Problem

    Board prep is not just about creating a PowerPoint deck.

    The harder part is knowing what matters.

    What changed since the last update? Where are the risks? Which numbers are final and which are preliminary? What decisions does the board need to make? What questions are they likely to ask?

    That is where executive prep gets expensive.

    The information already exists, but it is spread across too many places:

    • Executive emails
    • Strategy notes
    • Finance workbooks
    • Leadership updates
    • AI transformation reports
    • Draft presentation content
    • Q&A notes

    An executive does not need another place to search. They need the scattered pieces pulled into one clean operating picture.

    The Cowork Approach

    I gave Copilot Cowork a focused executive task:

    Prepare for a board meeting that was moved up by 48 hours using the provided source material, then create the artifacts needed to walk into the meeting prepared.

    The Prompt

    The prompt followed a simple structure:

    Role:
    Act as my executive strategy assistant for Kavora Industries.
    Goal:
    Help me prepare for a board meeting that was moved up by 48 hours.
    Sources:
    Use the provided executive emails, strategy notes, finance workbook,
    AI transformation report, and leadership updates.
    Task:
    Create a board-ready briefing package that includes:
    1. Executive summary
    2. Key risks and decisions
    3. AI transformation progress
    4. Financial and operational issues
    5. Likely board questions
    6. Recommended talking points
    Outputs:
    - Create a Word briefing memo
    - a PowerPoint board deck
    - a Q&A prep sheet
    Guardrails:
    - Keep the tone executive-ready, concise, factual, and decision-focused.
    - Do not invent facts outside the source material.
    - Use Kavora branding when creating files.

    This is the part executives should pay attention to.

    The prompt is not asking Cowork for a generic answer. It assigns a job. It points Cowork at the source material. It defines the output. It adds guardrails. It asks for files the business can actually use.

    The move: Do not ask for a summary when the real need is a briefing package. Ask for the work product.

    Insert screenshot here: Cowork task progress showing the memo, deck, and Q&A prep sheet being created.

    What Copilot Cowork Created

    Cowork created three core board prep artifacts and packaged them into a reviewable executive workflow.

    1. Board Briefing Memo

    The briefing memo became the anchor document.

    It pulled the scattered business context into a single executive narrative: current state, key numbers, strategic signals, risks, and decisions needed.

    This matters because executives need more than information. They need the story behind the information.

    The memo made the situation easier to review, challenge, and sharpen before the board meeting.

    2. Board Deck

    Cowork also created the board deck.

    The deck organized the material into a board-level flow: performance, division signals, risks, AI transformation progress, and decisions requested from the board.

    The important part was not just that slides were created. The important part was that the slides were structured around the meeting the executive actually needed to lead.

    One slide showed division performance and risk signals. Another brought the board back to the required decisions.

    That is exactly what an executive needs. Less noise. Clearer framing. Decisions visible.

    3. Board Q&A Prep Sheet

    This was the strongest artifact in the workflow.

    Cowork created a Q&A prep sheet with likely board questions, direct answers, anchor phrases, and source references.

    That is real executive value.

    The board is going to ask sharper questions than the internal team. Preparing for those questions before the meeting changes how the executive shows up.

    Instead of walking in with slides only, the executive walks in with prepared answers.

    4. Executive Review Email

    I prompted Cowork to also prepare and send an email with the board packet attached.

    Work does not end when the file is created. The package still needs to move to the right people with the right context.

    The email summarized what was included, called out the wording discipline applied, and highlighted the decision priority order.

    That is a complete workflow: source material to artifacts to communication.

    The executive shift: Cowork gets the leader to the decision point faster, with better context and real artifacts already in motion.

    That is the agent boss pattern in practice.

    The human stays accountable. The agent does the heavy lifting around gathering, synthesis, drafting, formatting, and first-pass artifact creation.

    That is how an executive should think about Copilot Cowork.

    The Executive Workflow

    This board prep scenario follows a workflow executives can reuse:

    1. Define the pressure moment.
    2. Point Cowork at the right source material.
    3. Ask for decision-ready artifacts.
    4. Review the output like an executive.
    5. Tighten the narrative.
    6. Send the right package to the right people.

    That workflow applies beyond board meetings.

    You could use the same pattern for quarterly business reviews, operating reviews, customer escalations, strategy offsites, town halls, finance reviews, and AI transformation steering committees.

    The structure stays the same. Pressure, sources, task, outputs, guardrails, review.

    What I Like About This Scenario

    This scenario works because it feels like real executive pressure.

    No gimmick. No fake magic. No perfect blank-page setup.

    Just a leader with scattered information, limited time, and a meeting that requires clear judgment.

    That is where AI at work becomes useful.

    Not when it sounds impressive in a chat window. When it produces the memo, the deck, the Q&A sheet, and the email that move the work forward.

    Best use case: Use Copilot Cowork to reduce the cost of preparation, then spend your human time on judgment.

    Final Thought

    Executives do not need AI that only sounds smart.

    They need AI that helps them get ready.

    That means finding the signal, organizing the story, creating the artifacts, and helping the leader walk into the room prepared.

    This is where Copilot Cowork gets practical.

    Board prep under pressure is not a productivity trick. It is a clear example of how executives can start working differently with AI agents inside the flow of work.

  • How I Keep Copilot Cowork Sessions Alive with a requirements.md File

    How I Keep Copilot Cowork Sessions Alive with a requirements.md File

    Copilot Cowork is strong at creating files. Documents, markdown files, HTML files, specs, plans, summaries, all of it.

    So I started using that strength against one of the biggest pain points in agent work: losing context.

    1. The Problem
    2. The Workaround
    3. The Prompt I Use
    4. What I Want Cowork To Track
    5. The Recovery Flow
      1. Step 1: Open the Output Folder
      2. Step 2: Copy the OneDrive Link
      3. Step 3: Start a New Cowork Session
    6. Why This Works
    7. My Recommendation
    8. Final Take

    The Problem

    Sometimes a session can glitch, freeze, or reach a point where starting fresh is easier.

    The painful part is not starting a new session.

    The painful part is rebuilding the context.

    You have to explain the goal again. Rebuild the requirements. Re-upload or reconnect files. Remind it what decisions were already made. Recreate the mental map of the work.

    That burns time.

    So I started giving Copilot Cowork a job before it does any other job:

    Keep the context alive.

    The Workaround

    At the start of the session, tell Cowork to create a requirements.md file and keep it updated while you work.

    That file becomes the session brain.

    It gives you a portable record of the work that can move from one Cowork session to another.

    Think of it like a handoff file.

    Not a final deliverable. Not a pretty summary. A working memory file.

    The Prompt I Use

    Create a requirements.md file and keep it updated throughout this session.
    Use it to track the full context of our work, including:
    - requirements
    - decisions made
    - open items
    - files created
    - key conversation details
    - risks
    - assumptions
    - and next steps
    I want to be able to pass this file to another Copilot Cowork session
    so it can continue with full context.

    You can change the file name if you want.

    For some sessions, I might use project-context.md, demo-notes.md, or handoff.md.

    But I like requirements.md because it forces the session to stay grounded in what is actually being built.

    Note

    This works best when the requirements.md file is updated throughout the session, not only at the end. When decisions change, files are created, or blockers appear, tell Cowork to update the file.

    What I Want Cowork To Track

    The file should not be a fluffy recap.

    I want it tracking the stuff that matters:

    • Session goal
    • Current objective
    • Requirements
    • Decisions made
    • Files created
    • Important assumptions
    • Open questions
    • Risks or blockers
    • Next actions
    • Anything another session would need to continue the work

    That last one is the key.

    Do not just ask Cowork to summarize.

    Ask it to prepare the next session to continue the work.

    The Recovery Flow

    If the session glitches, breaks, or you want to continue in a fresh session, here is the flow I use.

    Step 1: Open the Output Folder

    In Copilot Cowork, open the details pane and look for the Output folder.

    Click the folder icon to open the generated files in OneDrive.

    Once the folder opens in OneDrive, click Copy link.

    This gives you a link to the folder that contains the files from the previous Cowork session.

    Step 3: Start a New Cowork Session

    Open a new Copilot Cowork session.

    Paste the OneDrive folder link into the new session and tell Cowork:

    Im continuing the <Project or task name>.
    Use the files from our previous session. ( <Paste OneDrive Link> )
    Start by reading the requirements.md file.
    Then continue the work from there.

    Now Cowork has a fighting chance at picking up where the previous session left off.

    Why This Works

    Agent workflows are only as strong as the context behind them.

    If the context is trapped inside one chat session, you are exposed.

    If the context is written into a file, you can move it.

    That changes the way you work with Cowork.

    You are no longer relying only on the chat thread.

    You are creating a portable project trail that can survive a new session.

    My Recommendation

    Make this part of your normal Copilot Cowork workflow.

    Before you ask it to build the document, analyze the data, write the plan, or generate the assets, tell it to create the context file first.

    Then keep pushing Cowork to update that file as the session evolves.

    When a decision is made, tell it to update the file.

    When a requirement changes, tell it to update the file.

    When a file is created, tell it to update the file.

    Small habit.

    Big protection.

    Final Take

    Copilot Cowork can generate the work.

    But you should also make it generate the trail.

    The requirements file keeps the important context outside the chat window, inside the actual working folder, where another session can use it.

    That is the move.

    Use Cowork to build the output.

    Use Cowork to protect the context.

    This is currently a limitation on the product, which I assume the Team will fix in the future. But for now, this is how I manage long running tasks and work with Copilot Cowork.

  • Boost Productivity with Planner and Copilot Cowork

    Boost Productivity with Planner and Copilot Cowork

    Copilot Cowork Prompt of the Day: Planner + Cowork

    Most people open Planner, see a wall of tasks, and then burn time figuring out where to start.

    Bad move.

    A better play is to use the Planner (Frontier) agent to pull everything due this week, then hand that full output to Copilot Cowork so it can start moving the work immediately.

    That is exactly what I did here.

    I had 6 tasks due in the upcoming week. Instead of manually opening each one, rewriting the context, drafting emails, setting meetings, and creating documents one by one, I used Planner to extract the full list and Copilot Cowork to help kick things off.

    The scenario

    I had a packed week ahead with multiple tasks already assigned to me in Planner. I needed a fast way to get organized and get the work moving before the week started tightening up.

    So I used the new Planner (Frontier) agent to give me a full view of what was due, then I passed that output directly into Copilot Cowork.

    That gave Cowork real context to work with: due dates, notes, priorities, task titles, and the actual work that needed to happen.

    Step 1: Pull the weekly task list from Planner

    First, I asked Planner to show me everything due this week and give me the full details.

    Show me tasks that are due this week.
    Give me full details.
    I will be giving your output to Copilot Cowork to do the tasks.

    Planner returned the task list with the details I needed. Then I asked it for one more thing: put the output into a code block.

    Can you output this in code block

    That extra step is smart. It makes the output much easier to copy and paste cleanly without wrecking the formatting or losing structure. Also AI loves it.

    Step 2: Hand the extract to Copilot Cowork

    Next, I dropped that Planner output into Copilot Cowork with a very simple prompt.

    I pulled the list of items I need to get done this week coming up.
    Get these things going and started, so I can get them done on time.
    Here is the extract from Planner:
    <Paste output from Planner agent from step 1>

    No complicated framework. No giant system prompt. Just the actual task extract from Planner and a direct ask.

    That is where this gets good. Cowork is no longer guessing what matters. It has the real list in front of it.

    Step 3: Let Cowork start the work

    Once Cowork had the context, it started breaking the workload down and pushing the execution forward.

    In my example, the work included:

    • Drafting emails and Teams messages to align what was still left for the team to build
    • Setting up workshop meetings to gather more requirements
    • Checking availability and scheduling the right people
    • Creating a procedure document
    • Helping move general dev work forward

    That is a strong workflow because it cuts out the dead time between seeing the work and starting the work.

    Instead of looking at six tasks and thinking, I should probably get on this, Cowork starts lining up the actual actions that move those tasks forward.

    Teams message sent to group chat:


    Procedure document generated:

    Meeting scheduled:

    Recap

    Planner and Cowork each do a different job, and that is exactly why this combo works.

    • Planner gives you the structured workload
    • Planner gives you the dates, notes, priority, and task details
    • Cowork uses that context to help draft, schedule, create, and coordinate

    You are not starting from a blank chat. You are starting from actual work that already exists inside Microsoft 365.

    Prompt recap

    Planner prompt

    Show me tasks that are due this week.
    Give me full details.
    I will be giving your output to Copilot Cowork to do the tasks.

    Planner follow-up

    Can you output this in code block

    Copilot Cowork prompt

    I pulled the list of items I need to get done this week coming up.
    Get these things going and started, so I can get them done on time.
    Here is the extract from Planner:
    <Paste output from Planner agent from step 1>

    Why I like this prompt

    This one is simple, practical, and dangerous in a good way.

    You take a task list that usually just sits there, and you turn it into momentum.

    That is the real win. Less dragging. More movement.

    If you are already using Planner, this is one of the easiest Copilot Cowork workflows to start using right now.

  • 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.

  • Maximize Efficiency with GPT-5 Router-Optimized Prompts

    Maximize Efficiency with GPT-5 Router-Optimized Prompts

    This prompt pack is around general use, if you would like a more focused pack focused on a specific industry or scenario, comment below.

    Below you will find the prompt pack in 3 formats

    Word doc download:

    Markdown download (word press wont let me upload markdown file so I have uploaded to my GitHub for download: FlowAltDelete/GPT-5-Router-Optimized-Universal-Prompt-Pack

    If you don’t want to download, I have also put the prompt pack below

    GPT‑5 Router‑Optimized Universal Prompt Pack (v1.1)

    What this is: A field‑tested, router‑aware prompt pack tuned for GPT‑5.
    How to use: Paste the Router Boost Header 2.0 above any task below, then use the upgraded prompt. Each item includes a fast audit (strengths, gaps, tuning) so you know why it works.


    Router Boost Header 2.0 (paste above any prompt)

    Task: [one sentence describing “done”].
    Context/Grounding: [paste facts/links/notes]. Cite sources if summarizing; don’t invent.
    Constraints: audience=[…], tone=[…], length=[…], locality=[region/laws], non‑negotiables=[…].
    Output Contract: [exact format/schema; if JSON, include a schema].
    Tool Grants: You may use internal reasoning, code execution, and structured output. Do not expose chain‑of‑thought; return only the final results.
    Mode: Choose fast for simple tasks, deep for complex ones; state the choice on one line before the output.
    Self‑Check: Validate constraints, factuality (vs. sources), and format before returning. If JSON, ensure it parses.
    Failure Policy: If blocked or context is thin, list missing info and ask 3 sharp questions; otherwise proceed with explicit assumptions labeled “Assumptions.”

    Tip: Keep the header short in production—only include fields that matter. If you need determinism, ask for “low‑randomness; no lateral riffs.”


    Universal GPT‑5 Prompt Pack v1.1**

    Below: for each prompt

    • Use when: best fit.
    • Strengths: what’s good already.
    • Gaps: what to tighten for GPT‑5.
    • Router tuning: small switches that improve results.
    • Upgraded prompt: copy/paste ready.
    • (Optional) Strict JSON variant: when you need machine‑readable output.

    1) Executive Summary (Any Topic)

    Use when: You need crisp, executive‑level clarity in 30–90 seconds.
    Strengths: Forces prioritization; covers timing and action.
    Gaps: Can drift into fluff; doesn’t enforce one‑line bullets; missing “evidence”.
    Router tuning: Demand one‑line bullets with bold labels; add “evidence” blip; enforce count.

    Upgraded prompt

    Create exactly **5 one‑line bullets** summarizing [topic/brief].
    Each bullet starts with a bold label: **What matters**, **Why now**, **Risks**, **Decision**, **Next actions**.
    Add ≤12 words per bullet. Include 1 source or metric if available.
    Mode: [fast/deep]. Return as a simple bullet list—no preamble.
    

    Strict JSON variant

    Return valid JSON:
    { "what_matters": "...", "why_now": "...", "risks": "...", "decision": "...", "next_actions": "..." }
    

    2) Research Plan (Adversarial)

    Use when: You must test a claim/feature beyond happy‑path.
    Strengths: Calls for metrics, data, adversarial tests.
    Gaps: No threat model; no instrument plan; no stop/continue math.
    Router tuning: Introduce threat model + falsification criteria; add power checks.

    Upgraded prompt

    Design an **adversarial research plan** to evaluate [claim/feature]. Include:
    1) Objectives & hypotheses (null + alt); 2) Success metrics & thresholds; 3) Threat model (abuse, edge cases);
    4) Data to collect (fields, sample size/power);
    5) Protocols (A/B, holdout, offline evals);
    6) Adversarial tests & red‑team scripts;
    7) Stop/continue rule with math;
    8) Reporting template (tables/plots).
    Mode: [fast/deep]. Output as a numbered outline.
    

    3) Decision Memo

    Use when: A one‑pager to choose among options.
    Strengths: Options, costs, risks, reversibility, rec.
    Gaps: No owner/date format; no “evidence” box; weak contingency.
    Router tuning: Add RACI owner/date; add 30/60/90 follow‑ups.

    Upgraded prompt

    Write a one‑page decision memo for [choice]. Include:
    - Context (1 para) with constraints & evidence;
    - Options (3): summary, costs (one‑time/run), risks, reversibility;
    - Recommendation: **one** choice with rationale;
    - Owner + Decision date; 30/60/90‑day checkpoints;
    - Contingency triggers & rollback plan.
    Mode: [fast/deep]. Keep ≤400 words.
    

    4) Project Plan One‑Pager

    Use when: Turn messy notes into plan.
    Strengths: Scope, milestones, owners, risks, comms, RAID.
    Gaps: No critical path; RAID often hand‑wavy.
    Router tuning: Add dates & simple Gantt list; RAID as compact table.

    Upgraded prompt

    From these notes: [paste], produce a one‑page plan with:
    1) Scope (in/out);
    2) Milestones (name, owner, date) in order;
    3) Critical path (1‑3 bullets);
    4) Comms cadence (who, channel, freq);
    5) RAID summary table (Risk/Assumption/Issue/Dependency → owner, impact, mitigation);
    6) Acceptance criteria (bullet list).
    Mode: [fast/deep]. Keep it skimmable.
    

    5) Meeting → Decisions

    Use when: Converting raw notes to what matters.
    Strengths: Decisions & actions separation.
    Gaps: No owners on decisions; action status taxonomy missing.
    Router tuning: Add decision owner + rationale; status enum.

    Upgraded prompt

    Convert these notes: [paste] into:
    A) **Decisions** list (decision, owner, rationale, date);
    B) **Actions** table {owner, step, due, status ∈ [New, In‑Progress, Blocked, Done]}.
    Mode: [fast/deep]. No commentary, just the two sections.
    

    Strict JSON variant

    { "decisions": [ { "decision": "", "owner": "", "rationale": "", "date": "" } ],
      "actions": [ { "owner": "", "step": "", "due": "", "status": "New|In-Progress|Blocked|Done" } ] }
    

    6) Cold Email Trio

    Use when: 3‑touch outbound sequence.
    Strengths: Problem → proof → ask. Short.
    Gaps: ICP nuance; weak personalization; missing CTA micro‑asks.
    Router tuning: Insert first‑line personal hook; vary asks.

    Upgraded prompt

    Write **3 cold emails** for [offer] to [ICP].
    Email 1: name the **patterned pain**; end with a 10‑min micro‑ask.
    Email 2: social proof/insight (number/metric), 1 sentence case study.
    Email 3: crisp ask with 2 time options.
    Each ≤120 words, 5‑7 sentences, no fluff. Include a {First‑line personalization} placeholder.
    Mode: [fast/deep].
    

    7) LinkedIn Authority Post

    Use when: Thought leadership for execs + builders.
    Strengths: Structure, framework, prompt.
    Gaps: Risk of buzzwords; no proof.
    Router tuning: Require 1 mini‑case and 1 number.

    Upgraded prompt

    Write a LinkedIn post on [topic] for execs + builders:
    - 3 punchy paragraphs (≤60 words each);
    - 1 mini‑framework (3 bullets, named);
    - 1 thought prompt (1 line);
    - Include one concrete number or example; avoid buzzwords.
    Mode: [fast/deep]. No hashtags unless asked.
    

    8) X Post (Bold, No Hashtags)

    Use when: High‑signal micro‑take.
    Strengths: Tight character limit, bold stance.
    Gaps: Might overrun chars; no proof token.
    Router tuning: Enforce count; include 1 fact word/number.

    Upgraded prompt

    Write one confident X post on [insight/news]. ≤240 chars.
    Format: HOOK — TAKEAWAY. Include **one** concrete fact or number.
    No hashtags. No emoji at the end. Mode: [fast/deep].
    

    9) YouTube Kit

    Use when: Fast ideation + structure.
    Strengths: Titles, open, chapters.
    Gaps: Title length drift; missing viewer promise.
    Router tuning: Enforce title count/length; add “who it’s for.”

    Upgraded prompt

    For a video on [topic], produce:
    - **10 titles** (<60 chars);
    - A two‑sentence cold open that states who it’s for and the promise;
    - Chapter list with timestamps (estimate) and outcomes per chapter.
    Mode: [fast/deep]. No clickbait lies.
    

    10) Content Angle Generator

    Use when: Topic expansion without repetition.
    Strengths: Rich buckets.
    Gaps: Duplicates; vague angles.
    Router tuning: Enforce uniqueness + sample headline.

    Upgraded prompt

    List **25 distinct content angles** for [niche/product] across:
    how‑to, contrarian, teardown, story, data, tutorial, tool, myth vs fact.
    For each: 1‑line angle + a sample headline. No repeats. Mode: [fast/deep].
    

    11) Product Spec from Idea

    Use when: Move from idea to v1.
    Strengths: Users, JTBD, metrics, scope.
    Gaps: Test plan vague; acceptance criteria missing.
    Router tuning: Add measurable acceptance + de‑scoping rules.

    Upgraded prompt

    Turn this idea into a lean product spec:
    - Users & JTBD; key use cases;
    - Success metrics (leading/lagging) with targets;
    - V1 scope (must/should/could) and out‑of‑scope;
    - Acceptance criteria (measurable);
    - Test plan (happy path, edge, abuse).
    Mode: [fast/deep]. ≤500 words.
    

    12) UX Critique

    Use when: Actionable UI improvements.
    Strengths: Issues + fixes.
    Gaps: Evidence often light; microcopy not tested.
    Router tuning: Severity scale + before/after microcopy.

    Upgraded prompt

    Critique the UX of [flow/screen]. Deliver:
    - 10 issues with severity ∈ {P0, P1, P2}, evidence, and concrete fix;
    - A before→after microcopy table (3–5 rows);
    - One quick win and one deeper redesign note.
    Mode: [fast/deep].
    

    13) CSV Data Brief

    Use when: Shape an analysis plan before coding.
    Strengths: Questions → steps → visuals.
    Gaps: Schema ambiguity; data checks missing.
    Router tuning: Add sanity checks + exact chart types.

    Upgraded prompt

    Given CSV schema: [columns], produce:
    1) 5 decision‑driven questions;
    2) Validation checks (types, nulls, outliers);
    3) Analysis steps;
    4) Exact visuals/tables to produce (chart type, axes, groupings).
    Mode: [fast/deep]. No code unless asked.
    

    14) Code from Spec

    Use when: From spec to runnable core.
    Strengths: Architecture, snippets, tests, edges.
    Gaps: Env assumptions; complexity unbounded.
    Router tuning: Pin language/runtime; include complexity notes.

    Upgraded prompt

    Given this spec: [paste], provide:
    - Architecture diagram (text) and key components;
    - Core code snippets in [language/runtime] with minimal deps;
    - Tests (unit/integration) and fixtures;
    - Failure/edge cases + graceful handling;
    - Complexity & trade‑offs section.
    Mode: [fast/deep]. Keep idiomatic.
    

    15) Code Review + Refactor

    Use when: Improve safety & clarity with a plan.
    Strengths: Smells, hotspots, steps, tests.
    Gaps: Lacks risk scoring; migration path unclear.
    Router tuning: Add impact x effort; phased plan.

    Upgraded prompt

    Review this code: [paste]. Deliver:
    - Findings by category (correctness, security, perf, clarity);
    - Hotspots with complexity signals;
    - Refactor plan in small, safe steps with tests;
    - Risk/Impact vs Effort matrix (P0/P1/P2);
    - Before/after snippet for 1 key function.
    Mode: [fast/deep].
    

    16) Strict JSON Every Time

    Use when: Machine‑readable output required.
    Strengths: Clear schema.
    Gaps: No parser check; no enum constraints.
    Router tuning: Include enums & validation note.

    Upgraded prompt

    Return **only valid JSON** for [task]. Schema:
    {
      "title": "string",
      "summary": "string",
      "risks": ["string"],
      "actions": [ { "owner": "string", "step": "string", "eta": "YYYY-MM-DD" } ],
      "metrics": ["string"]
    }
    No prose. Validate keys, types, and date format before returning.
    

    17) SOP / Checklist

    Use when: Repeatable, low‑variance execution.
    Strengths: Steps + gates + recovery.
    Gaps: Timing windows; roles not explicit.
    Router tuning: Add roles & time boxes.

    Upgraded prompt

    Draft a step‑by‑step SOP for [process]. Include:
    - Prereqs & roles;
    - Steps with time boxes;
    - Quality gates with pass/fail checks;
    - Common failure recovery & escalation ladder.
    Mode: [fast/deep]. Output as a checklist.
    

    18) Positioning & ICP

    Use when: Sharpen message‑market fit.
    Strengths: ICP, pains, alts, value prop, messages, pitch.
    Gaps: Jobs vs pains; proof tokens missing.
    Router tuning: Add JTBD & proof lines.

    Upgraded prompt

    Define positioning for [product]. Provide:
    - ICP traits (firmographic + behavioral);
    - JTBD and top pains (ranked);
    - Alternatives (do‑nothing included);
    - Value proposition (benefit + proof);
    - 3 key messages;
    - 3‑line elevator pitch.
    Mode: [fast/deep].
    

    19) Competitive Teardown

    Use when: Side‑by‑side clarity.
    Strengths: Features, UX, pricing, moat, switching costs, objections.
    Gaps: Buyer role nuance; evidence weak.
    Router tuning: Add role lens + cite artifacts.

    Upgraded prompt

    Compare [your product] vs [competitor] for [buyer role]. Cover:
    - Features & UX (table);
    - Pricing (typical deal sizes/TCO);
    - Moat & switching costs;
    - Buyer objections + crisp replies;
    - Evidence links (docs, screenshots) if available.
    Mode: [fast/deep].
    

    20) Policy First Draft (Non‑Legal)

    Use when: First pass policy with clarity.
    Strengths: Rules, examples, do/don’t, escalation.
    Gaps: No scope/authority; review cadence missing.
    Router tuning: Add scope, owner, review cadence.

    Upgraded prompt

    Draft a **non‑legal** first‑pass policy for [topic]. Include:
    - Scope & definitions; policy owner;
    - Rules with examples; do/don’t lists;
    - Compliance checks & escalation path;
    - Exceptions process;
    - Review cadence and change log placeholder;
    - Legal review placeholder.
    Mode: [fast/deep].
    

    21) 7‑Day Learning Plan

    Use when: Focused upskilling in a week.
    Strengths: Daily objectives, resources, practice, quiz.
    Gaps: Entry level varies; no capstone.
    Router tuning: Add diagnostic + capstone.

    Upgraded prompt

    Build a 7‑day learning plan for [skill/exam]. Include:
    - Day 0 diagnostic (what to skip/focus);
    - Daily objectives, resources (≤3/day), and practice tasks;
    - Daily self‑quiz (5 Qs) with expected answers;
    - Day 7 capstone task with rubric.
    Mode: [fast/deep].
    

    22) Negotiation Prep

    Use when: Plan the conversation before the room.
    Strengths: Goals, walk‑away, BATNA, concessions, questions, opening.
    Gaps: Counter‑plays; objection map missing.
    Router tuning: Add opponent map + scripts.

    Upgraded prompt

    Create a negotiation brief for [deal]. Include:
    - Goals; walk‑away; BATNA;
    - Concession strategy (give/get);
    - Questions to surface interests;
    - Opening script;
    - Objection map with counters;
    - Opponent/alignment map (roles, power, interests).
    Mode: [fast/deep].
    

    23) Landing Page Copy

    Use when: Write conversion‑first copy.
    Strengths: Section list, direct tone.
    Gaps: Segment nuance; FAQ weak.
    Router tuning: Add segment option + proof elements.

    Upgraded prompt

    Write a landing page for [offer]. Sections:
    - Headline + subhead (clear promise);
    - Value bullets (3–6) with outcomes;
    - Proof (logos, testimonial lines, metrics);
    - CTA (primary + secondary);
    - FAQ (5–7 Qs).
    Optional: provide a variant for [segment].
    Mode: [fast/deep].
    

    24) Automation Blueprint

    Use when: Design automations with ROI.
    Strengths: Triggers, steps, data, errors, alerts, ROI.
    Gaps: SLAs; run‑costs; auditability.
    Router tuning: Add SLAs, idempotency, and cost model.

    Upgraded prompt

    Propose automations for [workflow]. Include:
    - Triggers & prerequisites;
    - Steps with systems & data sources;
    - Error handling (retries, dead‑letter, idempotency);
    - Alerts/observability (what, who, channel, thresholds);
    - SLAs & run‑cost model;
    - ROI estimate (baseline vs future, payback).
    Mode: [fast/deep].
    

    Bonus: Mini Switches You Can Add Anywhere

    • “Low‑randomness, no lateral riffs.” For deterministic outputs.
    • “Use a verification pass: compare output vs. constraints, fix before returning.”
    • “If citing, append a short sources list with titles + links.”
    • “Label assumptions explicitly if context is thin.”
    • “Return a ‘How to use this output’ note in one line.”

    Final Notes

    • Keep the Router Header lean; the power comes from clear Output Contracts and tight constraints.
    • Prefer JSON when downstream automation is needed; prefer skimmable bullets when humans are the primary consumer.
    • If you need extra toughness, combine “adversarial” and “self‑check” lines.

    Changelog v1.1 (this doc): Added threat models, self‑check, enum statuses, strict JSON variants, SLAs/costs for automation, and decision‑date/owner fields for memos.

  • 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.

    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.