A2AConnectGet started

A2AConnect

Hand off work across any agent runtime — without sharing an SDK.

The SDK-agnostic interop layer for multi-agent fleets. LF A2A–compatible. Complements MCP. Python runtime. Site at a2aconnect.dev.

How it fits together

Peers exchange typed envelopes over a pluggable transport. Adapters wrap your existing brains. Policy and audit sit at the boundary. LF A2A for peers on the wire; MCP for tools.

  • Discovery — hello / hello.ack, then capabilities.query → announce.
  • Negotiation — offers list required capabilities; mismatches reject cleanly.
  • Handoff — offer → accept → start → progress/events → result.
  • Governance — policy allowlists and audit trails for production.
Full architecture →
01

Agent brains

Your runtimes stay yours — Python, LangGraph-shaped graphs, CrewAI-shaped roles, OpenAI agents, or custom asyncio.

02

Runtime adapters

RuntimeAdapter → TaskHandler via from_async_fn. No hard SDK lock-in; wrap the brain you already run.

03

AgentPeer + governance

Handshake, capability negotiation, offer/accept, progress, events, result. Policy allowlists and MemoryAuditLog sit at the boundary.

04

Pluggable transport

Same envelopes over in-memory bus (dev), outbound buffer (backpressure), or HTTP JSON stub (edge).

05

Local interop profile

Typed JSON messages mapped conceptually to LF A2A task lifecycle. Complements MCP for tools — does not replace either standard.

LF A2A

Industry peer wire standard. A2AConnect maps profile ≈ Agent Card, task.* ≈ Task lifecycle — does not replace it.

MCP

Agent ↔ tools/data. Orthogonal vertical: use MCP for tools, A2AConnect for peer handoff.

Get started

Install the package, run the research-handoff quickstart, then the full cross-runtime demo (orchestrator → researcher → writer).

shell
python3 -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"
pytest
python demos/support_desk.py      # support agent→agent
python demos/incident_handoff.py  # incident agent→agent
python demos/two_agents.py        # cross-runtime brief
python demos/quickstart.py
demos/quickstart.py
import asyncio, json
from a2aconnect import AgentPeer, MemoryAuditLog, create_bus
from a2aconnect.adapters import from_async_fn

async def research_run(input, ctx):
    topic = (input or {}).get("topic", ctx.offer["goal"])
    await ctx.report_progress(percent=40, message=f"Researching {topic}")
    await ctx.emit_event(
        name="source.found",
        data={"title": f"{topic} overview"},
    )
    return {
        "topic": topic,
        "findings": [
            f"{topic}: fleets need a shared handoff layer",
            "LF A2A is the wire standard; A2AConnect is the runtime",
        ],
    }

async def main():
    bus = create_bus()
    audit = MemoryAuditLog()

    researcher = AgentPeer(
        profile={
            "id": "researcher",
            "name": "Researcher",
            "capabilities": [{"name": "research.web", "version": "1"}],
        },
        transport=bus.create_transport("researcher"),
        handlers={"research.web": from_async_fn(research_run)},
    )
    orchestrator = AgentPeer(
        profile={
            "id": "orchestrator",
            "name": "Orchestrator",
            "capabilities": [],
        },
        transport=bus.create_transport("orchestrator"),
        audit=audit,
    )

    researcher.start()
    orchestrator.start()

    await orchestrator.hello("researcher")
    outcome = await orchestrator.offer_task(
        to="researcher",
        goal="Research agent interop",
        input={"topic": "agent interop runtimes"},
        required_capabilities=["research.web"],
    )
    print(json.dumps(outcome["result"]["output"], indent=2))

asyncio.run(main())
# full file: demos/quickstart.py

Walk the full two-agent path on the examples page.

Open-core, sellable fleet control

OSS forever for the runtime. Charge when fleets go multi-team — not for inventing a wire protocol.

OSS

PyPI a2aconnect, local transports, policy/audit hooks.

Gateway

Auth, routing, rate limits, multi-tenant registry — roadmap.

Enterprise

SSO/SCIM, VPC, retention, SLA — roadmap.