Microsoft Agent Framework Adds Responses, Telegram, A2A and MCP Channels

Microsoft is separating agent logic from delivery channels

Microsoft introduced agent and workflow channels for Microsoft Agent Framework on August 26, 2026. The new Python packages let developers expose the same underlying agent or workflow through multiple external interfaces, including OpenAI Responses-compatible clients, Telegram, Agent2Agent (A2A) and Model Context Protocol (MCP).

The design is intentionally modular. Microsoft is not replacing the developer’s web framework or deployment stack. Instead, the channel packages sit at the protocol boundary while the application continues to own routing, authentication, authorization, storage, background processing and deployment.

Four channel integrations ship around a shared hosting core

Microsoft lists five packages in the initial release:

• agent-framework-hosting for shared target, workflow and session-state helpers.
• agent-framework-hosting-responses for converting OpenAI Responses requests and Agent Framework results.
• agent-framework-hosting-telegram for translating Telegram updates and outbound operations.
• agent-framework-hosting-a2a for connecting agents and workflows to native A2A SDK types.
• agent-framework-hosting-mcp for exposing Agent Framework targets as native MCP tools.

The practical benefit is that developers can add one or several channels without rewriting the agent for every protocol or adopting a second agent runtime.

Session identity stays application-controlled

The shared AgentState and WorkflowState helpers provide a common target and state model, but Microsoft deliberately leaves identity mapping to the application. A developer decides how an authenticated user, Telegram chat, Responses conversation, A2A context or MCP client maps to a canonical session ID.

That design can support cross-channel continuity. If a user’s Responses client and Telegram identity resolve to the same canonical session, both can load the same Agent Framework session. If an application keeps them in separate namespaces, their histories remain isolated.

This flexibility also means the security model is not automatic. Developers still need explicit authorization, identity linking, concurrency controls and session-store protections when sharing state across channels.

Responses compatibility is an adapter, not an OpenAI dependency

The Responses package converts incoming OpenAI Responses-shaped requests into Agent Framework run values and converts completed or streaming agent runs back into the Responses format. That gives applications a protocol-compatible surface while leaving the actual target, policies and hosting architecture under application control.

Microsoft’s sample uses FastAPI, but the company says the helpers operate at the protocol-conversion and execution-state layer and can be integrated with Django, Flask, other Python frameworks or native SDK servers.

A2A and MCP target different interoperability layers

For A2A, Microsoft provides adapters that generate native agent cards and connect Agent Framework targets to A2A task infrastructure. The application continues to own the executor, task lifecycle, event queue, routes and task store.

For MCP, AgentMCPTool and WorkflowMCPTool can derive native MCP tools from agents and workflows. Developers can also use lower-level conversion helpers with servers such as FastMCP or directly registered MCP handlers.

The distinction matters: A2A is oriented toward agent-to-agent interoperability and task exchange, while MCP exposes tools and callable capabilities to compatible clients. The new channel layer lets one Agent Framework implementation participate in both patterns.

Why this matters for production agent architecture

Agent teams increasingly need to serve more than a single chat UI. A production assistant may need to appear in a messaging app, answer a Responses-compatible API, expose callable MCP tools and communicate with other agents over A2A. Maintaining separate implementations creates drift in prompts, state, tools and business logic.

Microsoft’s new hosting packages try to keep the agent/workflow definition independent from the channel around it. That can reduce duplicate implementation work, but it does not remove the hard production responsibilities: identity, least-privilege authorization, persistence, rate limiting, message ordering, media handling and deployment still belong to the application.

Microsoft says it plans to add more channels and helpers. For teams already building on Agent Framework, the immediate opportunity is to standardize one agent core while making its protocol surfaces explicit rather than embedding channel behavior inside the agent itself.