GO TO A SECTION

↑ ↓ to navigate · Enter to openExplore all sections →
FDEInterviews logo
arXiv preprint

AgentScope 1.0: A Developer-Centric Framework for Building Agentic Applications

Alibaba's agent framework makes interruption, parallel tool calls, tool groups and saved state first-class. A design reference with no measurements, so test its claims yourself.

Breakdown by FDE Interviews · 13 min read · Updated

About the original · 2025
AUTHORS
Gao, Li, Xie, Kuang, et al.
FROM
Alibaba Group
PUBLISHED
Aug 2025 · arXiv preprint
CITED BY
17Semantic Scholar · Oct 2026
IN THIS BREAKDOWN · 10 SECTIONS

You can read 18% of this breakdown.

01

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.

THE IDEA, VISUALLY
FOUR FOUNDATIONAL MODULES Message typed blocks Model one schema Memory short + long Toolkit functions, MCP THE REACT AGENT reply() reason, act, answer observe() take in, no reply handle_interrupt() react to a stop parallel tool calls (asyncio.gather) · hooks before and after reply, observe, reasoning, acting, print · state_dict to save AROUND IT Evaluation General: one process Ray: distributed resumes after a stop Studio OpenTelemetry traces bootstrapped CIs unstable items Runtime Engine: FastAPI, A2A Sandbox: files, browser, training Built-in agents: deep research, browser use, meta planner. Mem0 backs the long-term memory implementation. A framework report: the paper contains no measurements. AN INTERRUPT IS AN EVENT, NOT JUST A STOP reason tool streams user: stop keep partial reason again asyncio cancellation; yielded chunks and partial model output stay in memory with "tool execution was interrupted". ONLY THE ACTIVE TOOL GROUP IS SHOWN browser files shell search crm The agent calls reset_equipped_tools to switch groups, e.g. from browsing to programming mid-task. MCP CLIENTS Stateless connect, call, close for every call Stateful connect once; session kept (browser cookies) Remote tools become local Python proxies, so they can be wrapped: remote search, local regex filter, remote summary.
AgentScope wraps a ReAct agent in the machinery a product needs: interruptions that keep partial work, tools shown in groups, sessions that persist across MCP calls, and evaluation and tracing around the loop.
Research notes: the problem, approach and results
3

agent entry points: reply to a query, observe without replying, and handle an interrupt

2 + 2

long-term memory methods: two the developer calls at fixed points, two the agent calls as tools

0

benchmark, latency or reliability measurements in the paper; claims of industrial-grade performance are untested

THE PROBLEM

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.

THE IDEA

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.

THE RESULT

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.

02

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.

THE FULL BREAKDOWN

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

Get Premium · ₹2,000 / $25
  • ◇1 architecture diagram
  • </>1 runnable code experiment
  • ▦3 results tables
  • ?5 interview questions with answers
  1. 03Key takeaways

    The building blocks, the agent loop's extras, the tooling, what is missing, and three misreadings

    Free account
  2. 04How it works

    The agent loop with interrupts, tool groups, MCP clients, memory modes, evaluation and deployment

    Premium
  3. 05The numbers that matter

    What the paper quantifies (very little), and the numbers you should collect before adopting it

    Premium
  4. 06Try it yourself

    Time parallel tools, interrupt a streaming and a blocking tool, and count tool-schema tokens

    Premium
  5. 07Where it breaks

    No evaluation, interruption semantics, unchecked identities in multi-agent hubs and small slips

    Premium
  6. 08Using it on a deployment

    Choosing or building an agent runtime with these features, and what to verify

    Premium
  7. 09Interview angles

    Five questions this paper prepares you for, with answer hints

    Premium
Back to the paper library →