← Part of: Deep Dive: Instructions, Skills, Runtime and Sandbox

Instructions and Skills Authoring

Build and test an RFP Response agent with an existing Skill, inspect its package, and chart source data in the sandbox. Optionally create your own Skill in Copilot Studio Preview.

Content last updated:

Level 300 30 min Intermediate

Instructions and Skills Authoring

Build and test an RFP Response agent with an existing Skill, inspect its package, and chart source data in the sandbox. Optionally create your own Skill in Copilot Studio Preview.

Lab Details

Level Persona Duration Purpose
300 Maker 30 minutes Attach, inspect, and test an existing Skill in a Copilot Studio agent, then use sandbox code execution to chart source data. Skill creation is optional extra credit.

Table of Contents

Why This Matters

Makers and Developers - Have you written the same long instructions into three different agents, and watched them drift apart?

Think of a Skill as a playbook the orchestrator picks up only when it is relevant:

  • Without Skills: Every rule lives in one agent’s top-level instructions. The prompt grows, unrelated behaviour leaks into every conversation, and nothing is reusable anywhere else
  • With Skills: “When to use me”, “the material I work from”, and “the procedure to follow” travel together as one component - loaded on demand, versioned, and portable across surfaces

Common challenges solved by this lab:

  • “My agent instructions are thousands of words and I am afraid to touch them”
  • “The agent loses track of the detailed procedure as its base instructions grow”
  • “The agent sounds confident about things the company cannot actually commit to”

In 30 minutes, build and test one Skill-equipped agent, inspect its playbook, and chart the RFP’s evaluation weights. Creating your own Skill is optional extra credit, outside the core timebox.

Introduction

A Skill packages a named, self-contained playbook: a description that tells the orchestrator when the Skill applies, instructions describing the procedure, and the reference material the work depends on. Instead of cramming every rule into an agent’s instructions, you hand the orchestrator something it can load only when a request matches.

Real-world example: a proposal team answers RFPs. The rules are stable - match the request to an offering, answer from pre-approved language, never claim a certification the company does not hold. A Skill keeps that procedure and its reference material together, ready for the agent to load when someone attaches a solicitation.

Use Case #1 is the complete core lab: build an RFP Response agent with a sample Skill and watch it load. If you have extra time, the optional Skill-creation exercise shows how to create a guided project-intake Skill in Copilot Studio Preview. It uses a separate agent so the procedures do not compete.

Core Concepts Overview

Concept Why it matters
Skill A named playbook - description, instructions, and bundled reference files - that the orchestrator loads only when a request matches it, keeping base instructions short and behaviour consistent
Skill description The text the orchestrator matches a user request against. It is the single most common reason a Skill does or does not fire
Skill generation and refinement Give an authoring assistant a process and examples, review its generated Skill, then test it in the target agent. Generation is a starting point, not proof that the Skill works
Bundled references and scripts The references/, assets/ and scripts/ folders that travel with SKILL.md, so the Skill answers from vetted material and can run its own helpers rather than improvising
Agent sandbox The runtime where the agent can execute code, analyze supplied files, and generate artifacts such as charts and PDFs; available libraries and tools must be observed rather than assumed
Skill guidance versus validation A Skill guides model behavior but does not guarantee exact question ordering, field validation, or branching. Test the behavior and use deterministic validation when guarantees are required

These resources cover agents and Skills powered by the GitHub Copilot harness in Copilot Studio.

Microsoft Learn: GitHub Copilot harness and Skills

CAT blog: The Custom Engine

Prerequisites

[!NOTE] If you are completing this lab as part of a CAT-led workshop or bootcamp, you do not need to complete these prerequisites: the CAT team has already prepared them in advance. These prerequisites apply only when completing the lab in a tenant that is not managed by CAT.

  • Everyone: access to Microsoft Copilot Studio with the GitHub Copilot harness, permission to create agents and use Skills, sandbox code execution with an available charting library, and a workshop account that can connect to Work IQ
  • The sample Skill package and test RFPs from AgentDudeSamples
  • Optional Skill-creation extra credit only: a reasoning-capable model in Copilot Studio, such as Opus 5.5 if available, plus file attachments and sandbox ZIP-file generation/download in Preview. Model names and availability vary by environment
  • Optional Skill-creation materials: download the source-materials ZIP and extract project-intake-process-v2.docx. Only this process document is needed; the archive contains source materials, not a finished Skill

Summary of Targets

By the end of the core lab you will:

  • Attach a Skill to a Copilot Studio agent and watch the orchestrator load it without being told to
  • Read a Skill package and explain what its description, references, assets and scripts each do
  • Use sandbox code execution to extract the RFP’s evaluation weights and create a downloadable chart, checking the result against the source
  • Explain why a Skill guides behavior but does not replace deterministic validation or guaranteed branching

Optional extra credit: turn a project-intake process into a Skill in a blank agent’s Preview, upload the package, add agent instructions, and test the guided conversation.

Use Cases Covered

Use Case #1 is the only required exercise. The Skill-creation exercise and other extra-credit sections are optional.

Suggested 30-minute session: 5 minutes for orientation, 20 minutes for Use Case #1, and 5 minutes for review and conclusions.

These are planning timeboxes for a prepared tenant, not measured execution guarantees. Complete tenant prerequisites before the session if you are not using a CAT-managed tenant. Allow extra time for connection prompts, model runs, or repairs. Extra-credit exercises are outside the 30-minute duration.

Route Use Case Value added Timebox
Everyone Use Case #1: Leveraging Skills in Copilot Studio agents Upload, inspect, and test an existing Skill, then chart source data in the sandbox 20 min
Optional extra credit Create and test a Skill with Copilot Studio Create a guided project-intake Skill in Copilot Studio Preview, then upload and test it 25 min extra

Instructions by Use Case

Use Case #1: Leveraging Skills in Copilot Studio agents

Core exercise. Timebox: 20 minutes. You do not need to publish the agent.

Step-by-step instructions

Create the agent

  1. Create a new agent in Copilot Studio.

    The agent designer opens on the Build tab with a new, unsaved agent.

  2. Select the name field at the top and replace Untitled Agent with:

    RFP Response Agent

    Name the new agent RFP Response Agent

  3. Take a moment to look at the agent configuration rail on the right. This is where every component of the agent is attached - Skills, Tools, Knowledge, Connected agents, and Memory.

    The agent configuration rail showing Model, Skills, Tools, Knowledge, Connected agents and Memory

    [!NOTE] Skills sits directly under the model, above Tools and Knowledge. That ordering reflects how the orchestrator works: a Skill is the playbook that decides when and how the tools and knowledge below it get used.

Add the Work IQ tool

  1. In the agent configuration rail, on the Tools section, select + (Add tool).

  2. In the Add a tool dialog, search for:

    Work IQ

    Then filter the results by MCP to narrow the list.

    [!TIP] Without the MCP filter, the search returns every connector with “work” anywhere in a name or action - dozens of results - and Work IQ is listed last, below the connector groups. Scroll to the bottom of the results rather than picking one of the “work order” actions near the top.

  3. Select Work IQ.

  4. On the Select a connection step, the connection shows Not connected. Select it, then choose Create new connection and Create. Sign in with your workshop account when the account picker appears.

    [!NOTE] Work IQ covers Microsoft 365 operations - mail, calendar, files, chats and more. The connection is created under your identity, so the agent acts on the signed-in user’s Microsoft 365 data.

  5. Select Add. Work IQ now appears under Tools in the rail.

Give the agent its instructions

  1. Copy the entire block below into the agent’s Instructions. These are agent instructions, not a chat message.

    You are the RFP Response Agent for our organization. You help our team write clear, accurate answers to customer RFPs (requests for proposal).

When you are given an RFP question or document:
- Find the material we already have: past RFP responses, product documentation, and company policies.
- Draft the answer in our voice - direct, specific, and free of marketing filler.
- Keep each answer self-contained so it can be pasted straight into the RFP form.
- Never invent facts about our products, pricing, security posture, or certifications. If you cannot find a source, say so.

Ask a clarifying question when the request is ambiguous. Keep answers concise unless the RFP asks for detail.

    The agent instructions describing the RFP Response Agent

    [!NOTE] These instructions stay deliberately short. They describe who the agent is and the rules that always apply. The detailed “how to handle this kind of request” procedure goes into a Skill in the next section - which is exactly the split Skills exist to enable.

