AgentScope Java 2.0 is a production-ready framework for building distributed, enterprise-grade agents, providing essential abstractions that work with rising model capability and built-in support for long-running, safely-controlled agent execution.
- Event System → A unified event stream with 28 typed events for real-time frontend rendering and human-in-the-loop.
- Permission System → Tool-call gating: allow / require user approval / deny.
- Middleware → AOP-style hook interception for flexibly extending the reasoning-acting loop.
- Workspace & Sandbox → Run tools in isolated environments — local, Docker, Kubernetes, or AgentRun cloud sandbox.
- Multi-Agent Orchestration → Multiple subagent definition patterns with
agent_spawn/agent_sendand real-time event forwarding. - Distributed Deployment → True distributed session and memory management (Redis / MySQL / PostgreSQL / OSS / COS) with cross-replica session recovery.
- [2026-07]
v2.0.0 GA: First production-ready release! Dual-layer agent architecture, event stream, permission system, middleware, workspace sandbox, multi-agent orchestration, and distributed deployment all ready. Docs | Release Notes - [2026-07]
v2.0.0-RC5: Model provider modularization; unified DataBlock multimodal support; native structured output; Channel IM integration; Tencent Cloud COS state persistence. Release Notes - [2026-06]
v2.0.0-RC4: Async tool execution and scheduled wakeup dispatching; subagent cross-replica routing and session recovery. Release Notes - [2026-06]
v2.0.0-RC3: Unifiedcall()/streamEvents()execution core;AgentResultEvent,CustomEvent,HintBlockEventnew event types. Release Notes - [2026-06]
v2.0.0-RC2: Fully stateless agent; one-line DistributedBackend; subagent event forwarding; Channel module (DingTalk, Feishu, WeCom); A2A / AG-UI protocol support. Release Notes - [2026-05]
v2.0.0-RC1: First 2.0 RC — harness engineering, enterprise distributed deployment, event stream / message model / middleware / HITL full redesign. Release Notes - [2026-05]
v1.1.0: Introducedagentscope-harnessandHarnessAgent; Workspace (persona / memory / skills / subagents); pluggable filesystem (local / shared store / sandbox); session persistence with cross-process resume; layered memory and context compaction; declarative subagent orchestration. Release Notes
Welcome to join our community on
| Discord | DingTalk | |
|---|---|---|
 |  |  |
AgentScope Java requires JDK 17 or higher.
<dependency>
<groupId>io.agentscope</groupId>
<artifactId>agentscope-harness</artifactId>
<version>2.0.0</version>
</dependency>Model providers are shipped as separate extension modules in 2.0. Add the one you need — for example, DashScope:
<dependency>
<groupId>io.agentscope</groupId>
<artifactId>agentscope-extensions-model-dashscope</artifactId>
<version>2.0.0</version>
</dependency>Other options: agentscope-extensions-model-openai, agentscope-extensions-model-anthropic, agentscope-extensions-model-gemini, agentscope-extensions-model-ollama. See the Model docs for details.
If you only need a bare ReActAgent without workspace / persistence / sandbox, depend on agentscope-core alone.
Start your first agent with AgentScope Java 2.0:
importio.agentscope.core.agent.RuntimeContext;
importio.agentscope.core.message.UserMessage;
importio.agentscope.harness.agent.HarnessAgent;
importjava.nio.file.Paths;
publicclassFirstAgent {
publicstaticvoidmain(String[] args) {
HarnessAgentagent = HarnessAgent.builder()
.name("assistant")
.sysPrompt("You are a helpful AI assistant.")
// ModelRegistry resolves the string and reads the matching// API-key env var (e.g. OPENAI_API_KEY) automatically.// Examples: "openai:gpt-4.1", "openai:o3",// "deepseek:deepseek-chat", "dashscope:qwen-plus",// "anthropic:claude-sonnet-4-7", "ollama:llama3"
.model("dashscope:qwen-plus")
// Or pass a ChatModel object directly:// .model(OpenAIChatModel.builder().model("gpt-4.1").build())
.workspace(Paths.get(".agentscope/workspace"))
.build();
RuntimeContextctx = RuntimeContext.builder()
.sessionId("demo").userId("alice").build();
// Blocking callagent.call(newUserMessage("Hello!"), ctx).block();
// Or stream events for real-time UI renderingagent.streamEvents(newUserMessage("Summarize today in three bullets."), ctx)
.doOnNext(event -> {
switch (event.getType()) {
caseTEXT_BLOCK_DELTA -> System.out.print(
((io.agentscope.core.event.TextBlockDeltaEvent) event).getDelta());
caseTOOL_CALL_START -> System.out.println(
"\n[tool] " + ((io.agentscope.core.event.ToolCallStartEvent) event).getToolCallName());
default -> { }
}
})
.blockLast();
}
}AgentScope Java 2.0 is a major step up from a "build an agent" toolkit toward a complete platform for running agents in production. The improvements fall into three focus areas:
A bare ReAct loop solves one reasoning turn. HarnessAgent layers engineering infrastructure on top of ReActAgent via Middleware and Toolkit channels — the reasoning core stays untouched, capabilities layer on:
- Self-evolution & skill repository — successful patterns auto-save as Markdown skills, shared across sessions and loaded on demand
- Layered memory — in-context conversation + agent-curated
MEMORY.md+ on-disk fact log, with auto-compaction to bound the prompt - Sub-agents — declare child agent specs in Markdown,
agent_spawn/agent_sendat runtime, sync or background delegation - Auto context management — structured compaction preserves goals / state / findings / next steps; oversized tool results offload to disk
- Plan Mode — read-only planning state for long tasks, plan files persist and drive execution
Production agents must serve many tenants, run untrusted code safely, and survive rolling restarts. AgentScope 2.0 is built for stateless horizontal scaling:
- Multi-tenant isolation —
session/user/agent/orgdimension isolation,RuntimeContextkeys flow through workspace paths, KV namespaces, and sandbox state slots - Secure sandbox — local subprocess / Docker / Kubernetes / E2B cloud sandbox, with snapshot and resume
- Permission control — three-state engine (allow / approve / deny), sensitive tools require HITL approval
- Session recovery —
AgentStateStore(in-memory / JSON file / MySQL / Redis / PostgreSQL) backs zero-downtime rolling deploys
Messages, events, and the extension model are smaller, more orthogonal — HITL and event streaming are part of how the framework runs, not add-ons:
- Event stream — 28 typed events covering model calls, text deltas, tool execution, and user confirmations in real time
- Message model — text / files / images / audio / video / tool results unified into
ContentBlock, role-strict validation at construction - Middleware —
onAgent/onReasoning/onActing/onModelCall/onSystemPromptfive stages replace v1's flat hooks - HITL first class — confirm tool arguments, approve sensitive actions, hand off to external systems, agent pauses and resumes exactly
For the complete architecture overview, see the documentation.
We welcome contributions from the community! Please refer to our CONTRIBUTING.md for guidelines on how to contribute.
AgentScope is released under Apache License 2.0.
All thanks to our contributors: