If you run Spring Boot, build your agents on Spring AI 2.0 and keep them in the JVM; you do not need a Python team to ship tool-calling agents in 2026. Pick LangChain4j if you are on Quarkus, or stuck on Boot 3 for another year. Google ADK for Java loses this comparison for most JVM shops. It has the best Agent2Agent (A2A) story of the three, but its Java edition is a port that still lags the Python one, and it is built around Gemini first.
All three are free, Apache 2.0 open source with no paid tier, so the price on this page is the upgrade work and the model bill. The table compares them on one workload: a Spring Boot service running one agent with five internal tools served over MCP, calling Claude on Amazon Bedrock and GPT on Azure, sending traces to an existing OpenTelemetry collector, and handing one task to a remote agent over A2A.
| Spring AI 2.0 | LangChain4j 1.24 | Google ADK for Java 1.15 | |
|---|---|---|---|
| Verdict | Default for Spring Boot 4 | Default for Quarkus, Boot 3, plain Java | Only if you run Gemini and want ADK's runner |
| Programming model | ChatClient + Advisors, @Tool methods |
AiServices interfaces, @Tool methods, langchain4j-agentic workflows |
LlmAgent builder, Runner, sessions, plugins |
| MCP client | Yes, MCP Java SDK 2.0, Streamable HTTP default | Yes: Streamable HTTP, stdio, WebSocket, Docker | Yes (McpToolset) |
| MCP server | Yes, @McpTool annotations in core |
Community module, stdio only | Not confirmed for Java in the docs |
| A2A | Community server project; client via raw A2A SDK | Client (a2aBuilder), beta |
Native client and server |
| Observability | Micrometer observations on chat, advisors, tools, vector stores; content off by default | Listeners + experimental Micrometer module; automatic OTel on Quarkus | OTel spans (call_llm), BigQuery analytics plugin; Java absent from observability docs |
| Bedrock / Azure OpenAI / Vertex | Yes / via OpenAI module / via Google GenAI | Yes / yes / yes, JSON Schema output on all three | Gemini and Claude native; others through the LangChain4j adapter |
| Platform requirement | Spring Boot 4.0 or 4.1, Spring Framework 7 | Any Java framework | Java 17+ |
| Recent releases | 2.0.0 (Jun 12) to 2.0.2 | 1.21 (Oct 2) to 1.24 (Nov 18) | 1.7.1 (Aug 3) to 1.15 (Nov 18) |
| Licence / price (checked Nov 18, 2026) | Apache 2.0, free | Apache 2.0, free | Apache 2.0, free |
Spring AI 2.0 Is the Right Default for a Spring Boot Estate
Spring AI is the right pick for a Spring Boot shop because it plugs AI calls into the auto-configuration, Actuator and Micrometer stack your platform team already runs. Spring AI 2.0.0 went GA on June 12, 2026 and is "designed to be used with Spring Boot 4.0 / 4.1 and Spring Framework 7.0." The project page lists 2.0.2 as the current release on November 18, 2026, after the 2.0.1 maintenance release on August 21.
The programming model is ChatClient, a fluent client for model calls, wrapped in a chain of Advisors. An Advisor is an interceptor around each model call that adds memory, retrieval, validation or the tool loop. In 2.0 the tool loop itself moved into that chain. The minimal tool-calling example from the reference docs:
class DateTimeTools {
@Tool(description = "Get the current date and time in the user's timezone")
String getCurrentDateTime() {
return LocalDateTime.now().atZone(LocaleContextHolder.getTimeZone().toZoneId()).toString();
}
}
String response = ChatClient.create(chatModel)
.prompt("What time is it?")
.tools(new DateTimeTools())
.call()
.content();
MCP is the strongest part of the release. Per the GA announcement, Spring AI 2.0 ships the MCP Java SDK 2.0.0, which the Spring team says is compliant with the 2025-11-25 MCP specification, makes Streamable HTTP the default transport and pulls the @McpTool, @McpResource and @McpPrompt annotations into Spring AI itself. You can turn an existing @Service into an MCP server with annotations, which neither rival offers in core.
Observability is the other reason to choose it. The observability reference lists Micrometer observations for ChatClient (spring.ai.chat.client), each Advisor, each model call (gen_ai.client.operation, with a gen_ai_client_token_usage_total metric split by input and output), each tool execution (spring.ai.tool) and each vector store query. Prompts, completions and tool arguments are all off by default, behind flags like spring.ai.tools.observations.include-content. Your security team will want that default.
Where it is weaker. Provider coverage is narrower than LangChain4j's. The chat model comparison marks Bedrock Converse as supporting tools but not built-in JSON output, so structured output on Bedrock falls back to prompt-based conversion. Azure OpenAI no longer has its own module: since 2.0.0-M5 the Azure page sends you to the OpenAI module. A2A is a community project, server side only, and its client example calls the A2A Java SDK directly and wraps it as a @Tool.
Who should not pick Spring AI: a team that cannot move to Boot 4 this year. Spring AI 2.0 will not run on Boot 3, and staying on 1.x means building on a line the project has moved past.
The 1.x to 2.0 Upgrade Is the Real Cost of Spring AI
The upgrade is where Spring AI costs you, and you should budget for it in sprints. The 2.0 upgrade notes list changes that touch most codebases:
ChatModelno longer runs the tool loop. Code that relied oninternalToolExecutionEnabledhas to move toChatClientor driveToolCallingManageritself.- Options are immutable and built with builders;
copy()andfromOptions()are gone. - The
spring-ai-azure-openaimodule is removed, and the Anthropic module is rebuilt on Anthropic's official Java SDK, withmaxTokensdefaulting to 4096 instead of 500. - JDBC chat memory adds a
sequence_idcolumn, so existing tables need a migration. - MCP annotation and transport packages moved, and server-side tool input validation is now on by default.
The patch releases also changed behaviour. The same notes say 2.0.1 applies default tool call limits (40 calls per tool, 150 per turn) and sets OpenAI's strict tool mode to false by default. An agent that ran 160 tool calls in a turn on 2.0.0 now hits the cap. Pin your version and read the notes before each bump.
LangChain4j Wins on Provider Breadth and Framework Neutrality
LangChain4j is the better choice when your estate is not all Spring Boot 4, because it runs on any Java framework and covers more model providers than either rival. The language model table lists 22 chat providers and marks JSON Schema structured output as supported on Amazon Bedrock, Azure OpenAI, Google Vertex AI Gemini, Anthropic and OpenAI. On our workload, that is Claude on Bedrock and GPT on Azure with typed output on both, and no fallback to prompt parsing.
The programming model is AiServices: you declare a Java interface and LangChain4j generates the implementation, including the tool loop.
class OrderTools {
@Tool("Look up an order's status by its ID")
String orderStatus(String orderId) { return orders.status(orderId); }
}
interface Assistant { String chat(String userMessage); }
Assistant assistant = AiServices.builder(Assistant.class)
.chatModel(model)
.tools(new OrderTools())
.build();
Multi-agent orchestration lives in langchain4j-agentic, which provides sequential, loop, parallel, conditional and supervisor patterns. The agents tutorial says plainly that "the whole module has to be considered experimental and is subject to change in future releases," and the 1.24.0 release notes still label it "Agentic (beta)." The same release changed behaviour inside the module: async agents whose output is unused now run fire-and-forget. A2A is client-side through a2aBuilder.
MCP is good on the client side. The MCP tutorial covers Streamable HTTP, stdio, WebSocket and Docker-packaged stdio servers. Serving MCP is weaker: the server page points to a community module that supports stdio only and says it "does not provide" Streamable HTTP, sending you to Quarkus, Helidon, Micronaut or the MCP Java SDK for that.
Observability depends on your framework. Core LangChain4j gives you listeners (ChatModelListener, ToolExecutedEventListener and others) and an experimental Micrometer metrics module that emits gen_ai.client.token.usage and gen_ai.client.operation.duration. On Quarkus, the Quarkus LangChain4j extension creates OpenTelemetry spans for each AI method and each tool automatically once quarkus-opentelemetry is on the classpath. On Spring Boot you wire that yourself.
Backing is broad. Microsoft's Java team describes Dmytro Liubarskyi as founder and project lead, says the project has "substantial backing from Red Hat," and reports a security audit that fixed SQL injection flaws in the PostgreSQL and MySQL vector stores. The release cadence is fast: 1.21.0 on October 2, 1.22.0 on October 8, 1.23.0 on October 28 and 1.24.0 on November 18, with backports to the 1.19.x and 1.11.x lines.
Who should not pick LangChain4j: a Spring Boot 4 shop that wants agents to look like every other Spring bean, with Micrometer traces it does not have to wire by hand. Also skip it if you need the multi-agent layer to be stable this year; it is still beta.
Google ADK for Java Is the Loser Here, and Why
Google ADK for Java loses this comparison because its Java edition trails the Python edition on the features an enterprise team checks first, and it treats non-Google models as an adapter. ADK for Java 1.0.0 shipped on March 30, 2026, and the releases page shows 1.15.0 on November 18.
ADK is the most complete agent runtime of the three. You get an LlmAgent builder, a Runner, session, memory and artifact services (in memory, Firestore, Vertex AI, GCS), a plugin system that intercepts agent, tool and model calls, and ToolConfirmation for human approval before a tool runs. Its A2A support is the best here: the 1.0 announcement describes RemoteA2AAgent for calling remote agents and an AgentExecutor for exposing ADK agents, both on the official A2A Java SDK. If the remote-agent leg of our workload is your main requirement, this counts in ADK's favour.
LlmAgent agent = LlmAgent.builder()
.name("order-agent")
.instruction("Answer order questions using the orderStatus tool.")
.model("gemini-2.5-flash")
.tools(FunctionTool.create(OrderTools.class, "orderStatus"))
.build();
Here is the evidence that Java is the second edition:
- The ADK observability page lists Python, Go and Kotlin as supported and leaves Java off. The Java release notes do show OpenTelemetry work (thinking budget on the
call_llmspan and a scoping fix in 1.11.0), so traces exist, but the documented integrations are not written for Java. - The MCP tools page shows Java client examples for stdio only; tool filters, HTTP transport and auth examples are Python and TypeScript.
- The 1.15.0 notes say "bring Claude to parity with ADK Python," nearly eight months after 1.0.
- The adk-java README still lists agent evaluation as "Coming soon."
Model coverage beyond Gemini and Claude goes through a separate google-adk-contrib-langchain4j artifact, which Google introduced so ADK could reach third-party models. For Bedrock and Azure, you end up running LangChain4j underneath ADK anyway. Minor releases also carry behaviour changes: 1.13.0 made CORS and /run_live same-origin by default, and 1.15.0 binds the dev server to 127.0.0.1.
Who should pick ADK for Java: a team already on Vertex AI or the Gemini Enterprise Agent Platform, running Gemini, that wants Google's session and runner model and native A2A. Who should not: anyone whose main models run on Amazon Bedrock or Microsoft Foundry. See our Google ADK tool page for the platform details.
When the Honest Answer Is a Python Agent Service
Keep the agent in a Python service and call it from Java when the agent is the product and needs features that ship in Python first. Three cases justify it.
First, the agent is a long-running, stateful workflow that needs durable checkpoints and replay. That tooling is more mature in Python (LangGraph and the durable execution engines we compared in our Temporal vs Inngest vs Restate vs DBOS guide) than in any of these three Java frameworks.
Second, you chose ADK. The Java edition is catching up to the Python one feature by feature, and an ADK Python service exposed over A2A gets you the lead edition while your Java callers use any A2A client.
Third, the people building the agent are an ML team that writes Python and runs its own evals. Making them write Spring beans costs more than an HTTP or A2A hop.
The Python service costs you something too. You run a second runtime, a second dependency tree and a second supply chain, and that supply chain is under attack: two Microsoft Agent Framework releases on PyPI shipped a credential stealer this month. For a tool-calling assistant inside an existing Spring app, which describes most enterprise agents, keep it in Java.
How to Decide Without Regretting It
The choice comes down to four facts about your estate, checked in this order:
- Your Boot version. Boot 4 points to Spring AI. Boot 3 with no upgrade planned for 2027 points to LangChain4j. Quarkus points to LangChain4j with the Quarkus extension.
- Where your models run. Bedrock with typed output today favours LangChain4j's JSON Schema support. Gemini on Vertex is the only case where ADK leads.
- Whether you serve tools or only consume them. If your teams will publish internal tools as MCP servers over HTTP, Spring AI's
@McpToolis the shortest path in Java. - How much multi-agent you need in 2026. If A2A between teams is a requirement now, ADK's native client and server beat both alternatives, and in Spring AI you would be assembling it from a community project and the raw SDK.
The answer changes if Spring AI promotes A2A into core, or if ADK's Java docs reach parity on observability and evaluation. Re-check both at your next framework review. Whatever you choose, put an MCP allowlist in front of the tools before the first agent reaches production.
This Week: Check your Boot version against Spring AI 2.0's Boot 4 requirement and write down which models you call and where they are hosted. Those two facts settle the choice for most teams.
This Month: Build the five-tool, one-agent workload above on your pick, export traces to your collector, and confirm that prompts and tool arguments stay out of them unless you turn them on.
Before Q1 Close: Pin the framework version, add the upgrade notes to your dependency review, and budget for the Spring AI 2.0 migration or the next LangChain4j agentic break.
Continue Reading
- MCP vs A2A vs OpenAPI: Which Agent Integration Standard to Use
- LangGraph vs CrewAI vs AutoGen: One of Them Is Retired
- OpenAI Agents SDK Alternatives: Leave Three Features, Not the SDK
- LangChain Alternatives: Fix Durability Before You Rewrite
- The 2026 Agentic AI Stack: 8 Layers, 3 You Can Skip
- Agent Orchestration Platforms: Score Exit, Not Features
