Protocolo A2A v1.0: Interoperabilidad Agente-a-Agente

¿Qué es A2A?

El Protocolo Agent-to-Agent (A2A) es un estándar abierto para la comunicación entre agentes de AI autónomos, sin importar el framework, proveedor o nube en que corran. Fue anunciado por Google en Cloud Next el 9 de abril de 2025 y donado a la Linux Foundation dos meses después. La versión 1.0 de la especificación se publicó en marzo de 2026, convirtiendo A2A de una propuesta de un proveedor en un estándar de grado producción multiindustria. Mientras MCP resuelve el problema agente-a-herramienta, A2A resuelve el problema agente-a-agente: cómo un agente descubre, delega a y colabora con otro agente que no construyó.

El principio de diseño es ejecución opaca. Dos agentes no comparten memoria interna, trazas de razonamiento ni plantillas de prompts propietarias. Exponen un contrato público -- un Agent Card que anuncia capacidades, una superficie JSON-RPC para invocarlas y un objeto Task que rastrea el progreso. Cualquiera de los dos lados puede ser un sistema cerrado; solo necesitan acordar el formato del cable.

A2A es deliberadamente complementario a MCP. MCP conecta herramientas a un solo agente; A2A compone múltiples agentes en un sistema. Un despliegue de producción en abril de 2026 típicamente usa ambos: servidores MCP exponen herramientas a cada agente individual, mientras que A2A conecta a los agentes entre sí. Google, AWS, Microsoft, IBM, Salesforce, SAP, Cisco y ServiceNow forman el comité directivo bajo la Linux Foundation.

Por qué abril 2026: v1.0, adopción en nubes y el primer aniversario

El 9 de abril de 2026 marca el primer aniversario del anuncio de A2A. Más de 150 organizaciones participan hoy -- hyperscalers, ISVs y empresas multinacionales. El repositorio de referencia en github.com/a2aproject/A2A superó las 25.000 estrellas de GitHub. A2A v1.0 (12 de marzo de 2026) es la versión que hizo el protocolo listo para producción: Agent Cards firmados para identidad criptográfica, multi-tenancy para que un endpoint aloje múltiples agentes, y bindings multi-protocolo sobre JSON-RPC, gRPC y REST. El ecosistema de SDKs se expandió de una sola implementación en Python a cinco lenguajes listos para producción: Python, JavaScript, Java, Go y .NET. La versión estable actual es v1.0.1 (mayo 2026), un parche de mantenimiento que refina el binding HTTP para preferir el media type application/a2a+json y clarifica los valores de TaskStatus en la especificación. Los cambios de spec ahora pasan por un proceso público de RFC bajo la Agentic AI Foundation de la Linux Foundation.

El soporte cloud-native llegó en paralelo. Microsoft integró A2A nativamente en Azure AI Foundry y Copilot Studio. AWS añadió soporte A2A al Amazon Bedrock AgentCore Runtime como feature de primera clase -- consulta la guía de AWS. Vertex AI y Agent Engine en Google Cloud añadieron soporte equivalente. Cargas de trabajo empresariales reales ya están en producción en Tyson Foods, Gordon Food Service, S&P Global, ServiceNow y Adobe.

La consecuencia práctica: si estás construyendo un nuevo sistema multi-agente en 2026, no soportar A2A es un error estratégico. Los protocolos de agentes específicos de un proveedor se ven hoy como se veían los protocolos privados de base de datos después de que SQL se estandarizó -- técnicamente funcionales, pero comercialmente aislados.

A2A vs MCP: La Comparación Que Todos Preguntan

La pregunta más común en 2026 es "¿uso MCP o A2A?". La respuesta es "ambos, en capas distintas". Los dos protocolos resuelven problemas ortogonales y están diseñados para componerse.

Regla práctica: si el llamado es una función que podrías escribir como endpoint REST, usa MCP. Si el llamado razona, planea y puede a su vez llamar otras herramientas o agentes, usa A2A. Un agente de revisión legal es un par A2A. Un ejecutor de queries Postgres es una herramienta MCP.

Agent Cards y Descubrimiento

El descubrimiento en A2A es nativo de HTTP. Cada agente compatible sirve un documento JSON en https://<host>/.well-known/agent-card.json describiendo quién es y qué puede hacer. El card es la única metadata pública obligatoria -- sin registro separado, sin DNS-SD, sin broker.

