AgentScope 2.0: a Python agent framework that keeps the loop visible

What AgentScope 2.0 is built for, and who it fits

AgentScope 2.0 is a Python framework for building agents whose behaviour comes from the model's own reasoning and tool use. The README states the design intent directly: the project aims to work with increasingly agentic LLMs and to use their reasoning and tool use abilities rather than constraining them with strict prompts and opinionated orchestrations. That is a real architectural position, not a slogan. Frameworks that encode a fixed dialogue graph tend to fight a model that wants to call three tools in a row and then revise its plan. AgentScope instead exposes the loop and lets the model drive it.

The audience follows from that. The pyproject.toml classifiers list Intended Audience as Developers and Science/Research, Development Status 4 - Beta, and requires-python >=3.11. The dependency list is a fair signal of the target: openai, anthropic, dashscope, mcp<2.0.0, opentelemetry-sdk, python-socketio, tree_sitter, pypdf. This is a framework for people who will write Python, install a model SDK, and read a trace when the agent does something odd. It is not a no-code tool, and the README points at the documentation site and the examples directory rather than at a hosted product.

The ReAct loop, the toolkit and the event bus

The building blocks table in the README describes the mechanism. ReAct is the reasoning-acting loop, with structured output, realtime interruption and resume, and batched tool acting that can run sequentially or concurrently. Toolkit manages tools drawn from three sources: plain Python functions, MCP servers, and skills. It also ships built-in coding tools (shell, file edit, search) plus task and plan tools, which is why the console example can run a coding agent without you writing tool wrappers first.

Around that loop sit three things worth understanding before you commit. Context handles automatic compaction, tool-result offload, and context injection for system prompt, RAG and memory through built-in middleware. The Event System is described as a unified event bus that streams reasoning, tool calls and multimodal content (text, image, audio) to the frontend, which is the mechanism behind the console and the Web UI. Permission and HITL gives fine-grained control over tools and resources, with confirmation and a bypass mode. Middleware provides composable hooks at named points: reply, reasoning, acting, model calling, permission checking, context compression, and system prompt.

The design consequence is that the loop is observable at each stage rather than only at the end. If you want to log every model call, or intercept a tool before it runs, the hook points exist. The trade-off is that you are now responsible for wiring them; nothing in the README suggests a default that inspects tool arguments for you.

Installing AgentScope and running a first agent in the console

AgentScope requires Python 3.11 or higher. The README gives two install paths. From PyPI, the command is uv pip install agentscope. From source, you clone the main branch and install the package in editable mode.

uv pip install agentscope

If you prefer to track the repository, the README's source route is a clone followed by an editable install. Note that the README uses uv for both; pip is not shown, though the package is published on PyPI.

git clone -b main https://github.com/agentscope-ai/agentscope.git
cd agentscope
uv pip install -e .

The README's first agent example composes an Agent from a model, a credential and a toolkit, then launches it in the terminal console. The snippet in the README is truncated at the model name, so treat the shape as the illustration and check the docs for the complete form.

from agentscope.agent import Agent
from agentscope.console import launch_console
from agentscope.tool import Toolkit, Bash, Grep, Glob, Read, Write, Edit
from agentscope.credential import DashScopeCredential
from agentscope.model import DashScopeChatModel

import os, asyncio