Add the RFP Response skill

  1. Download the skill package: rfp-response.zip

    The package contains a SKILL.md plus the reference material it draws on - an answer library, offering catalogs, past-performance and pricing references, and worked examples of RFP requests and responses.

    [!NOTE] The sample skill is written for a fictional company, Aventra Software Group. Its answers are grounded in that company’s catalog, past performance, and pricing, so Aventra will appear in the agent’s output even though the agent instructions say “our organization”. In a real deployment you would swap the bundled references for your own.

  2. In the agent configuration rail, on the Skills section, select + (Add skill).

  3. Select Upload a skill to use the existing package. Create from blank is another option for authoring a Skill directly in the UI. The screenshot below shows the upload and blank-authoring options.

    The Add skill dialog with the Upload a skill and Create from blank tabs

    [!NOTE] A skill file must be a SKILL.md, or a .zip package that contains one. The SKILL.md must carry a name and description in YAML frontmatter - that description is what the orchestrator matches a user’s request against when deciding whether to load the skill.

  4. Select the upload area and choose the rfp-response.zip you downloaded. Wait for Saving skill… to finish.

  5. rfp-response now appears under Skills in the rail, alongside the Work IQ tool.

    The rfp-response skill attached under the Skills section

    [!IMPORTANT] Uploading the skill saves the agent - the URL changes from /agents/new to the agent’s permanent ID, and Save disappears from the toolbar because there are no unsaved changes.

Inspect what you uploaded

  1. In the Skills section of the rail, select the rfp-response chip to open the skill.

  2. The viewer shows the whole package: 16 files, 141.2 KB. SKILL.md opens first - its Name and Description come from the YAML frontmatter, and Instructions is the body.

    The rfp-response skill viewer showing the bundle file tree alongside the SKILL.md name, description, and instructions

    [!NOTE] These fields are read-only. An uploaded skill is changed by editing the package and re-uploading it, not in the portal. A skill authored with Create from blank is editable in place.

    [!TIP] Read the Description closely. It is deliberately packed with the phrasings a user might actually type - “respond to this RFP”, “draft our bid”, “answer these vendor questions”. That text is what the orchestrator matches against, so a vague description is the most common reason a skill never loads.

  3. In the tree, select references/answer-library.md. This is the pre-approved answer library the skill reuses instead of composing new prose - a topic-key table covering security, data privacy, accessibility, hosting, SSO, SLAs, and pricing.

    The answer-library.md reference open in the skill viewer, showing the topic-key table

    [!TIP] This is what makes a Skill more than a long prompt. The instructions say how to behave; the bundled references/ and assets/ are the material it works from. Swap these files for your own catalog and answer library and the same skill drafts your proposals.

  4. Select Close to return to the Build tab. The Download icon pulls the package back out if you want to edit and re-upload it.

Test the agent and watch the skill load

  1. Select the Preview tab.

  2. Download the sample solicitation: 01-westbrook-permitting-portal.md
    • a City of Westbrook RFP for an online permitting and licensing portal.

    [!NOTE] The sample solicitations carry fixed submission dates that have since passed, so the agent may open its response by flagging that the deadline is behind us. That is the skill being careful rather than a fault - read past it and judge the proposal itself.

  3. In Copilot Studio > Preview chat, select Attach file and attach the RFP. Copy the block below into the chat composer, then select Send:

    We are bidding on this RFP. Draft our response.

    The Preview composer with the RFP attached and the prompt typed

  4. Watch the agent’s turn. Before it writes anything, it announces “I’ll start with the RFP response skill” and the orchestrator shows Loading skill: rfp-response under Reasoned through your request.

    The orchestrator loading the rfp-response skill, with its reasoning about which offering matches

    [!IMPORTANT] This is the whole point of the lab. You never told the agent to use the skill. The orchestrator matched your request against the skill’s description, decided it applied, and loaded it - then followed the skill’s procedure: identify the matching offering, read answer-library.md, past-performance.md and pricing.md, and only then draft.

  5. Select Loading skill: rfp-response to expand it. The trace shows the skill description the orchestrator matched against, and the call it made: skill: rfp-response.

    The expanded skill-load trace showing the matched description and the input skill: rfp-response

    [!TIP] This is the diagnostic to reach for when a skill does not fire. If the description does not contain the language a user would actually use, the orchestrator never matches it - and nothing in the transcript tells you the skill exists.

  6. Let the run finish. The agent drafts the proposal, then uses the tools available to it to render it as a PDF.

    [!NOTE] The full draft-plus-PDF run takes several minutes - it is writing a nine-page proposal and then rendering it. The reasoning trace updates as it works and is worth reading; the agent has not hung.

  7. Review the summary. It reports the matched offering, the commercials, coverage against the buyer’s scoresheet, and a numbered list of gaps to resolve before submission.

    The agent's closing summary listing the matched offering, commercials, scoresheet coverage and flags to resolve

    [!TIP] Note what it refused to invent: no pre-built Esri/Tyler connectors, no StateRAMP certification, no firm managed-services price. That restraint comes from the skill’s guardrails and answer library - the vetted position the company can actually commit to.

  8. Both artifacts are attached to the message: WB-2026-031-Aventra-Proposal.md and a nine-page WB-2026-031-Aventra-Proposal.pdf.

    The generated proposal markdown and PDF attached to the agent's response

