GitHub Copilot Studio is not just a chatbot builder anymore. As demonstrated on Microsoft Mechanics in October 2026, it now assembles agents, workflows, and Dataverse-backed apps in one place, and the sample solution flags certification gaps and cold-chain failures before a human ever opens the bid.
GitHub Copilot Studio agents, workflows, and apps in one build
GitHub Copilot Studio is Microsoft's low-code environment for building AI agents, automated workflows, and generated apps in a single browser workspace. In the Microsoft Mechanics walkthrough published on 5 October 2026, senior product manager Jack Rowbotham builds a supplier bid review solution that starts with an inbound email and ends with a human approval recorded in a Dataverse table.
The video describes the whole stack as running on the GitHub Copilot harness, the agent runtime Microsoft also uses for its coding assistant. Treat that as a vendor description of the architecture rather than an independently measured performance claim; no benchmark for the harness itself appears in the demo.
The practical argument is consolidation. Agent authoring, workflow steps, evaluation runs, and app screens live in one product rather than four, which matters when the same prompt-generated skills have to stay consistent across a multi-agent process.
How the procurement workflow runs step by step
The procurement workflow triggers on an incoming supplier email, classifies it, retrieves the attached bid, and routes the document to an evaluation agent. Rowbotham demonstrates this in the Workflows tab GitHub Copilot Studio](https://copilotstudio.microsoft.com), where steps are dragged onto a canvas rather than scripted.
The recorded sequence is:
- Change the start trigger from Manual to Connector, select Outlook, and choose When a new email arrives.
- Add a Classify step that reads the subject and message body; the demo uses one category, RFP, and notes that multiple categories are supported.
- Add a Get Attachment step through a connector so the bid document travels with the run.
- Add an Agent step and select the Bid Evaluation Agent from a dropdown.
- Add a Human Review step behind an if/else decision, so flagged bids pause for a person while the rest continue.
- Route unresolved bids to a Researcher agent for extra context, then to a recommendation agent.
- Write the final result as a new row in Dataverse, which the front-end app reads.
Each step can be tested on its own, which is the practical answer to debugging a long chain. The Activity tab shows timing per step and the path a given email took, and clicking a step reveals what the agent did plus its structured output. In the recorded run, one bid did pause for human review before continuing to a stored recommendation.
What the bid evaluation agent actually checks
The bid evaluation agent reasons over tender requirements and returns a pass or fail verdict with a supporting summary. Rowbotham starts from a natural language description that names the assessment logic, the live data sources, and the required output shape, and GitHub Copilot Studio generates the agent name, instructions, and reusable skills from it.
The generated skills are the part worth noting. Requirement coverage and evidence verification are stored as reusable instructions so the same checks apply on every run, and those skills can be attached to other agents or shared with colleagues. You can also upload existing skills or generate new ones by describing them.
Tool connections in the demo include Work IQ for supplier submission emails and the Dataverse MCP for procurement and bid data. The tool picker accepts connectors and MCP servers from Microsoft and from other vendors, so an existing system does not need a bespoke integration before it can be called by the agent. Model choice is a dropdown; the demo keeps Claude, Anthropic reasoning model, for this task. A specialist Supplier Risk agent is added for extra expertise, and memory can be carried across sessions.
In the preview run, the agent walked each requirement, checked the evidence, and flagged three problems: insufficient certification for medicine manufacturing, missing cold-chain handling, and insurance below the minimum. It recommended human review and advised against shortlisting until the supplier addresses the gaps. That is one preview run, not a validated accuracy figure.
Agent evaluations: what 89% does and does not mean
GitHub Copilot Studio's Evaluations feature runs structured test suites against an agent so quality can be tracked over time instead of spot-checked. Rowbotham imports 18 test cases as a CSV of sample requests, names the evaluation, and starts the run.
The reported result: the 18 tests ran sequentially in just over 22 minutes and met the configured criteria 89% of the time, with per-test outcomes available on drill-down. That 89% is scoped to this agent, this test set, and the criteria the maker defined in that session. It is a vendor demonstration of the feature, not independent validation of the approach, and it says nothing about how the same agent would score on a different requirement set. Individual results should be opened rather than summarized from the headline number.
Two other details matter for planning. GitHub Copilot Studio can auto-generate ten tests from how the agent was built if you have no conversation history to import, and the runs are sequential, so a large suite costs wall-clock time proportional to its size. Budget for that before scheduling evaluations in a release process.
Generating the review app on Dataverse
The final piece is a generated app that gives the procurement team a shared view of every bid, its status, and its recommendation. Building it starts in the Apps tab, where a natural language description names the desired experience, the Dataverse table to read, and the screens to include. The transcript mentions SharePoint as an alternative data location through connectors.
Generation takes several minutes and produces a first iteration, after which follow-up prompts refine it; in the demo, a branding prompt applies company styling within a few moments. The reviewer-facing view includes summary tiles, a bid queue with supplier, status and recommendation columns, a filter for bids needing human review, and a detail page with Approve and save actions.
The approval in the demo writes back and completes the end-to-end run. Everything before the app is unattended automation; the app is where people see the exceptions and make the call.
Where the demo stops short
The walkthrough is a product demonstration on sample data, so several questions stay open. The 89% evaluation figure comes from criteria the maker set in that session, and no false-positive or false-negative breakdown is shown, which is exactly what a procurement team would need before trusting an automated pass or fail verdict.
The demo uses an individual Outlook account as the intake trigger. Rowbotham notes a dedicated RFP intake account is possible, but mailbox permissions, retention, and audit requirements are configuration work the video does not cover.
Three further limits are worth stating plainly. The transcript does not specify which GitHub Copilot Studio license or capacity is required for Evaluations, app generation, or agent runs at production volume. It does not describe tenant data residency for the Dataverse MCP connection or any cross-tenant access pattern. And it does not present independent testing, security review, or accuracy data for procurement use, so any compliance conclusion has to come from your own assessment rather than from this demo.
GitHub Copilot Studio versus hand-built pipeline
Choosing between GitHub Copilot Studio and a hand-assembled agent pipeline comes down to who maintains it and how fast the process changes. The table below compares the two approaches on the dimensions the demo actually exercises.
| Dimension | GitHub Copilot Studio approach | Hand-built pipeline |
|---|---|---|
| Authoring | Prompt and drag-and-drop canvas | Code, framework choice, CI |
| Reusable logic | Generated skills shared across agents | Libraries and internal packages |
| Orchestration | Workflow steps with human review built in | Custom state machine and queues |
| Front end | Natural language app generation | Separate web app team |
| Evaluation | Structured test runs in-product | Test harness you build |
| Data layer | Dataverse table as the record store | Database of choice |
Neither column is universally better. The vendor-managed path compresses setup time and keeps non-developers involved; the hand-built path gives finer control over model routing, data residency, and cost. The demo supports the first claim only for this specific bid process.
FAQ
- What GitHub Copilot Studio? GitHub Copilot Studio is Microsoft's browser-based environment for building AI agents, automated workflows, and generated apps on shared data. Microsoft positions it for IT admins, Power Platform makers, solution architects, and operations teams rather than full-time developers.
- Does GitHub Copilot Studio require code? The Microsoft Mechanics walkthrough builds an agent, a workflow, and a review app without writing code. Practitioners should still expect configuration work around connectors, data sources, permissions, and evaluation criteria.
- What does the 89% evaluation result mean? GitHub Copilot Studio's Evaluations feature reported that 18 sequential test cases met the maker's configured criteria 89% of the time, in just over 22 minutes. It is a vendor-run demonstration against one test set, not an independent accuracy measure.
- Can GitHub Copilot Studio call non-Microsoft systems? The demo adds tools through connectors and MCP servers, and the tool picker accepts servers from Microsoft and other vendors. The transcript shows Work IQ and a Dataverse MCP connection as the concrete examples.
- Where does human review fit? The workflow includes a Human Review step behind an if/else decision. Flagged bids pause for a person, and everything else continues to the next agent without waiting.
From a recorded walkthrough to a written guide
A ten-minute product walkthrough carries the kind of detail that is hard to find in documentation: the order of steps, the three failures the agent flagged, the 22 minutes those tests took. That context lives in the video, and it is the reason a written version is worth having.
If you have similar material sitting in a recording, Skalablog turns a YouTube video into a structured article. Paste the URL, let it transcribe, and get a draft you can edit and publish.
Fork this article
Start a new branch from the same video, shaped your way. You keep the credit; the original keeps the attribution.
A fork in another language is filed as a translation of this article, so the two pages point at each other. You can unlink it later from the editor.
0/240
You are creating
- Format
- For
- Language
- Source
- Your angle
You will be asked to sign in before it is generated.
Buy credits