GitHub Copilot Harness in Copilot Studio: What's New Now That It's Generally Available

Microsoft has just taken one of its most significant Copilot Studio updates of the year to General Availability: the GitHub Copilot harness. For organisations building AI agents to run real business processes, not just answer questions, this is a meaningful shift in what's possible.

Since it entered preview, this capability has quietly changed what "an agent" can mean inside Copilot Studio. Now that it's generally available, it's worth stepping back to explain what a harness actually is, what's new, and why it matters if your organisation is building (or planning to build) agents on the Microsoft stack.

What is a "harness," and why does it matter?

In Copilot Studio, a harness is the runtime that sits between how you design an agent and the AI model that powers its reasoning. It's the layer that decides when to call the model, what context and tools to hand it, and how to act on what comes back.

Put simply: your design tells an agent what to do. The harness — together with the model — determines how it actually gets it done. Choosing the right harness is one of the most consequential decisions you'll make when building an agent, because it shapes how the agent behaves under real-world complexity, not just in a demo.

Three harnesses, three purposes

Copilot Studio now offers three harnesses, each suited to a different kind of work:

• Standard harness — best for rule-based agents and structured, repeatable conversations, where the paths through a scenario are well understood.
• Copilot Chat harness — designed for extending Microsoft 365 Copilot Chat with your organisation's own knowledge and data.
• GitHub Copilot harness — built for reasoning-heavy, multi-step business processes that involve ambiguity, multiple systems, and genuine decision-making.

It's this third harness that just reached General Availability, and it's the one changing the conversation around what agentic AI can realistically do inside an enterprise.

Introducing: the GitHub Copilot harness, now GA

According to Microsoft's Announcement, after a period in preview, the GitHub Copilot harness is now production-ready. It brings the same coding and reasoning foundation behind Copilot Cowork and the GitHub Copilot coding agent directly into Copilot Studio.

Practically, that means agents can now be built to take on work that was previously out of reach for low-code tooling: processes with many steps, multiple data sources, and decision points that don't reduce neatly to a flowchart.

What's new under the hood

A few capabilities stand out as the core of this harness:

• Plan & reason — the agent breaks a goal down into steps and adapts as circumstances change, rather than following a fixed script.
• An agentic loop — a continuous plan → act → observe cycle, letting the agent course-correct mid-task.
• Skills & memory — reusable behaviours, with relevant context carried across a task rather than reset at every turn.
• MCP & connected agents — native support for the Model Context Protocol, so agents can call tools, connectors, and other agents.
• Native file creation — agents can generate and edit Word, Excel, PowerPoint, and PDF files as part of their output.
• A secure, governed sandbox — every task runs in an isolated environment that Copilot Studio manages.

Taken together, this is less "chatbot with extra steps" and more a genuine agentic worker that can be trusted with a defined slice of a business process.

Built on frontier reasoning models

GitHub Copilot harness is powered by the latest frontier reasoning models, purpose-built for long-horizon, ambiguous work rather than short, single-turn exchanges. This is what allows it to handle processes spanning multiple steps and sources without needing every branch pre-scripted by a maker.

A redesigned experience for makers

The update isn't only under the hood — Microsoft has also reworked the agent-building experience around a single, more intuitive lifecycle:

1. Build — configure identity, knowledge, tools, skills, and model.
2. Preview — test the agent interactively, in real time.
3. Evaluate — run test sets to measure response quality before go-live.
4. Monitor — track tasks, files touched, and activity once the agent is in production.

Workflows get a matching upgrade, with a redesigned visual canvas, native AI actions, agent hand-offs, and node-level testing — all aimed at giving makers more confidence before an agent goes anywhere near production data.

Choosing the right harness for your scenario

Not every agent needs this level of reasoning power, and that's by design. As a general rule:

• If the process is well-defined and rule-based, the Standard harness remains the simpler, more predictable choice.
• If you're grounding Microsoft 365 Copilot Chat in enterprise knowledge, that's the Copilot Chat harness.
• If the process spans multiple systems, involves genuine judgement calls, or needs to produce documents and files as part of its output, the GitHub Copilot harness is purpose-built for it.

It's also worth noting for planning purposes: the GitHub Copilot harness is billed through Copilot Credits on a usage basis, rather than through existing Copilot Studio licensing — a factor to build into any business case.

Where Superware comes in

As a Microsoft partner working across Power Platform and Dynamics 365, we're already thinking about what updates like this mean for the organisations we work with — particularly in financial services and public sector, where processes are complex, data is sensitive, and governance isn't optional.

Capability like this is exciting, but it also raises the bar on how agents get designed, tested, and monitored before they touch real business processes. That's where our agile approach matters: rolling out agentic capability in a way that's tested, governed, and genuinely fit for how your teams work — not just technically impressive in a demo.

Final thoughts

The GitHub Copilot harness reaching General Availability is a real step-change for what's achievable natively in Copilot Studio. Reasoning-heavy, multi-step, multi-system processes that once required bespoke development are now squarely within reach of a low-code platform.

If you're exploring what this could mean for your organisation, get in touch — we'd be glad to talk through where agentic AI fits into your roadmap.