Use the sandbox to chart the evaluation weights

  1. In the same Preview conversation, reattach the sample RFP if it is no longer available. Copy the block below into Preview chat, then select Send:

    Use your sandbox to analyze section 4, Evaluation criteria, of the attached City of Westbrook RFP. Read the source file with code and extract the criterion names and numeric weights; do not use scores or coverage claims from our proposal.

Execute code to create a horizontal bar chart using matplotlib if it is installed, or another charting library already available in your sandbox. Keep the criteria in source order, label every bar with its weight, and label the axis "Evaluation weight (points)". Title the chart "City of Westbrook RFP - Evaluation criteria".

Check that there are five criteria and that their weights sum to 100. If the source differs, report the discrepancy rather than changing its values. Save the chart as westbrook-evaluation-weights.png, verify the image opens, and attach the actual PNG. Also show the extracted data table and name the charting library you used.

Do not regenerate the proposal, install packages, call external services, or invent data. If sandbox execution, the source file, or a usable charting library is unavailable, report that explicitly instead of claiming to have created a chart.

  2. Expand the run details under Reasoned through your request. Look for the sandbox/code-execution tool call that reads the RFP and renders the image. A claim that code ran is not evidence; if the tool details are not visible, record execution as unverified.

  3. Download and open westbrook-evaluation-weights.png. Compare the chart and extracted table with section 4 of the RFP: Technical approach 30, Relevant municipal experience 25, Cost 20, Project team 15, and Timeline 10. These are evaluation weights, not scores awarded to Aventra. Check the labels, all five bars, and the total of 100.

    [!NOTE] This step requires actual sandbox execution and a downloadable image, not a text-only chart or a suggested Python script. If it fails, capture the exact error and check sandbox access with your workshop facilitator. You can use the Extra Credit Harness Explorer exercise to investigate the observed runtime and libraries; it is not required to run this step.

Congratulations! You’ve completed Use Case #1!

You have completed the core lab. Continue to the conclusions and recommendations. If you have extra time, try creating your own Skill.

Conclusions and recommendations

Skill golden rules:

  • Write the description for the user’s words, not yours. List the phrasings someone would actually type. That text is the matching surface, and everything else in the Skill is dead weight if it never fires
  • Keep agent instructions short and put the procedure in the Skill. Base instructions describe who the agent is; the Skill describes how one kind of work gets done
  • Ground answers in files you control. An answer library the business has approved is what lets a Skill decline to claim a certification instead of quietly implying it
  • Check generated artifacts against their sources. Open the proposal and chart, verify the facts and evaluation weights, and do not treat a claimed file or tool run as proof of execution
  • Review before sharing. A human should review the proposal’s facts, certification gaps, and commercial numbers before it reaches a customer
  • Generate, test, and refine. Check behavior against examples and bring concrete failures back to the authoring tool. A generated package or a confident self-review is not evidence that it works in the target agent

Extra Credit: Create and test a Skill with Copilot Studio

Optional extra credit. Timebox: 25 minutes, outside the core lab.

Your goal: use Copilot Studio Preview to turn a project-intake process into a reusable Skill that asks for missing details and summarizes them for confirmation.

Try this after completing Use Case #1 if you have extra time. You need a reasoning-capable model and sandbox ZIP generation in Preview. No connectors or external data are needed.

