AgentScope 2.0: A Python Agent Framework Built for Observability and Production Deployment
Build and run agents you can see, understand and trust.
At a glance
- What is it?
- AgentScope 2.0 is a Python agent framework that emphasizes visible reasoning, tool control, and deployment as an agent service. It suits teams that need structured event streaming and permission checks, but its breadth of abstractions may overwhelm simple projects.
- Who is it for?
- Adopt AgentScope 2.0 if you are building a production agent service that needs fine-grained tool permissions, human-in-the-loop confirmation, and a unified event stream for frontend visualization. Skip it if you only need a thin wrapper around an LLM API or if your team cannot commit to Python 3.11 and the learning curve of middleware and workspace backends.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 2 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- agentscope-ai/agentscope36,048 ★ · +6,231
| Repository | 2026-08-27 | 2026-11-15 |
|---|---|---|
| agentscope-ai/agentscope | 29.8k | 36k |
6,231 Stars in the last 80 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
What Problem AgentScope 2.0 Actually Solves
Most agent frameworks hand you a loop and a prompt template. AgentScope 2.0 takes a different stance: it is built for increasingly agentic LLMs, meaning it tries to get out of the model's way and instead gives you hooks to observe and intervene. The README states the design goal as leveraging the models' reasoning and tool use abilities rather than constraining them with strict prompts and opinionated orchestrations. That matters for teams whose agents need to adapt to unexpected tool outputs or user interruptions. The target user is a developer building a multi-session, multi-tenant application, not someone experimenting with a single script. The framework ships a FastAPI backend with a pre-built Web UI, which suggests the intended deployment is a real service with multiple users. If your problem is just 'call an LLM with a system prompt', this is overkill.
The Architecture: SDK Building Blocks and an Agent Service
The repository splits into two layers. The SDK layer lets you compose an agent from discrete building blocks: ReAct for the reasoning-acting loop, Toolkit for tool management, Model for provider abstraction, Context for compaction and injection, and an Event System that streams reasoning, tool calls, and multimodal content to a frontend. The second layer is the agent service, a batteries-included FastAPI backend with a Web UI. The service supports multi-tenancy and multi-session,. The data flow is event-driven: the agent emits events (text, image, audio) on a unified bus, and the frontend or channel consumes them. This is a fundamental difference from frameworks that just return a final string. The ReAct building block also supports realtime interruption and resume. The middleware system sits across the loop, with hooks for reply, reasoning, acting, model calling, permission checking, context compression, and system prompt. That is a lot of extension points, and it makes the framework flexible but also demands that you understand the order of operations.
Getting Started: Installation and Your First Agent
Installation requires Python 3.11 or higher. The README gives two paths. From PyPI, run 'uv pip install agentscope'. From source, clone the repository and run 'uv pip install -e .' inside the directory. The quickstart example shows a console-based agent. You import Agent, launch_console, and several tools: Bash, Grep, Glob, Read, Write, Edit. You also need a credential object, in this case DashScopeCredential, and a model object, DashScopeChatModel. The example uses an environment variable for the API key. The agent is constructed with a name, a system prompt, and the model. The console launch is for testing and debugging in the terminal, which is a practical way to iterate without building a UI. The example imports launch_console to run the agent from the terminal. Note that the example uses DashScope, which is Alibaba's cloud, and the README lists other providers including OpenAI, Anthropic, and DeepSeek.
Permission and Human-in-the-Loop: Where the Framework Gets Opinionated
AgentScope 2.0 includes a Permission & HITL building block that provides fine-grained control over tools and resources, with confirmation and a bypass mode. This is a concrete answer to the common problem of agents executing dangerous shell commands or writing files without oversight. The permission system sits as a middleware hook, so it can be composed with other hooks. The bypass mode is interesting: it lets you disable confirmation for certain actions, which is useful for trusted, read-only tools. The trade-off is that you must design your permission rules carefully. If you set bypass too broadly, you lose the safety benefit. The README table describes the permission system as fine-grained control over tools and resources, with confirmation and bypass mode, and links to the permission-system docs.
Workspaces and Sandboxes: The Cost of Isolation
The framework supports isolated tool and code execution through workspaces. The listed backends are local, Docker, Apple Container, Bubblewrap, E2B, OpenSandbox, Daytona, and K8s. That is a wide range, from simple local execution to Kubernetes. The benefit is that you can run untrusted code or tools without risking the host. The cost is operational complexity. For example, using Daytona or K8s means you need to manage those infrastructures. A practical concern: if you choose local execution for simplicity, you lose the isolation that makes the sandbox valuable. For a small team, local or Docker is likely enough. For a large deployment, K8s is the target. The wrong choice is to ignore sandboxing entirely when your agent uses shell tools, because the built-in Bash tool can execute arbitrary commands.
Channels and Hubs: Deployment to IM and Tool Marketplaces
The 2026-09 and 2026-10 news items in the README show a rapid expansion of features: TeamPipeline, in which a leader agent delegates tasks to member agents; A2A protocol support through A2AAgent; realtime voice agents and realtime APIs (DashScope, OpenAI, Gemini and xAI) in RealtimeAgent; SOP support; and model routing through ModelRouterMiddleware. Several of these are marked Experimental. The team pipeline adds structure by having a leader assign work to members, which sits in tension with the agentic, non-opinionated philosophy: the framework wants to let models decide, but a pipeline imposes some structure. Check the docs for which of these features are stable before depending on them.
Limitations and Cases Where It Is the Wrong Tool
The most obvious limitation is the Python version requirement. Python 3.11 or higher excludes teams stuck on older LTS distributions. The README also does not mention any official support for other languages, so this is Python-only. Another limitation is the learning curve: the middleware system, event bus, and workspace backends form a complex stack. For a simple two-tool agent, the overhead of setting up the service and channels is unjustified. The framework's strength in observability depends on the event stream, but if you do not build a frontend that consumes it, you lose that benefit. Also, verify the default permission behavior in the docs before deploying, since the built-in toolkit includes shell tools.
Alternatives and How They Differ
The closest alternative in the Python ecosystem is LangGraph, which also builds agent workflows but with a graph-based state machine. LangGraph gives you explicit nodes and edges, so control flow is deterministic and inspectable. AgentScope 2.0, by contrast, favors a more autonomous loop with middleware hooks. If you need fine-grained control over the sequence of steps, LangGraph is a better fit. Another alternative is AutoGen (now Microsoft Agent Framework), which uses a conversation-based multi-agent model. AutoGen emphasizes agent-to-agent dialogue, while AgentScope's README emphasizes building blocks such as tooling, middleware and event streaming. The key difference is the event system: AgentScope treats every reasoning step and tool call as a streamable event, which is designed for live UI updates. If you need a strict workflow graph, choose LangGraph.
Maintenance, Licensing, and Upgrade Considerations
AgentScope is licensed under Apache-2.0, which permits commercial use, modification, and distribution without copyleft obligations. That is a permissive license, so you can embed it in proprietary products. The repository is active, with the last push on 2026-11-02 and recent releases v2.0.11 (2026-10-27), v2.0.10 (2026-10-12) and v2.0.9 (2026-09-28). The release cadence suggests ongoing maintenance. The news items show frequent feature additions, which is positive but also means the API may change between minor versions. The 2.0 designation implies a major version that may include breaking changes from 1.x. Before adopting, check the docs for a changelog or migration notes. The dependency on 'uv' for installation is a specific choice; teams using pip or poetry may need to adapt. The framework also pulls in many optional backends (K8s, Daytona, etc.), so the core install may be lighter than the full feature set, but you will need to install extras for those integrations. Verify which extras are required for your chosen workspace and channel.
Editorial conclusion
Adopt AgentScope 2.0 if you are building a production agent service that needs fine-grained tool permissions, human-in-the-loop confirmation, and a unified event stream for frontend visualization. Skip it if you only need a thin wrapper around an LLM API or if your team cannot commit to Python 3.11 and the learning curve of middleware and workspace backends. Before adopting, verify that your preferred model provider is supported (OpenAI, Anthropic, Gemini, DashScope, DeepSeek, Moonshot, xAI, Ollama are listed) and that your deployment target (local, Docker, K8s, etc.) matches the workspace options. Also confirm that the ReAct loop's realtime interruption and resume features work with your frontend stack, since the framework's value depends on that stream.
Frequently asked questions
Is AgentScope free to use?
The framework is published on PyPI under the Apache-2.0 licence and installs with a single uv command, so the code itself carries no fee. Model calls are a separate matter, because the quickstart supplies a provider credential from an environment variable, in that example DASHSCOPE_API_KEY, and provider extras such as model-ollama decide which endpoint you point at.
what is agentscope
It is a Python agent framework whose 2.0 release is organised as an SDK layer of nine building blocks, from ReAct and Toolkit to Permission, Middleware, Memory and Workspace, with a FastAPI agent service and a pre-built web UI on top. The design statement is that it targets increasingly agentic models and uses their reasoning and tool use rather than constraining them with strict prompts.
how to use agentscope
Install it with Python 3.11 or higher, either from PyPI with uv pip install agentscope or from a clone installed in editable mode, then compose an agent. The quickstart builds an Agent with a name, a system prompt, a chat model and a credential read from the environment, and launches it from the console.
agentscope vs langgraph
Its own positioning is that the framework is designed for increasingly agentic models and leans on their reasoning and tool use rather than constraining them with strict prompts and opinionated orchestrations.
agentscope vs spring ai alibaba
The Alibaba connection is authorship, not a language binding: the project file names the SysML team of Alibaba Tongyi Lab as the authors. The distribution is Python only, with requires-python of at least 3.11 and classifiers for Python 3 and 3.11, and no Java module in the tree.
agentscope alternative
It states the design intent, which is to use the reasoning and tool use abilities of newer models rather than constraining them, plus the list of building blocks and sandbox backends a team assembles for itself.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/agentscope-ai-agentscope)Star history chart for your README
[](https://hysenlabs.com/projects/agentscope-ai-agentscope)Was this useful?