All chapters
  1. Start hereOne agent asks. Another answers. The rest is the contract between them
  2. Foundations · 1One model, one tool, two agents: who is who, and who is responsible
  3. Foundations · 2Message passing: sender, recipient, payload, address and correlation
  4. Foundations · 3Topologies: central orchestrator, peer-to-peer and hierarchy
  5. Mechanics · 4Request and reply, or a task: synchronous versus asynchronous exchange
  6. Mechanics · 5Contracts: messages, artifacts, typed schemas, errors and versions
  7. Mechanics · 6The task lifecycle: submitted, working, input-required, completed, failed, canceled
  8. Mechanics · 7Discovery: Agent Cards, skills and how an agent says what it can do
  9. Protocol · 8A2A: the Agent2Agent protocol, part by part
  10. Protocol · 9A2A versus MCP: delegating to an agent versus calling a tool
  11. Protocol · 10Handoff, delegation or shared state: three ways to work together
  12. Production · 11How updates arrive: streaming, push notifications, callbacks, polling and queues
  13. Production · 12Security: identity, delegated scopes, trust across domains, authorization
  14. Production · 13Reliability: retries, idempotency, order, timeouts and compensation
  15. Production · 14Observability: one trace across three agents
  16. Reference · 15Frameworks: A2A SDKs, LangGraph, AutoGen, CrewAI and plain code
  17. Reference · 16Advanced: consensus claims, coordination failure, cost and isolation
  18. ReferenceGlossary
  19. AboutAbout this site and its sources
Reference · 15

Frameworks: A2A SDKs, LangGraph, AutoGen, CrewAI and plain code

One standard and several libraries, kept apart. Each read on its own documentation and described by what it carries for you, what it leaves to you, and when plain code is enough.

What you will understand
Standard or library
A standard says what goes over the wire. A library is code that does it for you. Never mix the two up.
One template each
A2A and its SDKs, MCP, LangGraph, AutoGen, CrewAI and plain code, each read on its own documentation today.
What each leaves to you
Every option carries some agreements for you and leaves others. The second list is where incidents start.

The insurer's example runs on about two thousand lines of standard-library Python: three agents, a message bus, an envelope, a task state machine, a tracer. No library is used. That was a choice for teaching, and the twelve cases UW-401 to UW-412 (this site's own ids) pass on it.

Now the illustrative extension from A2A becomes a plan. A second team will build the real assessment agent. It wants a library, not this site's bus. The intake agent's team prefers a different one. In UW-402 the assessment agent must stop and ask for the roof age, wait 15 simulated minutes for the broker, and resume the same task. In UW-409 the broker withdraws and the task must end canceled.

Which library carries those agreements for the two teams, which only carries them inside one program, and which leaves them to the team? A comparison of feature lists cannot answer that, because the lists use different words for different things. This page asks each option the same questions, reads the answers on its own documentation today, and keeps the standards apart from the libraries.

The agents here are scripted stand-ins, so these results show how the mechanism works, not how good any model is. Nothing on this page ranks anything.

1. A standard and a library are different kinds of thing#

A standard (here, a protocol specification) is a document. It names the messages, fields, operations and states that two programs must agree on. It contains no code you can run. A2A and MCP are standards.

A library is code you import. It gives you classes and functions that build messages, run agents, store state and route work inside your program. Some libraries also implement a standard, so that your program can talk to programs built with something else. The A2A SDKs, LangGraph, AutoGen and CrewAI are libraries.

Before AI. JMS is a Java specification for messaging; ActiveMQ is a product that implements it. The Servlet specification is a document; Tomcat is the code. A team that says "we use JMS" has said what it agreed to, not what it runs. The same care applies here: "we use A2A" names the wire format; "we use CrewAI" names the code.

The difference matters most at a boundary. Inside one program, a library's own agent-to-agent mechanism works for both sides because both sides are the same program. Across two teams, only what both sides implement in common reaches the other side. For agents today, that common thing is a protocol such as A2A.

2. The questions asked of each#

Every section below uses the same template, from the site's specification for framework treatment. A table answers it; the prose around the table says what the answers mean for the example.

RowThe question it answers
KindStandard, library or plain code
Problem it addressesWhat would be hard without it
How agents talkThe communication model: direct request and reply, broadcast to a topic, shared state, delegation through a tool, or a protocol on the wire
Minimum exampleThe smallest thing that shows the model; for anything not run here, "documented shape; not run here"
Carries for youAgreements you do not have to write
Leaves to youAgreements you still have to write; this is where the example's cases fail
Integration and securityHow it meets A2A or MCP, and what its documentation says about trust
Plain code is enough whenThe honest alternative
Version and dateWhat was verified, on which day
SourceThe primary pages read

"How agents talk" needs one more definition, because the libraries differ most there. Direct messaging means one agent addresses another and gets an answer back, like a method call. Broadcast means an agent publishes to a named topic and every subscriber receives a copy; nobody answers. Shared state means agents do not message each other at all: they read and write one state object, and the library decides who runs next. Delegation through a tool means an agent's model is given a tool such as "delegate work to a coworker", and calling it hands a piece of work to another agent.

The diagram places every option on one of three levels.

Diagram: Three levels: standards on the wire, libraries in the program, plain code

Read top to bottom. Standards are documents: they say what crosses between two programs. Libraries are code: inside one program each has its own way for agents to talk, and at the edge several of them speak A2A. Plain code is the example of this site: every agreement written by hand. Arrows mean 'implements or speaks'.

  1. Standards · what goes over the wire
    1. A2A: A protocol specification for delegating tasks between agents built by different teams.
    2. MCP: A protocol specification for connecting an AI application to tools and data.
  2. Libraries · code inside one program
    1. A2A SDKs: Libraries that implement A2A: cards, operations, bindings.
    2. LangGraph: Agents are nodes of one graph over one state; A2A through the LangSmith Agent Server.
    3. AutoGen: Direct messages and topic broadcast through a runtime. Archived; Microsoft Agent Framework is named its successor.
    4. CrewAI: Agents delegate to coworkers through tools their model calls; A2A client and server configs.
  3. Plain code · every agreement by hand
    1. uw-agents: Envelope, message bus, task table and tracer in standard-library Python. No library, no wire standard.

3. The comparison matrix#

The table holds the short answers. The filter buttons above it come from the columns with a few distinct values. Read the sections for the reasons; read the fact log docs/facts/frameworks.md for every source and date.

NameKindSpeaks A2AHow agents talkStatus read 2026-11-17
A2A protocolstandardis A2AMessages, tasks and artifacts between agents over three bindings1.0.0 released
A2A SDKslibraryyesClient and server code for A2A in six languagesPython a2a-sdk 1.3.1
MCPstandardnoTool calls and resources between a host and serversrevision 2026-07-28
LangGraphlibraryyesShared state in a graph; A2A through the LangSmith Agent Serverno notice; version not shown
AutoGenlibrarynot documentedDirect messages and topic broadcast through a runtimearchived, maintenance mode
Microsoft Agent FrameworklibraryyesAgents and graph workflows; A2A hosting and client packagesA2A packages prerelease
CrewAIlibraryyesDelegation tools inside a crew; A2A client and server configsno notice; version not shown
Custom orchestrationplain codenoEnvelopes on an in-process message busthis site's examples/uw-agents

The A2A protocol (standard)#

A2A is the home of the protocol; this section only fills the template so the standard sits next to the libraries.

RowA2A
KindStandard: a protocol specification. Open source project under the Linux Foundation, contributed by Google, part of the Agentic AI Foundation
Problem it addressesTwo agents built by different teams, on different stacks, must find each other, delegate work and get results without seeing inside each other
How agents talkA client sends a message; the server answers with a message or a task; tasks have eight states and produce artifacts
Minimum exampleOne SendMessage with one data part, answered by a task id. Shown on A2A. Documented shape; not run here
Carries for youDiscovery (Agent Card), message and task shapes, state names, eleven operations, three bindings, explicit version
Leaves to youThe meaning of the payload, deadlines, retries, trace context, which scopes a token carries
Integration and securitySecurity schemes are declared in the Agent Card; the credential travels on the transport
Plain code is enough whenBoth agents are written and released by one team, in one process or one service
Version and date1.0.0, specification read 2026-11-17
Sourcehttps://a2a-protocol.org/latest/specification/

The A2A SDKs (libraries)#

An A2A SDK is a library that implements the A2A protocol for one language: it builds and parses A2A messages, serves an Agent Card, exposes the operations over one or more bindings on the server side, and calls them on the client side. You write what the agent does; the SDK speaks the protocol.

The A2A project lists official SDKs for six languages. For Python, the package page says a2a-sdk implements specification 1.0 with a compatibility mode for 0.3, on all three bindings, client and server. Version 1.3.1 shows a release date of November 17, 2026, the day of reading. The project's v1.0 announcement says the community is working on v1.0 support across languages and does not say which SDKs already have it, so check each SDK's own page before relying on 1.0 behavior.

RowA2A SDKs
KindLibraries that implement a standard
Problem it addressesWriting the wire format, the bindings and the card by hand, and keeping them correct across versions
How agents talkOver A2A, exactly as the standard says
Minimum examplePython: pip install a2a-sdk; an executor class that runs your agent, a request handler and a task store behind an HTTP server. Documented shape; not run here
Carries for youSerialization, the operations, the card, the bindings, version handling (for Python, 1.0 with 0.3 compatibility)
Leaves to youEverything the standard leaves: payload contracts, deadlines, retries, tracing, authorization decisions
Integration and securityPython extras include signing (signed Agent Cards) and telemetry
Plain code is enough whenYou never cross a team or company boundary
Version and dateLanguages: Python, Go, Java, JavaScript, C#/.NET, Rust; Python a2a-sdk 1.3.1; read 2026-11-17
Sourcehttps://a2a-protocol.org/latest/ ; https://pypi.org/project/a2a-sdk/

MCP (the neighbor standard)#

MCP is not an agent-to-agent protocol, and A2A versus MCP is its home on this site. It appears here because every library below uses it, or something like it, for the other half of the job: reaching tools.

RowMCP
KindStandard: a protocol specification
Problem it addressesConnecting an AI application to many tools and data sources without a custom integration for each
How agents talkThey do not, through MCP. A host's client calls a server's tools and reads its resources
Minimum exampleOne tools/call for get_roof_assessment, shown on A2A versus MCP. Documented shape; not run here
Carries for youTool listing and calling, resources by URI, capability declaration on every request, input requests on a call
Leaves to youOwnership of long work (tasks are an optional extension), anything between two agents
Integration and securityExplicit user consent before a tool runs; tool annotations untrusted unless the server is trusted
Plain code is enough whenThe tools live in the same program as the agent and nobody else needs them
Version and dateRevision 2026-07-28, read 2026-11-17
Sourcehttps://modelcontextprotocol.io/specification/latest

LangGraph (library)#

LangGraph is a library for building agent workflows as graphs. Its overview calls it a low-level orchestration framework and runtime for long-running, stateful agents. You define a shared state, nodes that read and update it, and edges that decide which node runs next. Its documentation lists durable execution (state saved so a run can resume), pauses for a person, memory and streaming.

Multi-agent work in LangGraph is mostly shared state, not messages. Two agents in one graph are two nodes that read and write the same state; the graph's edges decide who runs. The related LangChain page on multi-agent systems describes handoffs as tool calls that update a state variable, and lists other patterns (subagents, router, skills) under LangChain's own documentation. A2A appears in a different place: the LangSmith Agent Server, which runs LangGraph graphs as a service, exposes an A2A endpoint per assistant at /a2a/{assistant_id}.

RowLangGraph
KindLibrary (with a separate server product, the LangSmith Agent Server, for deployment)
Problem it addressesLong-running, stateful agent workflows that must pause, resume and be inspected
How agents talkInside one graph: shared state and edges. Across services: A2A through the Agent Server
Minimum exampleA graph with two nodes over one state object, one edge between them. Documented shape; not run here
Carries for youControl flow, saved state, resumption after a pause, streaming of updates
Leaves to youBetween two graphs owned by two teams, everything except what the A2A endpoint carries
Integration and securityAgent Server A2A: v1.0 JSON-RPC binding (also accepts v0.3 method names); gRPC and HTTP+JSON not implemented; SubscribeToTask and push notification configs not supported; needs langgraph-api >= 0.4.21; uses the A2A contextId as its thread id, so the contextId must be a UUID
Plain code is enough whenThe workflow is a fixed sequence with no pauses and no need to resume
Version and dateNo version shown on the overview; no maintenance notice; read 2026-11-17
Sourcehttps://docs.langchain.com/oss/python/langgraph/overview ; https://docs.langchain.com/langsmith/server-a2a
What this is not. Choosing which node runs next, under which condition, is control flow. It is the subject of https://orchestrate.sammuthu.com, and LangGraph's graph belongs there more than here. This site cares about what crosses between agents.

AutoGen (library), and its successor#

AutoGen is a library from Microsoft Research for multi-agent applications. Its Core layer is the most message-shaped of the libraries here: its documentation says messages are the only means through which agents communicate. A message is a dataclass or Pydantic model. send_message() is direct messaging: the receiver's return value comes back to the sender, and so do its exceptions. publish_message() broadcasts to a topic; it is one-way and any responses are discarded. A runtime registers agents and delivers messages; the examples use a single-threaded one, and the documentation lists a distributed runtime.

The surprising fact of this page is in AutoGen's README. It says the project "has been archived and is no longer actively maintained by Microsoft", that Microsoft provides no bug fixes, security fixes or new features for it, that it is in maintenance mode (outside contributions limited to bug fixes, security patches and documentation), and it sends new users to Microsoft Agent Framework, which the README calls its successor. The Agent Framework overview says the same from the other side: it is the direct successor of Semantic Kernel and AutoGen, created by the same teams. The AutoGen documentation page read for this section shows no such banner.

RowAutoGen
KindLibrary; archived, maintenance mode
Problem it addressesBuilding multi-agent applications from agents that exchange typed messages
How agents talkDirect request and reply (send_message), broadcast to topics (publish_message), through a runtime
Minimum exampleTwo agents registered on a single-threaded runtime; one sends a dataclass message to the other and awaits the return value. Documented shape; not run here
Carries for youMessage routing by type, request and reply inside the runtime, topic subscriptions
Leaves to youTask states, cancel semantics, deadlines; the README read here does not mention A2A for AutoGen itself
Integration and securityFor new work, the README points to Microsoft Agent Framework
Plain code is enough whenOne process, a handful of message types, no need for topics
Version and dateREADME status read 2026-11-17; no version named on the pages read
Sourcehttps://github.com/microsoft/autogen ; https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/framework/message-and-communication.html

Microsoft Agent Framework, read for one row of the matrix and nothing more, documents A2A in both directions. In .NET, the packages Microsoft.Agents.AI.Hosting.A2A and Microsoft.Agents.AI.Hosting.A2A.AspNetCore (installed as prerelease) map an agent to an A2A HTTP+JSON endpoint and publish its Agent Card at the well-known address. In Python, agent-framework-a2a adapts an agent to the server side of the official a2a-sdk. Its documentation adds one sentence worth copying into any design: "Forwarded metadata isn't an authentication boundary."

CrewAI (library)#

