Curso de A2A - Agent2Agent

Diferenciar A2A como comunicación agente-agente frente a MCP como conexión agente-herramienta o agente-recurso.

Identificar cuándo un agente debe usar una herramienta local mediante MCP y cuándo debe delegar a otro agente mediante A2A.

Comparar A2A con APIs REST clásicas, webhooks, colas, eventos, gRPC, JSON-RPC y plataformas de integración.

Evaluar si un caso necesita interoperabilidad entre agentes, orquestación centralizada o simple automatización determinista.

Diseñar arquitecturas donde un agente A2A usa herramientas internas mediante MCP sin exponerlas al agente externo.

Evitar convertir A2A en una capa innecesaria cuando basta una API estable y no hay colaboración agentic.

Entender la diferencia entre “llamar un endpoint” y “delegar una tarea a un agente con lifecycle, contexto y artefactos”.

Crear matriz de decisión entre A2A, MCP, API, workflow engine, cola de mensajes y orquestador multiagente.

Identificar patrones híbridos: agente principal, agentes especialistas, herramientas MCP, servicios empresariales y revisión humana.

Realizar ejercicio de diseño de arquitectura para decidir qué interacciones usan A2A y cuáles no.

Comprender A2A como protocolo basado en estándares web y orientado a interoperabilidad entre aplicaciones agentic.

Revisar transportes y bindings disponibles, incluyendo JSON-RPC, HTTP+JSON/REST y gRPC cuando aplica.

Entender el papel de HTTP(S), headers, payloads JSON, endpoints, autenticación externa y respuestas del agente.

Analizar los objetos centrales del modelo: AgentCard, AgentSkill, Task, TaskStatus, Message, Part, Artifact y PushNotificationConfig.

Diferenciar operaciones síncronas, operaciones de larga duración, consultas de estado y notificaciones push.

Diseñar interacciones donde el cliente inicia tarea, consulta progreso, recibe eventos y recupera artefactos.

Comprender cómo se mantiene contexto mediante contextId y cómo se relacionan varias tareas.

Revisar versionado del protocolo, compatibilidad, negociación y evolución de implementaciones.

Identificar qué parte debe implementar el servidor A2A y qué parte corresponde al cliente A2A.

Realizar ejercicio de lectura de una especificación A2A y mapeo de objetos a una arquitectura real.

Diseñar Agent Cards como contrato de descubrimiento y autopresentación de un agente.

Definir identidad del agente: nombre, descripción, proveedor, versión, URL, documentación y propósito.

Describir capabilities como streaming, push notifications, modalidades soportadas y capacidades extendidas.

Definir skills con id, nombre, descripción, ejemplos, inputModes, outputModes y criterios de uso.

Evitar skills demasiado genéricas como “hacer tareas” que no permiten discovery útil ni autorización granular.

Indicar requisitos de autenticación y seguridad sin exponer secretos ni detalles sensibles innecesarios.

Diferenciar Agent Card pública, Agent Card autenticada, Agent Card extendida y variantes internas por permisos.

Crear convenciones de naming, versionado y semántica para Agent Cards en entornos enterprise.

Evaluar cómo un cliente decide si un agente es adecuado a partir de su Agent Card.

Realizar laboratorio de diseño de Agent Card para tres agentes especializados.

Implementar discovery mediante ruta well-known para agentes públicos, internos o de dominio controlado.

Diseñar discovery privado mediante configuración directa, variables de entorno, catálogos internos o service discovery corporativo.

Crear registros curados de agentes para entornos empresariales con búsqueda por skill, proveedor, dominio y criticidad.

Evaluar ventajas y riesgos de publicar Agent Cards en un endpoint accesible.

Proteger Agent Cards con autenticación cuando contienen endpoints internos, skills sensibles o datos de arquitectura.

Aplicar caching, ETag, Cache-Control y política de actualización para Agent Cards que cambian poco.

Diseñar mecanismos de aprobación antes de registrar un nuevo agente en catálogo corporativo.

Crear criterios de retirada de agentes obsoletos, duplicados, inseguros o sin owner.

Integrar discovery con API Management, developer portals, service catalog o plataformas internas.

