Task-oriented Coordination Requirements for AI Agent Protocols

Introduction

Purpose With the rapid advancements of AI technologies and their applications, AI agents utilizing Large Language Models (LLMs) have emerged as a pivotal direction in global technological evolution and market development. The single-agent systems exhibit inherent limitations when addressing complex tasks in dynamic environments, the efficient multi-agent collaboration for complex task completion has garnered increasing attention, wherein task-oriented coordination constitutes a critical component of standardized multi-agent systems. This document examines the requirements and operations for standardizing AI Agent protocols to support task coordination in multi-agent systems.

Terminology

Task:: ISO/IEC 22989, task is actions required to achieve a specific goal. These actions can be physical or cognitive. For instance, computing or creation of predictions, translations, synthetic data or artefacts or navigating through a physical space.
Shared Message Pool:: A pool where agents publish structured messages and subscribe to relevant messages based on their profiles.
Coordinator Agent:: An agent that receives tasks and decomposes or distributes tasks to other agents.
Execution Agent:: An agent responsible for executing tasks distributed by the Coordinator Agent.
Agent Communication Server:: The server enables Agents to communicate and collaborate with each other, which provides session management, routing function, etc.
Normative Language:: The key words "MUST", "REQUIRED", and "SHOULD" in this document are to be interpreted as described in .

Task Coordination Framework

| Agent X | |2.Task1 distributed +---------+ | | | | | | +---------+ 1.Task submitted +---------+ 3.Task1 completed| | Task |------------------->| |<-----------------+ | Invoker |<------------------ | Agent A |<-----------------+ +---------+ 4.Task completed +---------+ 3.Task2 completed| | | | | | | |2.Task2 distributed +---------+ +------------------->| Agent Y | +---------+ ]]> The system operates as follows: when a task invoker submits a task to Agent A (Coordinator), the Agent A SHOULD use the standard discovery mechanism to discover Agent X and Agent Y that own the required capabilities and assign tasks to them. Upon receiving completion notifications from both agents, Agent A aggregates the results and delivers the final artifact back to the task invoker.

Use Cases Some typical use cases in which multiple agents work together to complete tasks:

High throughput tasks: There are many tasks that have high bandwidth requirements. For example, in the collaborative framework for coordinating heterogeneous embodied agents-specifically, the robot dogs and drones-in a wide-area public network, the drone is assigned for wide-area surveillance and task delegation, while functionally specialized robot dogs perform ground-level operations such as video surveillance, material transport and obstacle clearance.
Low latency tasks: In collaborative multi-agent systems, control signal transmission tasks impose significantly more stringent latency requirements than routine model training data transfer. For example, the home robot remotely sends an alarm message to the end user.
High reliability tasks: Smart factory scenarios require critical reliability of agent task execution and fault-tolerant operation stability.

These categories of use cases (may be further extended) demonstrate the collaboration among agents spanning multiple distinct domains to achieve end-to-end task completion. The embodied agents (such as the robots and unmanned aerial vehicles) interacting with physical environments through embodied interfaces, while virtual agents (such as the various software applications and personal assistant) providing complementary capabilities, has demonstrated the advantages of collaboratively completing complex tasks in various scenarios.

Necessity

Task Complexity As task complexity increases, heterogeneous agents require multiple interaction rounds, precise planning, ordered execution, and efficient context sharing mechanisms to enhance resolution quality and robustness.

Resource Optimization Through task coordination and resource consumption monitoring, the multi-agent systems are able to support dynamic allocation of for example, the computing, storage and bandwidth resources to optimize the resource utilization efficiency.

Quality of Service Task coordination may dynamically prioritize resources allocations based on for example, task priorities, agent expertise and Quality of Service requirements. This ensures timeliness and accuracy of critical tasks, reduces service response latency, and maintains output stability and reliability.

Dynamic Adjustment The agents may update or adjust the task during task execution phase based on end user's inputs or contextual updates to better respond to the final task requirements.

Protocol Requirements

Task Description Precise task descriptions or task templates are REQUIRED to ensure all agents maintain a consistent understanding of the objectives, operational constraints and criteria. A well-defined task description:

Reduces ambiguity: Minimizes misinterpretations and conflicting actions among agents.
Enables verifiability: Translates abstract goals into executable and measurable plans.
Improves robustness: Ensures collaboration remains coherent and efficient under dynamic conditions.

The AI Agent protocol should support a structured task description format. A complete task description may include the following components:

Metadata: task identifier, task type (e.g., execution, monitoring), task priority, creation time, expected completion time, task initiator, etc.
Task objective: the objective described in natural language.
Task execution constraints: the constraints include resource limitations, safety requirements, etc.
Task artifact specifications: the expected output format and the desired artifact list.

Task descriptions assigned to different agents MUST follow the minimization principle, i.e., agents SHOULD receive only the minimal, contextually necessary information required to fulfill their tasks to prevent unauthorized access of sensitive information.

Task State The AI Agent protocol design should support comprehensive state descriptions throughout the task execution lifecycle. The potential task states may include task submitted, running, suspended (awaiting external input or output from other agents), completed, canceled, rejected, and failed, as well as management operations such as state queries, retrieval, and pushing intermediate results. Based on the length of time to complete the tasks, tasks can be categorized into short-term tasks that require a single request-response interaction and long-term tasks that may require multi-round interactions or extended waiting periods. For long-term tasks, the reporting and querying of intermediate states (e.g., progress percentage, checkpoints) should be supported. The Coordinator Agent may dynamically adjust the target of the task according to intermediate results from the Execution Agents and the context information. The AI Agent protocol design should support management of both long-term and short-term tasks.

Context Sharing When delegating tasks to Execution Agents, the Coordinator Agent may include task-relevant contextual about the contact information of the end user, the task itself, the historical preference information known by the Coordinator Agent, and other necessary conversation data, to facilitate the task execution. For example, in trip planning case, this may encompass historically booked flight/hotel preferences or dynamically perceived context like recent user dialog. The AI Agent protocol design should consequently support context sharing mechanisms through standardized definitions of context types, length constraints, and encoding formats to enhance the effectiveness of task execution. The context sharing MAY have an impact on privacy of the user, it is necessary to consider the limitations of the scope of context sharing, especially for the sensitive information e.g. name, age, address of the user.

Exception Handling Exception handling constitutes a critical mechanism for multi-agent collaborative task execution. If an execution agent cannot complete an assigned task due to lack of skills or overloaded, the failure in task execution may lead to such as releasing the connections.

The Requirements on the Agent Session Protocol The AI Agent protocol should consider separating the transmission of task control messages (such as task creation, task update, task status query and task result notification) from the transmission of real-time multimodal context (such as task-related voice, video, and images). These two different types of messages may require different transmission channels. This AI Agent protocol can be built on top of the Agent session protocol and make use of the Agent session protocol to enable the exchange of task control messages, real-time and non-real-time multimodal context between AI agents with low-latency. The AI Agent session protocol should be able to provide mechanisms beyond simple request/response, including the complex interaction modes for example message multicast, publication/subscription (PUB/SUB), asynchronous notifications.

Task Flow

Task Operation After receiving the target agent list from the discovery result, the Coordinator Agent may select one Execution Agent and send the task cooperation message to that agent. The Coordinator Agent may delegate agent identifier lookup to the Agent Communication Server, which is then responsible for routing the message according to the agent identifier. The Agent Communication Server MAY also provide task state management according to service requirements, for example, retry/re-entry after task failure.

(A): The AI Agent A sends a task request to AI Agent B via the Agent Communication Server.
(B): The Agent Communication Server verifies the request message and routes the request to AI Agent B.
(C): The AI Agent B receives the task request and sends a response to the Agent Communication Server.
(D): The Agent Communication Server transfers the response to AI Agent A.

(A): The AI Agent A sends a task request to AI Agent B via Agent Communication Server X.
(B): Agent Communication Server X verifies the request, parses agent B's identifier, obtains the routing address of Agent Communication Server Y, establishes a message channel with Server Y, and routes the request to Server Y.
(C): Agent Communication Server Y receives and verifies the task request message, then routes the request to agent B.
(D): AI Agent B receives the task request and sends a response to Agent Communication Server Y.
(E): Agent Communication Server Y transfers the response to Agent Communication Server X.
(F): Agent Communication Server X transfers the response to AI Agent A.

Task Parameters The following parameters are included in the agent task cooperation request:

Message Name: REQUIRED. It specifies the message name.
Agent Identifier: REQUIRED. It specifies the identifier of the Execution Agent.
Task Description: REQUIRED. It specifies the task description that needs to be completed by the Execution Agent, as defined in Section 4.1.
Input: REQUIRED. It specifies the task input parameters; the input can be text, file, image, and similar modalities.
Context: OPTIONAL. It specifies context information as defined in Section 4.3.

The following parameters are included in the agent task cooperation response:

Task State: REQUIRED. It specifies the task state as defined in Section 4.2.
Output: REQUIRED. It specifies the output result information of the task; the output can be text, file, image, and similar modalities.

Conclusions Task-oriented coordination constitutes a critical function for multi-agent collaboration. This document discusses the necessity of introducing task-oriented coordination to address complex tasks, optimize resource utilization, and guarantee service quality. Consequently, it analyzes the requirements imposed by task-oriented coordination on AI Agent protocol design, specifically concerning task descriptions, task states, communication mechanisms, context sharing, and exception handling. Finally, it introduces the task flow and parameters for task cooperation between Agents.

IANA Considerations This memo includes no request to IANA.

Security Considerations When designing the task-oriented coordination for AI agents communication, privacy should always be considered.