Agent2agent

What it is

Agent2Agent (A2A) is an open protocol for communication and interoperability between agentic applications that don't share internal implementation details — "opaque" agents built on different frameworks, by different teams, possibly running on different vendors' infrastructure. Instead of every agent framework inventing its own bespoke RPC format, A2A defines a common wire protocol so a LangGraph agent, a CrewAI agent, and something running on a proprietary stack can discover each other's capabilities, negotiate tasks, and exchange results without one side needing to know how the other is built internally.

It's a protocol spec plus reference tooling, not a runtime or orchestration engine. You still bring your own agents; A2A just standardizes how they talk.

Who builds it and why

148 contributors and a Shell-dominant repo (glue scripts, examples, CI) suggest this is driven by a broad coalition rather than a single vendor's SDK team, consistent with how it's been positioned publicly — as a cross-industry effort (Google was the original driver, joined by a long list of enterprise and tooling partners) to prevent agent interoperability from fragmenting into incompatible silos the way early IoT or messaging protocols did. The motivation is straightforward: as agentic apps proliferate, someone has to own the "how do two agents from different vendors negotiate a task" problem before every platform ships a mutually incompatible answer.

CNCF maturity status: not publicly available — treat this as living outside the CNCF maturity ladder for now, or check current CNCF Sandbox/Incubating listings directly before assuming a level.

Production readiness signal

• 24,568 GitHub stars and 148 contributors indicate real community traction, not a weekend side project.
• Last commit 2026-07-01 — actively maintained, not abandoned.
• Latest tagged release is v1.0.1 — past the initial 1.0 milestone, with a patch release already shipped, which is a reasonable signal of post-launch stabilization.
• Apache-2.0 licensing removes legal friction for commercial adoption.
• Founding date not publicly available, and CNCF maturity not publicly available — worth confirming directly with the project before betting critical infrastructure on its governance stability.

Net: healthy open-source signals, but as a protocol (not a battle-tested runtime), production risk depends heavily on how mature the specific SDK/implementation you adopt is, not just the spec's popularity.

Who should use this

• Teams building multi-agent systems that span more than one framework or vendor and need agents to discover and invoke each other without hard-coding integrations.
• Platform teams building an internal "agent mesh" who want a standard instead of maintaining N×N custom adapters between agent frameworks.
• Vendors and SaaS platforms who want their agents to interoperate with customers' or partners' agents without exposing internal implementation.

Who should NOT use this

• Teams with a single-agent, single-framework setup — A2A solves an interoperability problem you don't have yet, and adds protocol overhead for no benefit.
• Anyone needing a fully managed, batteries-included orchestration platform — A2A is a communication protocol, not a scheduler, memory store, or agent runtime.
• Latency-critical, tightly-coupled internal agent pipelines where you control both ends — a direct function call or internal RPC will be simpler and faster than protocol-level negotiation.
• Teams uncomfortable with early-stage governance uncertainty — with CNCF maturity and founding history not publicly documented, you're taking on some unknowns about long-term stewardship.

Alternatives

• MCP (Model Context Protocol) — solves a different but adjacent problem: connecting agents to tools/data sources rather than agent-to-agent task negotiation; often used alongside A2A, not instead of it.
• Custom internal APIs/gRPC contracts — fine if you fully control both sides of every integration and don't need cross-vendor interoperability.
• Vendor-specific agent orchestration frameworks (e.g., proprietary multi-agent platforms) — tighter integration within one ecosystem, at the cost of lock-in and no cross-vendor interoperability.

Pricing

Fully open source under Apache-2.0. No licensing cost for the protocol or reference implementations. Your actual cost is engineering time to implement/adopt an A2A-compliant SDK and whatever compute/infra you run agents on.