跪拜 Guibai
← Back to the summary

The 2026 JVM AI Ecosystem: 61 Projects, Seven Layers, and Where Java Actually Wins

The 2026 Java AI Agent Ecosystem: 50+ Open Source Projects Categorized, Tested, and Selected

On 2026-11-18 I tested 61 Java/JVM AI open source projects, broke them down into seven layers, dissected the divergent paths of Spring AI 2.0, LangChain4j, and AgentScope, and added a selection decision tree plus five real shortcomings.

1. A Counter-Intuitive Signal First

If I had to pick the most representative project for the 2026 JVM AI ecosystem, it wouldn't be Spring AI or LangChain4j. It would be Atmosphere — a 3,836-star project whose name sounds like a WebSocket framework, but whose README opens with "Portable AI agent runtime for the JVM."

Its core selling point is a single line:

One @Agent class runs on 12 runtimes: Spring AI, LangChain4j, Anthropic, Google ADK, Koog, Embabel, AgentScope, Semantic Kernel, and others.

This deserves the opening because it exposes the real state of the 2026 JVM ecosystem:

Frameworks have multiplied to the point where a layer of "adapters" is needed to consolidate them.

The Python path is "one LangChain eats all abstractions, then splits into LangGraph, CrewAI, AutoGen each claiming their niche"; the JVM ecosystem takes a different route — Spring family, LangChain family, agent-native family, and big-vendor SDK family coexist, and nobody has eaten anyone else. As a result, the ecosystem grew a "cross-framework portability" demand on its own.

This isn't bad. It means the JVM AI ecosystem has passed the primitive "can I call a model" stage and entered the engineering stage of "how to stuff agents into existing enterprise systems." But it also means: the framework you pick today will probably still exist in two years, but its API will change.

Below is the classification skeleton. Seven layers, from model access to application platform. The closer to the top, the closer to business; the closer to the bottom, the closer to infrastructure.

flowchart BT
    L6["L6 Application / Platform layer<br/>JeecgBoot · Chat2DB · RuoYi AI · LangChat · JManus"]
    L5["L5 Integration / Workflow layer<br/>Camel · Flink Agents · Camunda · Flowable · Kestra · Temporal"]
    L4["L4 Data / Retrieval / Inference layer<br/>Tika · Lucene · Vespa · Milvus · Qdrant · JLama · DJL"]
    L3["L3 Protocol layer<br/>MCP Java SDK · A2A Java SDK · Quarkus MCP"]
    L2["L2 Agent Orchestration / Runtime layer<br/>AgentScope Java · Embabel · Koog · ADK Java · LangGraph4j · Atmosphere"]
    L1["L1 Application framework layer<br/>Spring AI · LangChain4j · Solon AI · Agents-Flex · ai4j"]
    L0["L0 Model access / SDK layer<br/>openai-java · deepseek4j · ollama4j · various providers"]
    L0 --> L1 --> L2 --> L3
    L1 --> L4
    L2 --> L5
    L3 --> L6
    L5 --> L6
    L4 --> L6

Figure 1: Seven layers of the JVM AI ecosystem. Note that L2 and L1 are parallel, not a containment relationship — this is the biggest structural difference between Java and Python.

2. Scope Clarification: Why "Java AI Projects" Are Hard to Count

Before the list, three things must be clear, or the list becomes misleading.

First, GitHub's language field lies. I initially scanned topic:llm language:Java and got 2,058 repos; topic:ai-agents language:Java gave 782. But checking each one showed massive mislabeling: iFlytek's Astron Agent (8.9k stars) is marked Java, but its core is Python + TypeScript; Java might be just a SDK or engine component. Opik (23.4k stars) is also marked Java, but it's a Python/TS project. This article strips those out, keeping only projects whose primary language is genuinely JVM.

Second, star counts are severely inflated by 2026. At the same time, Python-side REA has 415k stars, Hermes Agent 250k, while the highest JVM-side star count, LangChain4j, is only 13.4k. That isn't a quality gap; it's an attention gap — JVM developers habitually "use but don't star." So this article's ordering is reference only; to judge activity, look at pushed_at and release cadence — those are far more honest than stars.

Third, the boundary between "framework" and "application" is dissolving. JManus is both a framework and a product; LangChat is both scaffolding and a platform. I classify by primary usage and note the dual identity in the commentary.

Under this scope, 60 projects fall into 7 layers, with wildly varying maturity — this is the most important table in the article, because it decides where you should spend your effort:

Layer Topic Items Representative Projects Maturity Judgement
L6 Application / Platform 14 JeecgBoot, Chat2DB, RuoYi AI, LangChat Sharply divergent: tool-type (Chat2DB) mature, platform-type highly homogeneous
L5 Integration / Workflow 8 Camunda, Camel, Kestra, Flowable Mature, being redefined: process engines collectively pivot to agent orchestration
L4 Data / Retrieval / Inference 13 opendataloader-pdf, Vespa, DJL, Tika Components mature, pipelines missing: parts exist, nobody assembles the whole machine
L3 Protocols 6 MCP Java SDK, A2A Java SDK Mature and in sync with Python: the only layer where JVM isn't behind
L2 Agent Orchestration / Runtime 8 AgentScope, Embabel, Koog, ADK, Atmosphere Rapidly evolving, API unstable: most opportunity, most traps
L1 Application Frameworks 8 Spring AI, LangChain4j Mature, entering engineering phase: selection largely converged
L0 Model Access 3 openai-java, deepseek4j Mature, official SDKs converging the market
Cross-cutting Observability / Governance 1 HertzBeat Nearly empty: see Section 12 "Cold Water"

3. L0: Model Access Layer — Least Glamorous, but the Last Thing You Should Write Yourself

This layer is the work of "wrapping HTTP requests into Java objects" — low technical difficulty, but high trap rate (streaming parsing, incremental tool-call concatenation, retries, timeouts, token counting). Conclusion first: unless you're integrating a niche domestic model, don't write this yourself.

Project Stars Latest Version Maker Positioning & Commentary
openai-java 1,568 v4.108.0 OpenAI official Official, Kotlin implementation but full Java support. Responses API, streaming, structured output all present. The best base for OpenAI and compatible endpoints (DeepSeek, Tongyi, Doubao, vLLM) — avoids half the protocol pitfalls compared to community SDKs
deepseek4j 751 — pig-mesh community The most widely used DeepSeek Java SDK in China; streaming handling of reasoning_content is finer than generic SDKs. Good for lightweight scenarios that only need DeepSeek
ollama4j 509 — Community Ollama's Java client; fine for local model PoCs. Production model management is weak; don't expect much

The real picture: Official SDKs are eating community SDKs. Two years ago Java developers were debating TheoKanning/openai-java (4,704 stars, archived in 2024). Now the official openai-java has sealed that path. That's a good signal — model vendors are finally treating JVM as a legitimate client.

4. L1: Application Framework Layer — The Main Battleground of Java AI

This layer solves "how to assemble models, tools, vector stores, and memory in Java." It's the most competitive and most mature layer in the JVM AI ecosystem.

Project Stars Latest Version Maker Positioning & Commentary
LangChain4j 13,420 v1.23.0 Community (LangChain4j team) De facto standard on the JVM side. API design closest to Python LangChain; ChatModel / EmbeddingStore / Tool / Memory abstractions complete. Note its dual-track version strategy: the core line (core / open-ai / http-client) follows stable versions, while the experimental line (agentic / mcp / guardrails / spring-boot-starter) only releases -betaN, and they must be upgraded in pairs (1.23.0 pairs with 1.23.0-beta33). Using the wrong version combo is the most common source of dependency hell
Spring AI 9,657 v2.0.2 Spring official Released 2.0 GA on June 12, 2026 at Spring I/O, paired with Spring Boot 4 / Framework 7 / Jackson 3, starting at JDK 21. 2.0 is a "tightening," not an "expansion": ChatClient unified entry, tool-calling interface redesigned, native MCP integration (@McpTool), JSpecify null-safety, structured output with self-correction. Current 2.0.2 is the stable baseline; 2.1.0-RC1 is out; 2.1 will introduce Session API and deprecate ChatMemory
Spring AI Alibaba 11,159 v1.1.2.2 (2.0.0-M1.1) Alibaba Cloud Highest tutorial coverage among Chinese Java AI frameworks; Graph orchestration + Nacos integration + Tongyi/Bailian adaptation smoothest. But it must be said honestly: it is currently in de facto stagnation — stable version stuck at 1.1.2.2, 2.0 only a pre-release M1.1 from June 2026, last main-branch commit 2026-10-07. Community has discussed "discontinued" but the official response hasn't been explicit. Evaluate this risk before choosing it
Agents-Flex 1,057 v2.3.0 Chinese community Lightweight, benchmarked against Spring AI but not tied to Spring. RAG, MCP, Skills, Text2SQL, Subagent, TTS/STT all present; Chinese-friendly docs. Good for small and medium teams to ramp up quickly
Solon AI 473 v4.1.1 Chinese community (Solon ecosystem) Extremely lightweight, no Spring dependency, fast startup, low memory. LLM-tool, Skill, RAG, MCP, Agent-ReAct all supported. A practical choice for domestic/embedded/low-resource container scenarios; the small ecosystem is the main weakness
ai4j 441 — Chinese community Explicitly supports Java 8+ , unified access to OpenAI / Anthropic / DashScope / Doubao / DeepSeek. A realistic solution for legacy systems (JDK 8) that want AI capabilities; the cost is missing out on virtual threads
Quarkus LangChain4j 325 v1.15.1 Quarkiverse Quarkus native extension for LangChain4j, compile-time injection + GraalVM native image. The only proper answer for cold-start-sensitive scenarios (Serverless, FaaS)
langchain4j-community 229 — Community Integrations that don't fit in the main repo live here (various domestic models, vector stores, document parsers). Look here first for niche integrations

4.1 Three Undercurrents in This Layer

Undercurrent 1: Spring AI and LangChain4j aren't an "either/or," they're a "layering." In 2026 more and more projects import both — using Spring AI for ChatClient and auto-configuration, and LangChain4j's agentic module for orchestration. Atmosphere productized this practice directly (providing both adapters). If your team is already on Spring Boot, don't avoid Spring AI for the sake of "purity."

Undercurrent 2: The beta status of experimental modules is the biggest engineering risk. LangChain4j's agentic, mcp, and guardrails still only release betas; Spring AI 2.1's Session API will deprecate ChatMemory. That means agent code written in 2026 will almost certainly need rewriting in 2027. The only coping strategy: confine framework calls to your own thin wrapper layer, and don't let it leak into business code.

Undercurrent 3: The "lightweight" path of domestic frameworks is rising. Agents-Flex, Solon AI, and ai4j share the trait of not being tied to Spring. The reason is practical — many enterprises need AI as a standalone service, an edge client, or a legacy-system plugin, and can't carry the weight of Spring Boot 4. This line grew noticeably in 2026, but its ecosystem size still can't support a "primary framework" position.

