"What if your AI agents could actually talk to each other, remember things, use real tools, recover from failures, and ship to production — without you duct-taping five different libraries together at midnight?"
That's not a dream. That's AgentScope 1.0.
And right now, most developers haven't found it yet.
This post is going to change that. I'm going to walk you through everything — what AgentScope is, how it thinks, how it works under the hood, and how to actually build something real with it. No fluff. No hype. Just the knowledge you need.
Grab a coffee. This is a long one — because you deserve a real explanation, not a surface-level overview.
First, Let's Talk About Why AI Agents Are Hard
Before we get into AgentScope, we need to understand the actual problem it's solving. Because if you don't feel the pain, the solution won't make sense.
Here's the reality of building AI agents in 2025:
Single agents hit a wall fast. You give a language model a task. It answers. Great. But what happens when the task is too complex for one pass? What if it needs to search the web, then write a report, then review that report, then send it somewhere? You can't just prompt your way out of that. You need multiple steps, multiple tools, possibly multiple agents working together.
Coordination is the hard part. Getting one agent to work is easy. Getting three agents to work together — sharing information, not duplicating effort, passing the right data at the right time — that's where frameworks fall apart. Most tutorials don't show you this part. Most frameworks don't handle it well.
Tools are unreliable. Your agent calls a tool. The tool times out. Or returns malformed data. Or requires state from a previous call. What does your agent do? Most frameworks: crash, hallucinate, or silently fail. None of those are acceptable in production.
Memory is fake in most frameworks. They give you a history list. You pass it into the prompt. When it gets too long, you truncate it. And now your agent forgot what it was doing. That's not memory. That's a hack.
Production is a completely different beast. Your agent works on your laptop. Then you try to deploy it. Now you need logging, monitoring, error recovery, authentication, scaling... and suddenly you're rebuilding half the framework yourself.
This is the wall every serious agent developer hits. And this is exactly what AgentScope was designed to solve.
What Is AgentScope, Really?
AgentScope is an open-source multi-agent framework built by Alibaba's Tongyi Lab. The first version came out in early 2024, and version 1.0 dropped in August 2025 with major architectural improvements.
The GitHub repo describes it simply: "Build and run agents you can see, understand and trust."
That word "trust" is doing a lot of work there. Most AI frameworks ask you to trust that things are happening correctly behind the scenes. AgentScope is designed so you can verify it.
It was built with a very specific developer in mind — someone who needs to go from "idea" to "production-ready agent system" without switching frameworks halfway through, without rewriting their architecture, and without losing visibility into what their agents are actually doing.
The core design decisions flow from this:
- Messages are the core primitive — everything passes through structured messages, so everything is traceable
- Agents are independent units — they don't know about each other, which makes them composable and testable
- ReAct is the reasoning backbone — reason → act → observe → repeat, grounded in peer-reviewed research
- Production concerns are first-class — logging, sandboxing, deployment are built in, not bolted on
Let's go deep on each of these.
The ReAct Loop: How AgentScope Agents Actually Think
Most people hear "AI agent" and imagine something magic. It's not magic. It's a loop.
The ReAct paradigm (from a 2023 paper by Yao et al.) is the foundation AgentScope 1.0 is built on. Here's how it works:
Task comes in
↓
REASON: What do I know? What do I need to find out? What's my plan?
↓
ACT: Call a tool, search something, write something, ask something
↓
OBSERVE: What did I get back from that action?
↓
REASON again: Did that help? What's next?
↓
Repeat until task is done
This loop is powerful because it's grounded. The agent isn't just generating text — it's taking actions, getting real results, and updating its reasoning based on those results. It can recover from mistakes. It can try a different approach if the first one fails. It can break complex tasks into steps.
Here's what this looks like in AgentScope in practice:
import agentscope
from agentscope.agents import ReActAgent
from agentscope.tools import web_search, code_execution
# Initialize with your model
agentscope.init(model_configuration=[{
"config_name": "my-gpt4o",
"model_type": "openai_chat",
"model_name": "gpt-4o",
"api_key": "YOUR_API_KEY",
}])
# Create an agent with tools
agent = ReActAgent(
name="ResearchAgent",
model_config_name="my-gpt4o",
tools=[web_search, code_execution],
sys_prompt="You are a helpful research assistant. Think step by step."
)
# Give it a task
result = agent("Find the top 3 open-source AI agent frameworks by GitHub stars and compare their key features.")
print(result.content)
What happens under the hood:
- Agent gets the task
- It reasons: "I need to search for GitHub star counts. Let me search for each framework."
- It acts: calls
web_search("langchain github stars 2025") - It observes: gets search results back
- It reasons again: "Good. Now let me search for AgentScope..."
- Repeats until it has all the data
- Writes the comparison
Every single step of that loop is logged and traceable. You can see exactly what the agent thought, what it did, and what it got back. No black boxes.
The Message System: Why This Architecture Is Smarter
This is the part most people gloss over but it's actually the most important design decision in the whole framework.
In AgentScope, everything is a message.
When an agent completes a task, it returns a Msg object. When agents need to communicate, they pass Msg objects. When a tool returns a result, it comes back as part of a message. Even multi-modal data — images, audio, documents — gets wrapped in a message.
Why does this matter?
Because it means you always know what information an agent received and what it sent back. There's no hidden state. No mystery. No "why did it do that?" because you can trace every message in the chain.
Here's a simple example of the message structure:
from agentscope.message import Msg
# A message has a role, content, and optional metadata
msg = Msg(
name="researcher", # who sent it
content="Here are the search results: ...", # what they said
role="assistant", # their role in the conversation
metadata={"tool_used": "web_search", "query": "..."} # extra context
)
And here's where it gets really powerful — the MsgHub.
from agentscope.pipeline import MsgHub, sequential_pipeline
# A MsgHub connects multiple agents and routes messages between them
async def research_pipeline():
researcher = ReActAgent(name="researcher", ...)
writer = ReActAgent(name="writer", ...)
reviewer = ReActAgent(name="reviewer", ...)
# Messages flow: researcher → writer → reviewer
# Each agent sees the output of the previous one
with MsgHub(participants=[researcher, writer, reviewer]):
result = await sequential_pipeline([researcher, writer, reviewer],
initial_msg=Msg(name="user",
content="Write a report on quantum computing",
role="user"))
return result
The researcher finds information. Passes it as a message to the writer. The writer drafts a report. Passes it to the reviewer. The reviewer suggests improvements. Each agent only sees what it needs to see. Clean. Predictable. Debuggable.
You can also do broadcast (one agent sends to all), parallel (multiple agents work simultaneously), or conditional flows (route to different agents based on content). The pipeline primitives are flexible enough to model almost any workflow.
The Tool Problem Nobody Warns You About
Here's a counterintuitive fact that AgentScope's designers took seriously:
More tools = dumber agent.
I'm not making this up. Multiple published papers in 2024-2025 showed that as you increase the number of tools available to an agent, its performance on any given task actually decreases. The model starts picking the wrong tool. Or picking the right tool with wrong parameters. Or getting confused about which tool handles what.
Think of it like this: if you ask a new employee to "just pick whichever tool you need" from a warehouse with 500 tools, they'll waste time searching and probably grab the wrong one. But if you hand them a small toolbox with exactly what they need for today's job, they'll be efficient and accurate.
AgentScope solves this with group-wise tool management.
from agentscope.tools import ToolManager, ToolGroup
# Define tool groups by task context
browser_tools = ToolGroup(
name="web_tools",
description="Use these for anything involving web browsing or search",
tools=[navigate_url, click_element, type_text, web_search, take_screenshot]
)
data_tools = ToolGroup(
name="data_tools",
description="Use these for analyzing data, running calculations, or processing files",
tools=[run_python, read_csv, create_chart, query_database]
)
communication_tools = ToolGroup(
name="communication_tools",
description="Use these to send messages or notifications",
tools=[send_email, post_slack_message, create_github_issue]
)
# Your agent gets all groups but only sees the relevant one at each step
agent = ReActAgent(
name="MultiTaskAgent",
tool_manager=ToolManager(groups=[browser_tools, data_tools, communication_tools]),
...
)
AgentScope's tool manager dynamically selects the right group based on what the agent is currently doing. Researching? Browser tools. Crunching numbers? Data tools. Writing a summary report? It knows not to offer the browser tools anymore.
The result: fewer wrong tool calls, shorter prompts (because you're not describing 50 tools every time), and significantly better task completion rates.
MCP — The Standard That Changes Everything
If you haven't heard of MCP (Model Context Protocol), you're about to hear a lot about it. It's an open standard (originally from Anthropic) that defines how AI agents connect to external tools and services.
Think of MCP as USB for AI tools. Instead of every tool needing a custom integration, MCP defines a standard interface. Any tool that speaks MCP can plug into any agent that supports MCP.
AgentScope 1.0 has deep, first-class MCP support — and critically, it solves a real pain point with a dual-client architecture.
The Problem with Raw MCP
Raw MCP connections are stateless by default. Every tool call starts fresh. No session. No persistent connection. This is fine for simple lookups — but it breaks completely for anything that requires maintaining state.
Imagine trying to automate a browser session with stateless calls. Every click would start a new browser instance. Login? Gone. Cookies? Gone. Page state? Gone.
AgentScope's Solution: Two Kinds of Clients
Stateful Client — creates a persistent connection to an MCP server that lasts across multiple tool calls. The session stays alive. State is preserved. This is what you want for:
- Browser automation (stay logged in, maintain page state)
- Database sessions (keep a transaction open)
- File system operations (working directory stays set)
- Any API that uses session tokens
Stateless Client — connects, makes a call, disconnects. Clean and simple. This is what you want for:
- One-off web searches
- Single API lookups
- Calculations or conversions
- Anything where state doesn't matter
# Register a stateful MCP server (browser automation)
agent.register_mcp_server(
name="browser",
url="http://localhost:3001",
mode="stateful",
auto_reconnect=True # reconnect if the connection drops
)
# Register a stateless MCP server (web search API)
agent.register_mcp_server(
name="search",
url="http://localhost:3002",
mode="stateless"
)
# The agent uses both transparently — you don't have to manage the connections
result = agent("Log in to the dashboard, find the monthly report, download it, and send me a summary.")
The agent will use the stateful browser client for all the login and navigation, and can fire off stateless search calls in parallel without affecting the browser session. You don't have to think about it. The framework manages it.
Memory: The Real Kind
Most agent frameworks describe their memory system like this: "We keep a list of messages and include them in the prompt."
That's not memory. That's a notepad that gets ripped up when it gets too long.
Real memory has layers. Real memory persists. Real memory is selective — it doesn't shove everything into every prompt. AgentScope has two real memory layers:
Short-Term Memory (InMemoryMemory)
This is the active working memory during a task. It holds:
- The conversation so far
- Tool calls that were made and their results
- The agent's reasoning steps (the "think" part of ReAct)
- Intermediate outputs from sub-tasks
It's automatically updated as the agent works through its ReAct loop. You don't have to manage it manually.
# You can inspect it any time
print(agent.memory.get_memory())
# You can add external context to it
agent.memory.add(Msg(name="system", content="User prefers responses under 200 words.", role="system"))
# You can clear specific entries
agent.memory.delete(index=3)
# Or start fresh
agent.memory.clear()
Visibility and control. That's the key difference.
Long-Term Memory
This is for information that needs to survive beyond a single conversation — user preferences, recurring patterns, facts the agent has learned over time.
AgentScope integrates with vector databases and persistent storage backends for long-term memory. When an agent starts a new conversation, it can query its long-term memory to recall relevant information from past sessions.
from agentscope.memory import LongTermMemory
ltm = LongTermMemory(backend="chroma", collection="user_preferences")
agent = ReActAgent(
name="PersonalAssistant",
long_term_memory=ltm,
...
)
# After the first conversation, the agent remembers:
# "This user prefers bullet points. They work in Python. They hate verbose explanations."
# Next conversation, it applies this automatically.
This is what makes the difference between an agent that feels "smart" and one that feels like it's meeting you for the first time every single session.
Observability: See Everything Your Agent Does
Here's a question: when your agent does something unexpected in production, how do you figure out why?
In most frameworks, the answer is "good luck." You might have some print statements. Maybe a log file. But connecting what the agent thought to what it did to what went wrong is usually a forensics exercise.
AgentScope bakes in OpenTelemetry tracing from the first line of code.
Every single LLM call is automatically wrapped in a traced span. You get:
- The exact prompt that was sent (including system prompt, history, tool descriptions)
- The exact response that came back
- Token counts (input + output + total)
- Latency in milliseconds
- Whether the call succeeded or threw an error
- The tool calls within that response, traced as child spans
# This is all you need to enable full tracing
agentscope.init(
model_configuration=[...],
trace_config={
"exporter": "langfuse", # or "arize_phoenix", "jaeger", "otlp", etc.
"endpoint": "http://localhost:3000",
"project": "my-agent-app"
}
)
# From this point, every agent action is automatically traced
# You don't write any extra logging code
In your Langfuse or Arize Phoenix dashboard, you'll see a tree of every action:
Task: "Research and summarize AI trends"
├── ReAct Step 1: Reasoning (34ms, 150 tokens)
├── Tool Call: web_search("AI trends 2025") (823ms)
│ └── Result: 5 search results returned
├── ReAct Step 2: Reasoning (41ms, 210 tokens)
├── Tool Call: web_search("multi-agent frameworks 2025") (756ms)
│ └── Result: 5 search results returned
├── ReAct Step 3: Synthesis (89ms, 890 tokens)
└── Final Response (2.1s total, 1250 tokens total)
When something goes wrong, you can see exactly which step failed, what data it had, and what it was trying to do. Debugging goes from "I have no idea" to "found it in 2 minutes."
Human-in-the-Loop: Staying in Control
One of the most underrated features in AgentScope is human-in-the-loop steering.
Here's the problem it solves: long-running agents can drift. They might misunderstand the goal halfway through. They might hit an edge case you didn't anticipate. They might be about to take an irreversible action (delete a file, send an email, deploy code) and you want to confirm first.
AgentScope lets you pause an agent mid-task, inspect its state, give it a correction, and let it continue — without starting over.
from agentscope.agents import ReActAgent, UserAgent
# A UserAgent represents a human in the pipeline
user = UserAgent(name="Human")
agent = ReActAgent(name="Worker", ...)
# Set checkpoints — agent pauses and waits for human input
# before taking high-risk actions
agent.set_human_checkpoint(
condition="before_tool_call",
tools=["send_email", "delete_file", "deploy_code"], # risky tools
prompt="About to {tool_name}. Confirm? (y/n)"
)
# When the agent hits a checkpoint, it sends a message to the UserAgent
# The human reviews, approves or redirects, and the agent continues
This is huge for real-world use cases. You can build fully autonomous workflows that still have the right guardrails. The agent handles the boring stuff automatically but pauses for anything consequential.
The AgentScope Runtime: From Local to Production
Building agents locally is one thing. Deploying them is a completely different problem. The AgentScope Runtime (a companion project) bridges this gap.
Secure Tool Sandboxing
Every tool your agent calls runs in a sandboxed environment. This means:
- A broken tool can't crash your whole agent process
- Tools can't accidentally access resources they shouldn't
- You can run untrusted tools without compromising your system
from agentscope_runtime import SandboxConfig
# Each tool type has its own sandbox
config = SandboxConfig(
code_execution={"timeout": 30, "memory_limit": "512mb"},
browser={"headless": True, "allowed_domains": ["*.github.com"]},
filesystem={"allowed_paths": ["/tmp/agent_workspace"]}
)
Agent as a Service
Wrap any agent in a REST API with a few lines of code:
from agentscope_runtime import AgentApp
app = AgentApp()
@app.agent_endpoint("/research")
async def research_agent(task: str):
agent = ReActAgent(name="researcher", ...)
return await agent(task)
# Now you have a REST API:
# POST /research {"task": "summarize AI news"}
# → {"result": "...", "trace_id": "abc123", "tokens_used": 1250}
Your agent becomes a microservice. Call it from your web app, your mobile app, your Slack bot, wherever.
Distributed Interrupt Service
For long-running agents (tasks that take minutes or hours), you need the ability to stop them cleanly, inspect their state, and optionally resume.
# Start a long-running task
task_id = await runtime.start_task(
agent=research_agent,
task="Analyze all pull requests from last month and create a summary report"
)
# Interrupt it mid-way if needed
await runtime.interrupt(task_id)
# Inspect the current state
state = await runtime.get_state(task_id)
print(state) # {'current_step': 14, 'completed': ['search', 'parse'], 'pending': ['write', 'review']}
# Resume with a course correction
await runtime.resume(task_id, steering_msg="Focus on security-related PRs only")
Async Everything
All sandboxes (browser, filesystem, GUI, mobile) are fully async in the latest version. This means your agents can run multiple tool calls concurrently without blocking each other.
import asyncio
async def parallel_research():
agent = ReActAgent(name="researcher", ...)
# These three searches happen simultaneously, not one after another
results = await asyncio.gather(
agent.call_tool("web_search", query="AgentScope features"),
agent.call_tool("web_search", query="LangChain limitations"),
agent.call_tool("web_search", query="AutoGen vs AgentScope"),
)
# All three results arrive at roughly the same time
# Then the agent synthesizes them together
A task that would take 9 seconds (3 searches × 3 seconds each) now takes 3 seconds. For complex workflows with 10+ tool calls, this difference is enormous.
Framework Comparison: The Honest Version
Let me give you a real comparison, not a marketing one.
LangChain
The biggest ecosystem. Tons of integrations. Tons of tutorials. You can find help for almost any problem.
The downside: it's complex. Really complex. The API has changed significantly multiple times. Debugging is painful because there are many layers of abstraction between what you write and what actually runs. It's great for getting something working quickly. Harder to maintain and debug at scale.
Best for: Prototyping, quick demos, situations where ecosystem breadth matters more than depth.
CrewAI
Nice abstraction for "role-based" agent teams. You define agents as characters (Researcher, Writer, Manager) and assign them tasks. Very intuitive for simple workflows.
The downside: less control over low-level behavior. When you need to customize how agents communicate or handle failures, you're fighting the abstraction. Not designed for complex dynamic workflows.
Best for: Simple, well-defined workflows where the roles don't change much.
AutoGen (Microsoft)
Strong research pedigree. Good for complex conversational agent scenarios where agents debate and refine outputs through dialogue. Active development.
The downside: heavier setup. More configuration. The conversation-centric model doesn't map naturally to task-execution workflows.
Best for: Research scenarios, multi-agent discussion/debate workflows.
AgentScope
Designed for developers who need to go to production. Transparent by design. Production concerns built in from the start. ReAct loop gives you a solid, research-backed reasoning foundation.
The downside: smaller ecosystem than LangChain. Fewer pre-built integrations (though MCP support helps here). Less community content (though that's changing fast).
Best for: Production systems, complex multi-agent workflows, teams that care about reliability and debuggability.
Quick comparison:
| Feature | LangChain | CrewAI | AutoGen | AgentScope |
|---|---|---|---|---|
| Ease of start | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ |
| Production-ready | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Observability | ⭐⭐ | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Debuggability | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Multi-agent | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| MCP support | ⭐⭐⭐ | ⭐⭐ | ⭐⭐ | ⭐⭐⭐⭐⭐ |
| Ecosystem size | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ |
Real-World Use Cases Where AgentScope Shines
Let me describe concrete scenarios where this framework earns its keep.
1. Automated Research and Report Generation
A researcher agent searches for information across multiple sources. A writer agent synthesizes it into a report. A reviewer agent checks for accuracy and clarity. The whole pipeline runs asynchronously (parallel searches), the human gets a checkpoint before the report goes out, and the full trace is logged for audit.
2. Customer Support Automation
An intake agent classifies the support ticket. A knowledge-base agent searches for relevant docs. A response agent drafts the reply. If the confidence is low (the agent flags it), a human gets the checkpoint and can correct or approve before the email sends. Long-term memory means the agent remembers this customer's history.
3. Code Review Pipeline
An agent pulls a pull request from GitHub (via MCP). A security analysis agent scans for vulnerabilities. A code quality agent checks for style and complexity. A summary agent writes a review comment. All three analysis agents run in parallel. The result is posted back to GitHub automatically.
4. Competitive Intelligence Monitoring
Runs on a schedule. Multiple agents monitor competitor websites, social media, job postings, and product updates. A synthesis agent compiles the changes into a weekly briefing. Delivered to Slack automatically. Fully observable. Full trace history if you ever need to verify a finding.
Full Working Example: Multi-Agent Research System
Let's put it all together. Here's a real, runnable multi-agent system:
import asyncio
import agentscope
from agentscope.agents import ReActAgent, UserAgent
from agentscope.pipeline import MsgHub, sequential_pipeline
from agentscope.message import Msg
from agentscope.tools import web_search, code_execution
from agentscope.memory import LongTermMemory
# ── 1. Initialize ──────────────────────────────────────────
agentscope.init(
model_configuration=[{
"config_name": "gpt-4o",
"model_type": "openai_chat",
"model_name": "gpt-4o",
"api_key": "YOUR_API_KEY",
}],
trace_config={
"exporter": "langfuse",
"endpoint": "http://localhost:3000",
}
)
# ── 2. Define Agents ───────────────────────────────────────
researcher = ReActAgent(
name="Researcher",
model_config_name="gpt-4o",
sys_prompt="""You are a research specialist. Your job is to find
accurate, current information on any topic. Always cite your sources.
Search thoroughly before concluding.""",
tools=[web_search],
max_steps=8, # maximum ReAct iterations
)
analyst = ReActAgent(
name="Analyst",
model_config_name="gpt-4o",
sys_prompt="""You are a data analyst. You receive raw research and
turn it into structured, insightful analysis. Use code execution
for any calculations or data processing.""",
tools=[code_execution],
)
writer = ReActAgent(
name="Writer",
model_config_name="gpt-4o",
sys_prompt="""You are a technical writer. You receive research and
analysis, and write a clear, engaging final report.
Use plain language. Avoid jargon. Structure well.""",
)
user = UserAgent(name="Human") # represents the human reviewer
# ── 3. Run the Pipeline ────────────────────────────────────
async def research_pipeline(topic: str):
initial_task = Msg(
name="Human",
content=f"Research topic: {topic}\n\nProvide a comprehensive analysis and written report.",
role="user"
)
with MsgHub(participants=[researcher, analyst, writer, user]):
# Sequential: researcher → analyst → writer
# Each receives the output of the previous
result = await sequential_pipeline(
[researcher, analyst, writer],
initial_msg=initial_task
)
return result
# ── 4. Run it ──────────────────────────────────────────────
if __name__ == "__main__":
result = asyncio.run(
research_pipeline("The current state of AI agent frameworks in 2025")
)
print(result.content)
Run this and you get a research report where:
- The Researcher found real current information with web search
- The Analyst structured the data
- The Writer made it readable
- The whole thing is traced in Langfuse
- Every step is inspectable
This isn't a demo. It's a starting point for something you can ship.
Getting Started: Your First 30 Minutes
Step 1: Install
pip install agentscope
Step 2: Run the hello world
import agentscope
from agentscope.agents import ReActAgent
from agentscope.tools import web_search
agentscope.init(model_configuration=[{
"config_name": "gpt-4o",
"model_type": "openai_chat",
"model_name": "gpt-4o",
"api_key": "YOUR_KEY_HERE",
}])
agent = ReActAgent(
name="HelloAgent",
model_config_name="gpt-4o",
tools=[web_search],
)
print(agent("What are the 3 newest AI agent frameworks in 2025?").content)
Step 3: Check the examples — the GitHub repo has a whole samples folder with production-ready templates.
Step 4: Read the paper — AgentScope 1.0 on arXiv — it's well written and explains the design decisions clearly.
Step 5: Add observability — set up a free Langfuse account and add the trace_config to your init. You'll immediately see what your agent is doing.
The Honest Summary
AgentScope isn't the flashiest framework. It's not the one with the most YouTube tutorials. It's not the one with the biggest Discord server.
What it is: a framework that was clearly designed by people who tried to build real agent systems and hit every wall we described at the top of this post. And instead of workarounds, they built actual solutions.
- Real message passing (not prompt hacks)
- Real memory (not a list of strings)
- Real tool management (not "here are all 100 tools, good luck")
- Real MCP support (stateful AND stateless, not just a thin wrapper)
- Real observability (not console.log)
- Real production deployment (not "figure it out yourself")
The AI agent space is growing up. The era of duct-tape frameworks is ending. Developers who care about reliability, debuggability, and production-readiness are moving to tools that take those concerns seriously.
AgentScope takes them seriously.
That's rarer than it should be in 2025.
If this helped you, drop a ❤️. If you're already using AgentScope, tell me what you're building in the comments — I'd love to see it.
→ GitHub: agentscope-ai/agentscope
→ Runtime: agentscope-ai/agentscope-runtime
→ Paper: AgentScope 1.0 (arXiv)
→ Original paper: AgentScope (arXiv, 2024)
Top comments (0)