Agent-to-Agent

A2A Agent Card Architecture in Depth

A 2500-word walkthrough of A2A agent card architecture: well-known URL, capabilities, skills, endpoints, auth, versioning, signing, registry.

The A2A Agent Card Specification, Field by Field

Every field in the A2A Agent Card, what it means, and how it's used by clients and registries.

A2A artifact exchange architecture

Deep-dive on A2A artifacts: the artifact/part object model, TextPart/FilePart/DataPart types, TaskArtifactUpdate streaming with append and lastChunk, …

A2A Artifact Types

How the three artifact types differ in wire format, size limits, and best-use cases.

A2A Authentication

The auth options in A2A: OAuth, API keys, mTLS, and how to choose based on trust domain.

A2A authentication and authorization -- agent identity, delegation, cross-org trust

Deep-dive on A2A auth: agent identity and verifiable credentials, OAuth/OIDC token authentication, scopes and claims, delegation for agents acting on …

A2A backpressure architecture

Deep-dive on backpressure in Agent2Agent systems: bounded admission windows, credit-based flow control, 429/Retry-After signals, SSE pull cadence and …

A2A Capabilities

How A2A agents advertise their capabilities via well-known JSON documents, enabling discovery.

Agent capability architecture

Deep-dive on agent capability: manifest, capability schema, discovery, versioning, policy match, consent, deprecation, conformance.

A2A Capability Discovery

Registries DNS-based and federated.

A2A Capability Negotiation

How client + server agree on features (streaming, notifications, extensions) before + during a session.

A2A circuit breaker architecture

Deep-dive on circuit breaking for Agent-to-Agent systems: the per-peer closed/open/half-open state machine driven by a rolling failure rate, failing f…

Agent conversation architecture

Deep-dive on agent conversation: turn manager, shared context, delegation, termination rules, retry, audit, human interject.

Dead-letter handling architecture

Deep-dive on dead-letter handling for agent-to-agent task delegation: how a task that cannot be delivered or completed after bounded retries is parked…

A2A Discovery

How A2A enables agent discovery via registries, well-known URLs, and capability matching.

A2A Distributed Tracing

How W3C Trace Context propagates through A2A calls to give you unified traces across agents.

A2A Error Handling

How A2A standardizes errors, distinguishes retryable from permanent failures, and enables recovery.

A2A error handling -- failures across agent boundaries

Deep-dive on A2A error handling: error types and structured errors (code/message/data), task failure states, retries and idempotency, timeouts, partia…

A2A Error Recovery

When the called agent fails, hangs, or lies.

A2A Error Codes

Every A2A error code, what causes it, and how clients should handle each.

A2A Examples

Concrete examples of A2A in action: routing agents, specialist chains, and cross-organization collaboration.

A2A Failure Isolation

Circuit breakers and degraded fallbacks.

A2A File Part Encoding

The three ways to attach files, with practical size/latency/security tradeoffs.

A2A idempotency architecture

Deep-dive on idempotency in agent-to-agent systems: client-generated task IDs as the dedup contract, atomic registration and replay, distinguishing re…

A2A Idempotency

The subtle semantics of reusing a task ID and what it means for resume, update, and duplicate detection.

A2A input-required State

How agents pause + ask for more info from users mid-task.

A2A JSON-RPC Request/Response Flow

The full round-trip of an A2A call, from client dial to server ack, byte-by-byte.

A2A load shedding architecture

Deep-dive on load shedding in agent-to-agent systems: why overload has a cliff and propagates as metastable failure, admission control with priority c…

A2A + MCP Interop Patterns

Combining A2A (agent-to-agent) with MCP (tool-to-agent) in the same architecture.

A2A Message Architecture in Depth

A 2500-word walkthrough of A2A messages: JSON-RPC 2.0 envelope, method versioning, trace context, signature, idempotency, cost, errors, audit.

Inside the A2A Message Envelope

Field-by-field breakdown of the A2A message envelope, with real JSON examples and edge cases.

A2A Message Parts

The precise wire format of each message part type + the interoperability gotchas.

A2A Message Types

The message part types in A2A: text, files, structured data, and how they compose in tasks.

A2A Multi-Tenancy: Architecture Deep-Dive

How tenant isolation survives agent delegation chains — signed identity at the edge, scoped token exchange per hop, tenant-keyed state and caches, per…

Agent negotiation architecture