// Example: /.well-known/agent-card.json (v1.0)
{
  "protocolVersion": "1.0",
  "name": "contract-review-agent",
  "provider": {
    "name": "AcmeLegal",
    "url": "https://acmelegal.example.com"
  },
  "description": "Reviews commercial contracts and flags unusual clauses.",
  "interfaces": [
    {
      "transport": "JSONRPC",
      "url": "https://agents.acmelegal.example.com/a2a"
    },
    {
      "transport": "GRPC",
      "url": "grpc://agents.acmelegal.example.com:443"
    }
  ],
  "capabilities": {
    "streaming": true,
    "pushNotifications": true,
    "stateTransitionHistory": true
  },
  "securitySchemes": {
    "oauth2": {
      "type": "oauth2",
      "flows": {
        "clientCredentials": {
          "tokenUrl": "https://auth.acmelegal.example.com/token",
          "scopes": {"contracts.read": "Read contracts"}
        }
      }
    }
  },
  "skills": [
    {
      "id": "review-contract",
      "name": "Review a commercial contract",
      "inputModes": ["text/plain", "application/pdf"],
      "outputModes": ["application/json"],
      "description": "Returns flagged clauses with severity and rationale."
    }
  ],
  "extensions": [
    {"uri": "https://x402.org/a2a/v1", "required": false}
  ],
  "signatures": [
    {"alg": "ES256", "kid": "acmelegal-2026-04", "signature": "eyJhbGciOi..."}
  ]
}

El array signatures es la adición de v1.0. Un cliente que confía en la clave pública del dominio emisor puede verificar que el card realmente vino de ellos, cerrando el ataque de suplantación. Los cards también pueden declarar capacidad extended-card expuesta solo a clientes con credenciales elevadas.

Ciclo de Vida de Tareas

Cada interacción A2A produce una Task. El objeto Task es la unidad de observabilidad, reintento y cancelación -- es a las llamadas de agente lo que una respuesta HTTP es a REST, excepto que puede vivir segundos, minutos u horas.

Estados no-terminales: submitted (reconocida, no iniciada), working (procesando), input-required (necesita más info del usuario), auth-required (necesita re-autenticación del cliente).

Estados terminales: completed (éxito, artefactos adjuntos), failed (error a nivel de agente), canceled (cancelación del cliente), rejected (agente rechazó antes de procesar -- violación de política, skill no soportada, rate limit). Una vez terminal, la tarea no transita más; un reintento crea una nueva tarea.

Los clientes observan transiciones de tres maneras. Polling vía tasks/get sirve para integraciones simples. Streaming vía tasks/subscribe sobre SSE es el default para UIs interactivas. Push notifications vía webhooks son la opción correcta para cargas de larga duración o desacopladas. La misma tarea puede tener múltiples observadores simultáneamente.

Métodos JSON-RPC Centrales

A2A usa JSON-RPC 2.0 sobre HTTP como protocolo de cable default. La superficie de métodos es pequeña y deliberada.

• tasks/send — enviar una nueva tarea; retorna Task o Message inmediato.
• tasks/sendStreaming — enviar y abrir conexión SSE para updates en vivo en un solo round trip.
• tasks/get — obtener el estado actual de la tarea, opcionalmente con historial completo.
• tasks/list — consultar tareas con filtros (estado, ventana de tiempo, skill) y paginación.
• tasks/cancel — solicitar cancelación de una tarea en curso.
• tasks/subscribe — abrir un stream SSE para una tarea existente.
• tasks/pushNotifications/create — registrar un webhook para updates de tarea.
• tasks/pushNotifications/list / get / delete — gestionar suscripciones de webhook.

// Example: submit a task with streaming (JSON-RPC 2.0 over HTTP)
POST /a2a HTTP/1.1
Host: agents.acmelegal.example.com
Authorization: Bearer <token>
Content-Type: application/json
Accept: text/event-stream

{
  "jsonrpc": "2.0",
  "id": "req-42",
  "method": "tasks/sendStreaming",
  "params": {
    "message": {
      "messageId": "msg-01",
      "role": "user",
      "parts": [
        {"kind": "text", "text": "Review this SaaS agreement for red flags."},
        {"kind": "url", "mediaType": "application/pdf",
         "filename": "agreement.pdf",
         "url": "https://files.example.com/agr-7891.pdf"}
      ]
    },
    "skill": "review-contract"
  }
}

// Response: SSE stream
event: status
data: {"taskId":"t-9f3...","state":"submitted"}