5. L2: Agent Orchestration & Runtime Layer — The True Battleground of 2026

If L1 solves "calling the model," L2 solves "letting the model run on its own." This layer saw the most dramatic change in 2026, and is where route divergence is sharpest.

Project Stars Latest Version Maker Positioning & Commentary
AgentScope Java 6,407 v2.0.5 Alibaba Tongyi Lab The most complete "distributed agent runtime" on the JVM side. Open-sourced 1.0 in December 2025, 2.0 in June–July 2026, re-architected into Harness / Runtime / Workspace / Skill four layers, with built-in 9 multi-agent collaboration patterns, state persistence, streaming cancellation, sandboxed workspaces, and A2A interop. Its ambition isn't a "framework," it's a "foundation" — benchmarked against Python's AgentScope + Runtime, not LangChain
Koog 4,665 v1.3.0 JetBrains Kotlin-first JVM agent framework, runs on JVM / Android / iOS / WasmJS. Graph-style workflows + strong fault tolerance are its calling cards: tool exceptions don't crash, can retry, can roll back, can cancel. JetBrains positions it as "Spring AI handles connectivity, Koog turns capabilities into reliable systems" — an accurate division of labor
Embabel 4,560 v1.5.4 Rod Johnson (Spring founder) The most counter-trend and most worth studying project. Core is GOAP (Goal-Oriented Action Planning): not letting the LLM decide every step, but letting code define domain actions, preconditions, and costs, with a planner searching paths in a type-safe action space. Rod's own words: "You can't vibe-code serious software." It bets on "enterprises want determinism," not on "models will get smarter"
Atmosphere 3,836 4.0.x Async-IO Cross-framework portable runtime. One @Agent annotation; whatever adapters are on the classpath run (12 kinds); exposes MCP / A2A / AG-UI endpoints uniformly; strengths are real-time transport + governance — WebSocket/SSE/gRPC share a broadcaster, policy admission, HITL persistent approvals, PII rewriting, cost caps, plan-and-verify (with SMT solver validation of tool-call sequences). It fills the gap of "Java has no agent gateway"
LangGraph4j 2,113 v1.9.10 Community (bsorrentino) Java port of LangGraph: graph orchestration + checkpoints + human-in-the-loop + subgraphs. The least-friction choice for teams migrating from Python LangGraph, at the cost of far fewer ecosystem plugins than the original
Google ADK Java 1,775 v1.14.0 Google Code-first agent toolkit, isomorphic with the Python/Go versions. Multi-agent hierarchy, tools, evaluation, deployment to Vertex AI Agent Engine in one flow. Heavy GCP coupling is both moat and ceiling; but pure local runs are fully possible
JManus ~1,100 V4.10.12 Alibaba Cloud Spring AI Alibaba team Pure Java implementation of Manus, later pivoted to an "agent development platform." PLAN-ACT mode + Func-Agent (precise step control) + visual configuration + 50+ prebuilt tools + HTTP call interface. It's more product than library, for teams wanting an "out-of-the-box multi-agent console"
Semantic Kernel for Java 28,786 (monorepo, mostly C#) Maintenance mode Microsoft Must be called out separately: in October 2025 Microsoft merged AutoGen and Semantic Kernel into Microsoft Agent Framework (GA 1.0 in April 2026), moving SK to full maintenance mode with only security fixes. The Java version lost independent evolution as a result. It's a good textbook for understanding the "plugins + function-calling" paradigm, but not recommended for new project selection in 2026

5.1 The Fundamental Divergence of Three Routes

Laying these projects out, you see they differ not in "how many features," but in how they answer the question "who decides?"

flowchart LR
    Q["What happens next?<br/>Who decides?"]
    Q --> A["LLM decides<br/>AgentScope Java<br/>ADK Java<br/>LangGraph4j<br/>Koog"]
    Q --> B["Code decides<br/>Embabel<br/>Camunda / Flowable<br/>Atmosphere plan-and-verify"]
    Q --> C["Doesn't decide, adapts<br/>Atmosphere<br/>(leaves choice to the team)"]
    A --> A1["Advantage: open tasks, exploratory<br/>Cost: uncertain, hard to test, cost uncontrolled"]
    B --> B1["Advantage: auditable, regression-safe, cost-calculable<br/>Cost: weak openness, high domain-modeling cost"]
    C --> C1["Advantage: no lock-in, incremental migration<br/>Cost: extra abstraction, performance overhead"]

Figure 2: Three routes of JVM agent frameworks. This isn't about technical superiority; it's a mapping of business determinism needs.

My judgment: the two routes will converge in 2027, not one winning. The reason is that enterprise needs are inherently layered — customer-service Q&A wants openness (LLM decides), order processing wants determinism (code decides), and the same system has both. AgentScope 2.0's Skill/Workspace layering, Embabel's support for embedding LLM sub-goals inside GOAP, and Atmosphere's plan-and-verify are all moving toward the middle.

Whoever can sew "open tasks" and "deterministic flows" together in the same runtime wins the enterprise market. Currently the closest are AgentScope Java (distributed runtime + multi-pattern collaboration) and Atmosphere (governance + portability), but neither is "out of the box" yet.

5.2 An Underrated Watershed: Long-Running Execution

The real technical watershed for 2026 JVM agent frameworks isn't "how many collaboration patterns," it's can it run long.

A demo agent that runs 30 seconds and an agent that runs 3 hours, with checkpoint-resume, human approvals, and cross-restart state recovery are two different species. The latter needs not prompt engineering but:

AgentScope Java 2.0's 2.0.x maintenance releases are almost entirely fixing such issues (of the 60-ish fixes in v2.0.5, state races, streaming cancellation, and silent sandbox failures are the bulk); Atmosphere makes "persistent sessions + safe replay on reconnect" a core feature; workflow engines like Temporal / Camunda attack from the other side.

This layer is where Java should really win. Because the enemies of long-running execution are "what if the process dies," "where does state live," "how do we audit" — these are the frontal battlefield of JVM's twenty years of enterprise-middleware experience, not a contest of model capability.

6. L3: Protocol Layer — The One Place Java Isn't Behind

If you look only at model and agent abstractions, Java lags Python by one to two years; but at the protocol layer, Java is nearly in sync. The reason is simple: protocols are language-independent, and Java's engineering strengths (strong typing, code generation, mature HTTP/SSE stacks) are actually an advantage when implementing protocols.

Project Stars Latest Version Maker Positioning & Commentary
MCP Java SDK 3,774 v2.2.0 Anthropic ecosystem / official Official Java implementation of MCP, both server and client, supports stdio / SSE / streamable HTTP. 2.x matches the 2026 MCP spec version, with session protocols and stateless modes caught up. The necessary path for connecting the tool ecosystem on the JVM side
A2A Java SDK 517 v1.5.1.Final Google donated / Linux Foundation Official Java SDK for the Agent2Agent protocol. Agent Card discovery, task lifecycle, streaming events. The standard answer for cross-language agent interop, works best with AgentScope / ADK
Quarkus MCP Server 204 v2.1.0.CR1 Quarkiverse Expose Quarkus beans as an MCP server via annotations, compile-time generation, native-image friendly. The lowest-cost way to "add an MCP door" to an existing Quarkus service
SonarQube MCP Server 689 — SonarSource official Exposes code-quality and security scanning to AI agents. A typical sample of "the Java ecosystem MCP-ifying its own tools"; similar are MCP plugins for JADX and Ghidra
jadx-ai-mcp 3,015 — Community MCP plugin for JADX (Android decompiler)
ghidra-mcp 6,271 — Community MCP server for Ghidra, 200+ reverse-engineering tools

An easily overlooked fact here: the highest-starred Java projects in the MCP ecosystem aren't frameworks but reverse-engineering tools (ghidra-mcp 6.3k, jadx-ai-mcp 3.0k). That shows JVM has a unique position in "wiring existing desktop tools into agents" — Ghidra, JADX, Burp, IntelliJ are themselves written in Java, so adding an MCP layer is far cheaper than reimplementing them. This is an underrated differentiation path for the Java ecosystem.

7. L4: Data, Retrieval & Inference Layer

The agent's ceiling is set by the model, its floor by retrieval. Java's maturity in this layer is actually decent — what's missing is "out-of-the-box RAG pipeline."

Project Stars Latest Version Positioning & Commentary
opendataloader-pdf 30,332 — The biggest surprise find this round. Parses PDFs into AI-ready data (structured JSON, tables, reading order), implemented in Java, Apache 2.0. 30k stars says "document parsing" is the real pain point of RAG — more demanded than any agent framework
Vespa 7,184 — Veteran AI search platform: vector + inverted index + structured filtering + ranking expressions in one. A heavy weapon for large-scale retrieval scenarios, with operational complexity to match
Apache Pinot 6,177 — Real-time analytics database, now supports vector retrieval. Good for "real-time metrics + semantic search" hybrid queries
DJL 4,861 v0.40.0 Java deep-learning framework, engine-agnostic (PyTorch / TensorFlow / ONNX / MXNet). The mature way to run embedding, rerank, and small-model inference in the JVM
Apache Tika 4,153 — The Swiss-army-knife of document metadata and text extraction, 1000+ formats. The default starting point for RAG preprocessing
Apache Lucene 3,613 — The base for vector retrieval (HNSW) + full-text search. Elasticsearch, Solr, OpenSearch all sit on it
JLama 1,311 — Pure Java LLM inference engine, using Panama Vector API for SIMD acceleration. Its significance isn't performance (it can't beat llama.cpp) but "zero native dependencies, embeddable, GraalVM-compilable"
memind 906 — Agent memory and context engine for Java, self-evolving memory. A rare JVM-side project dedicated to the "memory layer"
Elasticsearch Java Client 526 — Official client, full vector retrieval (dense_vector / kNN) support
Milvus Java SDK 501 — Official SDK
OpenSearch Java 163 — Official client
Qdrant Java Client 100 — Official client
Weaviate Java Client 34 — Official client, smallest scale

