Microsoft opens Copilot harness to developers via Foundry

Opening the Copilot infrastructure

Microsoft announced on October 28, 2026, that it is making the Copilot harness available to developers and enterprise customers through Microsoft Foundry. This harness serves as the multi-model orchestration layer that currently powers major products like GitHub Copilot, Copilot Studio, and the Copilot CLI. By opening this framework, Microsoft is allowing external users to access the same underlying technology used for its own flagship AI tools.

A harness is defined by Microsoft as the infrastructure surrounding an AI model. It provides the necessary instructions, context, execution environment, and controls required for an agent to complete a specific task. The system supports open standards, including the Model Context Protocol, as well as various agent skills and plugins. This means developers can focus on what the agent should do rather than how to manage the underlying technical plumbing.

The engineering team at GitHub originally built the Copilot harness, and Microsoft has since adopted it across the entire company. It is designed to perform across various model families, supporting more than 20 frontier models. Customers can choose which models to use, including the ability to bring their own API keys, while the harness handles the routing of work to the most appropriate model for the job.

How the Foundry Agent Service works

The harness is being introduced in the Foundry Agent Service in a public preview. This service combines four primary building blocks to help developers create functional agents. These include reusable skills, which package instructions and scripts into procedures, and connected tools that span supported Foundry and Model Context Protocol tools. These tools come with explicitly configured authentication and approvals to ensure secure interactions.

Execution and delegation are also core components of the harness. These features allow agents to work with files and code while handing off bounded tasks to built-in subagents. The main agent then coordinates the results from these subagents to complete the overall objective. Developers can manage these source-controlled agent definitions alongside their standard application code, making it easier to maintain complex systems.

The harness manages the working context as tasks develop and coordinates the steps between models and tools within specific policy boundaries. Customers can choose a supported Foundry model without having to rewrite the orchestration logic for each new model. This modularity allows for easier swapping of models as new ones become available or as requirements change. Developers can author these agents through several surfaces, including the Azure Developer CLI, the Foundry portal, and the GitHub Copilot app.

Performance and engineering roots

The Copilot harness is built on a foundation of high-performance engineering originally developed by GitHub. To achieve industry-leading performance, the team ported the Copilot agent runtime from TypeScript to Rust. This transition involved reaching over 832,378 lines of production Rust code by August 2026. The move to Rust was intended to reduce session overhead and improve the time it takes for a model to begin generating a response.

Benchmarks conducted by Microsoft engineers show significant improvements following the Rust port. In one test using the C# SDK, the time to create a client, session, and complete one turn dropped from 5.25 seconds to just 292 milliseconds. Additionally, the peak added memory for a batch of ten clients fell from 1,383 MB to 126 MB. These efficiencies are critical for maintaining low latency and high throughput in production environments where multiple users interact with agents simultaneously.

The harness also incorporates research from GitHub's Project HydraFusion. This research preview demonstrated how to build execution plans across multiple models using different patterns, such as single, cascade, and critique. In offline evaluations, these patterns showed improvements in verified task quality and significant cost reductions compared to some high-end models. These engineering choices ensure that the harness is not just a wrapper, but a highly optimized engine for complex AI reasoning.

Business impact and availability

For businesses, the availability of the harness means a faster path to deployment. Confluence Technologies CTO Chris Evans noted that his team had a solution running in less than a week, which allowed them to focus on design rather than infrastructure. Similarly, Fashable CEO Orlando Ribas Fernandes stated that the harness provides a foundation for turning complex sourcing processes into governed, measurable workflows. These examples highlight how the tool helps companies keep commercially binding decisions under human control while automating the heavy lifting.

Microsoft is offering three distinct approaches within the Foundry Agent Service to accommodate different needs. Users can prompt agents without the harness if the task is simple enough for basic instructions and tools. For more complex tasks involving skills, files, and subagents, users can opt for the Copilot harness. Finally, for teams that need their own specific framework or middleware, Microsoft offers hosted agents that retain Foundry-managed hosting.

The public preview currently allows customers to select the Copilot harness when creating a new agent, though existing agents cannot be switched to it yet. Foundry manages the execution environment's CPU, memory, and idle settings during this period. Billing for the Copilot harness in the Foundry Agent Service is scheduled to begin on December 1, 2026, on a consumption basis. Before that date, the harness runtime usage is free, though model inference and other connected services will still incur their standard charges.

Resilience for long-running tasks

One of the major additions to the Foundry Agent Service is long-running resilience for hosted agents. This feature is specifically designed for tasks that might take several hours or even days to complete. The system is built to detect interruptions and automatically restart the work using the original input. This ensures that long-running processes do not fail entirely if a connection is lost or a timeout occurs.

To make this work, the customer's code must be designed to save progress and intermediate results. This allows the agent to resume exactly where it left off rather than starting from the beginning. Microsoft notes that simply keeping a conversation history is not enough to restore work in progress; the state must be explicitly saved. This is particularly important for workflows where an agent is updating another system, as the code must prevent duplicate actions upon restart.

By providing these tools, Microsoft is moving toward a more robust production environment for AI agents. Developers can build complex, multi-step workflows with the confidence that the system can handle interruptions. This level of reliability is a key requirement for enterprise applications where data integrity and completion are paramount. As the service moves toward general availability, these resilience features will become standard for teams handling high-stakes automated tasks.