Microsoft released generally available connectors for GitHub Copilot and Claude Code in the Microsoft Agent Framework this week. The connectors let .NET and Python agents delegate coding tasks to either system through a standard tool interface, without writing custom adapter code for each backend.
This is one of those releases that sounds small on paper but changes how you think about agent architecture. Instead of building agents that can only code one way, you can now swap or combine the two most popular coding AI systems as if they were interchangeable tool plugins.
What the connectors actually do
The connectors plug into the Agent Framework’s tool system and handle all the plumbing: authentication, session management, and result streaming. You register either Copilot or Claude Code as a tool capability on your agent, and the framework manages the lifecycle of the coding session automatically.
The GitHub Copilot connector exposes shell command execution, file operations, URL fetching, and MCP server integration as agent-callable tools. The Claude Code connector provides similar capabilities through Anthropic’s SDK. Both connectors are GA, meaning they are production ready with support commitments and SLAs for Azure customers.
Under the hood, each connector translates the Agent Framework’s tool protocol into the respective backend’s API. The GitHub Copilot connector uses the Copilot SDK, which itself can call MCP servers. The Claude Code connector uses Anthropic’s agent SDK. This means agents built on the framework can indirectly access any MCP server through either connector, effectively making the Agent Framework a hub for MCP tool access.
Why this matters for multi-agent workflows
The Agent Framework is Microsoft’s converged platform that blends patterns from Semantic Kernel and AutoGen into a single SDK. It reached version 1.0 earlier this month. The Copilot and Claude Code connectors slot into the broader multi-agent orchestration story that Microsoft has been building.
Consider a real scenario: a planning agent decomposes a feature request into subtasks, delegates coding to a Copilot agent, while a second agent handles documentation through Claude Code. Both coding agents report back to the orchestrator, which integrates the results. This polyglot agent architecture was previously possible only with significant custom integration work. The connectors make it a configuration change in your agent harness.
Microsoft is taking an agnostic stance here. Rather than locking developers into Copilot-only tooling, the framework supports both major coding AI systems. This is a pragmatic move. The coding AI landscape is still evolving, and tying your agent framework to a single provider would be a bet few enterprise customers are ready to make. The connector pattern means if a third option emerges next year, adding it follows the same pattern.
How session management works
A subtle but important detail is session management. Without a connector, each agent tool call would need to establish a new session with the coding AI, losing context between calls. The connectors maintain session state across the lifecycle of a task. When an agent asks Copilot to implement a function, then fix a bug in the implementation, then add tests, all three requests share the same session context. This is what makes the difference between a coding agent that can complete a multi-file change and one that treats each request as a fresh start.
Result streaming is also handled transparently. The coding AI streams back code changes, terminal output, and reasoning steps as they happen. The Agent Framework surfaces these to the calling agent, which can decide whether to wait for completion or act on partial results. For long-running coding tasks, this is essential.
Practical implications for developers
The obvious benefit is less boilerplate. If you have built an agent that needs to write code, you previously had to implement the Copilot or Claude API yourself, or build a wrapper around a shell command. The connector handles the API contract, error handling, retries, and streaming.
The deeper benefit is composability. Because both connectors expose the same tool interface, you can swap between Copilot and Claude Code for A/B testing, cost optimization, or availability. You can route specific task types to different coding AIs: use Copilot for well-defined implementation tasks where its deep VS Code integration matters, and Claude Code for open-ended exploration and refactoring where its larger context window and reasoning capabilities shine. Over time, you can measure which system performs better on which task categories and adjust accordingly.
There is a cost consideration. Both connectors bill through their respective provider APIs. The Agent Framework does not add its own pricing on top of the connector usage, but you will pay for Copilot or Claude Code API calls directly. For teams already using either service, there is no additional cost to enable the connector.
Availability
The GitHub Copilot and Claude Code connectors are available now in the Microsoft Agent Framework for both .NET and Python. They require the Agent Framework SDK version 1.0 or later. Documentation is available on Microsoft Learn under the Agent Framework providers section.