AgentScope: Build Production-Ready AI Agents with a Single pip install
By Devy · yoDEV.dev
Most agent frameworks make you feel like you’re solving two problems at once: the problem your agent needs to solve, and the framework itself. Orchestration logic piles up, abstractions leak, and before you know it you’re debugging the scaffolding instead of building the product.
AgentScope takes a different path. It just crossed 21,000 stars on GitHub — and when you see what comes in a single installation, it’s not hard to understand why.
What is AgentScope?
AgentScope is an open source Python framework for building LLM-powered agents and multi-agent applications. It describes itself as “production-ready, easy-to-use” — a claim worth unpacking, because every framework says that. In this case, the installation command backs it up:
pip install agentscope
That’s it. From there you get: a built-in ReAct agent, memory management, planning, MCP support, A2A protocol (Agent-to-Agent), real-time voice, model fine-tuning integration, and deployment tools for local, serverless, and Kubernetes environments. No additional packages, no separate installations for each feature.
Apache 2.0 license. Requires Python 3.10+.
From zero to “hello” in 5 minutes
Here’s a minimal working example — a ReAct agent called Friday that can execute Python code and shell commands:
from agentscope.agent import ReActAgent, UserAgent
from agentscope.model import DashScopeChatModel
from agentscope.formatter import DashScopeChatFormatter
from agentscope.memory import InMemoryMemory
from agentscope.tool import Toolkit, execute_python_code, execute_shell_command
import os, asyncio
async def main():
toolkit = Toolkit()
toolkit.register_tool_function(execute_python_code)
toolkit.register_tool_function(execute_shell_command)
agent = ReActAgent(
name="Friday",
sys_prompt="You're a helpful assistant named Friday.",
model=DashScopeChatModel(
model_name="qwen-max",
api_key=os.environ["DASHSCOPE_API_KEY"],
stream=True,
),
memory=InMemoryMemory(),
formatter=DashScopeChatFormatter(),
toolkit=toolkit,
)
user = UserAgent(name="user")
msg = None
while True:
msg = await agent(msg)
msg = await user(msg)
if msg.get_text_content() == "exit":
break
asyncio.run(main())
The example uses DashScope (Alibaba’s model API), but AgentScope is completely model-agnostic — you can replace it with OpenAI, Anthropic, Gemini, or any local model by changing the model class and formatter. The architecture doesn’t care who runs the tokens.
The four things that really set it apart
1. MCP as a first-class citizen
AgentScope doesn’t treat MCP as a plugin — it’s built in. You can load an MCP server, get a specific tool as a callable local function, and use it in any context: pass it to an agent, wrap it in a more complex tool, or call it directly.
from agentscope.mcp import HttpStatelessClient
from agentscope.tool import Toolkit
async def control_granular_mcp():
client = HttpStatelessClient(
name="maps_mcp",
transport="streamable_http",
url=f"https://mcp.amap.com/mcp?key={os.environ['MAPS_API_KEY']}",
)
# Get the tool as a local function
func = await client.get_callable_function(func_name="maps_geo")
# Option 1: call it directly
await func(address="Buenos Aires", city="Buenos Aires")
# Option 2: pass it to an agent
toolkit = Toolkit()
toolkit.register_tool_function(func)
This granular control over MCP tools is something most frameworks don’t offer. You’re not forced to load entire MCP servers into an agent — you choose exactly which tools you need.
2. Multi-agent orchestration with MsgHub
Multi-agent coordination in AgentScope is handled by MsgHub — a message routing layer that manages who talks to whom, with dynamic participant management during the conversation:
from agentscope.pipeline import MsgHub, sequential_pipeline
from agentscope.message import Msg
async def multi_agent_conversation():
async with MsgHub(
participants=[agent1, agent2, agent3],
announcement=Msg("Host", "Please introduce yourselves.", "assistant")
) as hub:
await sequential_pipeline([agent1, agent2, agent3])
hub.add(agent4) # Add agent in the middle of conversation
hub.delete(agent3) # Remove agent in the middle of conversation
await hub.broadcast(Msg("Host", "See you later!", "assistant"))
You can add or remove agents from a conversation while it’s running. That’s not common.
3. Real-time voice, built-in
No external packages. AgentScope comes with native support for real-time voice agents — both individual and multi-agent. The repository includes a demo of multiple agents playing a werewolf game by voice. Niche? Maybe. But it shows what “batteries included” really means.
4. Fine-tuning integration with RL
If you want to train your agent on real tasks instead of just prompting it, AgentScope integrates with the Trinity-RFT library for reinforcement learning. Their own benchmarks show significant improvements: a navigation agent on “Frozen Lake” going from 15% to 86% success, and an agent in a werewolf game going from 50% to 80% win rate. These are small models (Qwen 2.5 7B-Instruct), which is exactly the point — you don’t need a frontier model if you fine-tune on your specific task.
A2A Support: agents talking to agents
In December 2025 AgentScope added support for the A2A (Agent-to-Agent) protocol — a standard for agents from different frameworks to communicate directly with each other. This is early-stage territory across the whole industry, but AgentScope being A2A-compatible means your agents can eventually interoperate with agents built in other frameworks, not just within the AgentScope ecosystem.
What it doesn’t do (yet)
AgentScope is built primarily around the Alibaba ecosystem — examples use DashScope and Qwen models by default, part of the community is Chinese-speaking, and the DingTalk channel suggests enterprise users in that ecosystem. Documentation quality is solid, but tutorial examples are biased toward those defaults.
For a Latin American dev stack (OpenAI, Anthropic, or local models via Ollama), you’ll need to find the right model class in the API documentation. It’s not hard, but it’s not as plug-and-play as the README makes it seem for the DashScope path.
Installation summary
# Standard installation
pip install agentscope
# Or with uv (faster)
uv pip install agentscope
# From source (for the latest)
git clone -b main https://github.com/agentscope-ai/agentscope.git
cd agentscope
pip install -e .
Requires Python 3.10+. No additional mandatory dependencies.
Full documentation at doc.agentscope.io
Is it worth it?
If you’re building with agents — not just adding a chatbot to a form — AgentScope deserves a serious look. It’s not the flashiest framework and the community is still maturing, but the features-vs-installation-friction ratio is hard to beat. MCP, multi-agent, voice and RL in a single package, with production deployment options included.
The 21,000 stars don’t come from tutorials. They come from people who tried it.
*Are you working on any agent projects? Which framework are you using now? Let us know in the comments.*GitHub - agentscope-ai/agentscope: Build and run agents you can see, understand and trust. · GitHub