Realizar ejercicio de catálogo privado de agentes con clasificación por dominio, skill, permisos y estado.

Comprender Task como unidad de trabajo stateful iniciada por un agente cliente.

Modelar estados de task: submitted, working, input-required, completed, canceled, failed o estados equivalentes según implementación.

Diseñar tareas de corta duración, tareas largas, tareas cancelables y tareas que requieren intervención del usuario.

Usar taskId para seguimiento y contextId para agrupar tareas relacionadas dentro de una conversación o proceso.

Gestionar actualizaciones de estado, progreso, mensajes intermedios y resultados finales.

Diseñar patrones de recuperación ante fallo: retry, reanudación, cancelación, idempotencia y consulta de estado.

Evitar tareas opacas que tardan mucho sin explicar progreso, incertidumbre ni pasos realizados.

Crear mapas de transición de estado para agentes de soporte, compras, análisis de datos y documentación.

Relacionar Task con Artifacts generados durante o al final del proceso.

Realizar laboratorio de implementación de task lifecycle completo.

Comprender Message como turno de comunicación entre agente cliente y agente remoto.

Diferenciar role user, role agent y mensajes generados por servicios en nombre del usuario.

Usar Parts como contenedores flexibles para texto, datos estructurados, archivos inline o referencias URL.

Trabajar con mediaType, filename y metadata para describir contenido intercambiado entre agentes.

Diseñar mensajes que transportan instrucciones, contexto, restricciones, preguntas, resultados parciales o solicitud de aclaración.

Modelar intercambio multimodal con texto, JSON, documentos, imágenes, formularios o archivos externos.

Evitar enviar contexto excesivo, datos sensibles innecesarios o archivos sin clasificación.

Crear convenciones para que los agentes distingan instrucciones, evidencias, restricciones y datos de entrada.

Diseñar validaciones de tamaño, tipo, seguridad y permisos sobre Parts recibidos.

Realizar ejercicio de intercambio de mensajes con texto, JSON, documento y referencia externa.

Comprender Artifact como resultado tangible generado durante una Task.

Diferenciar mensaje conversacional de artefacto entregable: informe, tabla, imagen, JSON, archivo, plan o documento.

Diseñar artifacts con artifactId, nombre, parts, metadata, versión y relación con la tarea.

Generar artefactos incrementales durante streaming para que el cliente pueda mostrar progreso útil.

Definir formatos aceptados por caso de uso: Markdown, PDF, JSON, CSV, HTML, imágenes, documentos o enlaces.

Validar artefactos antes de presentarlos como resultado final a humanos o sistemas.

Gestionar almacenamiento, retención, permisos y trazabilidad de artefactos generados.

Evitar que un agente devuelva decisiones críticas como artefactos finales sin revisión humana.

Crear catálogo de artefactos por tipo de agente y nivel de riesgo.

Realizar laboratorio de generación y recuperación de artefactos estructurados.

Comprender JSON-RPC como binding principal para operaciones A2A.

Diseñar requests y responses con ids, métodos, params, results y errores bien formados.

Mapear operaciones A2A a endpoints HTTP+JSON/REST cuando la implementación lo soporta.

Evaluar gRPC para entornos con alta eficiencia, contratos estrictos o plataformas enterprise.

Gestionar errores de protocolo, errores HTTP, errores de validación y errores de negocio.

Implementar idempotencia en operaciones sensibles para evitar duplicidades por reintentos.

Diseñar negociación de versión y compatibilidad entre clientes y servidores.

Probar llamadas A2A con REST clients, scripts, SDKs y tests automatizados.

Documentar contratos técnicos para equipos que integran clientes y servidores.

Realizar ejercicio de llamada A2A manual y posterior implementación con SDK.

Usar streaming cuando una tarea produce progreso, razonamiento parcial, resultados incrementales o estado en tiempo real.

Comprender Server-Sent Events como mecanismo de entrega de eventos del servidor al cliente.

Diseñar eventos de estado, eventos de artefacto, mensajes parciales y finalización controlada.

Controlar reconexión, timeouts, cancelación, errores y cierre de stream.

Diferenciar streaming útil de streaming ruidoso que expone detalles internos innecesarios.

Crear interfaces que muestran progreso sin dar falsa sensación de certeza.

Evitar enviar datos sensibles o internos durante el stream si no forman parte del resultado autorizado.

Probar streaming en local, tras proxy, API gateway, balanceador y entorno cloud real.

Medir latencia percibida, tiempo hasta primer evento, duración total y errores de conexión.

Realizar laboratorio de task streaming con progreso y artifact updates.

Usar push notifications cuando el cliente no puede mantener conexión abierta o la tarea dura demasiado.

Diseñar webhooks de callback seguros para recibir actualizaciones de tareas.

Configurar autenticación de notificaciones, validación de firma, secreto, timestamp y prevención de replay.

Gestionar reintentos, duplicados, idempotencia y orden de eventos.

Diferenciar polling, streaming y push según duración, criticidad, coste y experiencia de usuario.

Diseñar procesos offline: análisis documental largo, generación de informe, investigación, procesamiento batch o aprobación humana.

Registrar eventos relevantes para auditoría y troubleshooting.

Evitar notificar resultados sensibles a endpoints no verificados.

Crear estrategias de fallback si falla el webhook o el cliente no está disponible.

Realizar ejercicio de configuración de push notifications para una tarea de larga duración.

Diseñar interacciones donde un agente remoto necesita aclaraciones, credenciales, aprobación o información adicional.

Usar estados de input-required para pausar tareas sin fallarlas.

Crear patrones de pregunta-respuesta entre agente remoto, agente cliente y usuario humano.

Gestionar contexto multi-turn sin enviar todo el historial innecesariamente.

Diseñar experiencias donde el agente explica qué necesita y por qué lo necesita.

Controlar límites de conversación, expiración de tareas, reanudación y cancelación.

Evitar bucles de aclaración infinitos entre agentes mal diseñados.

Introducir revisión humana en acciones sensibles, decisiones de negocio y cambios irreversibles.

Documentar decisiones humanas dentro del contexto de la tarea.

Realizar laboratorio de workflow multi-turn con aprobación humana antes de ejecutar una acción.

Configurar entorno Python con versión compatible, entorno virtual, dependencias y SDK A2A oficial.

Crear un A2A Server sencillo con AgentExecutor, skills, Agent Card y endpoint de servicio.

Implementar lógica de agente con llamadas a LLM, funciones internas, herramientas o servicios de prueba.

Crear un A2A Client capaz de descubrir Agent Card, enviar mensajes, consultar tareas y recibir resultados.

Gestionar respuestas síncronas, tasks, streaming, artifacts y errores.

Integrar FastAPI o Starlette cuando se necesita servidor HTTP compatible.

Añadir persistencia básica de tasks, logs, estado y artefactos.

Probar compatibilidad entre versión de SDK, versión de especificación y modo de transporte elegido.

Estructurar proyecto Python con módulos, tests, configuración, secretos y Docker.

Realizar laboratorio de agente Python A2A de análisis documental.

Revisar SDKs y opciones de implementación para JavaScript, Java, C#/.NET, Go y Rust.

Crear cliente A2A en TypeScript para consumir agentes remotos desde backend o aplicación web.

Diseñar wrappers para gestionar discovery, autenticación, retries, streaming y artifacts.

Integrar A2A con backends Node.js, Hono, Express, Fastify, NestJS o runtimes serverless.

Usar tipado TypeScript para modelar Agent Card, Task, Message, Part y Artifact.

Comparar decisiones entre implementar desde SDK oficial o integrar directamente contra el contrato HTTP/JSON-RPC.

Preparar pruebas de interoperabilidad entre agente Python y cliente TypeScript.

Gestionar secretos, variables de entorno, CORS, proxies y gateways en clientes web o server-side.

Crear librería interna de cliente A2A reutilizable por varios equipos.

Realizar laboratorio de cliente TypeScript para invocar agentes A2A corporativos.

Exponer agentes creados en ADK, LangGraph, CrewAI, Semantic Kernel, BeeAI o frameworks propios como servidores A2A.

Separar lógica interna del agente de la interfaz A2A para mantener independencia y testabilidad.

Mapear capacidades del framework a skills A2A claras, limitadas y autorizables.

Diseñar adaptadores para traducir entrada A2A a prompts, state graphs, tool calls o workflows internos.

Convertir respuestas internas del framework en messages, artifacts y task updates.

Gestionar memoria interna del agente sin exponerla al cliente A2A.

Controlar herramientas internas, RAG, bases de datos y APIs a través de permisos propios del agente.

Evitar que el wrapper A2A sea un simple túnel sin validación, seguridad ni observabilidad.

Crear patrón de “agent adapter” reutilizable por distintos equipos.

Realizar ejercicio de exposición de un agente existente como A2A Server.

Diseñar agentes A2A que internamente usan MCP servers para acceder a herramientas, datos o APIs corporativas.

Diferenciar autorización del cliente A2A frente a autorización del agente sobre herramientas MCP internas.

Evitar exponer herramientas MCP directamente a agentes externos si deben permanecer privadas.

Crear patrones de tool mediation: el agente remoto decide qué herramienta usar y devuelve solo resultados autorizados.

Gestionar credenciales secundarias cuando el agente necesita actuar en nombre del usuario.

Diseñar flujos con human-in-the-loop cuando MCP permite acciones de escritura o cambios críticos.

Integrar RAG, búsqueda documental, CRM, ERP, Jira, GitHub, SharePoint o bases SQL mediante herramientas internas.

Registrar qué herramienta se usó, por qué, con qué autorización y qué resultado produjo.

Protegerse frente a prompt injection procedente de datos recuperados por herramientas.

Realizar laboratorio de agente A2A que usa MCP para consultar conocimiento corporativo.

Diseñar workflows donde un agente coordinador delega subtareas a varios agentes especialistas mediante A2A.

Crear patrones secuenciales: un agente produce un artefacto que alimenta al siguiente.

Crear patrones jerárquicos: un supervisor asigna tareas, revisa resultados y consolida respuesta final.

Crear patrones colaborativos: varios agentes aportan perspectivas y un agente sintetiza decisión o informe.

Gestionar dependencias, prioridades, reintentos, timeouts y cancelaciones entre tareas.

Evitar cascadas de agentes que multiplican coste, latencia y riesgo sin aportar calidad.

Crear criterios de selección de agente en función de skills, permisos, coste, confianza, latencia y especialización.

Diseñar consolidación de resultados contradictorios con revisión humana cuando procede.

Medir rendimiento del workflow completo, no solo de cada agente individual.

Realizar laboratorio de workflow multiagente para proceso empresarial transversal.

Aplicar HTTPS obligatorio en producción y verificar identidad del servidor mediante certificados válidos.

Configurar TLS moderno, mTLS cuando procede y restricciones de red en agentes internos.

Implementar autenticación con OAuth2, OIDC, API keys o HTTP authentication según el escenario.

Declarar esquemas de seguridad en Agent Cards sin incluir secretos ni credenciales estáticas.

Transmitir credenciales por headers estándar y no dentro del payload del protocolo.

Validar credenciales en cada request antes de procesar tasks o entregar artifacts.

Gestionar rotación de claves, expiración de tokens, scopes y revocación.

Diseñar separación entre identidad de usuario, identidad de cliente, identidad de agente e identidad de servicio.

Evitar que un agente remoto pueda impersonar usuarios o clientes sin control explícito.

Realizar ejercicio de configuración de autenticación Bearer/OAuth2 para un servidor A2A.

Aplicar autorización granular por skill, usuario, cliente, tenant, organización, entorno y sensibilidad de datos.

Diseñar scopes OAuth o permisos internos que habiliten unas skills y bloqueen otras.

Controlar acceso a artifacts, tasks históricas, datos de entrada y resultados generados.

Validar autorización antes de invocar herramientas internas, consultar bases de datos o ejecutar acciones.

Aplicar principio de mínimo privilegio para agentes, clientes, usuarios y credenciales de servicio.

Separar skills de lectura, análisis, recomendación, escritura, ejecución y acción irreversible.

Introducir aprobación humana para acciones de alto impacto: cambios en sistemas, comunicaciones externas o decisiones sensibles.

Registrar quién pidió la acción, qué agente la ejecutó, qué datos usó y qué resultado generó.

Evitar Agent Cards que anuncian skills que el cliente puede descubrir pero no debería usar.

Realizar ejercicio de autorización por skill en un ecosistema multiagente.

Clasificar datos intercambiados en messages, parts, artifacts, metadata y logs.

Aplicar minimización de datos en cada delegación entre agentes.

Evitar enviar documentos completos cuando basta un extracto, resumen autorizado o referencia segura.

Definir políticas de retención para tasks, artifacts, trazas, logs y datos intermedios.

Proteger datos en tránsito, en reposo y en herramientas internas usadas por agentes.

Gestionar datos personales, secretos empresariales, propiedad intelectual, información financiera y datos regulados.

Crear filtros de salida para evitar que un agente remoto devuelva información que el usuario no puede ver.

Documentar transferencias de datos entre sistemas, proveedores, tenants y jurisdicciones.

Evaluar cumplimiento con RGPD, políticas internas y requisitos sectoriales.

Realizar ejercicio de análisis de privacidad de un flujo A2A con datos sensibles.

Diseñar logging estructurado con taskId, contextId, traceId, agentId, skill, usuario y estado.

Integrar OpenTelemetry para trazabilidad distribuida entre clientes A2A, servidores A2A, herramientas y backends.

Medir métricas operativas: requests, errores, latencia, duración de tasks, timeouts, cancelaciones y artifacts generados.

Crear dashboards de salud de agentes, uso por skill, coste, latencia, calidad y tasa de fallo.

Auditar eventos críticos: creación de task, cambio de estado, autorización, uso de herramientas y entrega de resultados.

Evitar logs con prompts completos, secretos, documentos sensibles o datos personales innecesarios.

Correlacionar fallos entre varios agentes dentro de un workflow distribuido.

Crear alertas por error rate, degradación, credenciales caducadas, endpoints caídos o responses inconsistentes.

Preparar runbooks para diagnosticar problemas de discovery, auth, streaming, push y task lifecycle.

Realizar laboratorio de observabilidad de un workflow A2A con trazas distribuidas.

Crear tests unitarios para lógica de agente, validación de entradas y construcción de artifacts.

Crear tests de contrato para Agent Cards, schemas, operaciones A2A y errores esperados.

Probar clientes y servidores A2A contra agentes mock y agentes reales.

Validar compatibilidad entre versiones de SDK, protocolo, bindings y extensiones.

Probar discovery, autenticación, autorización, streaming, push notifications y cancelación.

Simular fallos: timeout, agente no disponible, task failed, credentials inválidas, payload incorrecto y artifact corrupto.

Crear pruebas de seguridad: acceso a skill no autorizada, Agent Card protegida, datos sensibles y replay de webhooks.

Automatizar pruebas en CI/CD con entornos efímeros o contenedores.

Medir interoperabilidad entre agentes de distintos lenguajes, frameworks y proveedores.

Realizar laboratorio de suite de pruebas para un ecosistema A2A.

Exponer servidores A2A detrás de API gateway, reverse proxy o plataforma de API Management.

Aplicar políticas centralizadas: autenticación, autorización, quotas, rate limits, routing y protección de tráfico.

Publicar Agent Cards, documentación y ejemplos en developer portals internos.

Gestionar onboarding de clientes A2A con credenciales, scopes, entornos, SLAs y límites de uso.

Diseñar entornos dev, staging, preproducción y producción para agentes A2A.

Versionar agentes, skills, Agent Cards y contratos de integración sin romper clientes existentes.

Crear catálogo de agentes aprobados, experimentales, deprecados y retirados.

Definir owners técnicos, funcionales, seguridad, soporte y mantenimiento de cada agente.

Medir uso y valor de agentes como activos de plataforma.

Realizar ejercicio de diseño de gobierno API para una red interna de agentes.

Diseñar agentes que atienden varios clientes, áreas, organizaciones o tenants sin mezclar datos.

Separar configuración, contexto, credenciales, artifacts, logs y almacenamiento por tenant.

