Google Just Admitted What Enterprise Already Knew: Agents Are Software
The AI agent hype cycle has been dominated by a seductive promise: anyone can build an agent, no coding required. Just describe what you want in natural language, wire up a few prompts, and watch your autonomous digital workforce spring to life. Gartner predicts over 40% of agentic AI projects will be cancelled by 2027 due to rising costs, unclear business value, or weak risk controls. In 2025, only 2% of organisations deployed AI agents at scale. The bottleneck was never ideas. It was getting pilots into production.
Google just placed a very different bet.
With the open-sourcing of their Agent Development Kit (ADK)—the same framework powering Google's own Agentspace and Customer Engagement Suite—they've made a clear architectural statement: serious agent deployments need real software engineering. Code-first development. Version control. Testing. CI/CD. The boring stuff that actually makes things work in production.
Since launching at Google Cloud NEXT in April 2025, ADK has accumulated over 15,000 GitHub stars, expanded from Python to TypeScript, Go, and Java, ships bi-weekly releases, and ran a community hackathon that drew over 10,000 participants. This isn't a press release framework. It's a living codebase with velocity.
And for anyone leading AI transformation in the enterprise, the implications are significant.
The "Agents Are Software" Thesis
ADK's core philosophy is quietly devastating to the no-code agent narrative. Instead of abstracting away the engineering, it leans into it.
Code-first development across Python, Java, TypeScript, and Go. Not YAML configs, not visual drag-and-drop. Event-driven runtime instead of request-response—agents maintain state, process events, and orchestrate tools as a continuous loop. Native version control, testing, and CI/CD—your agent pipelines get the same engineering discipline as your application code. Built-in evaluation frameworks that systematically assess both final output quality and step-by-step execution trajectories.
No-code agent builders get you speed, templates, and SaaS connectors. But as anyone who's tried to take a Zapier automation or a Copilot Studio agent into production-grade deployment knows, they rarely go deep on semantic mapping, error handling, or observability. They don't ship the primitives you need for identity propagation, policy guardrails, or production-grade debugging. The gap between a working demo and a reliable production system is where projects die.
Google's message is unmistakable: if you're building agents that handle customer resolutions, manage supply chains, or process financial transactions, you need the same engineering rigour you'd apply to any mission-critical software.
Clean Primitives, Composable Architecture
What caught my attention technically is how ADK structures the agent hierarchy. The primitives are deliberately simple.
LlmAgent handles reasoning—your LLM-powered brain that understands context, plans, and decides. SequentialAgent, ParallelAgent, and LoopAgent provide deterministic workflow orchestration when you need predictable pipelines. AgentTool lets you compose agents as tools inside other agents, enabling modular, hierarchical architectures.
Then there's LLM-driven routing for dynamic task delegation—the system decides at runtime which specialist agent should handle a particular request. Think of a customer service scenario: an incoming request gets intelligently routed to a billing agent, a technical support agent, or an escalation agent based on real-time context analysis. No hardcoded routing rules. No decision trees. The LLM orchestrates.
This composability matters because enterprise problems are never single-agent problems. They're multi-agent coordination problems, and ADK was designed from the ground up to handle that complexity.
The Standards War That Isn't: A2A, MCP, and the AAIF
Here's where the enterprise story gets really compelling—and more nuanced than most coverage suggests.
ADK supports both the Model Context Protocol (MCP) for connecting agents to tools and data sources, and Google's own Agent2Agent (A2A) protocol for agent-to-agent communication across services. The distinction is critical: MCP standardises how agents talk to tools. A2A standardises how agents talk to each other.
Both protocols are now under Linux Foundation governance. A2A was donated in June 2025 with backing from over 100 technology companies—AWS, Salesforce, SAP, ServiceNow, Microsoft, and Cisco among them. IBM's competing Agent Communication Protocol (ACP) has since merged into A2A, consolidating the agent-to-agent communication standard.
Then in December 2025, OpenAI, Anthropic, and Block co-founded the Agentic AI Foundation (AAIF), also under the Linux Foundation. Anthropic donated MCP. OpenAI contributed AGENTS.md (now adopted by over 60,000 open-source projects). Block brought its Goose agent framework. Platinum members include AWS, Google, Microsoft, Bloomberg, and Cloudflare.
The emerging stack is becoming visible: MCP for agent-to-tool connectivity, A2A for agent-to-agent communication, AGENTS.md for project-specific agent instructions. And in August 2025, Solo.io donated agentgateway to the Linux Foundation—a purpose-built proxy for securing and governing A2A and MCP traffic, with early contributions from AWS, Microsoft, Red Hat, IBM, Shell, and Cisco.
In practice, this means your customer-facing resolution agent can delegate to a backend inventory agent, which coordinates with a supplier's logistics agent—all through standardised protocols, regardless of whether those agents are built on ADK, LangGraph, CrewAI, or custom frameworks.
For enterprises running heterogeneous IT landscapes (which is all of them), this interoperability isn't a nice-to-have. It's the prerequisite for any serious multi-agent deployment.
The Contrarian Case: Why Comprehensive Beats Simple
There's a healthy debate about whether Google's comprehensive approach will win against simpler, grassroots alternatives. MCP gained rapid developer adoption precisely because it started simple and evolved incrementally. A2A, despite impressive corporate backing, hasn't yet reached a production-ready specification. Some observers note the relationship between A2A under its own Linux Foundation project and the AAIF isn't fully resolved—will they converge or compete?
But I'd argue that's the wrong frame for enterprise buyers.
CTOs don't want to discover governance gaps in production. They don't want to retrofit observability after an agent makes a costly mistake. They don't want three competing agent-to-agent protocols when they need one that works. The reason Solo.io built agentgateway from scratch in Rust rather than retrofitting Envoy is telling—existing API gateways simply weren't designed for agent protocols.
Enterprise contexts reward comprehensive, boring, well-engineered foundations. The no-code platforms that dominate "Top 10 Agent Builder" listicles are solving a different problem—fast prototyping, departmental automation, internal copilots. Important work, but a different category entirely from production multi-agent orchestration across business functions.
ADK is aimed squarely at the latter. And so is the emerging standards infrastructure around it.
What This Means for Enterprise AI Strategy
If you're leading AI transformation, ADK's release—combined with the rapid institutional consolidation around A2A, MCP, and the AAIF—signals three things worth internalising.
First, the "agents are easy" narrative is maturing. The industry is moving past the demo phase into the production phase. Production requires engineering discipline, observability, testing, and governance. ADK's architecture reflects these realities rather than hiding from them. The 40%+ cancellation rate Gartner predicts isn't about technology failure—it's about organisations treating agent deployment as a prompt engineering exercise when it's actually a systems engineering challenge.
Second, multi-agent orchestration is the real game. Single-purpose chatbots are table stakes. The competitive advantage comes from orchestrating specialised agents that collaborate across business functions. A customer service agent that doesn't just answer questions but triggers inventory checks, initiates returns, coordinates with logistics, and updates CRM records—all through composable, auditable agent pipelines—creates compound value that no single-agent solution can match. ADK's composable architecture and protocol support make this architecturally feasible.
Third, interoperability standards are consolidating faster than expected—engage now. Twelve months ago, A2A and MCP were competing visions from rival labs. Today they're complementary protocols under shared governance, backed by every major cloud provider and enterprise software vendor. Companies that participate in shaping these standards—rather than waiting for them to solidify—will have a meaningful advantage in how their agent ecosystems integrate with partners, suppliers, and customers.
The Bottom Line
Whether ADK becomes the dominant agent framework matters less than the architectural patterns it validates: code-first development, event-driven orchestration, composable multi-agent systems, and standardised inter-agent communication.
Those patterns are the future of enterprise AI. The specific framework is a choice. The engineering discipline is not.
Links:
