Google ADK Agents in Five Languages: MCP and A2A Setup Explained

Google’s latest Agent Development Kit update expands the framework across Python, Go, TypeScript, Java and Kotlin, giving teams a broader choice of language for building production-oriented AI agents. The October 14, 2026 announcement describes separate runtime implementations built around a shared architecture. That matters for organizations that want language-specific services without isolating their agents from one another.

The practical hook is the combination of two interoperability layers: the Model Context Protocol (MCP) for connecting agents to tools, and Agent2Agent (A2A) for coordinating work between agents over HTTP. Together, they make Google ADK agents in five languages with MCP and A2A setup a cross-language architecture question, rather than simply a framework installation exercise.

Area	Confirmed update	Important qualification
ADK runtimes	Python, Go, TypeScript, Java and Kotlin	Each language has its own implementation
MCP	All five runtimes include an MCP client	Tool compatibility should be tested in the chosen runtime
A2A	HTTP-based communication across languages or frameworks	Documented support and maturity vary by runtime
Deployment example	Cloud Run, Gemini Enterprise Agent Runtime or GKE	Cloud usage costs depend on the selected products and workload

What the five-language ADK release changes

Google’s documentation provides getting-started paths for all five languages. The setup flow can begin with uvx google-agents-cli setup, which checks authentication, installs the command-line tool and adds ADK skills to supported coding agents. Developers can then scaffold an agent project and target a Google-managed or Kubernetes-based deployment path.

For teams evaluating AI development services, the key decision is not only which language is most familiar. It is whether the selected runtime offers the integrations, testing, authentication, monitoring and deployment support the application requires.

How MCP and A2A fit into the setup

MCP and A2A solve different problems, so teams should design around their boundaries. An MCP client lets an ADK agent discover or invoke tools exposed by an MCP server, such as a document system, database service or business workflow. A2A operates at the agent boundary: one agent publishes an Agent Card describing its identity and capabilities, while another agent can send work through the protocol over HTTP. Google’s cross-language tutorial shows Python and Go agents collaborating with JSON-RPC 2.0.

That separation can make a larger system easier to evolve. A customer-facing TypeScript agent might delegate a specialist task to a Java or Python service, while the specialist uses MCP to reach its approved tools. Authentication, authorization, input validation and audit logging still belong in the application architecture; protocol support does not remove those responsibilities.

A practical implementation path

1. Choose the runtime. Start with the language that matches the team’s existing services and operational expertise, then verify the current documentation for the integrations required by the project.
2. Install and scaffold. Run uvx google-agents-cli setup in the supported development environment, complete authentication and create a small agent before adding production tools.
3. Connect tools through MCP. Define narrow tool permissions, validate returned data and test failure behavior before allowing an agent to affect business systems.
4. Add A2A selectively. Publish only the capabilities another agent needs, document the expected inputs and outputs, and test retries, timeouts and unavailable-agent responses.
5. Evaluate deployment. The documented scaffold can target Cloud Run, Gemini Enterprise Agent Runtime or GKE. Compare those options against data residency, observability, scaling and cost requirements.

Feature parity should remain a formal checkpoint. The A2A documentation reviewed for this update lists Python, Go and Java support with an Experimental label, while the announcement covers five ADK languages. Teams using TypeScript or Kotlin should therefore confirm protocol libraries, examples and deployment guidance before committing to a cross-language design. A focused project consultation can help map those requirements into a testable delivery plan.

Testing cross-language agent workflows

A working prototype is only the first checkpoint for Google ADK agents in five languages with MCP and A2A setup. Before production deployment, test each boundary independently. An MCP test should confirm that the agent can discover the intended server, receive a correctly shaped response and handle permission failures without inventing a result. An A2A test should verify Agent Card discovery, request validation, JSON-RPC 2.0 responses, timeouts and retry behavior.

Teams should also test the complete workflow with realistic but controlled data. Measure how long tool calls and delegated tasks take, identify where context is lost, and record which agent made each decision. Human approval remains important for actions such as sending messages, changing records, approving transactions or publishing customer-facing content. These controls are especially valuable when several agents can call tools or delegate work in sequence.

Operational checks before launch

• Authentication: Confirm service identities, credential rotation and least-privilege access for every MCP server and A2A endpoint.
• Observability: Capture request IDs, tool calls, delegation paths, latency, errors and model outputs in a privacy-conscious logging system.
• Availability: Define behavior for unavailable tools, unreachable agents, partial responses and repeated requests.
• Data handling: Review what information crosses service boundaries and whether retention, residency or redaction requirements apply.

The five-language model is most useful when it supports an existing engineering strategy. A Go service may remain responsible for a high-throughput workflow, while a Python specialist handles a data task and an MCP server limits access to approved systems. Teams can document that architecture through a structured project consultation service, then turn the design into runtime-specific tests and deployment criteria.

