GitHub announced on June 2, 2026, during Microsoft Build, that the GitHub Copilot SDK is generally available. The SDK lets developers embed the same agent runtime that powers the Copilot CLI into their own applications, services and developer tools, and it ships for .NET as the GitHub.Copilot.SDK NuGet package alongside TypeScript, Python, Go and other languages. For .NET teams, GA means a supported, semantically versioned way to build Copilot-powered automation without writing their own agent orchestration.

Key Facts#

  • GA date: June 2, 2026. Version 1.0.0 of GitHub.Copilot.SDK was published to NuGet the same day.
  • Preview period: the SDK entered public preview on April 2, 2026.
  • Languages: the repository lists packages for Node.js and TypeScript (@github/copilot-sdk), Python (github-copilot-sdk), Go, .NET (GitHub.Copilot.SDK), Java and Rust.
  • Architecture: every SDK talks to the Copilot CLI in server mode over JSON-RPC and manages the CLI process for you. The Node.js, Python and .NET SDKs bundle the CLI automatically.
  • .NET targets: .NET 8 and .NET Standard 2.0.
  • Access and billing: a Copilot subscription is required unless you bring your own model key (BYOK), and each prompt counts toward your Copilot usage allowance.
  • Versioning: the SDK is generally available and follows semantic versioning.

What Happened#

GitHub's Build 2026 recap summarized the change in one line: developers can now embed Copilot's agentic engine into their own applications, services and developer tools, with a stable API and production support. The GA release capped a two-month public preview that GitHub opened on April 2, 2026. At that point, GitHub highlighted fine-grained system prompt customization through replace, append, prepend and transform callbacks, token-by-token streaming, inline binary attachments such as screenshots, OpenTelemetry tracing with W3C trace context propagation across all SDKs, and a permission framework for gating sensitive operations. GitHub also said the preview was open to Copilot subscribers and non-subscribers alike, including Copilot Free for personal use and BYOK for enterprises.

The design is pragmatic. Rather than reimplementing the agent loop in six languages, each SDK drives the Copilot CLI as a local server. That keeps behavior consistent across languages and means improvements to the CLI's agent runtime reach SDK users automatically. Authentication can use a signed-in GitHub user, OAuth tokens from a GitHub App, standard environment variables such as GITHUB_TOKEN, or BYOK credentials for your own model provider.

The .NET quickstart in the repository shows the event-driven shape of the API:

C#
using GitHub.Copilot;

await using var client = new CopilotClient();
await client.StartAsync();

await using var session = await client.CreateSessionAsync(new SessionConfig
{
    Model = "gpt-5",
    // Approves every tool call; use only for local experiments.
    OnPermissionRequest = PermissionHandler.ApproveAll,
});

var done = new TaskCompletionSource();

session.On<SessionEvent>(evt =>
{
    if (evt is AssistantMessageEvent msg)
    {
        Console.WriteLine(msg.Data.Content);
    }
    else if (evt is SessionIdleEvent)
    {
        done.SetResult();
    }
});

await session.SendAsync(new MessageOptions { Prompt = "What is 2+2?" });
await done.Task;

Custom tools are defined with CopilotTool.DefineTool, which takes a delegate plus AIFunctionFactoryOptions from Microsoft.Extensions.AI for the tool's name and description, so the tool model will look familiar to anyone who has used AIFunctionFactory.

Background#

GitHub Copilot has been moving from an in-editor assistant toward a family of agents: a cloud agent that can run scheduled tasks or respond to repository events, the Copilot CLI in the terminal and, around Build 2026, a dedicated desktop app for managing agent sessions. The SDK turns the runtime behind those experiences into a building block. Instead of calling a model API and writing the planning, tool execution and context management yourself, you hand the SDK a prompt, tools and a permission policy, and it runs the loop.

For .NET developers, the SDK also sits alongside Microsoft's own agent stack. Microsoft Agent Framework, which reached 1.0 in April 2026, is a general-purpose framework for building agents on any model through IChatClient. The Copilot SDK is narrower and more opinionated: it packages GitHub's coding-oriented runtime, its tools and its governance model, and it is billed through Copilot.

Why It Matters for Developers#

The most obvious use is internal developer tooling: a bot that triages failing builds, a migration assistant that proposes pull requests, or a command-line tool that explains a repository to new team members. Before the SDK, teams built these on raw model APIs and reinvented the agent loop. Now they can reuse the runtime GitHub already ships in its own Copilot CLI.

Choosing between the Copilot SDK and Microsoft Agent Framework comes down to control versus convenience. Use the Copilot SDK when your scenario is code-centric, your developers already have Copilot seats and you want GitHub's runtime, tools and policies. Use Microsoft Agent Framework when you need your own models, custom workflows or deployment inside your own services, and see our AI agent architecture patterns guide for how the two styles differ.

A few practical points for production use:

  • Take permissions seriously. PermissionHandler.ApproveAll is convenient in a sample but dangerous in a service. The .NET README notes that it throws when managed settings are enabled and that custom handlers should check whether managed approval is required before approving a request. Mark genuinely read-only tools with CopilotToolOptions.SkipPermission instead of approving everything.
  • Trace everything. The SDK's OpenTelemetry support means agent sessions can appear in the same traces as the rest of your system. Our OpenTelemetry in .NET guide shows how to collect them.
  • Watch usage. Every prompt counts toward Copilot usage, so automated agents that run on every commit can consume allowances quickly. BYOK moves that cost to your own model provider.
  • Design tools like public APIs. Tool descriptions drive model behavior, as covered in our guide to function calling in C#.

What's Next#

The SDK has shipped regular patch releases since GA, with GitHub.Copilot.SDK 1.0.14 on NuGet in mid-September 2026. GitHub is also widening the surfaces that share Copilot's agent runtime: in August 2026 it said its Agent Plugins 1.0 format lets developers build a plugin once and use it in VS Code, the Copilot CLI, the Copilot SDK and the Copilot app. For how that desktop app fits in, see our story on the GitHub Copilot app, and for day-to-day Copilot practices in .NET, see AI-assisted .NET development.

Sources#