A cloud-based system diagram shows user credentials flowing through a central platform to containerized services and a workflow timeline.
Microsoft has released Copilot SDK 2.0. Microsoft announced the new Microsoft Copilot SDK at Ignite, and it was previously named the GitHub Copilot SDK. The 2.0 release changes how developers host agents. It moves away from one container per session and toward a shared runtime that serves many sessions. For anyone building agents on Azure, Foundry, GitHub or in-house infrastructure, the details matter. Several of the safety claims also depend on code you write yourself.

A cloud-based system diagram shows user credentials flowing through a central platform to containerized services and a workflow timeline. What the SDK is​

Microsoft says the SDK gives programmatic access to the Copilot harness behind products across its portfolio, covering coding, non-coding and creative apps. It is pitched as a way to build agents that run anywhere and can use any inference.

The name change was flagged earlier. Coverage from ecorpit.com says GitHub announced on 28 October that GitHub Copilot SDK was becoming Microsoft Copilot SDK, with no immediate changes required of existing users.

The packages are already out. The Python package microsoft-copilot-sdk 2.0.0 was published on PyPI on November 17, 2026. The GitHub v2.0.0 release notes list a rename of the public SDK identity branding to "Microsoft Copilot SDK". Microsoft's post says the SDK is available in TypeScript, Python, Go, .NET, Java and Rust.

The problem 2.0 targets​

Before 2.0, the container was the only option. Microsoft's post says the container's trade-offs then affected every implementation:

  • Every session used a container whether it needed one or not.
  • The first turn had to wait on infrastructure.
  • Cost scaled quickly with the number of sessions.
  • A session's identity was the same as the identity of the process running it.

Containers are not going away. Microsoft says most of its own teams still give each session its own sandbox. A hard boundary stays essential when an agent compiles code, runs untrusted scripts or needs a custom image.

What changed in 2.0​

A shared, multi-tenant runtime​

The new SDK removes the assumption that the runtime owns the machine it runs on. One process can now host many sessions. Each session has its own state, credentials, tools, files and history. Creating a session no longer needs a container, a process or a VM.

Microsoft also rebuilt the runtime core in Rust. It reports these figures for "the same warmed workload":

MetricBefore (TypeScript CLI)After (Rust core, in-process)
Create client and session, complete one turn5.25 seconds55.3 milliseconds
Memory for 10 clients1,383 MB126 MB
Throughput7.55 sessions/sec120 sessions/sec

These are Microsoft's own numbers. The post gives no hardware, no workload definition beyond "warmed" and no independent validation. Treat them as a sign of direction, not a promise for your workload. Real agent turns are usually dominated by model inference latency, not runtime startup.

Identity per session​

Before 2.0, the runtime acted under the identity that instantiated it. Now each session can run as the user who requested it. You pass that user's credential when you create the session. Model calls and tool calls are then attributed to the user, not to your server. For production, a gitHubTokenProvider callback can supply short-lived, rotating tokens, so you avoid storing long-lived credentials.

"Empty" mode and host-owned tools​

A shared runtime is only safe if sessions cannot reach the host. In mode: "empty", a session starts with no host shell, no host file system and no default tools. You register the tools a session may use, and they run in your process. You can also set an explicit per-session allow-list, such as custom:lookup_order in Microsoft's order-lookup example.

GitHub's multi-tenancy documentation adds some caveats:

  • The application still owns request routing and authorization.
  • Use unique session IDs.
  • Check ownership before any resume or delete.
  • Pass the user's token per session.
  • Avoid broad tool patterns such as builtin:* without review.
  • Set idle timeouts so abandoned sessions get cleaned up.

The docs also warn that the default CLI-style mode can expose host filesystem capabilities through ambient tools. Do not use it for shared servers. The captured versions of that documentation disagree on the name of that mode: GitHub's docs page calls it copilot-cli, while the repository text calls it coding-agent. Check the docs for your installed SDK version before relying on either name.

Durable, resumable sessions​

Two abstractions make sessions outlive processes:

  • Session journal. The runtime appends messages, tool calls and results, plans and checkpoints to an event log. Any runtime that can read the log can resume the session. That could be after a restart, on another service instance or on a different machine.
  • sessionFs. Your application supplies the file system that backs session state. That could be object storage, a database or tenant-scoped paths. Local disk becomes disposable.

This enables some useful patterns. A web client can disconnect while a long task keeps running. A webhook can resume a conversation hours later. A teammate can attach GitHub Copilot CLI to inspect a session. Idle sandboxes can stop and resume with disks intact.

Microsoft separates resuming a session from sharing one live session across clients. For live sharing, the SDK can run behind an Agent Host Protocol (AHP) host. Microsoft calls AHP a separate open protocol and says VS Code's agent host works this way.

