AgentScope 1.0 makes multi-agent systems work without the duct tape

Large language models (LLMs) already reason reasonably well, but the real value shows up when they can do something beyond generating text: query databases, call APIs, compute, drive a web browser. That is where the trouble starts — every provider has a different interface, tools scatter across the project, parallel calls and async are hard to reconcile, and traces of what the agent did are hard to debug and evaluate. AgentScope 1.0 arrives as a construction kit for practical agent systems: it makes an agent's interaction with its environment flexible, fast and predictable, without the pain of hand-wiring it all together.

What the kit is made of

Four clear components sit at the base: messages, model, memory, tools. The message is one format for everything — text, images, audio, video, reasoning steps, tool calls and tool results. Models from different providers share a single interface: streaming, multimodality, tools and the reasoning block all behave the same way. Memory splits into short-term (the history of the current session) and long-term (facts and preferences the agent can meaningfully come back to). Tools register in a single Toolkit: local functions and remote services over MCP look identical, and they can be grouped and switched on or off on the fly.

Reasoning and action in one loop

The agent's behavior is built on the ReAct paradigm (Reason + Action): think, take a step through a tool, look at the observation, repeat. This is not just a template but a whole framework: async execution, parallel calls to several tools within a single step, real-time control over the agent (interrupt it, correct it), state persistence, and extensible hooks for logging and checks. Parallel I/O speeds things up, and assembling the tool set dynamically for the current phase of a task saves context and lowers the chance of picking the wrong tool.

Memory that works for the task

Short-term memory keeps the whole session intact: the agent's thoughts, the tool calls and the results. Long-term memory can index entries semantically, surface what is relevant as reasoning proceeds, and even act as a tool in its own right — the agent decides when to write down an important fact and what to pull back from the past. That design holds up better on long tasks and helps the agent avoid losing intermediate findings.

Prebuilt agents out of the box

To get from an idea to a working system faster, there are preconfigured agents:

• Deep Research — expands queries, maintains a search tree, checks the draft against what it found, and keeps digging as long as it takes, until there is enough material for a precise answer.
• Browser-use — drives a browser through the Playwright MCP: navigates pages, clicks, types text, handles several tabs and long pages.
• Meta Planner — builds and executes a plan for complex goals: it decomposes the task, spawns worker agents with the tools they need, and tracks progress.

Multi-agent setups without the chaos

AgentScope lets you use an agent as a tool — a lead agent calls in "specialists" when it needs them — and build orderly communication between agents: pipelines that fix the order of turns, and a message hub that keeps a group's context in sync. That is how you scale a solution without tangling the architecture.

Evaluation is not a script off to the side here but a system of its own. There is one model for tasks, solutions and metrics: you can score the outcome (pass/fail, numbers) and the process (traces, tool errors) alike. Two runners are available, sequential for debugging and distributed for large sweeps — the interface is the same, and results are saved and resume from checkpoints.

On top of that sits Studio, a visual interface with OpenTelemetry-based telemetry: a live chat with the agent that shows its thoughts, its tool calls and any multimedia. It is easy to see what is slow — the model, a tool or the network. The same place holds interactive result charts, confidence intervals and side-by-side trace comparisons for picking apart flaky cases. A built-in copilot, Friday, demonstrates what the framework can do and helps developers with documentation and examples.

Going to production without extra risk

Runtime turns an agent into a dependable service: FastAPI deployment with monitoring, protocol support (Google's A2A, for one), session management and an isolated sandbox for tools. Ready-made environments come with it — a file sandbox, a browser one, a training one — all behind a single interface. That lowers the engineering risk, and tool safety is no longer something you have to invent from scratch.

What this buys you in practice

• Less code: unified message, model and tool interfaces lead to a cleaner architecture.
• More speed: parallel calls and async cut latency in heavy workloads.
• Better quality control: unified evaluation plus Studio speeds up debugging and improves stability.
• Room to grow: the multi-agent structure, memory and MCP make it easier to add new capabilities and external services without breaking flows that already work.

Where the ecosystem is heading

AgentScope 1.0 joins reasoning and action cleanly, turning LLMs from conversationalists into controllable operators. Modularity, compatibility and sandboxes lower the barrier to entry for serious agent applications. The next step is scalable, adaptive, reliable systems in which agents act confidently in a changing world — from deep research to business process automation. That is exactly the case this framework is built for from the first step.

💾 Code