Follow this sequence:

  1. Create a Skill ZIP in a blank agent’s Copilot Studio Preview.
  2. Upload that ZIP under the agent’s Build > Skills.
  3. Configure the agent by pasting the supplied base instructions into Build > Instructions.
  4. Test the agent in two fresh Copilot Studio Preview conversations.

Generating a ZIP does not install the Skill. The authoring prompt creates the package; the agent instructions define the agent’s role; the test prompts check the uploaded Skill. Keep these three kinds of text separate. Publishing is not required.

Get the source materials

  1. Download and extract the Skill-generation materials.

    [!WARNING] Do not extract the ZIP inside a OneDrive for Business folder. Your organization may automatically encrypt files saved there, and the agent will then be unable to read them. Extract the files to a location outside OneDrive.

  2. Use only project-intake-process-v2.docx. Attach this individual document to Copilot Studio Preview, not the materials ZIP. Ignore the other documents in the archive.

These are fictional source documents, not a ready-to-upload Skill. Use the supplied examples rather than real customer data.

Project-intake Skill package checklist

Reference checklist: use this after the Copilot Studio Preview steps below generate a Skill ZIP. You do not need to upload anything yet.

  1. Review the procedure. Compare the generated Skill with the project-intake process. It must collect the four details, reuse supplied answers, accept unknowns, and request confirmation without implying project approval.

  2. Check the package. Download the generated Skill ZIP, not the materials ZIP. It must contain SKILL.md at the root, YAML name and description fields, and all files referenced by the instructions. A prose response is not a completed package.

  3. Handle errors before continuing. If file generation fails, capture the error and ask your facilitator. If uploading fails, return the exact validation error and package structure to the authoring chat for repair.

Guided project intake

[!NOTE] Skills do not directly replace topics, but they can be used to guide conversations in a similar way. A Skill guides the model’s behavior; it does not guarantee exact question ordering, field validation, or branching. Use deterministic logic when those are requirements.

You will create a Skill that collects four details: business goal, intended users, desired outcome, and target date. It should ask one missing question at a time, accept unknowns, and summarize the answers for confirmation.

Use a new agent for this extra-credit exercise, not your RFP agent. You will first use its Preview chat to create the package, then upload the package and start a fresh chat to test intake.

Create the Skill in Copilot Studio Preview

  1. In Copilot Studio, create a new agent using the GitHub Copilot harness. Name it Project Process Assistant. Do not reuse your RFP agent.

  2. On Build, leave Instructions empty. If the new agent has generated instructions, clear them now. Do not add the intake instructions, a Skill, or connectors yet: the first conversation is for creating a package, not running intake.

  3. In the configuration rail, open Model and select a reasoning-capable model, such as Opus 5.5 if it is offered in your environment. Model names and availability vary; ask your facilitator which reasoning model to use if it is not listed.

  4. Select the agent’s Preview tab and start a new conversation. Attach only project-intake-process-v2.docx from the extracted materials. Do not attach the ZIP file.

  5. Copy the entire block below into Copilot Studio > Preview chat, alongside the attachment, then select Send. This is a chat prompt, not agent instructions. Keep Build > Instructions empty while generating the package.

Create a portable Agent Skill named project-intake-guide for a Copilot Studio agent powered by the GitHub Copilot harness.

Use the attached project-intake-process-v2.docx as the procedure. Activate for requests such as "I want to request a project" or "Help me scope a new project", not for general questions about project management.

Collect the business goal, intended users, desired outcome, and target date. Reuse details already supplied. Ask only one missing question at a time. Accept "not yet known" and record it without asking again. Once all four fields have either a value or an explicit unknown, show a summary and ask for confirmation. Apply corrections without restarting. Confirmation means the summary is accurate, not that the project is approved.

Use your sandbox to create a real downloadable ZIP with SKILL.md at its root. SKILL.md must have valid YAML front matter with name and description, followed by Markdown instructions. Include a faithful Markdown version of the Word process under references/ and refer to it from the instructions. The finished intake Skill must not require tools, scripts, external services, or automatic actions. Keep the agent's base instructions separate from the Skill. Create the package now; do not start the intake interview or add agent instructions.

Before packaging, check the procedure against an incomplete opening request and a request that supplies all four fields. Report limitations; this drafting check does not prove the uploaded Skill works. Provide the actual ZIP file, not just a description or a suggested script. If file generation fails, report the error rather than inventing a download.

