AgentScope Service launches open-source control plane for multi-framework agents

A unified control plane

The AgentScope Java community has released the AgentScope Service as an open-source component. It is designed to function as a control plane for enterprise-grade distributed agent scenarios. This means it acts as a central hub to manage how different AI agents behave and interact with one another.

Unlike some frameworks that require you to use a specific set of tools, AgentScope Service is not tied to any single platform. It provides a way to centrally manage agents built with various technology stacks, such as Claude, OpenClaw, and QwenPaw. It aims to unify these disparate systems into one manageable environment.

The service supports four main forms of integration for these agents. It can work with native AgentScope integrations, LangChain through an instrument() function, and out-of-band sidecar integrations for Claude and QwenPaw. This flexibility allows companies to adopt different tools for different departments while keeping them under one roof.

Visual observability and debugging

One of the core components of the new service is its visual dashboard. This console provides a user interface for monitoring cluster-wide information in real time. Users can see lists of online agents, deployment instance details, and active session information at a glance.

The dashboard also tracks specific metrics like token consumption to help teams understand how their cluster is operating. Beyond just monitoring, it allows for deeper inspection of active sessions. Users can view the real-time context state of a conversation and see the proportions of data in different sections.

Developers can use the dashboard to intervene in active sessions or dynamically adjust and compact the session context. These features are designed to make debugging and managing complex agent behaviors easier. It provides a way to see what is happening inside the

sections_count_check_note_internal_only_not_for_output_the_source_is_long_and_the_target_is_750_words_i_will_ensure_depth_by_explaining_the_difference_between_subagents_and_teams_and_the_distributed_architecture_as_requested_by_the_prompt_rules_for_depth

Defining the building blocks

The platform follows a specific architectural logic for creating agents. It begins by defining basic concepts called Workspaces and Memory. These are the fundamental components that hold the environment and information needed for an agent to function.

Once these are established, they are associated with an agent to create a complete entity. This structured approach ensures that every agent has a clear definition of its operational space and its ability to retain information during tasks.

Collaborative team dynamics

AgentScope Service organizes agents into operational collaboration units rather than simple chat rooms. A common pattern involves a Lead agent handling the decomposition of tasks and the initial acceptance of work. The Lead then assigns specific subtasks to Members based on their individual capabilities, such as research, coding, or verification.

This system manages the lifecycle of these tasks and handles message routing automatically. It removes the need for developers to write custom business code to handle multi-process communication. Instead, the platform manages the task board and ensures that members can claim, start, and complete work independently.

Dynamic team formation

One of the key features of the framework is that developers do not need to arrange members into a fixed team structure during the development phase. This allows for much greater flexibility in how agents are deployed and utilized across different projects or departments.

The system supports dynamic orchestration where a Main Agent can determine the need for teamwork during a live interaction. It can then create a team and designate itself as the Lead, instantiating selected Subagents as Workers on the fly. This means the Lead and Worker structure does not have to be designed in advance, as the system can spawn members as needed based on the specific task description provided by a human user.

Shared programming models

The framework provides different ways to handle agent interactions depending on the specific use case. For example, it distinguishes between hierarchical delegation, where a Main Agent sends instructions to a Subagent and waits for a result, and peer collaboration, where agents share a task board and communicate directly.

Despite these different behaviors, both models share the same TeamTool and TeamClient programming models. This consistency allows developers to choose the best method for their needs—whether it is one-way delegation or a collaborative team—without having to learn entirely different sets of tools or APIs for each approach.