event: status
data: {"taskId":"t-9f3...","state":"working"}

event: artifact
data: {"taskId":"t-9f3...","artifact":{
  "parts":[{"kind":"data","data":{"flags":[...partial...]}}],
  "index":0,"lastChunk":false}}

event: status
data: {"taskId":"t-9f3...","state":"completed"}

Autenticación y Mandatos

A2A reutiliza autenticación HTTP bien entendida en vez de inventar un mecanismo nuevo. El Agent Card declara los esquemas aceptados bajo securitySchemes, usando el vocabulario de OpenAPI: API key, HTTP Basic/Bearer, OAuth 2.0, OpenID Connect y mutual TLS. Los clientes eligen un esquema que puedan satisfacer y adjuntan la credencial en cada request.

Dos adiciones específicas de A2A importan. Primero, el estado auth-required permite a un agente pausar en medio de una tarea y pedirle al cliente un token con scopes adicionales -- por ejemplo, un agente planificador descubre que necesita acceso de escritura a un calendario al que solo tiene scope de lectura. Segundo, v1.0 introdujo mandatos, una credencial de delegación firmada que permite a un usuario autorizar a un agente a actuar en su nombre con autoridad acotada ("gasta hasta $200 en mi nombre esta semana, solo en estos comercios"). Los mandatos son la base del comercio agente-liderado seguro.

Para llamadas entre organizaciones, el patrón dominante es OAuth 2.0 client credentials con tokens de scope acotado, más Agent Cards firmados. Los despliegues internos prefieren mutual TLS dentro del service mesh; consulta la guía de Istio.

A2A con el Claude Agent SDK

El Claude Agent SDK no incluye un servidor A2A listo, pero envolver un agente Claude detrás de un endpoint A2A es poca cantidad de código de pegamento. El patrón: expón tu agente Claude como una skill A2A, traduce los mensajes A2A entrantes a mensajes Claude y transmite la salida de Claude como TaskArtifactUpdateEvents.

// a2a-claude-agent.ts
// Wrap a Claude Agent SDK session behind an A2A endpoint.
import { A2AServer } from "@a2a/server";   // hypothetical but follows spec
import { query } from "@anthropic-ai/claude-agent-sdk";

const a2a = new A2AServer({
  agentCard: {
    protocolVersion: "1.0",
    name: "research-agent",
    description: "Deep research agent powered by Claude.",
    interfaces: [{ transport: "JSONRPC", url: process.env.A2A_URL! }],
    capabilities: { streaming: true, pushNotifications: true },
    securitySchemes: {
      bearer: { type: "http", scheme: "bearer" }
    },
    skills: [{
      id: "research",
      name: "Research a topic",
      inputModes: ["text/plain"],
      outputModes: ["application/json", "text/markdown"]
    }]
  }
});

a2a.onSkill("research", async (task, send) => {
  const prompt = task.message.parts
    .filter(p => p.kind === "text")
    .map(p => p.text)
    .join("\n");

  await send.status("working");

  // Claude Agent SDK: stream the response
  for await (const ev of query({
    prompt,
    options: { model: "claude-opus-4-8", permissionMode: "acceptEdits" }
  })) {
    if (ev.type === "text_delta") {
      await send.artifact({
        parts: [{ kind: "text", text: ev.delta }],
        lastChunk: false
      });
    }
    if (ev.type === "done") {
      await send.artifact({
        parts: [{ kind: "text", text: "" }],
        lastChunk: true
      });
      await send.status("completed");
    }
  }
});

a2a.listen(8080);

El caso inverso -- un agente Claude que llama a otro agente vía A2A -- es igualmente útil. Expón A2A como una herramienta Claude regular: la herramienta hace POST a tasks/sendStreaming, lee el stream SSE y retorna el artefacto final. Así compones agentes especialistas: Claude llama delegate_to_legal_review o delegate_to_forecast_agent, y el wrapper maneja la mecánica del protocolo.

# Python: Claude tool that delegates to an A2A peer agent
from anthropic import Anthropic
import httpx, json

async def delegate_to_a2a(agent_url: str, skill: str, prompt: str,
                          token: str) -> dict:
    body = {
        "jsonrpc": "2.0", "id": "1",
        "method": "tasks/sendStreaming",
        "params": {
            "skill": skill,
            "message": {
                "messageId": "m1", "role": "user",
                "parts": [{"kind": "text", "text": prompt}]
            }
        }
    }
    async with httpx.AsyncClient(timeout=None) as c:
        async with c.stream("POST", agent_url,
                            headers={"Authorization": f"Bearer {token}",
                                     "Accept": "text/event-stream"},
                            json=body) as r:
            final = None
            async for line in r.aiter_lines():
                if line.startswith("data:"):
                    evt = json.loads(line[5:].strip())
                    if evt.get("artifact") and evt["artifact"].get("lastChunk"):
                        final = evt["artifact"]
            return final

# Register as a Claude tool via the Agent SDK; Claude calls it like any
# other tool, and the wrapper hides all A2A plumbing.

A2A + MCP: La Arquitectura Híbrida

La arquitectura de producción canónica en 2026 usa ambos protocolos. Cada agente conecta a sus herramientas vía MCP. Los agentes conectan entre sí vía A2A. El resultado es un grafo de dos capas: capa de herramientas privada por agente, capa de agentes pública entre equipos.

                         +--------- A2A ----------+
                         |                        |
    +---- Planner Agent (Team A) ---+     +-- Legal Agent (Team B) --+
    |                               |     |                          |
    |  MCP:  jira, github, slack,   |     |  MCP:  documentdb,       |
    |        filesystem, email      |     |        caselaw-search,   |
    |                               |     |        redaction-tool    |
    +-------------------------------+     +--------------------------+

       ^ private to Team A                    ^ private to Team B
       (MCP inside the agent's trust domain)

                      A2A (public contract, signed cards,
                           OAuth tokens, mandates)

Elegir es sencillo. ¿El llamado es una función determinística que controlas? MCP. ¿El llamado es otro agente -- especialmente uno de otro equipo, proveedor o nube? A2A. Los equipos que usan A2A para todo pagan el overhead del ciclo de vida en llamadas cortas; los que usan MCP para todo terminan implementando a mano auth, versionado y descubrimiento cross-team y reconstruyendo A2A mal.

El patrón de composición importa para arquitecturas multi-agente. Un agente supervisor tiene pocos pares A2A (especialistas) y muchas herramientas MCP (sus propias manos). El prompt del supervisor nunca necesita conocer los internos del especialista -- solo su Agent Card.

Despliegues en Producción: Azure AI Foundry y AWS Bedrock AgentCore

Ambas plataformas cloud principales de EE.UU. tratan A2A como una preocupación nativa del runtime, así que normalmente no implementas el protocolo desde cero -- el runtime lo hace y tú escribes la lógica del agente.

Azure AI Foundry y Copilot Studio

En Azure AI Foundry, los agentes construidos con Foundry Agents Service exponen un endpoint A2A por defecto. La plataforma publica un Agent Card firmado en la URL gestionada por Foundry, integra con Entra ID para OAuth y cablea el estado de tareas a Application Insights. Los agentes de Copilot Studio pueden publicar y consumir endpoints A2A, convirtiendo a cada cliente de Copilot Studio en un participante A2A latente.other.example.com/.well-known/agent-card.json transparently. This is meaningful because it turns every Copilot Studio customer into a latent A2A participant.

AWS Bedrock AgentCore Runtime

Bedrock AgentCore Runtime (consulta la guía de AWS) añadió un contrato explícito del protocolo A2A. Cualquier framework que corra en AgentCore -- Strands, LangGraph, OpenAI Agents SDK, Google ADK -- es envuelto con un ingress A2A y un cliente A2A saliente. AgentCore maneja cards firmados vía identidad respaldada por IAM, Cognito o Entra para OAuth, y CloudWatch para telemetría.

Google Cloud: Vertex AI, Agent Engine, ADK

En Google Cloud, A2A es nativo en ADK, Vertex AI Agent Engine y Agentspace. Despliega en Agent Engine para un path gestionado, Cloud Run para serverless o GKE para máximo control. Vertex GenAI Evaluation Service trata a los agentes A2A como de primera clase, evaluándolos vía sus interfaces públicas en vez de instrumentación interna.

Cloudflare: A2A en el Edge

Para agentes sensibles a latencia, Cloudflare Workers con Durable Objects (consulta la guía de Cloudflare) es un host interesante: los Durable Objects dan estado por-tarea, Streams dan SSE, y el anycast global mantiene p99 bajo para fetches de Agent Card. El soporte en producción de x402 en Cloudflare se empareja con la extensión x402 de A2A en el edge.

La Extensión A2A x402: Agentes Pagándole a Agentes

La extensión A2A x402 (github.com/google-agentic-commerce/a2a-x402) es una de las primeras extensiones reales de A2A y probablemente la más consecuente, porque permite que los agentes realmente transaccionen. Revive el código HTTP 402 "Payment Required" dormido: cuando un agente cliente llama a una skill paga, el servidor responde con una tarea en subestado payment-required incluyendo monto, moneda, wallet de destino y URL del facilitador. El cliente firma un pago stablecoin vía el protocolo x402 de Coinbase, reenvía la tarea con el pago adjunto y recibe la salida.

La extensión se compone con el framework más amplio Agent Payments Protocol (AP2) de Google y con mandatos a nivel de usuario: un humano firma un mandato diciendo "este agente puede gastar hasta $200 en mi nombre esta semana en APIs de investigación", y el agente presenta el mandato más un pago x402 a cada llamado. El rollout en producción de x402 de Coinbase -- Stripe sobre Base en febrero 2026, soporte en el edge de Cloudflare, más de 100 millones de pagos procesados -- es la infraestructura a la que esto se enchufa.

Si estás construyendo agentes que consumen servicios pagos externos, x402 sobre A2A es hoy el patrón de monetización más limpio: sin handshake de API key, sin reconciliación de facturas, sin chargebacks. Consulta la guía de Stripe y la guía de Full-Stack AI.

Implementación: Servidor A2A Mínimo

Rara vez implementas A2A desde cero -- los SDKs oficiales en github.com/a2aproject manejan el serving del Agent Card, routing JSON-RPC, framing SSE y entrega de webhooks. Un servidor mínimo en Python usando el a2a-sdk de referencia cabe en unas 30 líneas.

# a2a_server.py
from a2a.server import A2AServer, TaskContext
from a2a.types import AgentCard, Skill, Part, TaskState
import asyncio

card = AgentCard(
    protocol_version="1.0",
    name="summarize-agent",
    description="Summarizes long documents.",
    skills=[Skill(
        id="summarize",
        name="Summarize a document",
        input_modes=["text/plain"],
        output_modes=["text/plain"]
    )],
    capabilities={"streaming": True}
)

server = A2AServer(agent_card=card)

@server.skill("summarize")
async def summarize(ctx: TaskContext):
    text = next((p.text for p in ctx.message.parts
                 if p.kind == "text"), "")
    await ctx.update(TaskState.WORKING)

    # ... your actual summarization (MCP tool calls,
    # LLM inference, whatever) ...
    summary = await do_summary(text)

    await ctx.artifact(Part(kind="text", text=summary),
                       last_chunk=True)
    await ctx.update(TaskState.COMPLETED)

if __name__ == "__main__":
    asyncio.run(server.run(host="0.0.0.0", port=8080))

El SDK sirve /.well-known/agent-card.json, acepta JSON-RPC en /a2a, emite SSE para streaming y aplica el middleware de auth que configures. Despliega el contenedor detrás de cualquier ingress -- Cloud Run, ECS, Kubernetes, Workers -- y registra un Agent Card firmado en tu DNS público.

Seguridad y Notas de Producción

Tres modos de falla son específicos de despliegues A2A en abril 2026 y vale la pena explicitarlos.

• Agent Cards sin firmar son un antipatrón post-v1.0. Siempre firma. Un cliente que obtenga un card sin firmar de un dominio externo debería tratarlo como un navegador trata un certificado TLS autofirmado.
• Costo de tarea sin límite. Un agente llamado puede correr horas e invocar otros agentes pagos. Siempre pon presupuestos por tarea (tokens, wall clock, dinero) y aplica mandatos.
• Prompt-injection entre agentes. El contenido obtenido por un agente llamado puede contener instrucciones que secuestran al llamador. Mantén el system prompt del llamador estricto sobre ignorar instrucciones en artefactos A2A, y valida salida estructurada en vez de confiar en texto libre.
• Replay e idempotencia. Usa messageId y taskId como claves de idempotencia. Los agentes deben rechazar un segundo tasks/send con el mismo messageId dentro de la ventana de replay.
• Observabilidad. Instrumenta cada llamada A2A: propagación de trace id vía headers, task id en cada línea de log, métricas RED por skill. Azure AI Foundry, AgentCore y Agent Engine cablean esto; los despliegues self-hosted lo deben hacer a mano.