Judgement for this layer: every vector-store client has official Java maintenance; that's not a concern. The real shortfall is the "last mile" of the RAG pipeline — chunking strategies, hybrid retrieval, reranking, citation tracing. Python has one-stop solutions like LlamaIndex; Java has to assemble it manually (Spring AI's QuestionAnswerAdvisor and LangChain4j's RetrievalAugmentor are the two best current starting points, but neither qualifies as a "pipeline").

8. L5: Integration, Workflow & Runtime

This is Java's traditional strength zone, the place where it least should lose to Python.

Project Stars Latest Version Positioning & Commentary
Kestra 30,269 — Declarative workflow orchestration platform, Java implementation, has AI/LLM plugins. Its "orchestrate everything" positioning is broader than agent frameworks, suitable for treating an agent as one node in a flow
Flowable 9,661 8.0.0 BPMN engine, 8.0 starts adding AI/Agent integration. The realistic path to slot agents into approval flows
Apache Camel 6,414 — 350+ connectors + camel-langchain4j component. The old king of enterprise integration (EIP); nobody is more familiar with "getting agents to call SAP / MQ / FTP"
Camunda 4,367 v8.10.9 Note its self-positioning has changed to "Agentic Orchestration Platform" — gone from BPM engine to agent orchestration. A representative turn: process-engine vendors see agents as one type of process node
LiteFlow 3,911 — Domestic rule/component orchestration engine, strong rule-EL expressiveness. A lightweight way to mix "AI nodes + business nodes"
ByteChef 1,063 — Open-source AI agent + workflow automation, self-hostable or embeddable in SaaS. Positioned as the Java version of n8n
Flink Agents 494 — Flink-based streaming agent framework, event-driven, stateful, Exactly-Once. The only proper answer for running agents on real-time data streams; Apache incubating, maturity still early
Temporal Java SDK 444 — Persistence-execution engine's Java SDK. Outsourcing long-running agent "state and retries" to Temporal is an increasingly popular architecture, more reliable than building checkpoints inside a framework

An important trend hides here: in 2026 the mainstream form of enterprise agent deployment isn't "one agent framework runs everything," but "workflow engine + agent nodes." Camunda repositions, Flowable 8.0 adds AI, Kestra adds LLM plugins, Camel adds LangChain4j components — four of them in lockstep. The reason is practical: enterprises already have process engines, approvals, permissions, and audit trails. If an agent can just be a node, there's no need to overthrow everything.

If you're an enterprise architect, my advice is: prefer "workflow engine + agent nodes" over "agent framework + build your own workflow." The former inherits twenty years of process-governance capability; the latter starts from zero.

9. L6: Application & Platform Layer — The Best Place to See Who's Really Using This

Frameworks show ambition; applications show demand. Projects in this layer best reflect what JVM developers actually want to build in 2026.

Project Stars Latest Version Positioning & Commentary
JeecgBoot 48,511 — AI low-code platform, 48k stars. Permissions, multi-tenancy, workflow, reports, dashboards, AI knowledge base out of the box. The most mature "AI generates business code" play in China, and the highest-starred AI-related project on the JVM side
Halo 40,333 — Site-building tool, full AI plugin ecosystem (writing assistance, summarization, vector retrieval). A typical sample of content scenarios + AI
Chat2DB 28,365 v5.3.8 AI-driven database client, natural language to SQL, SQL explanation and optimization. "Text2SQL made into an IDE" — one of the most successful AI tool-type products on the JVM side
SuperSonic 5,200 — Tencent Music's open-source ChatBI platform: semantic-layer modeling + Text2SQL + multi-turn dialogue + metric attribution. A complete reference implementation of enterprise ChatBI; semantic-layer design is far more reliable than "just having the LLM write SQL"
RuoYi AI 5,838 v3.1.0 Enterprise AI platform based on RuoYi-Vue-Plus: multi-model management, knowledge bases, RAG, workflows, image generation. The most common starting point for domestic Java teams building private AI platforms. Positioned as "scaffolding" rather than "platform," so don't expect it to match Dify out of the box
ragent 4,482 — Enterprise-grade Agentic RAG project: document parsing, multi-path retrieval, intent recognition, question rewriting, session memory, MCP tool calls, deep thinking. High teaching and engineering value, a good reference implementation for reading the full RAG pipeline
langchain4j-aideepin 1,404 — AI application platform: chat, image generation, knowledge bases, workflows, MCP service marketplace, voice I/O, long-term memory. High feature density; good for product prototypes
LangChat 1,362 — AI agent application platform in the Java + LangChain4j ecosystem: multi-model, agents, knowledge-base RAG, Skills. Front-end/back-end separated, active domestic community
EnterpriseAgentFramework 1,053 — ReachAI enterprise agent platform, focusing on "querying data, filling forms, handling business inside existing OA / ERP / CRM systems." A Java implementation of RPA-style agents, pragmatic thinking
nexus-agent 681 — Enterprise agent platform: intelligent dialogue, document QA, web search, RAG, MCP, Skills, three-layer executor + dual-channel hybrid retrieval
spring-ai-agent-utils 688 — Spring AI community's "Claude Code style" tools and Agent Skills library. Brings the coding-agent tool paradigm to Spring AI — well worth reading
FinSight-AI 562 — Financial research agent: elastic workflow, evidence-anchored RAG, versioned reports. A complete sample of a vertical scenario
EDDI 394 — Configuration-driven agent engine: define agents in JSON, multi-agent orchestration, dialogue management. Another take on "low-code agents"
AI-Interview 261 — AI mock-interview system: digital-human interviewer + follow-up questions + per-question scoring, Java 21 + Spring

Three real demands can be read from this layer:

  1. "Private knowledge base + multi-model management" is the greatest common denominator. RuoYi AI, LangChat, aideepin, nexus-agent have highly overlapping feature lists, showing this is a demand enterprises will pay for.
  2. Text2SQL / ChatBI is JVM's sweet spot. Chat2DB's 28k stars and SuperSonic's 5.2k stars aren't coincidental — databases, SQL, JDBC are Java's home turf; wiring an LLM on top is natural. And both projects prove the same thing: the semantic layer matters more than the prompt.
  3. "Using AI to remodel legacy systems" is hotter than "building new AI applications." EnterpriseAgentFramework's positioning (handling business in OA/ERP/CRM) is closer to Chinese enterprises' actual budgets than any "generic agent platform."

10. Five Main Lines: What Actually Happened in the 2026 JVM AI Ecosystem

Having listed everything, time for judgment. I sum up JVM-side changes in 2026 under five main lines.

Main Line 1: Spring AI 2.0 Pulled Java AI to an "Engineering Baseline"

On June 12, 2026, Spring AI 2.0 went GA, paired with Spring Boot 4 / Framework 7 / Jackson 3. This is the dividing line between "works" and "confident for production" for JVM AI.

It wasn't about adding features; it was about tightening: ChatClient unified entry, tool-calling interface redesigned, JSpecify null-safety, native MCP integration, structured output with self-correction, virtual threads available by default. These changes let "AI code" finally pass through enterprise code review — type safety, testability, observability.

The cost is migration. 1.x to 2.0 has plenty of breaking changes, especially around tool-calling and advisor chains. I've seen many teams stuck on 1.x, afraid to upgrade. That will become an increasingly expensive decision in late 2026.

Main Line 2: Virtual Threads Finally Gave Java the Right Posture for Writing Agents

The essence of an agent is "lots of blocking waits" — waiting for model returns, tool execution, human approvals. Traditional Java uses thread pools; a few hundred concurrent hits the ceiling. Reactor breaks code readability.

Virtual threads (formal in JDK 21, mature with JDK 25 LTS) solve this: one agent session per virtual thread, write ReAct loops in blocking style, tens of thousands of concurrent sessions fine. Spring AI 2.0 and AgentScope Java do deep adaptation for this.

That's a structural advantage of JVM over Python — Python's asyncio model is significantly more complex engineering-wise in mixed "high concurrency + many blocking tool calls" scenarios (free-threading is advancing, but ecosystem migration is far from done). If you're building a product where ten thousand users each run an agent, Java really is a better fit than Python now.

Main Line 3: Spring AI Alibaba's De Facto Stagnation Is the Ecosystem's Biggest Uncertainty

This needs its own section because it affects the most people.

As of November 18, 2026, Spring AI Alibaba's stable version sits at 1.1.2.2, 2.0 only a 2.0.0-M1.1 pre-release from June 25, 2026, and the main branch's last commit is 2026-10-07. The community has discussed since September whether it's "discontinued"; some analysts say the team's resources shifted to AgentScope Java, others claim it's "changing its heart" (a rewrite). The official side hasn't given a clear timeline.

The damage isn't "one fewer framework"; it's "a pile of projects locked in." A large number of domestic Java AI tutorials, graduation projects, and enterprise PoCs are built on Spring AI Alibaba's Graph module. If it stops at 1.1.x, those codebases simultaneously lose the upgrade path to Spring AI 2.x and Alibaba's model-adaptation updates.

My advice: don't make it the sole dependency for new projects. For Graph orchestration, prefer LangGraph4j or AgentScope Java; for Tongyi/Bailian model adaptation, Spring AI's OpenAI-compatible endpoints also work. Treat it as a "replaceable adaptation layer," not a "foundation."

Main Line 4: Microsoft Exited the JVM Agent Framework Race

Semantic Kernel merged with AutoGen in October 2025 to form Microsoft Agent Framework, GA 1.0 in April 2026, sending SK to full maintenance mode. The Java version lost the ability to evolve independently as a result.

That's not small. It says: the path of "big vendor makes a multilingual SDK and keeps all language versions in sync" no longer works in the agent era. Agent frameworks evolve too fast; multilingual sync costs too much; Microsoft chose to concentrate on the .NET home turf.

The lesson for Java developers is direct: don't count on "some big vendor will keep maintaining the Java version." Google's ADK Java is active now (v1.14.0), but it's the same "three-language sync" model; whether it lasts depends on Google Cloud's business returns. When selecting, treat "does the governing body treat JVM as its main battlefield" as a hard criterion — Alibaba (AgentScope), JetBrains (Koog), Rod Johnson (Embabel) are all in it fully on the JVM side, so their incentive structure is more stable.

Main Line 5: Protocols Converged, and Java Kept Up with Standards for Once

MCP Java SDK is at 2.2.0, A2A Java SDK at 1.5.1.Final, both official SDKs matching the 2026 spec versions. Add Spring AI 2.0's @McpTool, Quarkus's MCP extension, LangChain4j's mcp module, and the JVM side's ability to connect to the tool ecosystem has caught up with Python.

This is the most underrated progress of 2026. Two years ago, connecting a new tool in Java meant writing a pile of adaptation code; now, if that tool provides an MCP server, McpToolProvider hangs on and works. Note the distinction: "integration capability" is level, not "tool richness" — ready-made Java-native agent tools are still far fewer than Python's, but at least you're no longer locked out by protocol.

11. Selection Decision Tree

With all that said, down to "which one should I use." The tree below branches on your existing tech stack and business determinism requirements, not star counts.

flowchart TB
    S["Your scenario"] --> Q1{"Already on Spring Boot<br/>monolith / microservices?"}
    Q1 -->|Yes| Q2{"Building<br/>RAG / customer service / content generation?"}
    Q1 -->|No| Q3{"What's your JVM stack?"}

    Q2 -->|Yes| A1["Spring AI 2.0<br/>+ ChatClient + Advisor<br/>(don't reinvent the wheel)"]
    Q2 -->|No, need long-running multi-agent| A2["AgentScope Java<br/>distributed runtime + state persistence"]
    Q2 -->|No, need deterministic flow| A3["Embabel or<br/>Camunda/Flowable + agent nodes"]

    Q3 -->|Quarkus / native| A4["Quarkus LangChain4j<br/>compile-time + GraalVM"]
    Q3 -->|Kotlin / multiplatform| A5["Koog<br/>JVM/Android/iOS/Wasm"]
    Q3 -->|No framework / ultra-light| A6["Solon AI / Agents-Flex<br/>/ ai4j (JDK 8)"]
    Q3 -->|GCP / Vertex| A7["Google ADK Java"]

    A1 --> X{"Need cross-framework portability<br/>or an agent gateway?"}
    A2 --> X
    A3 --> X
    X -->|Yes| A8["Atmosphere<br/>@Agent + MCP/A2A/AG-UI + governance"]
    X -->|No| Z["Keep it simple, don't add a layer"]

Figure 3: Selection decision tree. Note the final branch — most teams don't need the Atmosphere layer; adding abstraction costs.

Direct answers for a few specific scenarios:

Scenario Recommendation Reason
Have Spring Boot system, add AI capability Spring AI 2.0 Auto-config, Actuator, Security all ready; lowest migration cost
Migrating from Python LangChain LangChain4j Closest API semantics; least team cognitive load
Migrating from Python LangGraph LangGraph4j Graphs, checkpoints, interruption/recovery map one-to-one
Building "one long-running agent per user" AgentScope Java State persistence, streaming cancel, sandbox are hard requirements; it does them most completely
Finance / government, needs auditability and rollback Embabel or BPMN engine Planning in code; paths enumerable, testable, explainable
Serverless / cold-start sensitive Quarkus LangChain4j Native image, millisecond startup
Kotlin team / needs mobile targets Koog The only real cross-JVM + iOS + Wasm option
Legacy JDK 8 system ai4j Explicitly supports Java 8; cost is no virtual threads
Need private AI platform, fast delivery RuoYi AI / LangChat Scaffolding complete; lower modification cost than building yourself
Need agent gateway / multi-channel / human approval Atmosphere Real-time transport + governance on the critical path; that's its only position

12. Cold Water: Five Real Shortcomings of the JVM Ecosystem

A survey post is easiest to write as fluff. This section speaks only of the ugly.

Shortcoming 1: Evaluation (Eval) is nearly empty. Python has Ragas, DeepEval, LangSmith, Opik; the Java side has no agent-evaluation framework that has formed a climate (scattered small libs exist, but nobody uses them for production regression). To do regression testing, you write your own assertions and your own LLM-as-judge. This is the biggest hole in the 2026 JVM AI ecosystem — no evaluation, no engineering.

Shortcoming 2: Observability is cobbled together externally. Micrometer + OpenTelemetry's GenAI semantic conventions work, but agent-specific structures (multi-turn, tool-call trees, token attribution) have no native Java solution. Atmosphere's lineage and Spring AI's observability are the two best current efforts, but both are early. The only Java project positioned as "AI-driven observability" in the ecosystem is HertzBeat (7,469 stars), but it solves "using AI to observe systems," not "observing AI agents" — the two are not the same thing.

Shortcoming 3: Model provider coverage will always lag. When a new model releases, the Python SDK is available that day; Java waits for community adaptation. That gap won't disappear, only shrink. Coping method: prefer OpenAI-compatible endpoints. Most domestic models support them, which bypasses 90% of adaptation wait.

Shortcoming 4: Beta-module instability is systemic. LangChain4j's agentic/mcp/guardrails only ship betas; Spring AI 2.1 will deprecate ChatMemory; AgentScope 2.0 just rewrote its architecture. Writing JVM agent code in 2026 means assuming APIs will change. That's not one project's problem; it's the inevitable cost of an ecosystem still in rapid evolution.

Shortcoming 5: Community size is one to two orders of magnitude smaller. Using the same methodology and same day to count GitHub topic:ai-agents repos: Python 58,543; TypeScript 34,010; Java only 782. Of course the number is inflated — Python's community loves tagging topics, while Java projects often tag nothing — but a 75x gap can't be explained by tagging habits alone. LangChain4j's 13.4k stars vs LangChain's 146k stars is the same signal. Consequence: when you hit a niche problem, you can't find the answer; when you want a wheel, you build it yourself. This gap showed no sign of closing in 2026.

13. Advice for Three Roles

For Java back-end engineers: you don't need to switch to Python. The maturity of JVM-side frameworks in 2026 is enough for 90% of enterprise AI needs, and your advantages (transactions, concurrency, integration, stability) are more valuable in the agent-deployment phase than "knowing prompt tricks." What you need to shore up isn't Python but RAG retrieval principles, agent state-machine design, and evaluation methodology.

For architects: don't obsess over "which framework." Decide first where the agent sits in the workflow. Is it a node (workflow engine + agent) or a principal (agent framework + tools)? That decision is ten times more impactful than framework choice. Also, write "framework replaceability" into your architecture constraints — the API stability of 2026 can't support a five-year plan.

For tech leads: if the team will invest long-term, prioritize projects whose governing body treats JVM as its main battlefield (AgentScope, Koog, Embabel, LangChain4j) over "multilingual synced" big-vendor SDKs. The former's incentive structure is more reliable; the latter can be downgraded any time due to commercial priorities — Semantic Kernel Java is the precedent.

14. Conclusion: Java's Opportunity Isn't "Catching Python," It's "Taking Over Production"

Reading this list from start to finish, you get the feeling: the JVM ecosystem has everything, but nothing is good enough.