CrewAI is a library for teams of agents. Its introduction names Flows (the application's steps, state and control), Crews (teams of agents a flow hands work to), Agents (each with a role, a goal and tools) and Tasks. Inside a crew, agents talk by delegation through tools: with allow_delegation=True, an agent's model gets two tools, "Delegate work to coworker" and "Ask question to coworker", each taking the task or question, its context and the coworker's name. A hierarchical process adds a manager model that assigns the work.

Across services, CrewAI documents A2A in both directions. As a client, an agent configured with A2AClientConfig (pointing at a remote Agent Card) decides for each task whether to do it itself or delegate it to the remote agent; with several remote agents, the model picks one. As a server, A2AServerConfig exposes an agent, with skills generated from its tools when none are given.

RowCrewAI
KindLibrary
Problem it addressesOrganizing role-based agents into a team with a process and a flow
How agents talkInside a crew: delegation and questions through tools the model calls. Across services: A2A
Minimum exampleTwo agents with allow_delegation=True in one crew, one task; or an agent with a2a=A2AClientConfig(endpoint=...). Documented shape; not run here
Carries for youRole and task structure, delegation tools, A2A client and server wiring
Leaves to youWhich delegation the model makes (the model chooses), task states between crews, deadlines beyond the client timeout
Integration and securityClient defaults: timeout 120 s, max_turns 10, fail_fast true. Server defaults: protocol_version 0.3.0, streaming on, push off, auth SimpleTokenAuth from AUTH_TOKEN. A2AConfig is deprecated, to be removed in v2.0.0
Plain code is enough whenThe order of work is fixed and no model needs to choose a coworker
Version and dateNo version shown on the pages read; read 2026-11-17
Sourcehttps://docs.crewai.com/en/introduction ; https://docs.crewai.com/en/concepts/collaboration ; https://docs.crewai.com/en/learn/a2a-agent-delegation
Production pitfall. A CrewAI server left on its documented default says it speaks A2A 0.3.0. A client that sends only 1.0 requests (with the A2A-Version: 1.0 header and the 1.0 method names) meets a server set up for the previous version. Under the 1.0 rules a server answers an unsupported version with VersionNotSupportedError; a server built for 0.3 may not even do that. Set the version on both sides on purpose, and test the pair.

Custom orchestration in plain code#

Custom orchestration means writing the agents' communication yourself, with no agent library: your own envelope, your own transport, your own task table. It is what examples/uw-agents/ does, on purpose, so that every agreement is a visible line of code. Its README says no library is used.

The whole topology of a run is wired in one function, run_case.py:build, quoted verbatim. Read it as a list of the agreements a library would otherwise make for you: who exists, who forwards to whom, which deadlines apply.

def build(case: dict[str, Any], topology: str, dedupe: bool = True, idempotency: bool = True, use_seq: bool = True,
          deadlines: bool = True, propagate: bool = True, silence: tuple[str, ...] = ()) -> tuple[Bus, dict[str, Any], World]:
    """Wire one run: the world, the tracer, the bus and the agents of one topology."""
    world = World(case, idempotency=idempotency)
    bus: Bus
    tracer = Tracer(case["run_id"], lambda: bus.now, propagate=propagate)
    bus = Bus(case["run_id"], tracer, dedupe=dedupe, deadlines=deadlines, faults=case["world"].get("faults", []),
              silence=tuple(case["world"].get("silence", [])) + tuple(silence))
    Cockpit(world, tracer, bus)
    cards = load_cards()
    kw = {"use_seq": use_seq}
    agents: dict[str, Any] = {"intake-agent": IntakeAgent("intake-agent", world, tracer, cards["intake-agent"],
                                                           first_hop=FIRST_HOP[topology], case=case, **kw)}
    if topology == "orchestrator":
        agents["coordinator"] = Relay("coordinator", world, tracer, evidence_to="assessment-agent", **kw)
    if topology == "hierarchy":
        # the supervisor's deadline covers the lead's own two attempts of 30 s each
        agents["supervisor"] = Relay("supervisor", world, tracer, evidence_to="assessment-lead",
                                     deadlines={"evidence.request/v1": 90_000}, **kw)
        agents["assessment-lead"] = AssessmentLead("assessment-lead", world, tracer, **kw)
    agents["assessment-agent"] = AssessmentAgent("assessment-agent", world, tracer, cards["assessment-agent"],
                                                 forward_to="underwriting-agent" if topology == "peer" else None, **kw)
    agents["underwriting-agent"] = UnderwritingAgent("underwriting-agent", world, tracer, cards["underwriting-agent"], **kw)
    for a in agents.values():
        bus.register(a)
    return bus, agents, world

Every switch in the signature is an agreement made explicit: deduplication, the idempotency key, sequence numbers, deadlines, trace propagation. The command below runs all twelve cases in the peer topology, where no agent sits in the middle. A successful run proves that plain code carries the whole contract of this site, including the question back (UW-402), the cancel (UW-409) and the silent callee (UW-412), with no library.

cd examples/uw-agents          # a scratch copy: the runner may write out/
PY=/opt/homebrew/bin/python3
$PY run_case.py --all --topology peer --dry-run
All cases · topology peer · agents: scripted stand-ins (no model called)
case    msgs  recommendation rows  evidence    result
UW-401     6  approve           1  completed   PASS
UW-402     9  approve           1  completed   PASS
UW-403     6  escalate          1  completed   PASS
UW-404     6  decline           1  completed   PASS
UW-405     6  decline           1  completed   PASS
UW-406     6  request_info      1  completed   PASS
UW-407     6  escalate          1  completed   PASS
UW-408     6  approve           1  completed   PASS
UW-409     6  -                 0  canceled    PASS
UW-410     6  approve           1  completed   PASS
UW-411     6  approve           1  completed   PASS
UW-412     5  escalate          1  failed      PASS

The message counts are from this example and synthetic. UW-409 stores no row because the work was canceled; UW-412 ends with the evidence failed on the caller's side and the case escalated as evidence unavailable. Each recommendation is a recommendation to a person: the model recommends; a person decides.

RowCustom orchestration in plain code
KindPlain code (no library)
Problem it addressesSeeing and owning every agreement between agents
How agents talkEnvelopes on a message bus; tasks with ids and states; tools as plain function calls
Minimum exampleexamples/uw-agents/, run above
Carries for youNothing you did not write; every behavior is yours to read and test (45 unit tests in the example)
Leaves to youEverything, including the parts a library would have tested for years: real transports, dropped connections, clocks that disagree
Integration and securityNo wire standard: another team cannot call it without reading your code. Map it to A2A at the boundary
Plain code is enough whenOne team owns every agent, the agreements are few, and nobody outside needs to call in
Version and dateThis site's example, run 2026-11-17
Sourceexamples/uw-agents/README.md

4. The failure: two libraries, one assumption each#

Put the plan from the top of the page together. The intake agent's team builds on one library; the assessment agent's team builds on another and exposes it over A2A. Each team tests its own side. Three things the matrix already shows can still break UW-402 on the first day:

What one side assumesWhat the other side doesWhat happens on UW-402
The intake agent sets contextId to its own run_id, run-5e02A LangGraph Agent Server uses contextId as its thread id and requires a UUIDThe request is rejected before a task exists; no question ever reaches the broker
The intake agent sends A2A 1.0 requestsA CrewAI server left at its default protocol_version 0.3.0A version error, or a misread request; the evidence task never starts
The intake agent waits for a push notification while the task is input-requiredThe server does not support push notification configs (the LangSmith page lists them as unsupported)The caller never learns that a question is waiting, so it never asks the broker; the task sits in input-required until someone polls it

None of these is a bug in a library. Each is an agreement that one side's library carried and the other side's did not. The cure is the one the whole site teaches: write the agreements down, and test the pair, not each side.

What this is not. This page compares how options carry messages between agents. It does not measure how good any of them makes an agent; that is the subject of https://eval.sammuthu.com. It does not cover the runtime around one model call either; that belongs to https://harness.sammuthu.com.

The same idea for a coding agent. A planning agent works in a repository under its repository instructions. Inside one tool, its test agent and review agent may be nodes of one graph or members of one crew: shared state or delegation tools, all in one process. The day the review agent belongs to another team, that convenience stops at the process edge, and what crosses is a protocol such as A2A, with a task id for "review this pull request". CI stays the judge that is not an agent. Shipping the change is the subject of https://diff-to-deploy.sammuthu.com.

5. Checklist before choosing#

Advanced perspective#

In-process agreements do not cross a processWhy a library's multi-agent feature is not a protocol

Shared state, delegation tools and runtime-routed messages all rely on both agents living under one runtime: one state object, one scheduler, one set of Python types. They make strong guarantees cheaply because nothing can arrive late, twice or out of order between two nodes of one graph unless the library lets it. The moment one agent moves to another service, every one of those guarantees has to be rebuilt on a network, and the library's in-process feature does not travel with it.

A design reviewer asks for each edge: what is the failure model here? Inside one runtime, a node that crashes takes the run with it, and resumption is the library's checkpoint. Across services, the callee can be slow, silent or upgraded independently, and the contract is the protocol plus your own agreements on top. Mixing the two in one diagram without marking which is which is the most common source of surprise.

Who chooses the calleeCode, a graph edge, or the model

The options differ in who decides which agent gets the work. In plain code and in a graph, a person wrote the routing: forward_to="underwriting-agent" in the example, an edge in LangGraph. In CrewAI's delegation tools and its A2A client mode, the model chooses the coworker or the remote agent at run time. That moves a routing decision from reviewed code into a model's judgment, with the Agent Card or the agent's role text as the model's evidence.

Two consequences. A card or role description becomes an input that steers routing, so a misleading description is a routing bug, and a description is a claim, not a guarantee. And the route itself must now be traced and evaluated, because it can differ between two runs of the same case. Neither is wrong; both should be decided on purpose.

Treat a library's status as a dependency with a dateArchived, renamed, prerelease: read it again before you ship

On the day of reading, one of the libraries the site's specification named was archived and pointed to a successor, the A2A packages of that successor were marked prerelease, one library's A2A server defaulted to the previous protocol version, and an SDK published a release on the same day. None of this is unusual for a field that moves this fast. It argues for three habits: pin versions, record the date you last read each project's own status, and keep the protocol edge (A2A) separate from the library choice, so that replacing a library does not change what your partners see on the wire.

Questions for the design reviewWhat a Principal engineer asks before approving a library

Which agreements of Contracts and Task lifecycle does this library carry, and which does it leave to us, written as two lists? What happens to a running task when we deploy a new version of the agent? Where do deadlines, attempt numbers and trace context live, given that A2A's core objects have no field for them? If the library is replaced in two years, which code changes and which partners notice? Can we run the twelve cases of our own suite against the library-based version and get the same results as the plain-code version? A library that passes that last test has earned its place; one that cannot be tested that way has not yet been understood.

In one breath#

A2A and MCP are standards: documents that say what goes over the wire, one between agents and one to tools. The A2A SDKs, LangGraph, AutoGen and CrewAI are libraries: code that runs agents and, in different ways, speaks A2A at the edge, while inside one program they talk by shared state, direct messages, topics or delegation tools. Read each one's status on its own pages before you rely on it: on the day this page was written, AutoGen was archived in favor of Microsoft Agent Framework. Whatever you pick, write down what it leaves to you, and test the pair across the boundary on a question back, a cancel and a silence.

You can now place any option on the map and name what it carries. What remains are the problems no library removes: agents that agree with each other for the wrong reasons, groups of agents that fail together, and the cost of every extra message. Advanced takes them one at a time.