GitHub Copilot SDK: Build Agents into Any App with Universal Agent Skills

GitHub announced the Copilot SDK in technical preview today (January 22, 2026). This SDK provides programmatic access to the same agent runtime that powers the GitHub Copilot CLI, making it easier to embed advanced agentic workflows—like planning, tool invocation, file editing, and command execution—directly into your own applications.

GitHub Copilot SDK: Agent Runtime for Every App

GitHub's Copilot SDK represents a significant evolution in AI agent development, similar to how the Claude Agent SDK emerged from Claude Code. Both SDKs expose production-tested execution loops, allowing developers to build reliable AI agents without reinventing orchestration, context management, safety checks, or model routing.

Key Highlights

• Production-Ready Runtime — Exposes the same execution loop that powers Copilot CLI, handling authentication, multi-model support, MCP integration, custom agents/skills/tools, and streaming
• Multi-Language Support — Node.js/TypeScript, Python, Go, and .NET (C#)
• Flexible Architecture — SDKs communicate with Copilot CLI via JSON-RPC, either managing the CLI process automatically or connecting to external instances
• Subscription-Based — Requires Copilot CLI installation and active GitHub Copilot subscription (usage counts toward quotas)

Quick Start Installation

# Node.js / TypeScript
npm install @github/copilot-sdk

# Python
pip install github-copilot-sdk

# Go
go get github.com/github/copilot-sdk/go

# .NET
dotnet add package GitHub.Copilot.SDK

Check the official repo for examples, cookbook, and full docs →

Copilot SDK vs Claude Agent SDK

Both SDKs share similar origins and capabilities, born from their respective CLI tools:

Both SDKs excel at providing universal agent runtimes that handle the complex orchestration of AI agents, allowing developers to focus on domain-specific logic rather than infrastructure.

Agent Skills: Universal Across SDKs

The Copilot SDK inherits full support for Agent Skills from the underlying CLI, enabling the same universal skill ecosystem that powers other agent frameworks. As I explored in my recent post "Agent Skills Beyond Coding: A Universal Standard for Agent Workflows", Agent Skills provide a standardized way to package reusable capabilities across different agent platforms.

Custom Tools in Copilot SDK

The Copilot SDK provides rich support for custom tools, the most directly programmable aspect of agent extension:

Recommended Approach (Python with Pydantic):

from pydantic import BaseModel, Field
from copilot import define_tool

class AddNumbersParams(BaseModel):
    a: int = Field(description="First number")
    b: int = Field(description="Second number")

@define_tool(description="Add two numbers")
async def add_numbers(params: AddNumbersParams) -> str:
    return str(params.a + params.b)

# Pass to session
session = await client.create_session({
    "model": "gpt-5",
    "tools": [add_numbers]
})

Low-Level Approach:

from copilot import Tool

async def lookup_issue(invocation):
    # Parse args, execute logic, return result
    ...

session = await client.create_session({
    "tools": [
        Tool(
            name="lookup_issue",
            description="Fetch issue details",
            parameters={...},  # JSON schema
            handler=lookup_issue
        )
    ]
})

Agent Skills in Programming Practice

In my daily development workflow, Agent Skills have become indispensable for several reasons:

1. Domain Expertise Packaging Skills allow me to capture complex workflows once and reuse them across different agent platforms. For example, a "code review checklist" skill I created works identically in Claude Code, Copilot CLI, and now through the Copilot SDK.

2. Cross-Platform Compatibility The same skill folder structure works across Claude Desktop, OpenCode Coworker, GitHub Copilot, and custom applications built with either SDK. This universality saves significant development time.

3. Incremental Skill Development Skills enable progressive enhancement. Start with simple prompts, then add scripts, custom tools, and complex workflows as needed. This approach scales from individual developer productivity to enterprise automation.

Non-Coding Frameworks Using Agent Skills

Agent Skills extend far beyond traditional coding tools, powering workflows in diverse domains:

Claude CoWork & OpenCode Coworker

These collaborative interfaces use Agent Skills to enhance team productivity, enabling shared workflows for documentation, project management, and cross-functional collaboration.

Business & Data Frameworks

• Databricks: Uses Agent Skills for notebook automation, ETL workflows, and ML operations
• Spring AI: Integrates skills into Java/Spring applications for documentation generation and enterprise automation
• Mux: Leverages skills for video infrastructure management and observability

Enterprise Integration

Agent Skills enable consistent behavior across different tools within organizations. A skill developed for code review in Claude Code can enhance the same workflow when accessed through Copilot SDK in a custom enterprise application.

Building with Copilot SDK

The SDK provides a clean, async-first API for building agent-powered applications:

import asyncio
from copilot import CopilotClient

async def main():
    # Create and start the client
    client = CopilotClient()
    await client.start()

    # Create a session with custom configuration
    session = await client.create_session({
        "model": "gpt-5",
        "tools": [custom_tools],
        "skills": ["code-review", "testing"]  # Reference skill directories
    })

    # Set up real-time event handling
    done = asyncio.Event()

    def on_event(event):
        if event.type.value == "assistant.message":
            print(event.data.content)
        elif event.type.value == "session.idle":
            done.set()

    session.on(on_event)

    # Send prompts and interact
    await session.send({"prompt": "Review this pull request for security issues"})
    await done.wait()

    # Cleanup
    await session.destroy()
    await client.stop()

asyncio.run(main())

Key Features for Developers

• Full Async Support with real-time event streaming
• Automatic CLI Management or external server connections
• Session History via get_messages()
• Streaming Deltas for incremental output
• Configurable Options (logging, auto-restart, transport modes)

The Universal Agent Skills Ecosystem

Agent Skills represent a significant advancement in AI agent development by providing a universal, file-based interface for embedding procedural knowledge across platforms. Whether you're building with GitHub Copilot SDK, Claude Agent SDK, or integrating with frameworks like Databricks and Spring AI, the same skills work consistently.

This standardization reduces development friction and enables organizations to build once, deploy everywhere. As both GitHub and Anthropic continue evolving their SDKs, the Agent Skills ecosystem grows more powerful and interconnected.

The Copilot SDK's technical preview marks another step toward mainstream agent development, making sophisticated AI capabilities accessible to every developer. Combined with the universal Agent Skills standard, it opens new possibilities for building intelligent applications that work seamlessly across the entire AI agent landscape.

Read more about the universal Agent Skills ecosystem →