Pick Spring AI for Spring Boot, LangChain4j for Quarkus

Spring AI 2.0 is the default for Spring Boot 4 shops, LangChain4j fits Quarkus, Boot 3 and Bedrock-heavy estates, and Google ADK for Java only makes sense for Gemini teams that need native A2A.

By Rajesh Beri·November 18, 2026·12 min read
Share:
A developer's desk with an open laptop showing Java code in an IDE, a printed Maven pom.xml file with three dependency blocks circled in pen, and a coffee mug beside it, under an office desk lamp.

Illustration generated using AI

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:

  • ChatModel no longer runs the tool loop. Code that relied on internalToolExecutionEnabled has to move to ChatClient or drive ToolCallingManager itself.
  • Options are immutable and built with builders; copy() and fromOptions() are gone.
  • The spring-ai-azure-openai module is removed, and the Anthropic module is rebuilt on Anthropic's official Java SDK, with maxTokens defaulting to 4096 instead of 500.
  • JDBC chat memory adds a sequence_id column, 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_llm span 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:

  1. 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.
  2. 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.
  3. Whether you serve tools or only consume them. If your teams will publish internal tools as MCP servers over HTTP, Spring AI's @McpTool is the shortest path in Java.
  4. 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

Share:

Frequently Asked Questions

Should a Spring Boot team use Spring AI or LangChain4j for AI agents?

Use Spring AI 2.0 if you can run Spring Boot 4. It ships Micrometer observations for chat, advisors and tool calls, and MCP server annotations in core. Choose LangChain4j if you are on Quarkus, cannot leave Boot 3, or need JSON Schema structured output on Amazon Bedrock.

Does Spring AI 2.0 work with Spring Boot 3?

No. Spring AI 2.0 is designed for Spring Boot 4.0 and 4.1 with Spring Framework 7.0, so a Boot 3 application has to upgrade Boot first or stay on Spring AI 1.x.

Which Java agent framework has the best A2A support?

Google ADK for Java. Its 1.0 release added RemoteA2AAgent for calling remote agents and an AgentExecutor for exposing ADK agents, both on the official A2A Java SDK. LangChain4j's A2A support is client-side and beta, and Spring AI's is a community server-side project.

Is LangChain4j's agentic module production ready?

Treat it as unstable. The LangChain4j agents tutorial says the whole agentic module is experimental and subject to change, the 1.24.0 release notes label it beta, and that release changed how async agents behave.

When should a Java company build its AI agents in Python instead?

When the agent is a long-running stateful workflow that needs durable checkpoints, when you have chosen Google ADK and want the lead Python edition, or when an ML team that writes Python owns the agent. Expose it over A2A or HTTP and call it from Java.

Newsletter

More on Frameworks, every Sunday

The week's enterprise AI news, Frameworks included, in one Sunday email.

Weekly, free. Unsubscribe any time. Privacy

Latest Articles

View All →