AgentScope 2.0: Alibaba’s Framework for Production-Grade Multi-Agent Systems

AIDeveloper44 Team

Moving LLM Agents from Prototype to Production

In the rapidly evolving landscape of large language models, the gap between building a prototype AI agent and deploying it securely in a production environment is notoriously wide. Scaling agentic applications requires solving complex issues like state management, secure tool execution, and multi-tenant isolation. To address these hurdles, Alibaba’s Tongyi Lab has officially released AgentScope 2.0, a major update that transforms the open-source library from a developer toolkit into a robust platform for enterprise-grade, distributed deployment.

Available now on GitHub and PyPI, AgentScope 2.0 focuses on the real-world operational challenges of agent ecosystems. Built to leverage the natural reasoning and tool-use capabilities of advanced LLMs rather than constraining them with rigid prompt orchestration, this release marks a significant milestone in agent engineering.

From AgentScope 1.0 to a Full Production Platform

To understand the significance of this update, we have to look back. The AgentScope 1.0 paper (published in August 2025) introduced a developer-centric framework built around the ReAct (Reasoning and Acting) paradigm, standardized foundational modules, and dynamic tool provisioning. It effectively made agent creation more manageable.

However, 2.0 (released in May 2026, with an "Agent Team" feature following in June 2026) shifts the focus heavily toward horizontal scaling and execution safety. The framework introduces a suite of sophisticated abstractions designed to isolate user data, safely execute arbitrary code, and cleanly decouple agent logic from execution environments.

Key Features in AgentScope 2.0

1. Unified Event System & Real-Time Streaming

AgentScope 2.0 completely rewrites how messages and events are handled. Every step an agent takes—from the model call and text delta to tool execution and tool results—is surfaced as a typed event on a unified stream. Because these streams support multi-modal data via a unified ContentBlock, developers can subscribe once and render rich, responsive UIs seamlessly, eliminating the need to write custom REST adapters.

2. Robust Permission & Execution Security

A major pain point in autonomous operations is the risk of an agent performing unsafe or destructive actions on a host machine. Version 2.0 introduces a static and dynamic Permission System. High-risk shell commands and sensitive file operations can be intercepted or held for review. Native Human-in-the-Loop (HITL) support allows developers to confirm or edit tool arguments mid-run. If a sensitive action needs approval, the agent safely pauses and later resumes exactly where it left off.

3. Decoupled Workspaces & Sandboxing

AgentScope 2.0 introduces an abstract Workspace System. Developers can now move an agent from their local laptop to a Docker container or an E2B cloud sandbox simply by changing a single line of code. Working directories, MCP (Model Context Protocol) clients, and state variables are cleanly isolated per user or session, dramatically reducing the overhead typically required to construct secure sandbox environments.

4. Agent Service & Agent Teams

The framework now ships with an extensible FastAPI-based Multi-tenancy and Multi-session Service backend. You can host agents over REST and Serverless-Sent Events (SSE) out of the box, with built-in resumable streams and background task offloading. Furthermore, as of June 2026, AgentScope introduced Agent Teams. A "leader" agent can automatically spawn and coordinate "worker" agents to distribute long-running or highly complex task planning workflows.

Getting Started: Hello AgentScope

Despite its enterprise-grade features, AgentScope 2.0 remains straightforward to initialize. Here is a quick example of defining a foundational agent utilizing Alibaba's DashScope API and async event streams:

from agentscope.agent import Agent
from agentscope.tool import Toolkit, Bash, Grep, Glob, Read, Write, Edit
from agentscope.credential import DashScopeCredential
from agentscope.model import DashScopeChatModel
from agentscope.message import UserMsg
from agentscope.event import EventType
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"]),
            model="qwen3.6-plus",
        ),
        toolkit=Toolkit(
            tools=[Bash(), Grep(), Glob(), Read(), Write(), Edit()]
        ),
    )

    # Stream the agent's actions and responses natively
    async for evt in agent.reply_stream(UserMsg("Tony", "Hi, Friday!")):
        match evt.type:
            case EventType.TEXT_BLOCK_DELTA:
                # Update UI in real-time
                pass

asyncio.run(main())

The Takeaway

Alibaba’s Tongyi Lab has recognized that the AI community no longer just needs easier ways to prompt models; it needs secure, decoupled, and scalable infrastructure to run them. By integrating robust permission systems, isolated workspaces, and a multi-tenant service backbone, AgentScope 2.0 cements itself as a serious contender for development teams building the next generation of autonomous AI applications.

Enjoyed this?

Get more posts like this delivered to your inbox.

Subscribe