The Agent2Agent Principle

The Agent2Agent Protocol and AgentHub Implementation

This document explores the core principles of Google’s Agent2Agent protocol and how AgentHub implements a communication broker based on these concepts. We distinguish between the Agent2Agent protocol specification (task structures and communication patterns) and our custom AgentHub broker implementation.

Agent2Agent vs AgentHub: What’s What

Agent2Agent Protocol (Google)

The Agent2Agent protocol defines:

• A2A Message Structures: Message, Task, Artifact with structured content parts
• Task State Management: TaskState enums (SUBMITTED, WORKING, COMPLETED, FAILED, CANCELLED)
• Communication Patterns: Asynchronous task delegation with context-aware message handling

AgentHub Implementation (This Project)

AgentHub provides:

• Hybrid EDA+A2A Broker: Centralized gRPC service implementing A2A protocol within Event-Driven Architecture
• A2A-Compliant Pub/Sub: Publisher-subscriber pattern using native A2A message structures
• A2A Subscription Mechanisms: SubscribeToTasks, SubscribeToMessages, SubscribeToAgentEvents methods
• A2A Agent Implementations: Sample agents using A2ATaskPublisher and A2ATaskSubscriber abstractions

Philosophy and Core Concepts

Beyond Simple Request-Response

Traditional software architectures rely heavily on synchronous request-response patterns where a client requests a service and waits for an immediate response. While effective for simple operations, this pattern has limitations when dealing with:

• Complex, multi-step processes that require coordination between multiple specialized services
• Long-running operations that may take minutes or hours to complete
• Dynamic workload distribution where the best processor for a task may vary over time
• Autonomous decision-making where agents need to collaborate without central coordination

The Agent2Agent protocol addresses these limitations by defining task structures and communication patterns for autonomous agents. AgentHub implements a broker-based system that enables agents to communicate using Agent2Agent-inspired task structures:

1. Delegating work to other agents based on their capabilities
2. Accepting and processing tasks according to their specializations
3. Reporting progress during long-running operations
4. Making collaborative decisions about task distribution and execution

Autonomous Collaboration

In an Agent2Agent system, each agent operates with a degree of autonomy, making decisions about:

• Which tasks to accept based on current capacity and capabilities
• How to prioritize work when multiple tasks are pending
• When to delegate subtasks to other specialized agents
• How to report progress and handle failures

This autonomy enables the system to be more resilient, scalable, and adaptive compared to centrally-controlled architectures.

Key Design Principles

1. Asynchronous Communication

Agent2Agent communication is fundamentally asynchronous. When Agent A requests work from Agent B:

• Agent A doesn’t block waiting for completion
• Agent B can process the task when resources are available
• Progress updates provide visibility into long-running operations
• Results are delivered when the work is complete

This asynchronicity enables:

• Better resource utilization as agents aren’t blocked waiting
• Improved scalability as systems can handle more concurrent operations
• Enhanced resilience as temporary agent unavailability doesn’t block the entire system

2. Rich A2A Task Semantics

The Agent2Agent protocol defines rich task structures with flexible message content that AgentHub implements:

message Task {
  string id = 1;                         // Unique task identifier
  string context_id = 2;                 // Conversation/workflow context
  TaskStatus status = 3;                 // Current status with latest message
  repeated Message history = 4;          // Complete message history
  repeated Artifact artifacts = 5;       // Task output artifacts
  google.protobuf.Struct metadata = 6;   // Additional context
}

message Message {
  string message_id = 1;                 // Unique message identifier
  string context_id = 2;                 // Conversation context
  string task_id = 3;                    // Associated task
  Role role = 4;                         // USER or AGENT
  repeated Part content = 5;             // Structured content parts
  google.protobuf.Struct metadata = 6;   // Message metadata
}

message TaskStatus {
  TaskState state = 1;                   // SUBMITTED, WORKING, COMPLETED, etc.
  Message update = 2;                    // Latest status message
  google.protobuf.Timestamp timestamp = 3; // Status timestamp
}

This rich A2A structure enables:

• Context-aware routing based on conversation context and message content
• Flexible content handling through structured Part types (text, data, files)
• Workflow coordination via shared context IDs across related tasks
• Complete communication history for debugging and audit trails
• Structured artifact delivery for rich result types

3. A2A Status Updates and Progress Tracking

Long-running tasks benefit from A2A status updates through the message history:

// Progress updates are A2A messages within the task
message TaskStatus {
  TaskState state = 1;                   // Current execution state
  Message update = 2;                    // Latest status message from agent
  google.protobuf.Timestamp timestamp = 3; // When this status was set
}

// Progress information is conveyed through message content
message Message {
  // ... other fields
  repeated Part content = 5;             // Can include progress details
}

// Example progress message content
Part progressPart = {
  part: {
    data: {
      data: {
        "progress_percentage": 65,
        "phase": "data_analysis",
        "estimated_remaining": "2m30s"
      },
      description: "Processing progress update"
    }
  }
}

This A2A approach enables:

• Rich progress communication through structured message content
• Complete audit trails via message history preservation
• Context-aware status updates linking progress to specific workflows
• Flexible progress formats supporting text, data, and file-based updates
• Multi-agent coordination through shared context and message threading

4. A2A EDA Routing Flexibility

AgentHub’s A2A implementation supports multiple routing patterns through EDA metadata:

message AgentEventMetadata {
  string from_agent_id = 1;              // Source agent
  string to_agent_id = 2;                // Target agent (empty = broadcast)
  string event_type = 3;                 // Event classification
  repeated string subscriptions = 4;      // Topic-based routing
  Priority priority = 5;                 // Delivery priority
}

• Direct A2A addressing: Tasks sent to specific agents via to_agent_id
• Broadcast A2A addressing: Tasks sent to all subscribed agents (empty to_agent_id)
• Topic-based A2A routing: Tasks routed via subscription filters and event types
• Context-aware routing: Tasks routed based on A2A context and conversation state

This hybrid EDA+A2A approach enables sophisticated routing patterns while maintaining A2A protocol compliance.

Architectural Patterns

Microservices Enhancement

In a microservices architecture, Agent2Agent can enhance service communication by:

• Replacing synchronous HTTP calls with asynchronous task delegation
• Adding progress visibility to long-running service operations
• Enabling service composition through task chaining
• Improving resilience through task retry and timeout mechanisms

Event-Driven Architecture with A2A Protocol

AgentHub integrates A2A protocol within Event-Driven Architecture by:

• Wrapping A2A messages in EDA event envelopes for routing and delivery
• Preserving A2A semantics while leveraging EDA scalability and reliability
• Enabling A2A conversation contexts within event-driven message flows
• Supporting A2A task coordination alongside traditional event broadcasting
• Providing A2A-compliant APIs that internally use EDA for transport

// A2A message wrapped in EDA event
type AgentEvent struct {
    EventId   string
    Timestamp timestamppb.Timestamp

    // A2A-compliant payload
    Payload oneof {
        a2a.Message message = 10
        a2a.Task task = 11
        TaskStatusUpdateEvent status_update = 12
        TaskArtifactUpdateEvent artifact_update = 13
    }

    // EDA routing metadata
    Routing AgentEventMetadata
}

Workflow Orchestration

Complex business processes can be modeled as Agent2Agent workflows:

1. Process Initiation: A workflow agent receives a high-level business request
2. Task Decomposition: The request is broken down into specific tasks
3. Agent Coordination: Tasks are distributed to specialized agents
4. Progress Aggregation: Individual task progress is combined into overall workflow status
5. Result Assembly: Task results are combined into a final business outcome

Benefits and Trade-offs

Benefits

Scalability: Asynchronous operation and agent autonomy enable horizontal scaling without central bottlenecks.

