Universal Agent Protocols (UAP) for Distributed Multi-Agent Systems

Abstract

In the era of rapidly expanding distributed systems and artificial intelligence, the need for a scalable, flexible, and robust protocol for multi-agent communication and coordination is paramount. This white paper introduces the Universal Agent Communication Protocol (UACP), Universal Agent Discovery Protocol (UADP), and Universal Agent Coordination Protocol (UACO). These protocols are designed to enable seamless interaction among agents in a distributed environment, ensuring scalability, interoperability, and future-proofing for various types of agents and use cases. Detailed examples, message schemas, and diagrams are provided to illustrate the protocols' functionality and implementation.

---

Table of Contents

1. Introduction
2. Overview of Protocols
   • 2.1 Universal Agent Communication Protocol (UACP)
   • 2.2 Universal Agent Discovery Protocol (UADP)
   • 2.3 Universal Agent Coordination Protocol (UACO)
3. Detailed Protocol Specifications
   • 3.1 UACP Specification
   • 3.2 UADP Specification
   • 3.3 UACO Specification
4. Communication Examples
   • 4.1 Task Delegation
   • 4.2 Agent Discovery
   • 4.3 Negotiation and Coordination
5. System Diagrams
   • 5.1 System Flow Diagram
   • 5.2 Execution Context Diagram
   • 5.3 Distributed Store Architecture
   • 5.4 Sequence Diagrams
6. Scalability and Future-Proofing
7. Security Considerations
8. Error Handling and Fault Tolerance
9. Implementation Guidelines
10. Conclusion
11. Appendix
    • 11.1 Enumerations
    • 11.2 Message Schemas
    • 11.3 Glossary
    • 11.4 References

---

1. Introduction

As distributed systems grow in complexity and scale, the need for standardized protocols that can handle diverse agent interactions becomes critical. The Universal Agent Protocols are designed to address these needs by providing a unified framework for communication, discovery, and coordination among agents.

These protocols aim to:

• Ensure Scalability: Handle millions of agents interacting simultaneously without bottlenecks.
• Support Diverse Agents: Accommodate various types of agents, from simple scripts to complex AI entities.
• Facilitate Interoperability: Enable agents developed by different organizations to work together seamlessly.
• Provide Robust Security: Secure communications and operations to prevent unauthorized access and ensure data integrity.
• Allow for Future Expansion: Design protocols that can evolve to meet future requirements without significant overhauls.

---

2. Overview of Protocols

2.1 Universal Agent Communication Protocol (UACP)

Purpose: UACP standardizes the communication between agents, ensuring consistent message formats, interaction patterns, and communication methods.

Key Features:

• Standard Message Structure: Defines a consistent message schema for all communications.
• Supports Multiple Communication Patterns: Request-response, notifications, and task delegation.
• Asynchronous Messaging: Enables agents to communicate without blocking operations.
• Security Integration: Includes authentication, authorization, and encryption mechanisms.
• Extensibility: Allows for protocol upgrades and custom extensions.

2.2 Universal Agent Discovery Protocol (UADP)

Purpose: UADP enables agents to discover each other dynamically, facilitating load balancing and scalability.

Key Features:

• Decentralized Discovery: Uses peer-to-peer mechanisms to avoid central points of failure.
• Capability-Based Searches: Agents can find others based on required capabilities.
• Dynamic Registration: Agents can join or leave the network at any time.
• Load Balancing Support: Agents advertise their current load and availability.

2.3 Universal Agent Coordination Protocol (UACO)

Purpose: UACO provides mechanisms for agents to coordinate tasks, negotiate terms, and collaborate on complex workflows.

Key Features:

• Negotiation Mechanisms: Support for proposing, countering, and accepting terms.
• Commitment Protocols: Agents can formalize agreements to perform tasks.
• Group Coordination: Facilitates collaborative efforts among multiple agents.
• Conflict Resolution: Provides methods to resolve disputes and inconsistencies.

---

3. Detailed Protocol Specifications

3.1 Universal Agent Communication Protocol (UACP) Specification

3.1.1 Message Structure

UACP messages consist of a header and a payload.

Header Fields:

• messageId (UUID): Unique identifier for the message.
• protocolVersion (String): Version of the UACP protocol (e.g., "1.0").
• timestamp (ISO8601): Time the message was sent.
• senderId (String): Unique identifier of the sender agent.
• recipientId (String): Unique identifier of the recipient agent or "Broadcast".
• messageType (Enum): Type of message (Request, Response, Notification, Error).
• correlationId (UUID): Links responses to requests.
• authToken (String): Authentication token (e.g., JWT).
• signature (String): Digital signature for integrity.
• contentType (Enum): Format of the payload (JSON, XML, Binary).
• priority (Enum): Message priority (Low, Normal, High, Urgent).

Payload Fields:

• action (String): Action to be performed or type of response.
• data (Object): Data relevant to the action.

Enumerations:

• messageType:

  • Request
  • Response
  • Notification
  • Error

• contentType:

  • JSON
  • XML
  • Binary

• priority:

  • Low
  • Normal
  • High
  • Urgent

3.1.2 Interaction Patterns

3.1.2.1 Request-Response

• Usage: When an agent requires specific information or action from another agent.
• Flow:
  1. Agent A sends a Request to Agent B.
  2. Agent B processes the request and sends a Response back using the same correlationId.

3.1.2.2 Notification

• Usage: For one-way communication where no response is expected.
• Flow:
  1. Agent A sends a Notification to Agent B or broadcasts to multiple agents.

3.1.2.3 Task Delegation

• Usage: When an agent delegates a task to another agent.
• Flow:
  1. Agent A sends a Request with action executeTask to Agent B.
  2. Agent B acknowledges receipt (optional).
  3. Upon completion, Agent B sends a Response with the results.

3.1.3 Detailed Example

Example: Agent A Delegates a Data Processing Task to Agent B

Step 1: Agent A Sends Task Request

{
  "header": {
    "messageId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "protocolVersion": "1.0",
    "timestamp": "2023-10-06T12:00:00Z",
    "senderId": "agent-A",
    "recipientId": "agent-B",
    "messageType": "Request",
    "correlationId": "abcd1234-ef56-7890-abcd-ef1234567890",
    "authToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
    "signature": "MEUCIQD1Vb+Xj4...",
    "contentType": "JSON",
    "priority": "Normal"
  },
  "payload": {
    "action": "executeTask",
    "data": {
      "taskId": "task-001",
      "taskType": "DataProcessing",
      "parameters": {
        "inputFile": "s3://data/input.csv",
        "outputFile": "s3://data/output.csv",
        "processingType": "Aggregation",
        "columns": ["sales", "region"],
        "aggregationFunction": "SUM"
      },
      "deadline": "2023-10-06T14:00:00Z",
      "priority": "High"
    }
  }
}

Explanation:

• Action: executeTask indicates that Agent A wants Agent B to execute a specific task.
• Data Fields:
  • taskId: Unique identifier for the task.
  • taskType: Specifies the type of task (DataProcessing).
  • parameters: Detailed parameters required to perform the task.
    • inputFile: Location of the input data file.
    • outputFile: Desired location for the output.
    • processingType: Type of data processing to perform.
    • columns: Columns to focus on.
    • aggregationFunction: Function to apply.
  • deadline: When the task should be completed by.
  • priority: Importance level of the task.

Step 2: Agent B Processes Task and Sends Response

{
  "header": {
    "messageId": "f1e2d3c4-b5a6-7890-abcd-ef0987654321",
    "protocolVersion": "1.0",
    "timestamp": "2023-10-06T12:30:00Z",
    "senderId": "agent-B",
    "recipientId": "agent-A",
    "messageType": "Response",
    "correlationId": "abcd1234-ef56-7890-abcd-ef1234567890",
    "authToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
    "signature": "MEQCIFwRLdF7...",
    "contentType": "JSON",
    "priority": "Normal"
  },
  "payload": {
    "action": "taskResult",
    "data": {
      "taskId": "task-001",
      "status": "Success",
      "outputFile": "s3://data/output.csv",
      "resultSummary": {
        "totalSales": 1500000,
        "regionsProcessed": 5
      },
      "completionTime": "2023-10-06T12:29:45Z"
    }
  }
}

Explanation:

• Action: taskResult indicates the response contains the result of the task.
• Data Fields:
  • taskId: References the original task.
  • status: Indicates success or failure.
  • outputFile: Location where the output is stored.
  • resultSummary: A summary of the results.
    • totalSales: The aggregated sales figure.
    • regionsProcessed: Number of regions included in the aggregation.
  • completionTime: When the task was completed.

---

3.2 Universal Agent Discovery Protocol (UADP) Specification

3.2.1 Agent Registration

Agents register themselves upon startup and update their status periodically.

Registration Message Example:

{
  "agentId": "agent-B",
  "host": "192.168.1.2",
  "port": 8080,
  "capabilities": ["DataProcessing", "DataAnalysis"],
  "status": "Online",
  "load": 35, // Percentage indicating current load
  "metadata": {
    "version": "2.1.0",
    "tags": ["HighPerformance", "SSDStorage"],
    "customProperties": {
      "maxTasks": 10,
      "currentTasks": 3
    }
  },
  "timestamp": "2023-10-06T12:00:00Z",
  "signature": "MEUCIQDYm6iK..."
}

Explanation:

• Capabilities: Indicates what tasks the agent can perform.
• Load: Current workload as a percentage.
• Metadata: Additional information about the agent.
  • version: Software version of the agent.
  • tags: Keywords for discovery.
  • customProperties: Agent-specific properties.

3.2.2 Discovery Requests and Responses

Discovery Request Example:

{
  "senderId": "agent-A",
  "criteria": {
    "capabilities": ["DataProcessing"],
    "status": "Online",
    "tags": ["HighPerformance"]
  },
  "timestamp": "2023-10-06T12:01:00Z",
  "signature": "MEQCIGqWjgF..."
}

Discovery Response Example:

{
  "agents": [
    {
      "agentId": "agent-B",
      "host": "192.168.1.2",
      "port": 8080,
      "capabilities": ["DataProcessing", "DataAnalysis"],
      "status": "Online",
      "load": 35,
      "metadata": {
        "version": "2.1.0",
        "tags": ["HighPerformance", "SSDStorage"],
        "customProperties": {
          "maxTasks": 10,
          "currentTasks": 3
        }
      },
      "timestamp": "2023-10-06T12:00:00Z"
    },
    {
      "agentId": "agent-C",
      "host": "192.168.1.3",
      "port": 8081,
      "capabilities": ["DataProcessing"],
      "status": "Online",
      "load": 20,
      "metadata": {
        "version": "1.5.2",
        "tags": ["GPUEnabled"],
        "customProperties": {
          "maxTasks": 5,
          "currentTasks": 1
        }
      },
      "timestamp": "2023-10-06T12:00:30Z"
    }
  ],
  "timestamp": "2023-10-06T12:01:05Z",
  "signature": "MEYCIQD3KQh..."
}

Explanation:

• Agents: List of agents matching the criteria.
• Load Balancing: Agent A can select an agent based on load and capabilities.

---

3.3 Universal Agent Coordination Protocol (UACO) Specification

3.3.1 Negotiation Messages

Negotiation Initiation Example:

{
  "header": {
    "messageId": "n1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "protocolVersion": "1.0",
    "timestamp": "2023-10-06T12:02:00Z",
    "senderId": "agent-A",
    "recipientId": "agent-B",
    "messageType": "Request",
    "correlationId": "negotiation-1234",
    "authToken": "eyJhbGciOiJIUzI1NiIsInR...",
    "signature": "MEUCIQDrw3Q...",
    "contentType": "JSON",
    "priority": "High"
  },
  "payload": {
    "action": "negotiate",
    "data": {
      "negotiationId": "negotiation-1234",
      "topic": "TaskExecution",
      "parameters": {
        "taskId": "task-002",
        "taskType": "ModelTraining",
        "parameters": {
          "dataset": "s3://data/training.csv",
          "modelType": "NeuralNetwork",
          "epochs": 50,
          "learningRate": 0.01
        },
        "deadline": "2023-10-07T12:00:00Z",
        "compensation": 500 // Proposed payment or resource exchange
      }
    }
  }
}

Negotiation Response Example (Counter Offer):