Deep-dive on agent-to-agent negotiation: signed offers, counters, policy bounds, termination, deadlock detection, escalation, audit.

A2A Negotiation Patterns

Cost time and quality trade-offs at runtime.

Agent-to-agent orchestration architecture

Deep-dive on multi-agent orchestration: coordinator, message bus, role specialization, arbitration, shared memory, guardrails, budget, and trace.

A2A Orchestration Patterns

Hub-and-spoke, peer-to-peer, mesh — which to pick.

A2A Over gRPC

gRPC as an A2A transport: proto definitions, streaming, and interop tradeoffs.

A2A Protocol Overview

What Google's A2A protocol is, why standardizing agent communication matters, and how it enables multi-agent ecosystems.

A2A Pagination for Task History + Long Message Lists

Getting task history + long streams without loading everything at once.

A2A Protocol Details

The technical protocol of A2A: HTTP endpoints, JSON message shapes, and the task lifecycle.

Agent-to-Agent Protocol Architecture in Depth

A 2500-word walkthrough of A2A protocol architecture: agent cards, discovery, auth, task messages, streaming updates, signed bus, policy, and observab…

A2A push notification architecture

Deep-dive on A2A push notifications: pushNotificationConfig registration and SSRF-safe URL vetting, the notifier queue and JWT signing, webhook receiv…

A2A Push Notifications

Configuring push notifications so servers can deliver task completion without client polling.

A2A Rate Limit Response Format

The standard error + headers that A2A servers return on rate-limit, and how clients should react.

A2A rate limiting -- protecting agents from overload and abuse

Deep-dive on A2A rate limiting: the overload need, per-agent limits, the token bucket (rate + burst), 429 + Retry-After, distributed limiting (shared …

Agent registry architecture

Deep-dive on agent-to-agent registry: discovery, capabilities, versioning, reputation, policy, auth, rate caps, audit, governance.

Agent reputation architecture

Deep-dive on agent reputation: signals, weighting, decay, aggregation, gaming resistance, dispute, transparency, cold start.

A2A Resumable Long-Running Tasks

Design pattern for tasks that outlive a single HTTP connection.

A2A Security

How to secure A2A deployments: auth, authz, sandbox agents, and defend against malicious agents in the ecosystem.

A2A Skill Matching

The algorithm for matching a user intent against an agent's advertised skills.

A2A task state -- the lifecycle of a delegated task

Deep-dive on A2A task state: the delegated task as a stateful entity, the state machine (submitted/working/terminal), terminal states (completed/faile…

A2A State Handoff

What survives the agent boundary.

A2A Streaming

How A2A supports streaming task progress via SSE, enabling responsive UIs and long-running tasks.

A2A streaming architecture

Deep-dive on A2A's long-running task machinery: message/stream SSE subscriptions, the task state machine, incremental artifac…

Agent-to-agent task architecture

Deep-dive on agent tasks: signed envelope, producer/consumer, lifecycle, result, retry, deadline, compensation, audit.

A2A task cancellation architecture

Deep-dive on cancellation in the Agent-to-Agent protocol: tasks/cancel as a cooperative signal, the cancel token checked at safe points, saga-style co…

A2A task delegation architecture

Deep-dive on agent-to-agent delegation: capability discovery, task graph DAG, signed envelopes, typed results, merge.

A2A Task Lifecycle States

The six task states, valid transitions, and what each means for clients.

A2A tasks/send vs tasks/sendSubscribe

The two entry-point methods, streaming vs blocking, and the tradeoffs.

A2A timeout handling

Deep-dive on timeout handling in agent-to-agent systems: putting a deadline on every delegated call, propagating a shrinking budget down the chain, wa…

Agent-to-agent distributed tracing architecture

Deep-dive on distributed tracing for multi-agent systems: root spans, W3C Trace Context propagation across A2A hops, nesting tool and LLM calls as chi…

A2A Trust Models

SPIFFE workload identity for inter-agent calls.

A2A protocol versioning

Deep-dive on versioning in agent-to-agent systems: advertising protocol versions and capabilities in the Agent Card, negotiating the highest common ve…

A2A Well-Known Agent Card Discovery

How clients find agent cards at /.well-known/agent.json + caching considerations.

Beyond Monoliths: Crafting Interoperable AI Systems with Google’s A2A Agent Architecture

Securing A2A Endpoints with OAuth 2.0 and Scoped Permissions