Upload the Skill, then add agent instructions

  1. Check the response in Preview. The first prompt may already have created a downloadable Skill ZIP. If it has, skip the follow-up prompt below and continue to the download step.

    Only if no downloadable Skill ZIP was created, answer any clarifying questions, then send this follow-up in the same Preview chat. Use it if the agent returned only a draft or started the intake interview instead of creating the package:

    Create the reusable Skill package from the process; do not run intake yet. Provide the downloadable ZIP.

    If it cannot generate a file, capture the error and ask your facilitator; a text-only response is not a completed package.

  2. Download the generated Skill ZIP from Preview, unzip it, and review its contents using the project-intake package checklist.

  3. In the same agent, go to Build > Skills > + > Upload a skill. Upload the generated ZIP and wait for it to save. Add only the intake Skill.

  4. After the upload succeeds, paste the entire block below into Build > Instructions and wait for it to save.

You help users capture and confirm project intake details. Use relevant Skills when requests match, and follow the loaded Skill's procedure for the conversation.

Never invent missing details or imply that a project has been approved, funded, or scheduled. Do not send messages or make changes to external systems. Answer general project-management questions without starting intake unless the user requests it.

Test the intake Skill in Copilot Studio Preview

In the same agent, open Preview and start a new conversation. No attachments are needed. Use the prompts below without naming the Skill, and check the reasoning trace to confirm that the Skill loads.

Keep replies for one test in the same conversation. Start a new conversation for Test 2 so the first test’s answers cannot carry over.

Test 1: Complete missing intake details

Copy this block into Copilot Studio > Preview chat, then select Send:

I want to request a new project: an agent to help our support team.

Wait for the agent to ask for a missing detail. Copy only the matching reply below into the same Preview chat and select Send. Do not send all three replies together.

If asked about the business goal:

Reduce repeat onboarding questions for our support team.

If asked about the desired outcome:

A searchable FAQ assistant covering common onboarding questions.

If asked about the target date:

Not yet known.

When the agent shows the summary, copy this confirmation into the same Preview chat and select Send:

Yes, that summary is accurate.

Check: it reuses the support-team audience, asks one missing question at a time, and reaches a four-field summary without guessing a date. Confirmation must not mean project approval.

Test 2: Correct a complete intake summary

Start a new Preview conversation. Copy this block into Copilot Studio > Preview chat, then select Send:

Help me scope a new project. Goal: reduce repeat support questions. Intended users: our support team. Desired outcome: a searchable FAQ assistant. Target date: not yet known.

It should summarize without repeating intake questions. Copy this correction into the same Preview chat and select Send:

Change the intended users to new support hires.

After it shows the revised summary, copy this confirmation into the same Preview chat and select Send:

Yes, that summary is accurate.

Check: only the audience changes; the goal, FAQ outcome, and unknown date remain. It should request confirmation without restarting or claiming approval.

After both tests, use the refinement steps below if needed. If a test failed, keep its prompt and output for troubleshooting.

Refine the intake Skill in Copilot Studio

If both tests pass, you are done. Record the result and continue to the conclusions. If a test fails, revise the Skill and test it again.

There is no automatic synchronization between the authoring chat and the uploaded Skill. Every revision needs a new ZIP and a manual replacement in Copilot Studio. Never share credentials or real customer data. A Harness Explorer report can provide extra context, but is optional.

  1. Create a separate blank agent with Instructions empty and a reasoning model. In its Preview, attach the intake process and latest Skill ZIP. Keep Project Process Assistant unchanged as your test agent.

  2. Fill in the placeholders below with what actually happened, then send the completed block in the blank agent’s Preview, not the intake test conversation:

    Revise the Skill, not the test input or expected result.
Test prompt: [paste]
Expected behavior: [paste]
Actual output or exact error: [paste]
Skill loaded in the reasoning trace: [yes/no/not visible]
Fix the procedure or activation description responsible for the mismatch.
Keep the existing guardrails and provide a new downloadable ZIP.

  3. Download the revised package. In Project Process Assistant > Build > Skills, open the uploaded Skill’s menu and select Replace, then upload the new ZIP. See Replace a skill you uploaded. Start new Preview conversations and rerun both intake tests to check for regressions.

  4. If both tests pass, record the result; do not invent a failure to force another loop. Extra revisions and an out-of-scope prompt to check that the Skill does not activate unnecessarily are optional follow-on work.

