A2A vs Agora: one fixed protocol or negotiated ones

A2A (Agent2Agent) is for delegating work between independent agents through one fixed set of operations and data types that every implementation shares. Agora is for letting language-model agents agree on their own message formats as they go: plain natural language for rare exchanges, and structured protocols with code behind them for frequent ones.

The two sit at different levels. A2A is a wire protocol: it defines requests, tasks, states and bindings. Agora is a meta-protocol: it defines how agents identify, share and adopt protocols, and says little about what those protocols contain.

Status as of September 26, 2026. Agora was introduced in an arXiv paper by Samuele Marro and co-authors, first submitted on October 14, 2024. Its MIT-licensed Python library describes itself as open beta, and the public repositories of the Agora project show no commits since March 2025. Agora has no foundation or standards body behind it. A2A is a Linux Foundation project whose current protocol version is 1.0 (release v1.0.1, May 28, 2026).

What Agora is for

The paper frames agent communication as a trilemma. A protocol should be versatile (handle many kinds of messages), efficient (cheap to compute and send) and portable (easy for many agents to support). The authors argue that existing approaches give up at least one of the three. Natural language is versatile and portable but costly, because a model has to read and write every message. Fixed, human-written protocols are efficient but take human effort to design and implement.

Agora mixes the two by frequency:

• Frequent exchanges use standardized, human-written routines, such as an existing API.
• Moderately frequent exchanges use structured messages handled by routines that the language models write themselves.
• Rare exchanges, and fallbacks when something fails, use natural language.

The unit of agreement is a protocol document: a plain-text description of a message format and its meaning, identified by its SHA1 hash. An Agora message carries three fields, per Appendix B of the paper. Illustrative:

{
  "protocolHash": "5d41402abc4b2a76b9719d911017c592aa0f1d3e",
  "protocolSources": ["https://agents.example.com/protocols/pallet-quote.txt"],
  "body": "{\"origin\": \"Toronto, ON\", \"destination\": \"Chicago, IL\", \"pallets\": 40}"
}

The body is a string formatted as the protocol document specifies. A null protocolHash means the body is natural language. A receiver that does not know the hash downloads the document from one of the protocolSources, checks that the hash matches, and caches it.

When two agents talk often, they can negotiate a new protocol. They discuss a format in natural language until both accept it, then each writes a routine for its own side. Protocol documents can reference other documents, so agents can build on earlier agreements. The paper leaves transport, identity and security out of the protocol; the reference implementation sends JSON over HTTPS.

What A2A is for

A2A defines the same operations for every agent: SendMessage, SendStreamingMessage, GetTask, ListTasks, CancelTask, SubscribeToTask, push notification configuration and GetExtendedAgentCard. Messages are made of parts: text, files, or structured data with a media type. The receiving agent turns a message into a task with a lifecycle, and returns results as artifacts.

What varies between A2A agents is described in the Agent Card: skills in natural language with tags and examples, accepted input and output media types, and the security schemes a client must use. For anything the core leaves out, A2A has extensions. An agent lists extension URIs in its card’s capabilities.extensions, and a client opts in per request, for example with the A2A-Extensions HTTP header.

Side by side

	Agora	A2A
Purpose	Let LLM agents agree on message formats at run time and move common exchanges from natural language to code	Give independent agents one shared protocol for delegating and tracking tasks
Layer	Meta-protocol above whatever messages agents exchange	Application protocol with a fixed data model
Who talks to whom	Any two agents in a decentralized network, with no central authority	A client agent and a remote agent that publishes an Agent Card
Transport	Out of scope in the paper; the reference implementation uses JSON over HTTPS	JSON-RPC 2.0, gRPC or HTTP+JSON; Server-Sent Events; webhook push
Discovery	Protocol documents fetched from URIs and identified by hash; agent discovery not specified	Agent Card at /.well-known/agent-card.json, registries or direct configuration
Auth	Out of scope	Declared in the card: API key, HTTP auth, OAuth 2.0, OpenID Connect, mutual TLS; optional signed cards
State	Each negotiated protocol defines its own	Tasks with defined states; contextId across related tasks
Governance and status	Research proposal (arXiv, October 2024); Python library in open beta; no commits since March 2025	Linux Foundation project; version 1.0

When to use A2A

Use A2A when agents from different organizations need to interoperate now, with predictable behaviour on both sides. A fixed protocol means a client written against the specification works with any conforming server, and security reviewers can reason about a known set of operations. It also fits regulated or high-stakes exchanges, where you want every message to follow a schema that someone reviewed.

When Agora’s ideas fit

Agora is worth reading if you run many LLM agents that talk to each other at volume and you control both sides. Its central observation holds whatever protocol you use: natural language is a good way to start a conversation between agents and an expensive way to repeat one. Treat it as research to learn from. The library is in beta, the project is not under active public development, and self-written routines raise review questions that production systems have to answer.

Using both

Agora’s pattern can run inside A2A without changing either:

1. Two agents start with A2A text parts, which is natural language inside a standard envelope.
2. When an exchange repeats, they agree on a JSON format and switch to data parts with a mediaType and an agreed structure.
3. To make the agreement explicit, one side can publish an A2A extension whose URI names the format, and both sides declare it.

This keeps A2A’s discovery, authentication, task lifecycle and bindings, and borrows Agora’s move from language to structure. The negotiation step itself is not specified by A2A, so anything that writes or accepts new formats automatically needs the same review as any other code change.

Common misconceptions

“Agora competes with A2A as a standard.” Agora was published as a research proposal and has no governance body. A2A is a Linux Foundation project with released versions. They answer different questions.

“A2A cannot handle open-ended requests.” Text parts carry natural language, and skills are described in prose. A2A fixes the envelope and the task model. What agents say inside them is up to the agents.

“Negotiated protocols remove the need for security.” The paper leaves identity and security out of scope. Agents using Agora-style negotiation still need authentication, authorization and review of any generated code.

“A protocol hash proves who wrote the protocol.” A SHA1 hash lets a receiver confirm it fetched the document the sender meant. It says nothing about who wrote it or whether its routines are safe to run.