Standard or GitHub Copilot Harness? A Decision Guide

Copilot Studio now runs agents on three harnesses. What each is for, the real trade-offs in cost and control, and how to decide, and migrate, without a rewrite for its own sake.

By Ajith Joseph · Thu Oct 01 2026 · Updated Thu Oct 01 2026 · 11 min read · intermediate

#architecture #copilot-studio #github-copilot #ai-agents

For most of Copilot Studio's life there was one way to build an agent. In 2026 there are three, and the choice is made quietly, in a dropdown, before anyone has written an instruction.

Microsoft's term for the choice is the harness: the runtime between the model and your agent's configuration that decides when to call the model, what context to send it, how to read the result and which tool to call next. The model supplies the reasoning, the harness equips and directs it. The harness you pick changes what the agent can do, how it behaves under pressure, and how you are billed.

This guide is based on Microsoft's own harness documentation, which was updated on 30 September 2026, so it reflects the position as of 1 October. It is a decision aid, not a recommendation to move: Microsoft's own guidance says a working standard-harness agent "doesn't need to move simply because another harness is available."

The Three Harnesses

The standard harness is for rule-based agents and structured, repeatable conversations. You define the topics, prompts and paths, so behaviour is predictable. Context is spread across topics, variables, tools and subagents, and you manage the handoffs. It has the established channels and features, and standard-harness agents keep the pre-existing Copilot Studio licensing model.

The GitHub Copilot harness is for reasoning-heavy agents and workflows that complete long, multi-step business processes. It takes a goal, breaks it into steps, calls tools across connectors, knowledge, MCP and connected agents, and adjusts when a step fails. Microsoft lists what it adds: longer-running tasks, larger files and datasets, agentic loops with several AI tasks in parallel, iterative reasoning, persistent memory, and ongoing subagent conversations with shared context. It can create and edit Word, Excel, PowerPoint and PDF files, supports skills, and runs each task in a secure sandbox with a Bash container. Microsoft's comparison page says reasoning models and some emerging agentic capabilities are available only through this harness. The standard-harness model page still lists models tagged Deep, so check the model you actually need rather than relying on either page alone. Microsoft's 2 September 2026 blog describes the harness as generally available.

The Copilot chat harness extends Microsoft 365 Copilot Chat with your organisation's knowledge, for internal teams. Billing is consumption-based or included in a Microsoft 365 Copilot licence. It is a narrower choice than the other two and mostly a question of whether your goal is to connect people to information.

A point worth knowing for privacy reviews: Microsoft states that the GitHub Copilot harness "is a Microsoft Copilot Studio authoring and orchestration framework, not the GitHub Copilot service." It shares underlying technology and SDK components, but customer data is not sent to or processed by the GitHub Copilot service when agents run in Copilot Studio, and existing Copilot Studio privacy, security, compliance and data residency commitments continue to apply.

The Trade-offs Microsoft Describes

The guidance is candid that neither harness is universally better:

Concern Standard harness GitHub Copilot harness
Best fit Short, bounded tasks, structured conversations, rule-based processes Long-running, multi-step processes across tools, systems and outputs
When the task is simple A proportionate runtime "May introduce unnecessary reasoning, latency, and Copilot Credit consumption without materially improving the result"
When the task is complex You write more routing, handoff and exception logic as it grows Plans, selects tools, uses memory and recovers from exceptions, so less guidance from the maker
Control Tighter, but unexpected conditions need more authored logic Adapts to changing results, but "its execution path can be less predictable for agent-only solutions"
Latency and cost Suited to high-traffic, responsive scenarios Longer latency and higher consumption can be justified where reasoning, large files and orchestration add measurable value
Maturity Established features and channels, but some newer models and capabilities are missing Latest agentic capabilities and reasoning models, but "customers should validate required features and channels as the experience matures"

Both can publish to internal teams or external customers, and both can mix predictable and adaptive behaviour: topics in the standard harness, workflows in the GitHub Copilot harness.

Billing Is Part of the Architecture

The billing model differs in a way that affects design, not just budgeting:

  • Standard harness: billing starts after you publish, using the credit rates for answers, actions, flows and tools
  • GitHub Copilot harness: usage-based billing "starts when you start building". Creating a solution in natural language, previewing and testing an agent, and generating and creating evaluations all consume credits, as do tokens, tools including knowledge and MCP, and the harness itself

That has a practical consequence. A prototype on the GitHub Copilot harness costs money in the maker's environment before it has a user. Microsoft's governance guidance says to govern the environment, not just the published agent, and notes that developer and trial environments moved to usage-based billing on 1 September 2026. Usage by these agents is also not included with a user's Microsoft 365 Copilot licence. The companion post on credits covers the controls in detail.

A Decision Process

Microsoft's guidance starts from the scenario, not the technology. Turn that into questions you can answer in a meeting.

1. How heavy is the work?

Lighter tasks have a bounded set of data, a stable set of actions and one main outcome. Heavier work runs longer, spans systems, needs analysis across large files and produces several outputs. The more your process looks like the second description, the stronger the case for the GitHub Copilot harness.

2. Can you write down the path in advance?

If the correct sequence of actions is known, the standard harness gives you control and consistency. If it depends on intermediate results, so the agent has to evaluate its progress and decide whether to continue, change approach, delegate or stop, that is the case for an agentic loop. Microsoft is specific that the distinction "isn't simply whether repetition is possible, but where adaptation is managed, how much data can be processed, and which tools are available."

3. Does the product requirement include a fixed conversation?

An HR intake bot that must always collect the same fields and hand off by a predefined rule should not improvise a resolution. Microsoft's own example of a standard-harness fit is exactly that. If the ordered conversation is the product, keep it deterministic.

4. Does the agent depend on something that is not available yet?

An existing production agent that relies on a particular channel, rich UI, topic structure or system variable may use a capability that "isn't yet available or fully mature" on the newer harness. The guidance's advice is to preserve the working implementation until the capability and a migration path exist. Check the current documentation for the specific channel or feature you rely on, because I am not claiming any particular gap.

5. Are you buying capability or just novelty?

A sensible test is whether you can name the improvement: better quality, more efficient orchestration, long-running execution, access to a specific reasoning model, or a new capability you need. If you cannot, the guidance points the other way.

Where Each One Wins

Microsoft's scenarios make the split concrete. Use them as pattern-matching, not as rules.

Standard harness

  • An HR intake and routing bot with required fields and deterministic handoff
  • An internal help desk answering common questions and routing simple requests
  • A production agent that depends on established channels or features
  • A predictable agent that answers from known knowledge and calls a small, stable set of actions

GitHub Copilot harness

  • Customer meeting preparation across emails, notes, CRM updates and incidents, producing a briefing document and a presentation
  • A deep compliance or operational audit that aggregates years of records and writes a full report
  • Accounts payable reconciliation: read the invoice, find the purchase order, verify the match, record results in a spreadsheet, and adapt when records disagree, with skills encoding the procedure and a deterministic workflow handling the predictable approval and notification steps

Both together. The guidance describes high-volume standard-harness agents serving users while a GitHub Copilot harness agent runs on a schedule to clean up the data behind them: turning big workbooks into structured Dataverse tables, reorganising SharePoint content and adding metadata. The conversational layer stays fast and controlled, and the heavy curation work happens off the critical path. If retrieval quality is what limits an otherwise good standard-harness agent, this is worth considering before a migration.

If You Do Migrate

Microsoft's advice is to treat migration as re-architecture, not component conversion. The migration is complete "when the rebuilt agent performs its core journeys successfully, not when every old component is mechanically reproduced." A practical order:

  1. Write down what the agent must do. Tasks, outcomes, boundaries, risks and the evaluation criteria.
  2. Inventory what exists and why. For each topic, flow, variable and prompt, record its purpose, not its implementation.
  3. Map purposes to the new model. Microsoft's list of targets is instructions, skills, tools, workflows, memory, code execution and connected agents. The table below is my illustration of how that could look, not an official conversion table.
Standard harness component Typical home on the GitHub Copilot harness
A topic that collects fields and routes Instructions, or a workflow if the steps must stay deterministic
A topic encoding a company procedure A skill, which can be reused across agents
Variables carrying context between topics The agent's working context and, where useful, memory
An agent flow with fixed steps A workflow used as a tool
A child agent or specialist A connected agent
Calculations done in a prompt Code execution in the sandbox or a tool
  1. Reuse the same test set before and after. If you built a regression set for the standard agent, run it against the rebuilt one. The migration question then has a measured answer, and the earlier posts on evaluations and the evaluation API cover how.
  2. Compare the cost of the run, not just the quality. Measure credits per completed outcome on both. If the new agent is no better and noticeably more expensive, you have your answer.
  3. Keep the old agent until the new one has earned its place.

Find Out What You Already Have

You cannot make a harness decision for an estate you cannot see. The Power Platform inventory exposes a properties.harness field for Copilot Studio agents. Filtering on the value GitHub Copilot identifies the agents on that harness, and Microsoft provides a sample inventory query that counts agents by harness. Start there, then ask for each GitHub Copilot harness agent which environment it lives in, who owns it and who pays.

A Decision Record Worth Keeping

Whatever you decide, write it down in a form someone can challenge later:

Agent:            order-desk-assistant
Decision:         stay on the standard harness
Date:             2026-10-01
Why:              fixed collection order is a product requirement; high-traffic, latency-sensitive;
                  depends on <channel> which we have not validated on the newer harness
Revisit when:     we need to process attachments over <size>, or a reasoning model is required
Cost evidence:    <credits per resolved conversation, measured over 30 days>
Owner:            <name>

The most useful field is "revisit when," because it turns a decision into a trigger and stops the agent being re-litigated every time a new capability is announced.

The Short Version

  • The harness is a design decision that affects capability, behaviour and billing, so make it deliberately
  • Choose the standard harness for bounded, rule-based, high-traffic work where consistency and proven channels matter
  • Choose the GitHub Copilot harness for long-running, multi-source, reasoning-heavy work that produces documents or must recover from surprises
  • Do not migrate a working agent without naming the improvement
  • If you migrate, rebuild around outcomes, reuse your evaluation set, and measure credits per outcome
  • Govern the environments from day one, because building costs credits on the newer harness

Sources

  • Harnesses in Copilot Studio, Microsoft Learn, updated 30 September 2026
  • Compare Copilot Studio agent harnesses, Microsoft Learn, updated 30 September 2026
  • Overview of usage-based billing (GitHub Copilot harness), Microsoft Learn, updated 28 September 2026
  • Govern Copilot Credit consumption for GitHub Copilot harness agents, Microsoft Learn, updated 18 September 2026
  • What's new in Copilot Studio: GitHub Copilot harness, Microsoft Copilot Blog, 2 September 2026
  1. AJ's Tech Notes
  2. Standard or GitHub Copilot Harness? A Decision Guide