Microsoft has shipped generally available connectors for GitHub Copilot and Claude Code in the Microsoft Agent Framework, letting developers build .NET and Python agents that delegate coding tasks to either system without writing custom adapter code.
The connectors plug into the Agent Framework’s standard tool-use pipeline, so agents can call out to Copilot or Claude Code the same way they call any other tool. No SDK-specific glue code, no custom protocol handling.
What the connectors do
The GitHub Copilot connector gives agents access to the same capabilities developers get from Copilot in their IDE: code generation, refactoring, debugging suggestions, and code review. The agent passes a prompt or task description, and Copilot returns code or analysis. The Claude Code connector works the same way, routing through the Agent Framework’s tool abstraction to invoke Claude Code’s coding agent capabilities on Azure.
Both connectors are GA from day one, not preview. That matters for teams building production agent systems that need stability guarantees. They are not experimental features you have to opt into — they ship as stable components with the v1.0 SDK.
How they fit into the Agent Framework
Microsoft Agent Framework is a multi-agent orchestration SDK that consolidates patterns previously spread across AutoGen and Semantic Kernel. The framework handles tool registration, message routing, state management, and middleware for both Python and .NET. Dropping a Copilot or Claude Code connector into this pipeline means any agent built on the framework can delegate coding work without the orchestrator knowing which coding assistant is on the other end.
Under the hood, the GitHub Copilot connector uses the Copilot SDK agent provider, which wraps the Copilot API as a standard tool. The Claude Code connector routes through Azure Foundry’s model configuration. Both are registered as tool providers in the Agent Framework’s middleware pipeline, with message injection for coordinating results between agents. The middleware can intercept, transform, or log messages passing between the agent and the connector, which is useful for adding observability or enforcing policy.
Copilot vs Claude Code: when to use which
Having both connectors available raises an obvious question: when do you use one over the other? The answer depends on the task.
GitHub Copilot is strongest at inline code generation and refactoring within a known codebase. If your agent needs to write a function, fix a bug, or suggest a test, Copilot is the natural fit. It works within the context of your project, understands your existing code patterns, and generates suggestions that match your style. The Copilot CLI capabilities also let agents interact with GitHub directly — opening PRs, running workflows, checking commit history, and managing issues.
Claude Code, on the other hand, has a broader context window and is better suited for tasks that require understanding large codebases or following complex multi-step instructions. If your agent needs to analyze an entire codebase for a security vulnerability, refactor across multiple files, or generate documentation from source code, Claude Code’s larger context lets it work with more information at once. The Azure Foundry integration also means you can run Claude Code agents on Azure infrastructure with managed scaling and enterprise compliance.
The smartest approach is to use both. The Agent Framework is designed for multi-agent orchestration, so you can route code generation tasks to Copilot and analysis tasks to Claude Code from the same orchestrator. The connectors handle the protocol differences, and the middleware pipeline lets you inject coordination logic between them. A typical pattern: the orchestrator sends a task to Copilot for implementation, receives the result, passes it to Claude Code for review, then merges the feedback. The framework’s state management ensures context is preserved across the handoff.
Practical considerations for production
These connectors are GA, but they are still connectors between systems with different latency profiles, cost structures, and failure modes. Copilot and Claude Code have different response times, different token limits, and different rate limits. Your orchestrator needs to handle timeout, retry, and fallback logic for each connector independently.
The Agent Framework’s middleware pipeline helps here. You can inject logging middleware to track which connector handled each request, retry middleware to handle transient failures, and circuit breaker middleware to stop routing requests to a connector that is consistently failing. The framework’s InMemoryHistoryProvider tracks state across calls, so the orchestrator maintains context even when switching between connectors mid-task. For production deployments, you can swap the in-memory provider for a persistent store like Azure Cosmos DB.
Authentication is also worth noting. The GitHub Copilot connector authenticates through the Copilot SDK, which uses your existing GitHub credentials. The Claude Code connector authenticates through Azure Foundry, which uses Azure AD. Your agent needs credentials for both systems configured before it can use either connector. The Agent Framework supports environment-based configuration, so you can load credentials from environment variables rather than hardcoding them.
Getting started
The connectors ship with the Agent Framework v1.0 SDK for Python and .NET. Install the SDK via pip or NuGet, register the connector as a tool provider, and define your agent’s tool-use pipeline. The framework handles the rest: routing, state, error handling, and middleware execution.
Documentation is available on Microsoft Learn for both the GitHub Copilot provider and the Claude Code configuration. For teams that want to experiment without deploying infrastructure, the Azure Foundry playground includes pre-configured agent templates that use both connectors. The GitHub repo for the Agent Framework has examples in both Python and C#.