AgentScope

The core is a stateless reasoning-acting loop in Agent: the model reasons, calls tools from a Toolkit, and every step is published on one event stream (text deltas, tool calls, results). Middleware hooks wrap reasoning, acting, model calls, permission checks and context compression, and a workspace decides where tools actually execute.

Multi-agent work goes through pipelines that expose several agents behind a single reply_stream. TeamPipeline gives a leader a TeamAssign tool; members run in their own contexts, concurrently when assigned in the same round, and never talk to each other. GoalPipeline loops an executor against a verifier, and the agent service adds a leader-worker Agent Team with task planning. Remote agents can join through A2AAgent.

Working memory is managed by context middleware (compaction, tool-result offload). Long-term memory is middleware backed by Markdown files, ReMe or Mem0. The agent service persists session state in SQL or NoSQL backends.

Every tool call passes the permission system, which returns allow, deny or ask. On ask, the agent emits RequireUserConfirmEvent with the pending calls and suggested rules and parks the reply; the app sends a confirmation result back through reply / reply_stream to resume, and accepted rules can be persisted. Tools marked for external execution pause the same way. Running agents can be interrupted and resumed from a consistent state, and in TeamPipeline a member's confirmation request is routed back to that member by reply_id. A2AAgent proxies do not support these controls.

uv pip install agentscope

import asyncio, os
from agentscope.agent import Agent
from agentscope.console import launch_console
from agentscope.credential import OpenAICredential
from agentscope.model import OpenAIChatModel
from agentscope.pipeline import TeamMember, TeamPipeline
from agentscope.tool import Toolkit, Read, Grep

async def main() -> None:
    model = OpenAIChatModel(credential=OpenAICredential(api_key=os.environ["OPENAI_API_KEY"]), model="gpt-4o-mini")
    lead = Agent(name="Lead", system_prompt="Split the task and assign parts.", model=model, toolkit=Toolkit())
    reader = Agent(name="Reader", system_prompt="Read files and summarize them.", model=model,
                   toolkit=Toolkit(tools=[Read(), Grep()]))
    team = TeamPipeline(leader=lead, members=[TeamMember(agent=reader, description="Reads and summarizes local files.")])
    await launch_console(agent=team)  # terminal chat with tool-call confirmation

asyncio.run(main())

• Requires Python 3.11 or higher; the docs recommend installing with uv.
• Use the documentation version that matches the installed package; /latest/ is development docs, and 1.x and 2.x APIs must not be mixed.
• The leader in a TeamPipeline needs a toolkit (the pipeline registers TeamAssign there), and member names must be unique and differ from the leader's.
• A2A needs pip install "agentscope[a2a]"; the agent service and AG-UI middleware come with the service extra.
• Set the provider key (for example DASHSCOPE_API_KEY in the official quickstart, or OPENAI_API_KEY with OpenAICredential).

Yes. Agents load MCP servers through MCPClient in the Toolkit, A2AAgent talks to remote A2A agents, and the agent service includes an AG-UI protocol middleware.

Yes. It is Apache-2.0 and no paid tier is documented; you pay for the model provider you connect.

Most directly through TeamPipeline: a leader agent assigns tasks to members with a TeamAssign tool and gets back only their final replies. GoalPipeline and the service-level Agent Team are other options.

This repository is the Python SDK (Python 3.11+). The FAQ lists separate TypeScript and Java implementations with their own APIs and releases.

Yes. When the permission system returns ask, the agent emits RequireUserConfirmEvent and waits; sending the user's answer back resumes it.