Resilience: Agent failures don’t cascade as easily since tasks can be retried or redistributed.

Flexibility: New agent types can be added without modifying existing agents.

Observability: Rich task semantics and progress reporting provide excellent visibility into system operations.

Modularity: Agents can be developed, deployed, and scaled independently.

Trade-offs

Complexity: The system requires more sophisticated error handling and state management compared to simple request-response patterns.

Latency: For simple operations, the overhead of task creation and routing may add latency compared to direct calls.

Debugging: Distributed, asynchronous operations can be more challenging to debug than synchronous call chains.

Consistency: Managing data consistency across asynchronous agent operations requires careful design.

When to Use Agent2Agent

Agent2Agent is particularly well-suited for:

Complex Processing Pipelines

When work involves multiple steps that can be performed by different specialized agents:

• Data ingestion → validation → transformation → analysis → reporting
• Image upload → virus scan → thumbnail generation → metadata extraction
• Order processing → inventory check → payment processing → fulfillment

Long-Running Operations

When operations take significant time and users need progress feedback:

• Large file processing
• Machine learning model training
• Complex data analysis
• Batch job processing

Dynamic Load Distribution

When workload characteristics vary and different agents may be better suited for different tasks:

• Multi-tenant systems with varying customer requirements
• Resource-intensive operations that need specialized hardware
• Geographic distribution where local processing is preferred

System Integration

When connecting heterogeneous systems that need to coordinate:

• Third-party service coordination
• Cross-platform workflows

A2A Protocol Comparison with Other Patterns

vs. Message Queues

Traditional message queues provide asynchronous communication but lack:

• A2A structured message parts (text, data, files)
• A2A conversation context and task threading
• A2A bidirectional artifact delivery
• A2A complete message history preservation
• A2A flexible content types and metadata

vs. RPC/HTTP APIs

RPC and HTTP APIs provide structured communication but are typically:

• Synchronous (blocking) vs A2A asynchronous task delegation
• Lacking A2A-style progress tracking through message history
• Point-to-point rather than A2A context-aware routing
• Without A2A structured content parts and artifact handling
• Missing A2A conversation threading and workflow coordination

vs. Event Sourcing

Event sourcing provides audit trails and state reconstruction but:

• Focuses on state changes rather than A2A work coordination
• Lacks A2A structured task status and message threading
• Doesn’t provide A2A artifact-based result delivery
• Requires more complex patterns vs A2A’s built-in conversation context
• Missing A2A’s multi-modal content handling (text, data, files)

A2A Protocol Future Evolution

The A2A protocol and AgentHub implementation opens possibilities for:

Intelligent A2A Agent Networks

Agents that learn from A2A conversation contexts and message patterns to make better delegation decisions based on historical performance and capability matching.

Self-Organizing A2A Systems

Agent networks that automatically reconfigure based on A2A workflow patterns, context relationships, and agent availability, using A2A metadata for intelligent routing decisions.

Cross-Organization A2A Collaboration

Extending A2A protocols across organizational boundaries for B2B workflow automation, leveraging A2A’s structured content parts and artifact handling for secure inter-org communication.

AI Agent A2A Integration

Natural integration points for AI agents that can:

• Parse A2A message content parts for semantic understanding
• Generate appropriate A2A responses with structured artifacts
• Maintain A2A conversation context across complex multi-turn interactions
• Make autonomous decisions about A2A task acceptance based on content analysis

Enhanced A2A Features

• A2A Protocol Extensions: Custom Part types for domain-specific content
• Advanced A2A Routing: ML-based routing decisions using conversation context
• A2A Federation: Cross-cluster A2A communication with context preservation
• A2A Analytics: Deep insights from conversation patterns and artifact flows

The A2A protocol represents a foundational shift toward more intelligent, context-aware, and collaborative software systems that can handle complex distributed workflows while maintaining strong semantics, complete audit trails, and rich inter-agent communication patterns.