Spring AI Alibaba's Kernel Shift to AgentScope: Java's AI Future Is Deterministic Runtime

Version History Shows Maintenance, Not Abandonment

A screenshot of Spring AI Alibaba (SAA) releases showed the latest stable version stuck at v1.1.2.2 since March 10, 2026, with no further updates. However, the main branch received 137 commits after that release, including 35 PRs merged between July 24 and August 25 (8 on August 24 alone). These commits focused on Graph serialization fixes, Admin localization, and JUnit 5 migration — maintenance work, not new feature development. By contrast, the sibling project AgentScope Java moved from 2.0.2 (Sept 3) to 2.0.3 (Sept 7) in four working days, indicating where engineering resources are concentrated.

Kernel Migration Planned a Year Ago

According to the Java2AI article "One Article Explains Spring AI Alibaba and AgentScope Positioning and Differences," SAA is built around Graph for workflow orchestration, while AgentScope uses an Agentic foundation to maximize foundation model capabilities. The SAA ecosystem will eventually support AgentScope via AgentScope Starter and Runtime Starter. The Admin open-source post states directly that SAA will upgrade its kernel to AgentScope. Version v1.1.2.2 already introduced spring-ai-alibaba-starter-agentscope, wrapping AgentScope's ReActAgent as a BaseAgent node inside SAA's Graph — a handoff preparation, not abandonment.

Two Runtime Models: Fixed Graph vs. Model-Driven Loop

SAA: StateGraph → CompiledGraph

SAA's core structure is StateGraph compiled to CompiledGraph. State lives in OverAllState (a Map with KeyStrategy, AppendStrategy, ReplaceStrategy for merge conflicts). Nodes are AsyncNodeActionWithConfig, edges are AsyncEdgeAction. Persistence uses Checkpointer with threadId for checkpoint recovery and deterministic replay. Human-in-the-loop uses interruptAfter; returnDirect lets tools return directly. Control flow is declared by developers, not the model.

StateGraph g = new StateGraph(keyStrategyFactory);
g.addNode("model", AsyncNodeActionWithConfig.node_async(modelAction));
g.addEdge(StateGraph.START, "model");
g.addEdge("model", StateGraph.END);

CompiledGraph cg = g.compile(CompileConfig.builder()
  .saverConfig(SaverConfig.builder()
    .register(SaverConstant.MEMORY, new MemorySaver())
    .build())
  .build());

cg.invoke(input, RunnableConfig.builder().threadId("t-1").build());

AgentScope: ReActAgent with Internal Reason-Act-Observe Loop

AgentScope centers on ReActAgent. The model decides which tool to call and whether to continue; no developer-drawn graph can capture this dynamic. It includes memory compression via CompressionConfig (triggered when summary count exceeds trigger_threshold, with keep_recent preserving latest messages). Real-time interruption uses interrupt with cancellation callbacks ( handle_interrupt). Session state is managed automatically.

ReActAgent agent = ReActAgent.builder()
  .name("Jarvis")
  .sysPrompt("你是一个有帮助的助手")
  .model(DashScopeChatModel.builder()
    .apiKey(System.getenv("DASHSCOPE_API_KEY"))
    .modelName("qwen3-max")
    .build())
  .toolkit(toolkit)
  .build();

Msg resp = agent.call(Msg.builder().textContent("现在是什么时间").build()).block();

In short: SAA hard-codes flow; AgentScope lets the model drive the loop.

Why Graph Orchestration Can't Support Harness

The industry shifted from node orchestration (Dify, n8n) to Harness — models that self-decompose tasks, select tools, and execute continuously. This requires agent runtime capabilities: context compression, tool execution constraints, task resumption after interruption. These belong to the runtime layer, not orchestration. Graph excels at determinism, traceability, and control — fixing business processes — but autonomous decision loops and memory compression must be built separately. Meanwhile, Spring AI 2.0 (GA June 12, on Spring Boot 4.1 / Spring Framework 7.0) already promotes Tool Calling to a first-class citizen in ChatClient: tools register as ToolCallback, and ToolCallingAdvisor handles the calling loop. SAA is squeezed: upward it lacks autonomous execution; downward Spring AI already covers model integration. Alibaba's answer: let AgentScope own the Agentic layer, while SAA retreats to Spring ecosystem integration after aligning with Spring AI.

Java's AI Value Is Deterministic Infrastructure, Not Frameworks

A project's release cadence doesn't define Java's position in AI. Spring AI 2.0 natively supports multi-model switching via config; AgentScope provides its own Java runtime. Cross-language runtime integration is feasible without rewriting business systems. The real value sits in the deterministic layer: wrapping side-effects in nodes, replaying via checkpoints — classic distributed-systems idempotency problems that are Java's home turf. Transactions, thread pools, distributed locks, state-machine transitions remain valid regardless of model API changes. Agents don't write SQL; they express intent: "query the user's last three cross-border orders, categorize by customs code, generate a customs summary." The underlying microservices, sharding strategies, and risk rules must be connected by developers. These atomic capabilities live inside business boundaries — no model or code assistant can generate them. Therefore, frameworks will stop updating and swap kernels; Java's job is not to chase frameworks but to expose orders, payments, risk control as discoverable, callable, auditable interfaces. No one else can do that — which is exactly why it's valuable.