[!TIP] Keep the 25-minute extra-credit timebox: aim for one package, one upload, and two short tests. If generation or a repair runs longer, record the next change and continue later. An authoring self-check is not a substitute for testing the uploaded Skill.

Congratulations! You’ve completed the Skill-creation extra credit!

You created a project-intake Skill in Copilot Studio Preview, uploaded it, and checked it in two conversations. Record the results; no further exercises are required.

Extra Credit: Explore the agent harness

Extra Credit: install the Agent Harness Explorer Skill from the CAT Agent Skills gallery to discover what an agent’s runtime actually exposes: Python libraries, tools, Skills, and MCP servers. This is not a prerequisite for any use case.

  1. Open the gallery page and review its instructions, source, and safety boundaries. Under Add this skill, read the Add only what you trust notice. Acknowledge it only if you trust the package, then select Download bundle (.zip). Keep the downloaded ZIP if you will need it offline.

  2. In Copilot Studio, create a separate agent the same way as in Use Case #1. Name it Harness Explorer. Keep it separate from your RFP and project-process agents so diagnostic requests do not interfere with their tests. Copy the block below into Build > Instructions, not into chat:

    Help me understand the capabilities actually available in this agent's harness. Use the Harness Explorer Skill for runtime inspection. Distinguish observed capabilities from assumptions and unavailable observations. Never expose secrets or full environment-variable values.

  3. On Build > Skills > + > Upload a skill, upload the downloaded gallery ZIP, preserving its bundled instructions, references, and scripts. Confirm that agent-harness-explorer appears under Skills. Do not add Work IQ or other connectors just for this exercise; you do not need to publish the agent.

  4. Open Preview. Copy the block below into Preview chat, then select Send:

    Inspect the harness. Use the Skill's passive probes only. Report the observed Python runtime and installed libraries, and the tools, Skills, and MCP servers actually visible to this agent. Clearly distinguish observed, not visible, and unverified capabilities. Do not install packages, make network requests, run active-safe probes, or read unrelated files. Generate a downloadable HTML harness report.

  5. Inspect the run details for the agent-harness-explorer Skill load and its bundled probe execution. Open the report and check that it describes observations from this run, not just a generic list of platform features. A Python script cannot independently see every agent tool or MCP server: not visible does not mean unsupported. If inspection or report generation fails, capture the error; do not treat an unexecuted probe as a successful check.

  6. Copy this follow-up into the same Preview chat, then select Send:

    Based on this snapshot, which installed libraries could create a chart like our RFP evaluation-weight chart, and which could help read documents or create PDFs? For each recommendation, give the observed package name and version, its purpose, and any unverified capability. Do not install or assume missing packages.

  7. Optionally copy this block into the same Preview chat and select Send:

    Export the latest snapshot.

    Download the JSON and Markdown exports. You can provide the report to your chosen authoring chat as supporting context when refining a Skill. Treat it as a snapshot of this agent’s observed runtime, not a guarantee about another agent, tenant, future session, or tool permissions. Do not share reports containing sensitive information.

Extra Credit: Generate with AI (preview)

Copilot Studio also offers an in-product Skill authoring preview. Generate with AI might not be available yet in your environment. If you do not see the option, skip this extra credit or try the Preview-based Skill-creation exercise. This optional Skills menu is separate from the free-form Preview chat that generates a ZIP for you to upload.

Generate with AI (preview) showing the text description box and Build button

[!NOTE] The preview shown here does not accept file attachments. Paste text from your source documents into its description box rather than trying to upload them. This limitation concerns Skill generation, not the agent’s Preview chat where you test with documents.

To try it when available:

  1. Use a separate test agent and open Skills > Add skill > Generate with AI (preview).
  2. Use the project-intake authoring prompt from the Skill-creation extra credit, then copy the text from project-intake-process-v2.docx into the same box. Remove the instructions about attachments and downloadable ZIP packaging.
  3. Select Build, answer the agent builder’s questions, review the generated Skill, and select Add to agent.
  4. Run the same two tests in the agent’s Preview chat. Generating a Skill does not validate its behavior.

See Create a skill for an agent, including Generate with AI.

Updated: