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
@Agentclass 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 | 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:
- State persistence (checkpoints, event sourcing)
- Cancellation semantics (streaming cancel doesn't stall, tool calls can be interrupted)
- Idempotency and retries (calling a tool twice can't place duplicate orders)
- Resource isolation (sandboxed workspaces, filesystem queues)
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:
- "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.
- 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.
- "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:
- Virtual threads solve the concurrency model for high-concurrency long-running agents
- The Spring ecosystem solves "how to stitch AI capability into existing systems"
- BPMN/workflow engines solve "how deterministic flows coexist with open agents"
- Strong typing + compile-time checks solve "how agent code passes code review"
- Twenty years of middleware experience solves "state, retry, idempotency, observability"
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.