That judgment is half right. In "exploring model capabilities," Java truly can't catch Python, and shouldn't try. New paradigms, papers, tricks will always land in Python first.

But enterprise demand in 2026 has changed. From "let's see what an agent can do" to "stick the agent into a production system, and make it auditable, rollback-able, and cost-calculable." At this inflection, Java's legacy advantages start to cash in:

Java doesn't need to be the best AI language; it needs to be the most reliable AI deployment language. From the vantage point of November 2026, that path is workable — it just needs someone to fill in the three gaps of evaluation, observability, and RAG pipelines.

Whoever fills those becomes the next Spring.

Appendix: Full List Quick Reference

Stars measured on 2026-11-18; versions are Latest Release; "—" means no formal release or not retrieved. 61 entries total, where #16 Semantic Kernel is a multilingual repo (stars include the C# main repo), #60 HertzBeat belongs to "AI-enhanced observability" rather than an AI framework, and #61 is a supplement, listed all together for reference.

# Project Stars Version Layer One-liner
1 langchain4j 13,420 1.23.0 L1 JVM-side de facto standard, dual-track versions
2 spring-ai 9,657 2.0.2 L1 Spring official, engineering baseline
3 spring-ai-alibaba 11,159 1.1.2.2 L1 Highest domestic coverage, currently stagnant
4 agents-flex 1,057 2.3.0 L1 Lightweight, benchmarks against Spring AI
5 solon-ai 473 4.1.1 L1 No Spring dependency, ultra-light
6 ai4j 441 — L1 Supports Java 8
7 quarkus-langchain4j 325 1.15.1 L1 Quarkus + native
8 langchain4j-community 229 — L1 Collection of niche integrations
9 agentscope-java 6,407 2.0.5 L2 Distributed agent runtime
10 koog 4,665 1.3.0 L2 Kotlin multiplatform, strong fault tolerance
11 embabel-agent 4,560 1.5.4 L2 GOAP, deterministic planning
12 atmosphere 3,836 4.0.x L2 Cross-framework runtime + governance
13 langgraph4j 2,113 1.9.10 L2 LangGraph's Java version
14 adk-java 1,775 1.14.0 L2 Google code-first
15 JManus ~1,100 V4.10.12 L2/L6 Java implementation of Manus
16 semantic-kernel 28,786 Maintenance mode L2 Merged into MS Agent Framework
17 java-sdk (MCP) 3,774 2.2.0 L3 Official MCP Java SDK
18 a2a-java 517 1.5.1.Final L3 Official A2A Java SDK
19 quarkus-mcp-server 204 2.1.0.CR1 L3 Annotation-based MCP server
20 sonarqube-mcp-server 689 — L3 Code-quality MCP
21 jadx-ai-mcp 3,015 — L3 Decompiler MCP
22 ghidra-mcp 6,271 — L3 Reverse-engineering MCP
23 opendataloader-pdf 30,332 — L4 PDF to AI-ready data
24 vespa 7,184 — L4 AI search platform
25 pinot 6,177 — L4 Real-time analytics + vector
26 djl 4,861 0.40.0 L4 Java deep learning
27 tika 4,153 — L4 Document extraction
28 lucene 3,613 — L4 Retrieval base
29 jlama 1,311 — L4 Pure Java inference engine
30 memind 906 — L4 Agent memory engine
31 elasticsearch-java 526 — L4 ES client
32 milvus-sdk-java 501 — L4 Milvus client
33 opensearch-java 163 — L4 OpenSearch client
34 qdrant java-client 100 — L4 Qdrant client
35 weaviate java-client 34 — L4 Weaviate client
36 kestra 30,269 — L5 Declarative workflow
37 flowable-engine 9,661 8.0.0 L5 BPMN + AI
38 camel 6,414 — L5 Integration framework + langchain4j
39 camunda 4,367 8.10.9 L5 Agentic orchestration platform
40 liteflow 3,911 — L5 Rule orchestration
41 bytechef 1,063 — L5 Agent workflow automation
42 flink-agents 494 — L5 Streaming agents
43 sdk-java (Temporal) 444 — L5 Persistence execution
44 JeecgBoot 48,511 — L6 AI low-code
45 halo 40,333 — L6 Site building + AI plugins
46 Chat2DB 28,365 5.3.8 L6 AI database client
47 ruoyi-ai 5,838 3.1.0 L6 Enterprise AI platform scaffolding
48 ragent 4,482 — L6 Agentic RAG practice
49 langchain4j-aideepin 1,404 — L6 AI application platform
50 langchat 1,362 — L6 LangChain4j application platform
51 EnterpriseAgentFramework 1,053 — L6 Legacy system AI transformation
52 nexus-agent 681 — L6 Enterprise agent platform
53 spring-ai-agent-utils 688 — L6 Claude Code style tools
54 FinSight-AI 562 — L6 Financial research agent
55 EDDI 394 — L6 JSON-driven agents
56 AI-Interview 261 — L6 AI mock interviews
57 openai-java 1,568 4.108.0 L0 Official OpenAI SDK
58 deepseek4j 751 — L0 DeepSeek SDK
59 ollama4j 509 — L0 Ollama client
60 hertzbeat 7,469 — L7 AI-driven observability
61 supersonic 5,200 — L6 Tencent Music ChatBI platform (supplement)

Note & disclaimer: Star counts and versions change with each repo; the data here only represents the point-in-time of 2026-11-18. Maintenance status of some projects (like Spring AI Alibaba) is contested in the community; this article only states verifiable commit and release facts, and does not infer official intent.