IN THIS BREAKDOWN · 10 SECTIONS
You can read 18% of this breakdown.
The paper in one minute
AgentScope is Alibaba's open-source framework for building agent applications, and this paper describes its 1.0 redesign. It is organized in three layers.
The first layer is four foundational components. A message is a sender name, a role and a list of typed content blocks (text, image, audio, video, tool use, tool result, thinking), with an ID and timestamp. The model layer hides provider differences behind formatters and a single response schema, tracks tokens and latency per call, and emits OpenTelemetry traces. Memory has a short-term buffer and a long-term interface, with an implementation built on Mem0. The toolkit turns Python functions and MCP servers into JSON schemas the model can call.
The second layer is the agent. AgentScope recommends one architecture, ReAct, and gives every agent three entry points: reply to reason, act and answer; observe to take in information without answering; and handle_interrupt to react when a user stops it. Around that loop it adds parallel tool calls, tools the agent can switch on and off in groups, hooks before and after every step, and state that can be saved and restored.
The third layer is developer tooling: an evaluation module with a sequential evaluator for debugging and a Ray-based one for scale, a studio that renders traces and evaluation results, and a runtime that deploys an agent as a FastAPI service and runs tools in sandboxes.
The paper ends with built-in agents for deep research, browser use and multi-step planning. It contains no experiments.
Research notes: the problem, approach and results
agent entry points: reply to a query, observe without replying, and handle an interrupt
long-term memory methods: two the developer calls at fixed points, two the agent calls as tools
benchmark, latency or reliability measurements in the paper; claims of industrial-grade performance are untested
A basic model-and-tool loop is easy to write and hard to ship. Users want to redirect an agent mid-task, tools pile up until the model picks the wrong one, remote tool servers need sessions, and developers need to trace, evaluate and deploy what they built without rewriting it for each step.
Standardize four building blocks (messages, models, memory, tools) and build one recommended agent, ReAct, with three entry points: reply, observe and handle an interrupt. Make interruptions observable events that keep partial output, run tool calls in parallel with asyncio, let the agent switch tool groups itself, and add hooks, saveable state, an evaluation module, an OpenTelemetry-based studio and a sandboxed runtime.
A framework report with code listings, workflows and built-in agents for deep research, browser use and planning. It reports no benchmark, latency or reliability numbers, so its value is as a catalog of runtime features to look for, or to build, in any agent framework.
Why it matters to an FDE
When a customer pilot moves from a notebook to people using it, the questions change. Users interrupt: "stop, check the other account first." Agents grow from five tools to forty. A browser tool needs to stay logged in between calls. A security team asks where tools run. The product manager asks whether last week's prompt change helped.
AgentScope is useful because it names these needs as framework features, so you can use it as a checklist when you choose or build a runtime.
Interruption keeps partial work. When a user cuts in, whatever the model or tool already produced is kept in memory with a note saying it was interrupted. The next reasoning step can resume, revise or change course instead of starting blind.
Tools come in groups. Only active groups go into the prompt, and the agent switches groups itself. Fewer tool descriptions per call means fewer tokens and fewer wrong picks.
Sessions are a choice. Stateless MCP clients reconnect for every call; stateful ones keep a session, which a logged-in browser needs.
Evaluation reports a distribution. The studio shows repeated-run results with bootstrapped confidence intervals and sorts test items into consistently right, consistently wrong and unstable.
Because the paper reports no measurements, treat each feature as a claim about design, not about results. The parts worth copying are the interfaces; whether they hold up under your load is for you to measure.
Understand the mechanism. Try it on a real problem.
Unlock this breakdown and 149 more papers.
Premium opens every paper in full, plus every answer, concept, course and guide on the site. One payment for six months of access.
6 months · One payment · No auto-renewal
- ◇1 architecture diagram
- </>1 runnable code experiment
- ▦3 results tables
- ?5 interview questions with answers
- 03Key takeaways
The building blocks, the agent loop's extras, the tooling, what is missing, and three misreadings
Free account - 04How it works
The agent loop with interrupts, tool groups, MCP clients, memory modes, evaluation and deployment
Premium - 05The numbers that matter
What the paper quantifies (very little), and the numbers you should collect before adopting it
Premium - 06Try it yourself
Time parallel tools, interrupt a streaming and a blocking tool, and count tool-schema tokens
Premium - 07Where it breaks
No evaluation, interruption semantics, unchecked identities in multi-agent hubs and small slips
Premium - 08Using it on a deployment
Choosing or building an agent runtime with these features, and what to verify
Premium - 09Interview angles
Five questions this paper prepares you for, with answer hints
Premium - 10Read next
Where to go from here on this site
Premium