Because protocol support can change independently of the announcement, record the documentation version and library versions used during evaluation. Recheck A2A guidance for TypeScript and Kotlin before release, and treat experimental support as a reason for additional testing rather than as a production guarantee.

Where the five-language approach fits

Google ADK agents in five languages with MCP and A2A setup are most practical when an organisation already operates services in more than one language. A team does not need to rewrite every component around a single runtime. Instead, it can assign each agent to the environment best suited to its existing libraries, deployment processes and operational skills, then connect capabilities through documented protocols.

That flexibility should be balanced against integration overhead. Every additional runtime can introduce differences in configuration, dependency management, testing conventions and telemetry. Before adopting a mixed-language architecture, define which responsibilities belong to each agent and which data may cross the boundary. A focused application development service can support that analysis when the workflow spans customer-facing apps, internal systems and external APIs.

Questions to answer before choosing a runtime

• Which language is already operationally mature? Existing deployment templates, monitoring and incident procedures may matter more than a new framework feature.
• Which integrations are essential? Confirm MCP client behavior, available server libraries and the authentication method required by each tool.
• Where is delegation necessary? Use A2A when a separate agent owns a meaningful capability, not merely to divide a simple prompt into smaller calls.
• What happens when a dependency changes? Record protocol versions, runtime versions and fallback behavior so upgrades can be evaluated deliberately.

Pricing also requires careful separation. The reviewed announcement describes ADK as open source and does not identify a separate ADK license or price. That does not make a complete agent system cost-free: model usage, hosting, storage, networking, monitoring and third-party services may all create expenses. Cloud Run, Gemini Enterprise Agent Runtime and GKE should therefore be compared using the expected request volume, latency targets, security controls and operational workload.

Finally, treat the October 2026 announcement as a capability milestone, not a guarantee that every runtime has identical production readiness. Build a small cross-language proof of concept, verify the required MCP and A2A paths, and preserve evidence from tests before expanding the architecture.

Designing a safer cross-language workflow

The most reliable implementation starts with a narrow responsibility for each agent. Define the task it owns, the tools it may call and the information it is allowed to return. MCP can expose approved tools to an agent, while A2A can connect that agent to another specialist through a documented service boundary. This separation makes failures easier to isolate and helps teams review permissions before expanding the workflow.

For example, a customer-support agent could handle the conversation, an internal service could retrieve account information through MCP, and a separate policy agent could review an escalation through A2A. Each step should have an explicit input and output contract. Avoid passing unnecessary customer data between services, and require confirmation before an agent performs an irreversible action.

Testing MCP and A2A in practice

Before production deployment, test each protocol independently and then test the full sequence. An MCP test should verify server discovery, response validation and permission-denied behavior. An A2A test should check Agent Card discovery, JSON-RPC 2.0 validation, timeouts, retries and clear error reporting.

Use controlled data to measure latency, context loss and failure recovery. Record request IDs, tool calls and delegation paths so an operator can reconstruct what happened. Human approval remains appropriate for actions such as changing records, approving transactions or publishing customer-facing content.

Operational decisions before launch

• Identity: Assign least-privilege credentials to every MCP server and A2A endpoint.
• Monitoring: Track latency, errors, retries and model outputs without retaining unnecessary sensitive data.
• Fallbacks: Define behavior when a tool, agent or deployment region is unavailable.
• Versioning: Record runtime, library and protocol versions used in evaluation.

Teams building a mixed-language proof of concept may benefit from an application development service when the workflow spans internal systems, customer-facing applications and external APIs. The key is to validate the exact runtime combination before committing to a larger architecture, especially where A2A support remains experimental or documentation is still evolving.

What Google ADK agents in five languages mean for teams

Google ADK agents in five languages with MCP and A2A setup give engineering teams a practical way to combine language-specific services without forcing every component into one stack. Python, Go, TypeScript, Java and Kotlin now share the ADK architecture, but the implementations and surrounding documentation should still be evaluated separately.

The safest rollout is incremental. Start with one useful agent, one approved MCP tool and a clearly bounded task. Then test delegation to a second agent through A2A using representative inputs, deliberate failures and realistic authentication. This approach exposes protocol or runtime gaps before they become architectural dependencies.

Key takeaways

• ADK supports five programming languages, but feature maturity may differ between runtimes.
• MCP is suited to exposing tools, while A2A is suited to communication between independently managed agents.
• The documented setup command can help configure the CLI and supported coding-agent integrations, but teams should verify its behavior in their own environment.
• Cloud Run, Gemini Enterprise Agent Runtime and GKE are deployment examples, not a universal recommendation.
• Open-source availability does not remove costs associated with models, hosting, monitoring, networking or data storage.

For developers, the announcement lowers the barrier to experimenting with cross-language agent systems. For businesses, its value depends on disciplined boundaries: clear ownership, least-privilege access, observable workflows and human review for consequential actions.