{
  "header": {
    "messageId": "r1s2t3u4-v5w6-7890-abcd-ef0987654321",
    "protocolVersion": "1.0",
    "timestamp": "2023-10-06T12:05:00Z",
    "senderId": "agent-B",
    "recipientId": "agent-A",
    "messageType": "Response",
    "correlationId": "negotiation-1234",
    "authToken": "eyJhbGciOiJIUzI1NiIsInR...",
    "signature": "MEYCIQCGmF...",
    "contentType": "JSON",
    "priority": "High"
  },
  "payload": {
    "action": "negotiationResponse",
    "data": {
      "negotiationId": "negotiation-1234",
      "response": "CounterOffer",
      "counterOffer": {
        "compensation": 600,
        "additionalTerms": {
          "extendedDeadline": "2023-10-07T18:00:00Z"
        }
      }
    }
  }
}

Explanation:

• Counter Offer:
  • Compensation: Agent B requests higher compensation.
  • Additional Terms: Proposes an extended deadline.

Commitment Message Example (Agreement):

{
  "header": {
    "messageId": "c1d2e3f4-g5h6-7890-abcd-ef1122334455",
    "protocolVersion": "1.0",
    "timestamp": "2023-10-06T12:10:00Z",
    "senderId": "agent-A",
    "recipientId": "agent-B",
    "messageType": "Request",
    "correlationId": "negotiation-1234",
    "authToken": "eyJhbGciOiJIUzI1NiIsInR...",
    "signature": "MEQCIC8v8Z...",
    "contentType": "JSON",
    "priority": "High"
  },
  "payload": {
    "action": "commit",
    "data": {
      "negotiationId": "negotiation-1234",
      "terms": {
        "taskId": "task-002",
        "compensation": 600,
        "deadline": "2023-10-07T18:00:00Z",
        "additionalTerms": {
          "dataPrivacy": "Data must be deleted after task completion.",
          "reporting": "Progress updates every 2 hours."
        }
      }
    }
  }
}

Explanation:

• Agreed Terms:
  • Compensation: Agreed at 600 units.
  • Deadline: Extended as proposed.
  • Additional Terms: Specific conditions are outlined.

---

4. Communication Examples

The detailed examples above illustrate how agents interact using the protocols. Additional examples include:

4.1 Task Delegation

Scenario: Agent A delegates a task to Agent B and continues processing other tasks while awaiting the result.

Sequence:

1. Agent A sends a Request to Agent B with task details.
2. Agent B acknowledges receipt with a Response (optional).
3. Agent A continues its workflow.
4. Agent B processes the task.
5. Upon completion, Agent B sends a Response with the task result.
6. Agent A receives the result and integrates it into its workflow.

4.2 Agent Discovery

Scenario: Agent A needs to find an agent capable of image recognition tasks.

Process:

1. Agent A sends a Discovery Request with criteria capabilities: ["ImageRecognition"].
2. Neighboring agents respond with matching agents.
3. Agent A selects an agent based on capabilities and current load.
4. Agent A proceeds to interact with the selected agent.

4.3 Negotiation and Coordination

Scenario: Multiple agents coordinate to process a large dataset in parallel.

Process:

1. Agent A initiates a negotiation with Agents B, C, D.
2. They negotiate terms such as data partitioning, resource allocation, and compensation.
3. Upon agreement, they commit to the terms.
4. The agents coordinate to process different parts of the dataset.
5. Results are aggregated by Agent A.

---

5. System Diagrams

To better understand the protocols and their interactions, the following diagrams illustrate the system flow, execution context, distributed store architecture, and sequence of interactions.

5.1 System Flow Diagram

+------------+       +-------------+       +-------------+       +-------------+
|            |       |             |       |             |       |             |
|  User      +------>|  Entry      +------>|  Agent      +------>|  Task       |
|  Interface |       |  Agent      |       |  Discovery  |       |  Execution  |
|            |       |             |       |  Protocol   |       |  Agents     |
+------------+       +-------------+       +-------------+       +-------------+
     ^                     |                       |                   |
     |                     v                       v                   v
+------------+       +-------------+       +-------------+       +-------------+
|            |       |             |       |             |       |             |
|  State     |<------+  Communication<-----+ Coordination+-------+  Shared     |
|  Updates   |       |  Protocol    |       |  Protocol  |       |  State      |
|            |       |             |       |             |       |  Store      |
+------------+       +-------------+       +-------------+       +-------------+

Explanation:

• User Interface: Where the user interacts with the system.
• Entry Agent: Receives user requests and orchestrates the workflow.
• Agent Discovery Protocol: Helps find suitable agents.
• Task Execution Agents: Perform the actual tasks.
• Communication Protocol: Manages messaging between agents.
• Coordination Protocol: Handles negotiation and coordination.
• Shared State Store: Where agents read/write shared data.
• State Updates: Propagated back to the user interface.

5.2 Execution Context Diagram

+---------------------+
|  Execution Context  |
+---------------------+
| - contextId         |
| - taskList          |
| - currentState      |
| - dataStore         |
+---------------------+
         ^
         |
+---------------------+         +---------------------+         +---------------------+
|     Agent A         |         |     Agent B         |         |     Agent C         |
+---------------------+         +---------------------+         +---------------------+
| - Uses contextId    |         | - Uses contextId    |         | - Uses contextId    |
| - Reads/Writes data |<------->| - Reads/Writes data |<------->| - Reads/Writes data |
+---------------------+         +---------------------+         +---------------------+

Explanation:

• Execution Context: Shared among agents involved in a workflow.
• contextId: Unique identifier linking related tasks and data.
• Agents A, B, C: Collaborate using the shared execution context.

5.3 Distributed Store Architecture

+-------------------+      +-------------------+      +-------------------+
|    Agent A        |      |    Agent B        |      |    Agent C        |
+-------------------+      +-------------------+      +-------------------+
|                   |      |                   |      |                   |
| Local Data Store  |      | Local Data Store  |      | Local Data Store  |
| (Part of DHT)     |<---->| (Part of DHT)     |<---->| (Part of DHT)     |
+-------------------+      +-------------------+      +-------------------+
       ^                            ^                           ^
       |                            |                           |
       +----------+    +------------+-----------+    +----------+
                  |    |                        |    |
                  |    |   Distributed Hash     |    |
                  +----+       Table (DHT)      +----+
                       |                        |
                       +------------------------+

Explanation:

• Local Data Stores: Each agent maintains a portion of the distributed data.
• Distributed Hash Table (DHT): Enables decentralized data storage and retrieval.
• Data Replication: Ensures fault tolerance and data availability.

5.4 Sequence Diagrams

5.4.1 Task Delegation Sequence

User        Entry Agent       Agent Discovery       Agent B
 |               |                   |                |
 |---Request---->|                   |                |
 |               |---Discovery Req-->|                |
 |               |<--Discovery Res---|                |
 |               |---Task Request-------------------->|
 |               |                   |                |
 |               |<--Acknowledgment--|                |
 |               |                   |                |
 |               |                [Agent B processes task]
 |               |                   |                |
 |               |<-----Task Result-------------------|
 |               |                   |                |
 |<--Update------|                   |                |

Explanation:

• User: Initiates a request.
• Entry Agent: Orchestrates the workflow.
• Agent Discovery: Helps find Agent B.
• Agent B: Executes the task and returns the result.

5.4.2 Negotiation Sequence

Agent A            Agent B
  |                   |
  |---Negotiate----->|
  |                   |
  |<--Counter Offer--|
  |                   |
  |---Accept Terms--->|
  |                   |
  |<--Commitment-----|
  |                   |
  |---Task Request-->|
  |                   |
  |<--Task Result----|

Explanation:

• Negotiation: Agents exchange proposals.
• Commitment: Formal agreement to terms.
• Task Execution: Proceeds after agreement.

---

6. Scalability and Future-Proofing

Scalability Features:

• Decentralized Architecture: Eliminates single points of failure.
• Dynamic Load Balancing: Agents distribute workload based on real-time metrics.
• Horizontal Scaling: System capacity increases with the addition of agents.
• Asynchronous Processing: Reduces bottlenecks and improves throughput.

Future-Proofing Measures:

• Protocol Versioning: Supports backward compatibility.
• Extensibility: Protocols can be extended with new features.
• Modular Components: Agents and protocols can evolve independently.
• Adaptability: Designed to integrate emerging technologies.

Applicability to Future Agents:

• Supports a wide range of agents, including:

  • AI Agents: Capable of learning and adapting.
  • IoT Devices: Sensors and actuators with limited resources.
  • Cloud Services: High-performance computing resources.
  • Edge Computing Nodes: Providing low-latency processing.

---

7. Security Considerations

• Authentication and Authorization:

  • Use of digital certificates and mutual TLS (mTLS).
  • Tokens (e.g., JWT) for session management.
  • Role-Based Access Control (RBAC) for permissions.

• Encryption:

  • TLS/SSL for securing communication channels.
  • Data encryption for sensitive information.

• Integrity and Non-Repudiation:

  • Digital signatures on messages.
  • Timestamps to prevent replay attacks.

• Trust Management:

  • Reputation systems to assess agent reliability.
  • Blacklisting of malicious agents.

• Regular Updates:

  • Security patches and protocol updates.
  • Compliance with industry standards.

---

8. Error Handling and Fault Tolerance

• Standardized Error Codes:

  • Define specific codes (e.g., ERR001: Unauthorized, ERR002: Task Failed).

• Retry Mechanisms:

  • Exponential backoff strategies.
  • Circuit breakers to prevent overload.

• Fallback Procedures:

  • Alternate agents or methods when failures occur.

• Timeouts and Deadlines:

  • Clear expectations and handling of delays.

• Monitoring and Alerts:

  • Real-time monitoring of agent health.
  • Automatic alerts for critical failures.

---

9. Implementation Guidelines

• Agent Development:

  • Follow protocol specifications strictly.
  • Ensure agents can handle concurrent tasks.

• Testing:

  • Unit tests for individual components.
  • Integration tests for protocol compliance.

• Monitoring and Logging:

  • Consistent logging formats.
  • Use of monitoring tools (e.g., Prometheus, Grafana).

• Documentation:

  • Detailed API documentation.
  • Clear descriptions of agent capabilities.

• Compliance and Standards:

  • Adhere to data protection regulations (e.g., GDPR).
  • Follow best practices for security and reliability.

---

10. Conclusion

The Universal Agent Protocols provide a comprehensive framework for scalable, secure, and interoperable agent interactions. By adhering to these protocols, developers can build agents that operate effectively in a planet-scale distributed system, accommodating future advancements and diverse applications.

These protocols are designed to support the needs of current and future multi-agent systems, ensuring they remain robust and effective as technology evolves.

---

11. Appendix

11.1 Enumerations

Message Types (UACP):

• Request
• Response
• Notification
• Error

Agent Status (UADP):

• Online
• Offline
• Busy
• Unavailable

Negotiation Responses (UACO):

• Accept
• Reject
• CounterOffer

11.2 Message Schemas

Detailed JSON schemas for messages are provided to ensure consistent implementation.

Example: UACP Message Schema

{
  "type": "object",
  "properties": {
    "header": {
      "type": "object",
      "properties": {
        "messageId": { "type": "string", "format": "uuid" },
        "protocolVersion": { "type": "string" },
        "timestamp": { "type": "string", "format": "date-time" },
        "senderId": { "type": "string" },
        "recipientId": { "type": "string" },
        "messageType": { "type": "string", "enum": ["Request", "Response", "Notification", "Error"] },
        "correlationId": { "type": "string", "format": "uuid" },
        "authToken": { "type": "string" },
        "signature": { "type": "string" },
        "contentType": { "type": "string", "enum": ["JSON", "XML", "Binary"] },
        "priority": { "type": "string", "enum": ["Low", "Normal", "High", "Urgent"] }
      },
      "required": ["messageId", "protocolVersion", "timestamp", "senderId", "recipientId", "messageType"]
    },
    "payload": {
      "type": "object",
      "properties": {
        "action": { "type": "string" },
        "data": { "type": "object" }
      },
      "required": ["action"]
    }
  },
  "required": ["header", "payload"]
}

11.3 Glossary

• Agent: An autonomous entity capable of performing tasks and interacting with other agents.
• Protocol: A set of rules governing data exchange between agents.
• Context ID: An identifier used to correlate related messages and tasks.
• Correlation ID: An identifier used to link responses to requests.
• Distributed Hash Table (DHT): A decentralized storage system that allows data retrieval based on keys.
• Gossip Protocol: A communication protocol used for spreading information in a network.

11.4 References

• Distributed Systems Principles
• Security Best Practices for Distributed Systems
• Peer-to-Peer Networking Fundamentals
• Asynchronous Messaging Patterns

---

Note: This white paper provides a comprehensive overview of the Universal Agent Protocols, including detailed examples and diagrams. Implementers should refer to the full protocol specifications and schemas for detailed guidance.