async def main() -> None:
    agent = Agent(
        name="Friday",
        system_prompt="You're a helpful assistant named Friday.",
        model=DashScopeChatModel(
            credential=DashScopeCredential(
              api_key=os.environ["DASHSCOPE_API_KEY"]
            ),

The example reads DASHSCOPE_API_KEY from the environment, so export that variable before running it. What you should see is an interactive terminal session where the agent's reasoning and tool calls are printed as they happen, which is the console building block announced in the August 2026 news entries. There is also a web_ui example under examples/ if you want the browser front end instead.

Where AgentScope gets in the way

The dependency list is heavy and it is not optional. A base install pulls in anthropic, openai, dashscope, mcp, opentelemetry-api, opentelemetry-sdk, opentelemetry-exporter-otlp, python-socketio, tree_sitter with tree_sitter_bash, pypdf, numpy and jinja2. If you only wanted a ReAct loop against one provider, you are installing observability, a socket layer, a parser stack and a PDF reader alongside it. Model-specific SDKs for Gemini, Ollama and xAI are split into optional extras (model-gemini, model-ollama, model-xai), but the three biggest provider SDKs are not.

The second constraint is Python 3.11. Projects pinned to 3.10 or older cannot install it at all, and there is no Java or Spring AI port in this repository, despite search interest in that direction. The third is the Beta classifier. Combined with a release cadence that moved from v2.0.6 to v2.0.7 to v2.0.7.post1 inside August 2026, it means you should expect API movement between minor versions and pin accordingly.

Finally, the framework deliberately does not decide your orchestration. If your problem is a fixed sequence of five steps with no branching, a ReAct loop with a toolkit is more machinery than the task needs, and you will spend time constraining a model that has been invited to plan. The Pipeline building block, announced in August 2026, is the answer for fixed logic across multiple agents behind one event stream, but it is one entry in a list, not the default posture.

AgentScope compared with LangChain and LangGraph

The most common comparison question is AgentScope against LangChain or LangGraph, and the difference is where the control flow lives. LangGraph models an application as a graph of nodes and edges that you define, so the topology of the computation is explicit and the model fills in node behaviour. AgentScope 2.0 inverts that: the ReAct loop is the topology, and the model decides which tool to call next. The README states this preference openly, describing the goal as using the models' reasoning and tool use abilities rather than constraining them with strict prompts and opinionated orchestrations.

That has practical consequences. A graph gives you a diagram you can reason about and a bounded set of transitions, which is easier to audit when the workflow is regulated or when you need deterministic retries. An open loop gives you less to specify and more to observe, which is why AgentScope invests in the event bus, middleware hooks and the permission system. If your team's mental model is a flowchart, LangGraph matches it. If your mental model is a capable assistant with a toolbox and an audit trail, AgentScope's abstractions are closer.

The second real difference is scope. AgentScope ships an agent service: a FastAPI backend with a pre-built Web UI in examples/web_ui, channels for DingTalk, Feishu (Lark) and Discord, and a hub for browsing and installing MCP servers and skills. That is deployment surface, not just a library. Whether you want it depends on whether you are building a product or embedding an agent in an existing service.

Licence, release cadence and what an upgrade costs

AgentScope is Apache-2.0, declared both in the LICENSE file and in pyproject.toml. That is a permissive licence with an explicit patent grant, and it permits commercial use and modification. The repository does not state any additional terms, but Apache-2.0 obligations around attribution and notice files still apply to redistributed copies, so route the specifics through your own legal review rather than treating this paragraph as advice.

The maintenance signal is concrete. The last push to main was on 2026-08-28, and the most recent release, v2.0.7.post1, carries the same timestamp. v2.0.7 landed on 2026-08-24 and v2.0.6 on 2026-08-07. Three releases in one month, with a post-release patch, tells you the project is moving and that patch releases appear quickly after a minor. The repository is not archived.

For upgrade cost, read the dependency pins. mcp is capped below 2.0.0, json_repair is pinned at >=0.63.4, and the OpenTelemetry packages carry minimums. Those caps exist because upstream changes would break the framework, and they will also constrain you if another part of your stack wants a newer MCP. The Beta classifier plus this cadence means pinning agentscope to an exact version and reading the release notes before bumping is the cheaper habit. Nothing in the README documents a rollback procedure or a deprecation policy, so version pinning is the only mechanism you control.

Editorial conclusion

Adopt AgentScope if you want the reasoning-acting loop, tool permissions and event stream exposed as Python objects you can inspect and extend, and if your runtime is Python 3.11 or newer. Do not adopt it if you need a Java or Spring AI integration, or if you want a visual workflow builder instead of code. Before committing, verify that the model provider you intend to use has an entry in the Model building block, and check whether the sandbox backend you need (local, Docker, Bubblewrap, E2B, OpenSandbox, Daytona, K8s) is listed in the workspace documentation.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes