# Microsoft Copilot SDK 2.0: Rust Runtime and What Changes

> Source: <https://byteiota.com/microsoft-copilot-sdk-2-rust-runtime-faster-sessions/>
> Published: 2026-11-19 16:09:08+00:00

**Key takeaway:** Copilot SDK 2.0's Rust core cuts session-start overhead from 5.25 seconds to 55.3 milliseconds (not model inference), and `mode: "empty"` starts each session with zero tools so multi-tenant apps must explicitly opt in per session.

Microsoft shipped Copilot SDK 2.0 at Ignite last week, alongside a name change, a full runtime rewrite in Rust, and a session model that finally makes multi-tenant agent apps practical to build and ship. If you are still on the GitHub Copilot SDK 1.x, you are on a maintenance branch with a deadline: VS Code deprecated the old local agent harness in its November update, and **February 2027** is the migration cutoff.

## The Rust Runtime — What 95x Actually Means

Microsoft is leading with a “95x faster” headline, and the number is real — but it needs context before you repeat it in a planning meeting.

The 1.x SDK ran each session in its own container or process. Spinning that up was expensive: creating a client, starting a session, and completing one turn took 5.25 seconds in the TypeScript CLI. The 2.0 Rust core does the same workload in 55.3 milliseconds — that is where the 95x ratio comes from.

What this does not measure: model inference. Your GPT-6.2 or Claude Fable calls are not getting 95x faster. The improvement is in the agent scaffolding overhead — the tax you pay every time a session starts. For a single developer building a personal assistant, that is barely noticeable. For a SaaS platform spinning up thousands of short-lived agent sessions per hour, it is a compounding cost and latency win that actually shows up in bills and p99 numbers.

## Mode “empty” Makes Multi-Tenant Agent Apps Safe to Ship

The more important change — especially if you are building a product that runs agent sessions on behalf of multiple users — is the new session isolation model.

In 1.x, sessions inherited the ambient capabilities of the host: its shell, its filesystem, its default tools. For single-user tools, that is fine. For multi-tenant apps, it is a liability. One user’s session could see tools registered by another, and you were responsible for patching that gap yourself.

SDK 2.0 introduces `mode: "empty"`. It starts every session with zero capabilities — no shell, no filesystem, no tools — and requires you to explicitly opt in:

``` js
import { CopilotClient } from "@microsoft/copilot-sdk";

const client = new CopilotClient({ mode: "empty" });
const session = await client.createSession({
  availableTools: ["custom:lookup_order"]
});
```

Each session gets exactly the tools it is supposed to have. Cross-tenant contamination is now a configuration failure, not an architecture hazard waiting to happen.

## Durable Sessions: Agents Survive Process Restarts

Sessions in 2.0 are first-class durable objects. They outlive any process or client connected to them. When you restart your server or deploy an update, existing agent sessions do not evaporate — you reconnect with `resume_session()`, and the agent picks up with its model config, tool registrations, and conversation history intact.

In 1.x, session durability was something you built yourself: serialize state, store it, reload it on reconnect. 2.0 handles that at the runtime layer — a real quality-of-life improvement for anyone shipping agent features in a production web app.

## Agent Controls: Microsoft’s Answer to Agent Governance

Shipping alongside 2.0 is [Agent Controls](https://commandline.microsoft.com/introducing-agent-controls-an-enterprise-control-plane-for-agent-behavior/), a managed Azure service built on the open Agent Control Specification (ACS). It evaluates policies at four points in every agent turn: before the agent reads input, before it calls a tool, after a tool returns, and before the final response goes out. The ACS SDK integrates with LangChain, the OpenAI Agents SDK, the Anthropic SDK, AutoGen, Semantic Kernel, and MCP tools — not locked to the Microsoft stack.

The honest note: Agent Controls is a managed Azure service. Your policy layer gains a vendor dependency. For teams already running on Azure who need enterprise-grade agent governance, that trade-off probably makes sense. For everyone else, watch how the open ACS specification matures before committing.

## Migration: Package Names, Breaking Changes, Deadline

The rename is straightforward — update your package references:

- Node.js: `npm install @microsoft/copilot-sdk`
- Python: `pip install microsoft-copilot-sdk`
- Go: `go get github.com/microsoft/copilot-sdk/go/v2`
- .NET: `dotnet add package Microsoft.Copilot.SDK`

The breaking changes are real: client and session options have been regrouped, RPC signatures changed, and the SDK now requires protocol version 4. The [v2.0.0 release notes](https://github.com/microsoft/copilot-sdk/releases/tag/v2.0.0) have the full list. The 1.x line still gets bug patches — its PyPI page now links directly to the v2 breaking-changes guide — but no new features are coming to it.

The deadline to care about: [VS Code 1.146](https://windowsforum.com/news/vs-code-1-146-deprecates-local-agent-harness-copilot-migration-due-february-2027.451860/) deprecated the local agent harness in November. Migration to the new harness — which requires Copilot SDK 2.0 — is due by February 2027. If you use VS Code’s agent features in your workflow, that is a hard deadline, not a suggestion.

The [official announcement](https://commandline.microsoft.com/microsoft-copilot-sdk-2-0-github/) includes a full getting-started guide. If you are building multi-tenant, multi-user agent apps and have not yet looked at `mode: "empty"`, that is the first thing worth reading.