Implementar autorización tenant-aware en cada request, task, artifact y operación interna.

Evitar Agent Cards que revelan capacidades o endpoints no visibles para un tenant concreto.

Gestionar límites por tenant: cuota, rate limit, coste, prioridad, concurrencia y retención.

Diseñar estrategias de aislamiento: base de datos separada, namespaces, claims, scopes o despliegues independientes.

Auditar accesos cruzados y errores de configuración que puedan provocar fugas entre tenants.

Crear tests de aislamiento para datos, artifacts, tasks y logs.

Definir modelo operativo para agentes SaaS multi-tenant.

Realizar laboratorio de agente A2A multi-tenant con control de acceso.

Comprender cómo A2A permite extensiones sin romper el núcleo estable del protocolo.

Declarar extensiones en Agent Cards de forma clara y versionada.

Diseñar extensiones solo cuando existe una necesidad real no cubierta por el estándar.

Evitar extensiones propietarias que eliminan interoperabilidad y bloquean a clientes.

Evaluar custom protocol bindings cuando el entorno necesita transporte o integración específica.

Aplicar gobernanza de extensiones: propuesta, revisión, piloto, documentación, compatibilidad y retirada.

Mantener compatibilidad hacia atrás y rutas de migración para clientes existentes.

Documentar semántica, errores, seguridad y limitaciones de cada extensión.

Decidir cuándo proponer una extensión a la comunidad y cuándo mantenerla interna.

Realizar ejercicio de diseño de extensión controlada para metadata empresarial.

Contenerizar servidores A2A con Docker, variables de entorno, healthchecks y configuración segura.

Desplegar agentes en Kubernetes, Cloud Run, ECS, Azure Container Apps, serverless o plataformas internas.

Gestionar escalado horizontal, concurrencia, colas internas y límites de tareas largas.

Separar componentes: servidor A2A, motor de agente, almacenamiento de tasks, artifacts, logs y tracing.

Configurar secrets, certificados, credenciales de proveedor LLM y acceso a herramientas internas.

Diseñar estrategias de resiliencia: retry, circuit breaker, timeout, backpressure y degradación controlada.

Gestionar coste de modelos, latencia, tokens, herramientas y almacenamiento.

Crear CI/CD con tests, escaneo de seguridad, despliegue por entornos y rollback.

Preparar operación 24/7 cuando el agente participa en procesos críticos.

Realizar laboratorio de despliegue de servidor A2A con contenedor y observabilidad básica.

Diseñar caso de soporte IT donde un agente de triage delega a agentes de conocimiento, infraestructura y resolución.

Diseñar caso de compras donde un agente de procurement consulta agentes legales, financieros y de proveedores.

Diseñar caso legal donde un agente de intake delega revisión contractual, privacidad y compliance.

Diseñar caso de ventas donde un agente comercial consulta agentes de producto, pricing, CRM y generación de propuesta.

Diseñar caso de datos donde un agente de negocio delega análisis a agentes SQL, BI, reporting y visualización.

Diseñar caso DevOps donde un agente de incidente coordina observabilidad, runbooks, cambios y comunicación.

Diseñar caso de RRHH donde un agente de empleados delega a agentes de políticas, formación y solicitudes internas.

Diseñar caso industrial donde agentes de mantenimiento, planificación, calidad y compras coordinan acciones.

Evaluar qué tareas deben quedar como recomendación y cuáles pueden ejecutar acciones controladas.

Realizar ejercicio de selección de casos de uso A2A por valor, riesgo, datos, coste y madurez.

Identificar riesgos de prompt injection entre agentes y contenido recuperado desde herramientas o documentos.

Proteger agentes frente a instrucciones maliciosas incluidas en artifacts, mensajes, URLs o datos externos.

Validar inputs, media types, archivos, enlaces y datos estructurados antes de procesarlos.

Aplicar allowlists de skills, agentes remotos, dominios, herramientas y formatos aceptados.

Diseñar políticas de egress para limitar a qué endpoints puede conectarse un agente.

Detectar intentos de escalada de permisos, exfiltración de datos o uso indebido de credenciales secundarias.

Separar instrucciones del sistema, instrucciones de usuario, datos recuperados y resultados de otros agentes.

Crear red-team tests para flujos A2A sensibles.

Registrar y revisar eventos sospechosos sin almacenar más datos de los necesarios.

Realizar laboratorio de ataque y defensa sobre un workflow A2A vulnerable.

Definir métricas de calidad para agentes A2A: exactitud, completitud, utilidad, seguridad, latencia y coste.

Evaluar si el agente remoto resuelve la skill anunciada en su Agent Card.

Crear datasets de pruebas con tareas reales, resultados esperados y criterios de aceptación.

Comparar respuestas entre agentes especializados y detectar contradicciones.

Implementar revisión humana en resultados críticos, decisiones sensibles o artifacts enviados a terceros.

Diseñar feedback loops para mejorar instrucciones, tools, skills, Agent Cards y workflows.

Evitar medir solo número de llamadas o tiempo ahorrado sin evaluar calidad y riesgo.

Crear scoring de confianza por agente, skill, versión y tipo de tarea.

Documentar limitaciones conocidas y condiciones de uso de cada agente.

Realizar ejercicio de evaluación comparativa de tres agentes A2A.

Diagnosticar madurez de una organización en agentes, APIs, MCP, datos, seguridad y gobierno de IA.

Identificar oportunidades donde la interoperabilidad entre agentes aporta valor frente a automatizaciones existentes.

Seleccionar quick wins de bajo riesgo para demostrar valor sin rediseñar toda la arquitectura.

Diseñar pilotos con alcance, agentes, skills, usuarios, datos, métricas, controles y plan de soporte.

Preparar entregables consultivos: mapa de agentes, matriz de skills, modelo de seguridad, catálogo y roadmap.

Estimar esfuerzo técnico, coste de modelos, coste de integración, operación y mantenimiento.

Definir modelo de ownership entre negocio, IT, data, seguridad, legal y equipos de agentes.

Diseñar formación para desarrolladores, administradores, owners funcionales y usuarios finales.

Preparar estrategia de escalado por dominios, tenants, departamentos y flujos de alto valor.

Realizar ejercicio de propuesta de implantación A2A para cliente enterprise.

Diseñar una arquitectura multiagente empresarial basada en A2A para un caso realista de negocio.

Crear inventario de agentes necesarios: coordinador, soporte, datos, legal, compras, operaciones y documentación.

Definir Agent Cards para cada agente con identidad, skills, capabilities, endpoints, seguridad y ejemplos.

Implementar al menos dos servidores A2A funcionales con SDK oficial o implementación compatible.

Implementar un cliente A2A que descubra agentes, envíe tareas, consulte estado y recupere artifacts.

Crear un workflow secuencial donde un agente genera un artefacto que alimenta a otro agente.

Crear un workflow jerárquico donde un agente supervisor delega, consolida y presenta resultado final.

Implementar streaming con SSE para una tarea larga con actualizaciones de estado y artefactos incrementales.

Implementar push notification o webhook seguro para proceso asíncrono de larga duración.

Añadir autenticación Bearer, OAuth2 simulado o mecanismo equivalente con credenciales fuera del payload.

Aplicar autorización granular por skill y por rol de cliente.

Integrar un agente A2A con una herramienta interna o MCP server de laboratorio.

Crear trazabilidad con taskId, contextId, requestId, logs estructurados, métricas y OpenTelemetry básico.

Diseñar almacenamiento de tasks, artifacts y estados con política de retención.

Crear tests de contrato para Agent Cards, messages, parts, artifacts, errores y permisos.

Simular fallos de agente remoto, timeout, credencial inválida, skill no autorizada y artifact mal formado.

Desplegar los agentes en contenedores o entorno cloud controlado con variables, secrets y healthchecks.

Preparar documentación técnica: arquitectura, endpoints, Agent Cards, seguridad, operación, pruebas y troubleshooting.

Crear matriz de riesgos: privacidad, seguridad, autorización, prompt injection, coste, latencia, calidad y revisión humana.

Presentar la solución final defendiendo diseño, interoperabilidad, seguridad, valor de negocio, gobierno y roadmap de mejora.