Skip to content

AI Partner Up Flow Protocol

The AI Partner Up Flow Protocol defines the standard for interaction between different components of the system, enabling interoperability across multiple language implementations.

What is the Protocol?

The protocol is a language-agnostic specification that ensures seamless communication between nodes running different implementations. It provides all specifications needed to implement a compatible library without reference to specific implementations.

Key Features

  • Language Agnostic: Designed to be implemented in any programming language (Python, Go, Rust, JavaScript, etc.)
  • Interoperability: Ensures seamless communication between nodes running different implementations
  • Extensibility: Allows for future enhancements without breaking existing implementations
  • Completeness: Provides all specifications needed to implement a compatible library

Protocol Documentation

The protocol specification is organized into the following documents:

📋 Getting Started

  1. Overview - Protocol introduction, versioning, and standards
  2. Protocol goals and version information
  3. Standards compliance (JSON-RPC 2.0, A2A Protocol, JSON Schema)
  4. Implementation guide

🔑 Core Concepts

  1. Core Concepts - Fundamental concepts and interfaces
  2. Flow, Task, Executor, Node, TaskManager

  3. Key definitions and relationships

  4. Data Model - Complete task schema and data structures

  5. Task schema definition
  6. Field specifications and types
  7. JSON Schema definitions

⚙️ Execution

  1. Execution Lifecycle - State machine and execution rules
  2. Task state transitions
  3. Execution rules and dependencies
  4. Priority scheduling

📚 Reference

  1. Examples - Comprehensive examples and use cases
  2. Basic task examples
  3. Complex workflow examples

  4. Real-world scenarios

  5. Interface Protocol - API specifications

  6. JSON-RPC 2.0 API
  7. A2A Protocol integration
  8. Transport layer specifications

✅ Compliance

  1. Conformance - Implementation requirements and compliance
  2. MUST/SHOULD/MAY requirements
  3. Compliance checklist

  4. Testing guidelines

  5. Error Handling - Error codes and handling procedures

  6. Standard error codes
  7. Error response format

  8. Error handling best practices

  9. Validation - Validation rules and algorithms

  10. Input validation
  11. Schema validation
  12. Validation algorithms

Quick Navigation

For Implementers

New to the protocol? Start here:

  1. Overview - Understand the protocol goals and structure
  2. Core Concepts - Learn the fundamental concepts
  3. Data Model - Understand the task schema
  4. Execution Lifecycle - Learn how tasks execute
  5. Examples - See practical examples

Implementing a library? Follow this path:

  1. Read Core Concepts and Data Model
  2. Study Execution Lifecycle for state transitions
  3. Review Examples for usage patterns
  4. Implement core components (Task, Executor, TaskManager, Storage, API)
  5. Validate using Conformance checklist
  6. Test with Examples and Validation rules

For Users

Using an existing implementation? Check these:

Protocol Version

Current Version: 1.0

Version Format: MAJOR.MINOR.PATCH - MAJOR: Breaking changes to the protocol - MINOR: New features that are backward compatible - PATCH: Bug fixes and clarifications

MUST: Implementations MUST specify the protocol version they support.

SHOULD: Implementations SHOULD be backward compatible with previous minor versions when possible.

Protocol Standards

The protocol builds on and complies with established standards:

  • JSON-RPC 2.0: All RPC operations use JSON-RPC 2.0 format
  • A2A Protocol: Enhanced agent-to-agent communication
  • JSON Schema Draft 7: Task schema definitions and validation
  • UUID (RFC 4122): Task identifiers
  • ISO 8601: Timestamp fields

See Overview for detailed compliance requirements.

Next Steps

Ready to dive in? → Start with Overview →