Google's A2A Just De-Risked Building Your Own Enterprise AI Agents

Custom AI agent development for enterprise means building autonomous systems tailored to your workflows, data, and rules rather than renting a fixed SaaS tool. Thanks to open protocols like MCP and Google’s A2A — now governed together under the Linux Foundation’s Agentic AI Foundation — a custom-built agent can interoperate across vendors without lock-in, which changes the build-versus-buy math.

For two years the biggest argument against building your own agents was isolation: pour money into a bespoke system and risk stranding it on a proprietary island the moment a vendor changed direction. That argument is weakening fast. When Google’s Agent2Agent Protocol (A2A) joined the Agentic AI Foundation (AAIF) as its fifth hosted project — alongside Model Context Protocol (MCP), goose, Agents.md and agentgateway — it put the coordination layer between independent agents under the same neutral governance as the connection layer beneath them. For a buyer weighing a custom build, that is not a technical footnote. It resets the risk calculation.

Why ‘what’s the ROI on our agentic AI?’ is really five questions

The question every executive asks — “what’s the ROI on our agentic AI?” — collapses several distinct decisions into one. It’s really asking: which process are we automating, how much does building it cost, how long until it’s in production, what happens to that investment if the vendor ecosystem shifts, and who’s accountable when the agent gets something wrong. Treating those as a single ROI number is how projects stall. AAIF Executive Director Mazin Gilbert frames the accountability piece bluntly: agents will make mistakes and hallucinate, and the liability sits with “the consumer, the enterprise” — never the agent itself. A useful ROI conversation separates the five and answers each. The lock-in question, which used to have no good answer for custom builds, now does.

What A2A joining the Agentic AI Foundation actually changes

MCP and A2A solve different problems, and understanding the split is what makes the architecture decision clear. MCP is how a single agent reaches the outside tools, APIs, databases and files it needs — without it, in Gilbert’s words, an agent is “dumb.” Anthropic’s adoption figures cited by the foundation put MCP at around half a billion downloads a month. A2A is the layer that lets your agent discover and securely transact with an agent you don’t control — a merchant’s system, a bank’s, a partner’s. Gilbert’s example: your agents needing to talk to Safeway’s or Marks and Spencer’s agents, systems with their own security and their own agenda. Housing both specifications under one governance family means the plumbing your custom agent depends on evolves in a coordinated, neutral way rather than at a single vendor’s whim.

How open protocols remove the lock-in risk from building

The old build-versus-buy tradeoff was ownership versus safety. Build, and you own the logic but gamble on the ecosystem. Buy, and you’re safe but stuck with someone else’s roadmap. Open, foundation-governed protocols dissolve the middle of that tradeoff. A custom agent built to speak MCP and A2A can swap underlying models, connect to tools it wasn’t originally designed for, and hand work to external agents across vendor boundaries — because the interfaces are standardized and stewarded independently. The membership rolls are the evidence: on August 13th the AAIF added 57 new members including Visa, Wells Fargo and Alibaba, four days before the A2A announcement. When the institutions that hate lock-in most — banks and payment networks — commit to the standard, the interoperability bet is no longer speculative. If you’ve been holding off on a custom build purely over vendor risk, that specific objection has largely expired.

What a standards-based custom agent architecture looks like

In practice, a defensible custom architecture has three layers you can reason about separately. Your agent connects to your systems — CRM, data warehouse, internal APIs — through MCP, which, since its July 28th revision, runs statelessly behind conventional load balancers and Kubernetes, with an OAuth hardening pass and a formal 12-month deprecation guarantee. That connective tissue is the same enterprise integration and API work that already underpins reliable software. Above it sits your custom agent logic — the guardrails, the human oversight, the business rules only you know. A2A sits at the edge, letting your agent transact with external agents securely. The APAC market has already built this shape: Huawei standardized A2A between Celia, its OS-level assistant, and in-app agents across Harmony OS, and Tencent’s WeChat runs message, voice and video calls initiated through AI assistants with dual authorization over the protocol. Gilbert expects the pattern to reach the US and Europe and go mainstream “within three years.”

Build vs. buy: when to build a custom agent and when not to

Buy an off-the-shelf tool when the process is generic, the data isn’t sensitive, and speed to a working demo matters more than fit — customer FAQ deflection, meeting notes, standard content drafting. Build custom when the agent touches proprietary workflows, regulated data, or a competitive edge you can’t outsource to a shared vendor model. Simply put, if switching tools next year would cost you nothing, buy; if the agent will hold your logic, your liability, and your differentiation, build it on open protocols and own the outcome without owning the lock-in. Our even-handed comparison of custom AI versus SaaS AI walks through cost of change, launch time, and what breaks first in each. Don’t build when you lack the data to make the agent better than a generic one — that’s spending custom-build money for off-the-shelf results.

Questions to ask any AI agent development partner

Before committing budget, press any partner on five points. Does the architecture speak MCP and A2A, or a proprietary format that traps you? Where do the guardrails, auditability and traceability live — the AAIF has stood up eight working groups including Identity & Trust and Observability & Traceability precisely because these primitives don’t yet have industry-wide answers. Who is accountable when the agent errs, and how is that logged? What’s the day-two operations plan for running at scale, not just the pilot? And what does the deprecation path look like if a model or protocol changes? A partner who can answer all five is thinking about production, not a demo.

From strategy to production: what a scoped build takes

A scoped custom agent build starts with picking one process with a measurable cost, wiring the MCP connections to your systems, encoding the business rules and guardrails, then hardening for reliability before A2A-based external handoffs come into play. Gilbert names the two areas the AAIF itself is focused on over the next six to twelve months — scale and trust — and those are exactly the two that separate a pilot from something an enterprise can stand behind. Start narrow, prove the ROI on one workflow, then expand. The interoperability standards mean the second and third agents cost less to add than the first.

A2A is early — backed by around 150 organizations and still maturing its trust-and-scale working groups — but the governance shape is already in place, and we expect the financial sector’s early commitment to pull Western enterprise adoption forward faster than the three-year timeline suggests.

FAQ

Q: What is custom AI agent development for enterprise? A: It’s building autonomous AI systems tailored to a specific organization’s workflows, data, security rules and accountability requirements, rather than adopting a fixed off-the-shelf tool. Built on open protocols like MCP and A2A, these agents connect to internal systems and can interoperate with external agents across vendor boundaries.

Q: What’s the difference between MCP and A2A? A: MCP (Model Context Protocol) is how a single agent connects to the tools, APIs, databases and files it needs to do its job. A2A (Agent2Agent Protocol) lets independent agents — ones you don’t control, like a merchant’s or bank’s — discover each other and transact securely. Both are now governed under the Agentic AI Foundation.

Q: Does building a custom AI agent create vendor lock-in? A: Far less than it used to. Because MCP and A2A are open specifications stewarded by the Linux Foundation’s Agentic AI Foundation with neutral governance, a custom agent built to those standards can swap models and connect across vendors. The July 28th MCP revision even added a formal 12-month deprecation guarantee.

Key Takeaways

• The lock-in objection to custom agents has largely expired — build on MCP and A2A and you own the logic without being trapped in one vendor’s ecosystem.
• Break your ROI question into five: which process, what cost, what timeline, what happens if the ecosystem shifts, and who’s accountable for errors.
• Watch financial-sector adoption — Visa and Wells Fargo joining the AAIF signals the interoperability bet is safe enough for the institutions that fear lock-in most.
• Buy off-the-shelf for generic, low-sensitivity, easily-switched tasks; build custom when the agent holds your proprietary data, liability, or competitive edge.
• Vet any development partner on protocol support, guardrails, accountability logging, day-two scale, and deprecation paths before committing budget.
• Start with one measurable workflow — standards make the second and third agents cheaper to add. Book an AI agent architecture consultation before you scope the build.