Python: Proposal: Agent-to-agent handoff and messaging protocols for multi-agent workflows

[vystartasv]

Problem

Microsoft Agent Framework is Microsoft's newest agent orchestration platform — but multi-agent workflows currently lack standardized communication primitives. When Agent A needs to hand off a task to Agent B, the handoff is bespoke per deployment. Same for agent-to-agent messaging — every team reinvents the wire format.

Proposed Solution

Two complementary protocols from Works With Agents (CC BY 4.0):

1. Handoff Protocol (L4)

Task transfer with complete context and verifiable acceptance:

from agent_framework import Agent
from works_with_agents import HandoffProtocol

agent_a = Agent("researcher")
agent_b = Agent("writer")
handoff = HandoffProtocol.transfer(
    from_agent=agent_a.id,
    to_agent=agent_b.id,
    task={"query": "...", "context": {...}},
    require_acceptance=True  # cryptographic ACK
)

2. IACP (L5) — Inter-Agent Communication Protocol

Full-duplex agent↔agent messaging. The companion to MCP (agent↔tool):

from works_with_agents import IACP

channel = IACP.open(agent_a.id, agent_b.id)
channel.send({"type": "handoff", "payload": task})
response = channel.receive()  # signed, verifiable

Why Agent Framework:

• MS's newest agent platform — ideal place to standardize communication early
• Multi-agent workflows need structured handoff, not ad-hoc state passing
• IACP is the natural companion to MCP support already in the ecosystem

Resources:

• Handoff spec: https://workswithagents.dev/specs/handoff.md
• IACP spec: https://workswithagents.dev/specs/iacp.md
• SDK: pip install works-with-agents

Would a PR adding Handoff + IACP as optional protocols be welcome? Happy to follow the contribution process.

[moonbox3]

Thanks for the proposal, but going to decline.

Two issues with the framing:

1. We already have a JSON-RPC wire format for agent-to-agent: A2A. It's a first-class integration in both Python (agent_framework_a2a) and .NET (Microsoft.Agents.AI.A2A, plus the hosting packages). MAF agents can be exposed as A2A servers and consumed as A2A clients/tools today, see python/samples/04-hosting/a2a/ and dotnet/samples/05-end-to-end/A2AClientServer. Adopting a parallel third-party protocol (works-with-agents) would fragment that surface, not standardize it.

2. Handoff and orchestration outputs are already standardized in MAF. Workflows, executors, and the Magentic patterns provide structured handoff with typed context, not ad-hoc state passing. And anything we add at the protocol layer has to keep Python and .NET MAF types compatible across the SDK boundary; pulling in an external Python-only SDK breaks that contract.

Also worth flagging: pip install works-with-agents returns 404 on PyPI, so the SDK referenced here isn't actually published.

Closing as not planned. If there's a concrete gap in our existing A2A or handoff support, happy to look at an issue scoped to that.