Building Cross-Language AI Agents with Spring AI, Google ADK, and A2A A tutorial published in early October 2026 demonstrates building cross-language AI agents by pairing a Spring AI coordinator written in Java with a Google Agent Development Kit (ADK) specialist in Python, connected through the Agent2Agent (A2A) protocol rather than custom REST endpoints. The example pins google-adk[a2a]==2.9.2, a2a-sdk[http-server]==1.1.4, and Python 3.12, and keeps only two steps as model inference — the coordinator selecting the researchSupplier tool and the specialist executing its domain tool — while discovery, serialization, timeouts, and error handling stay in deterministic code. The pattern targets enterprises where Java owns customer-facing APIs, identity, and policy and Python owns model experimentation, turning each new agent integration into a configuration task instead of a custom software project. Enterprise AI rarely exists in a single language, making building cross-language AI agents https://a2a-protocol.org/latest/specification/ essential for modern architectures. Java typically manages customer-facing APIs, identity, policy, and long-running business services. Python handles model experimentation, data tooling, and specialist agent workflows. Connecting the two with bespoke REST endpoints creates an unstandardized, private protocol that both teams must continuously maintain. The Agent2Agent A2A protocol offers a more durable boundary. This article builds a Spring AI coordinator in Java that delegates supplier research to a Google Agent Development Kit ADK specialist in Python. The frameworks stay independent; the network contract becomes the integration point. A standardized agent boundary transforms each new agent integration from a custom software project into a straightforward configuration task. The primary business benefits emerge in four key areas: This integration pattern is suitable wherever a governed Java front door must invoke specialist reasoning owned by a separate team. When building cross-language AI agents https://spring.io/projects/spring-ai , the primary scenario is detailed in the first row of the table below, while the additional use cases follow an identical structure. In each case, the coordinator keeps the final decision and the human-review policy. The specialist supplies evidence, not verdicts. When a user requests a supplier assessment through the Java API, the Spring AI coordinator determines that external research is required and invokes the researchSupplier tool. The adapter reads the specialist’s Agent Card, dispatches an A2A message, and returns the result. Finally, the coordinator separates the remote findings from its own internal inference. Only two steps involve model inference: the coordinator selecting the appropriate tool, and the specialist determining how to execute its domain tool. Discovery, endpoint selection, serialization, timeouts, and error handling remain in deterministic code, preventing the model from invoking arbitrary endpoints. While a standard REST endpoint eliminates runtime coupling, development teams must still define custom semantics for discovery, task states, streaming, artifacts, and error handling. The A2A protocol standardizes these core agent concepts while maintaining abstraction over remote implementations. Consequently, Spring AI only requires knowledge of the specialist’s capabilities and endpoint location, without needing visibility into its prompts, models, or state management. The example was verified against the versions below as of early October 2026. Pin them in your build files; protocol SDKs and framework integrations move quickly. You need an API key for the model behind Spring AI and a Google API key or Google Cloud credentials for Gemini. The supplier data is a local fixture, so no third-party research API is required. The following implementation code is fully executable as presented. Install Google ADK alongside its A2A extension and pin the A2A SDK to ensure explicit transport versioning: mkdir supplier-agent && cd supplier-agentuv init --package --python 3.12uv add "google-adk a2a ==2.9.2" "a2a-sdk http-server ==1.1.4" uvicorn The underlying tool returns a deterministic fixture to allow testing of the bridge without external dependencies. The system prompt explicitly identifies this data, ensuring the model does not present demonstration fixtures as live operational research. python src/supplier agent/agent.pyfrom google.adk.agents import Agentfrom google.adk.a2a.utils.agent to a2a import to a2adef lookup supplier signals company: str, country: str - dict: """Return demonstration-only supplier signals.""" return { "company": company, "country": country, "source": "demonstration fixture", "signals": {"category": "operations", "finding": "Single regional warehouse"}, {"category": "finance", "finding": "Payment terms not verified"}, {"category": "compliance", "finding": "Human review required"}, , }root agent = Agent name="supplier research agent", model="gemini-flash-latest", description="Researches supplier operating and compliance risk", instruction="""You are a supplier research specialist.Use lookup supplier signals for every assessment.State that demonstration fixtures are not live evidence.Return findings, assumptions, and follow-up checks.Do not make a procurement decision.""", tools= lookup supplier signals , ADK builds the A2A server, task store, and Agent Card.a2a app = to a2a root agent, port=8001 Google ADK’s to a2a https://adk.dev/a2a/quickstart-exposing/ function encapsulates an existing agent as an A2A service and automatically generates its Agent Card. Because ADK 2.9.2 designates its A2A integration as experimental, explicit dependency versioning should be maintained. Start the service and verify discovery as follows: export GOOGLE API KEY="replace-me"uv run uvicorn supplier agent.agent:a2a app --host 0.0.0.0 --port 8001 In another terminalcurl -H "A2A-Version: 1.0" http://localhost:8001/.well-known/agent-card.json The card lists the agent’s skills, input and output modes, and its endpoints. Under A2A 1.0, endpoints appear in a supportedInterfaces array https://a2a-protocol.org/latest/specification/ , each declaring its own protocol binding and version. The Java implementation below is fully executable with package declarations and imports omitted from the secondary snippet for brevity . To maintain clear architecture boundaries, the table below outlines framework-provided elements versus custom application code. The example does not depend on any A2A support inside Spring AI. It uses plain HTTP so every protocol detail is visible. pom.xml dependencies