v1.1.0-RC1

Build your own OpenClaw-style agent that keeps evolving inside a workspace, while the same stack scales to enterprise, distributed deployments and can run tools and code in a securely isolated execution environment.

Highlights

This release introduces agentscope-harness, a production-oriented layer on top of agentscope-core’s ReActAgent. The single user-facing entry point is HarnessAgent. Harness does not replace the ReAct loop; it injects hooks and a curated toolkit at the right points so agents can answer: what happens on the next turn, the next day, when context explodes, when state is lost, or when work is too heavy for one agent.

What’s new

1. Workspace as source of truth

A structured workspace directory is the canonical place for persona (AGENTS.md), consolidated long-term memory (MEMORY.md), domain knowledge, skills (skills/), subagent specs (subagents/), and per-agent session data (agents/<agentId>/). Hooks such as WorkspaceContextHook inject workspace content into the system prompt each turn; memory hooks write back so the agent evolves with use, not only within a single chat.

2. Pluggable filesystem (AbstractFilesystem)

All file-oriented behavior goes through one abstraction so the same agent logic can target:

• Local disk + shell (default): full file tools and optional shell when the backend supports it.
• Remote / shared storage: durable memory and session data for multi-replica deployments; execute is intentionally not registered by default to reduce remote execution risk.
• Sandbox: isolated file and command execution on the sandbox side, with workspace projection and configurable isolation scope (e.g. session vs user vs global) for multi-tenant patterns.

3. Session persistence

Stable sessionId (and userId for multi-tenant namespaces) drives:

• Serialized runtime snapshots under agents/<agentId>/context/ for cross-process resume.
• JSONL conversation logs under agents/<agentId>/sessions/ for audit and search, alongside compressed model-facing history.

4. Memory and context management

• Two-layer memory: append-only daily notes under memory/, plus background consolidation into MEMORY.md.
• memory_search / memory_get backed by indexed search (e.g. SQLite FTS) so facts stay retrievable without stuffing everything into context.
• Configurable compaction of long threads; context overflow handling with forced compaction and retry where applicable.
• Large tool-result eviction so oversized tool outputs can be spilled to the filesystem and referenced instead of blowing the context window.

5. Subagent orchestration

Declarative subagents (workspace markdown with front matter, programmatic specs, built-in general-purpose, or custom factories). Synchronous delegation for blocking workflows and asynchronous tasks with IDs and polling via task tools, with safeguards against unbounded subagent recursion.

6. Built-in toolkit

Filesystem tools (read_file, write_file, edit_file, grep_files, glob_files, list_files), memory and session search/list/history, and subagent/task management are wired for you; execute appears only when the configured backend supports the intended isolation model.

Who it’s for

• Local / single-user agents (e.g. personal assistants, coding-style workflows): workspace + optional shell, memory, compaction, skills.
• Enterprise data / analytics agents: sandbox execution, durable sandbox state, shared memory across replicas, subagents for long or parallel work.
• Online business agents: remote filesystem, no shell by default, explicit business tools only, shared session and memory across instances.

Getting started

Add the io.agentscope:agentscope-harness dependency, prepare a workspace with at least AGENTS.md, build HarnessAgent with RuntimeContext (sessionId, and userId when you need tenant isolation). See the agentscope-examples/harness-example module (e.g. QuickstartExample) and the harness documentation under docs/zh/harness/ (overview, workspace, memory, filesystem, sandbox, subagent, session, tool, architecture) for full detail.