There are important limits in GitHub's documentation:

  • Concurrent access. The SDK provides no built-in session locking, and concurrent access to one session is undefined. Add your own locking or queueing.
  • Tool state. In-memory tool state is not persisted. Make tools stateless, or have them persist their own state.
  • Credentials. Provider and API keys for bring-your-own-key setups are not persisted. You must supply them again on resume.
  • Approvals. With sessionFs, the runtime does not partition remembered approval grants by session ID. Sessions that share a provider namespace share grants. Use separate namespaces where tenants or sessions must stay isolated, and reconnect resumed sessions to their original namespace.

In-process embedding​

Microsoft says it exposed a C ABI that works from any language and made in-process the default. Your agent code should not change whether the runtime runs in your process, as a child process or as a shared service. The PyPI listing for the Python package mentions stdio, TCP and in-process (FFI) transports.

Six architectures​

Microsoft frames the design as two separate decisions: where the agent thinks (the model loop) and where it acts (shell and file work).

  1. Many sessions in a shared runtime. There is no sandbox. Tools are your app's APIs, MCP servers or web calls, running under each user's identity. It is cheap, but isolation is enforced by the application. Microsoft says it is largely unhelpful for coding or complex knowledge work on its own.
  2. Start shared, promote when needed. Sessions begin on the shared runtime and move into their own sandbox when they need a shell or files. The session ID, conversation and tools carry over. The move is one-way and costs a single wait while the sandbox starts.
  3. Shared loop, sandboxed execution. The model loop stays shared. The bash, view and edit tools are replaced with host implementations that run in a sandbox. Side effects stay isolated, but each state-changing command needs approval, and sandbox output flows back into the model's context. It suits code interpreters and custom harnesses.
  4. Coordinator and workers. A shared coordinator starts independent worker agents, each in its own sandbox. You get real parallelism. You also pay for an agent and a container per worker, tasks must be self-contained and workers do not share a disk.
  5. Mixed. The coordinator runs quick commands in its own sandbox and delegates long or parallel work to workers. It is the most flexible and the most complex to operate, with approvals at both levels.
  6. Container per session. This is still the right choice when sessions need a shell and files from turn one, or when a hard boundary is required.

The decision rule is short. Ask whether every session needs a shell and files from the first turn. If yes, use an isolated container. If no, run the model loop on a shared runtime and then decide what, if anything, needs a sandbox.

Where to run it​

The SDK does not choose an architecture for you. Microsoft says you currently build and run these architectures on your own infrastructure. Two managed options exist today. GitHub Copilot cloud sandboxes run each session in an isolated Linux environment hosted by GitHub. Microsoft Foundry managed agents have Microsoft run the agent loop and the sandbox. Microsoft says more hosting options are "coming soon" but gives no dates.

What IT and dev teams should take from this​

  • Shared does not mean safe by default. "No session can see another" describes the runtime model. A buggy tool handler that ignores the user ID, or a sloppy ownership check on resume, can still leak data. Microsoft's own example scopes the order lookup to the signed-in user, and that pattern is the one to copy.
  • Credential choice matters. The examples use GitHub tokens. If you serve many users, per-session tokens preserve content exclusion, quota and model routing behavior at the user level. A shared service token does not.
  • Plan for storage as a security boundary. sessionFs namespaces hold transcripts and approval metadata. Protect them with the same tenant isolation as any other sensitive store.
  • Confirm the version. The Python package shows a 2.0.0rc0 pre-release on November 15, then 2.0.0 on November 17. The GitHub release notes for v2.0.0 mostly list fixes and documentation changes. They include warnings for Marketplace plugins and redaction of credentials from engine message telemetry. Review them before migrating.
  • Governance is the open question. The ecorpit.com preview points to an Ignite session on securing SDK agents with Entra, Purview and Defender controls. That session had not yet taken place, and Microsoft's announcement does not describe those integrations. Do not assume them yet.

Bottom line​

The headline idea is that agent sessions become cheap, durable and portable. A session is no longer chained to a container. For multi-user SaaS and internal platforms, that could cut both cost and first-response delay. The trade is that more security responsibility moves into your own code: tool design, token handling, ownership checks and storage isolation. Containers remain the answer when agents run untrusted code. For everything lighter, 2.0 gives teams a way to stop paying for a sandbox they do not need.

 

References

  1. .md # Written when the conversation is compacted │ └── ... ├── plan.md # Agent's planning state (if any) └── files/ # Session artifacts ├── analysis.md # Files the agent created └── notes.txt # Working documents ``` | Data | Persisted? | Notes | |------|------------|-------| | Conversation history | ✅ Yes | Full message thread | | Tool call results | ✅ Yes | Cached for context | | Agent planning state | ✅ Yes | `plan.md` file | | Session artifacts | ✅ Yes | In `files/` directory | | Provider/API github.com
  2. Multi-tenancy and server deployments - GitHub Docs docs.github.com
  3. Introducing the Microsoft Copilot SDK 2.0 - Microsoft Microsoft 2026-11-17T18:29:15+00:00