A GitHub code search for the Agent2Agent (A2A) protocol’s own discovery file turns up 634 public repositories, and one person’s GitHub account owns 371 of them: 58.5%. That number is the point of this post, and it sits awkwardly next to the framing from A2A’s one-year anniversary announcement under Linux Foundation governance on 2026-04-09 , which cites 150+ supporting organizations and “active production deployments” across supply chain, financial services, insurance, and IT operations. We built themsquared/a2a-inventory-demo to check that claim against the one artifact A2A itself requires every agent to publish, and this is what it found.
The claim we can’t check from outside
The Linux Foundation’s announcement is specific about some things and vague about others. It names real integrations: Google, Microsoft, and AWS platforms, deep enough to matter. It doesn’t say how many of the 150+ organizations are running A2A in production versus sponsoring the spec, attending working group calls, or shipping a client library nobody uses yet. “Production-ready” is the project’s own label for the protocol, not a count of production deployments. None of that makes the claim false. It makes it unfalsifiable from outside the foundation and its member companies, which is exactly the gap a public GitHub scan can partially fill.
The skeptics aren’t just shrugging either. An Ask HN thread titled “Is anyone using the A2A protocol?” got 92 points, and its top reply says the poster evaluated A2A and rejected it because it assumes agents have a well-defined identity, which they argue agents don’t inherently have, and that the protocol’s gRPC transport adds indirection on top of a problem that didn’t need it. A reply underneath pushes back with a narrower read: most teams right now are building MCP servers for coding agents and chatbots, not agents that need to talk to other agents at all, so thin A2A adoption might reflect a market that hasn’t arrived yet rather than a flawed protocol. Both of those are judgment calls about demand and design. We went looking for something we could count instead.
What we actually measured
A2A agents are supposed to be discoverable. The spec has every agent publish a JSON “agent card” describing its name, skills, and how to reach it, served at a fixed, spec-defined URI: /.well-known/agent-card.json under the current spec, or /.well-known/agent.json under the pre-Linux-Foundation naming still used by anything built against the earlier version. Because the file only does its job if it’s publicly fetchable, a project that commits one to a public repo is telling you, structurally, that it built something meant to be found by other agents. That’s a narrower claim than “this is in production,” but it’s a real one, and it’s the same signal regardless of which vendor is doing the counting.
scripts/scan.py in the repo queries GitHub’s code search API for both filenames, paginates up to the API’s 1,000-result cap per query, dedupes by repository, and reports who owns them:
git clone https://github.com/themsquared/a2a-inventory-demo
cd a2a-inventory-demo
export GITHUB_TOKEN=$(gh auth token) # any no-scope PAT works; code search requires auth
python3 scripts/scan.py
That’s the whole quickstart. No dependencies beyond Python 3.9+ and a token: the script uses urllib from the standard library, not a GitHub SDK, so there’s nothing to pip install.
What it found
Run on 2026-10-16: 634 deduped repositories publish one of the two agent card files, owned by 247 distinct GitHub accounts.
One account owns 371 of them. 58.5%. CSOAI-ORG is a single person’s user account, not an organization despite the name, belonging to Nicholas Templeman, who runs something called Council of AI (CSOAI Ltd) out of London. The account has mass-produced hundreds of near-identical single-tool repos, gdpr-compliance-ai-mcp, recipe-finder-ai-mcp, iso-27001-ai-mcp, date-calculator-ai-mcp, dozens more, each wrapping one MCP tool behind a templated agent card that points back to mcp.meok.ai. Here’s the actual card from iso-27001-ai-mcp:
{
"name": "Iso 27001 Ai Mcp",
"version": "1.0.10",
"url": "https://mcp.meok.ai/iso-27001-ai-mcp/a2a",
"protocolVersion": "0.3.0",
"description": "AI-powered iso 27001 ai MCP server for agents. Supports audit isms, risk assessment, gap analysis. By MEOK AI Labs.",
"provider": {
"organization": "MEOK AI LABS",
"url": "https://meok.ai"
}
}
Swap the name, the slug, and the three skill words, and that’s the template behind most of the 371. We didn’t probe mcp.meok.ai itself; whether any of these 371 endpoints serve real traffic is a separate question from what this scan measures, which is the shape of the public evidence, not what happens behind each URL.
After that one account, adoption falls off fast. The next-largest is inference-gateway, a small real open-source LLM gateway project, with 6 example agent repos. Every other account in the top 10 has 2 to 4. The long tail below that, roughly 240 accounts, is personal sites, course exercises (gilbertsahumada/erc8004-course), hackathon projects, and one-off experiments. We checked for the names a 2025-era A2A launch roundup would cite, Salesforce, Box, MongoDB, PayPal, Atlassian, and found none of them publishing their own public agent card.
What this does and doesn’t prove
This is not evidence that A2A has no real users. A company running A2A between internal services has no reason to publish a public agent card at all, and the biggest deployments the Linux Foundation’s announcement gestures at are exactly the kind that would stay internal. A public GitHub scan is structurally blind to private production traffic, full stop.
What it does show: the one slice of A2A adoption that’s independently observable from outside any vendor’s own numbers is dominated, by a wide margin, by one person’s templated content operation, and the organic remainder looks like typical early-protocol hobbyist activity rather than the broad enterprise base the anniversary framing implies. “150+ organizations support a standard” and “a search for people actually building on it finds mostly one account and a long tail of side projects” can both be true at the same time, because they’re measuring different things. The honest finding here is the gap between them, not a verdict that the protocol is dead.
GitHub’s code search also isn’t exhaustive. It has known indexing lag, the 1,000-result cap means our two queries (634 deduped results after a 403 from a secondary rate limit trimmed the second query short) are a floor, not a ceiling, and any agent that serves its card from a live URL without ever committing it to a repo doesn’t show up here at all.
Where this sits next to MCP and agentgateway
A2A and MCP solve different problems: MCP connects an agent to tools, A2A connects one agent to another. agentgateway treats both as traffic it can see, authorize, and route, marking a route as A2A with a single policy field and proxying it to a backend agent the same way it fronts MCP tool calls. That capability is real and shipped, and it’s orthogonal to this post. A gateway supporting a protocol says nothing about how many independent teams are using that protocol, which is the question we were actually trying to answer. For more on where A2A fits among the protocols an agent-aware gateway has to understand, see What Is an Agentic Mesh (vs a Service Mesh)? .
Check our number, not just our word
CSOAI-ORG’s 58.5% share is exactly the kind of figure that moves as repos get created and deleted, so re-run the scan before citing it anywhere, including from this post. If that share drops because independent teams start publishing their own agent cards, that is itself the signal of real adoption this post couldn’t find. And if you’re one of the 150+ organizations the Linux Foundation counts and you’re genuinely running A2A in production, we’d like to know what that deployment looks like, because a public GitHub scan structurally can’t see it.