¿Cómo se comunican los agentes de IA entre sí?

La comunicación entre agentes de IA es el mecanismo por el cual dos o más agentes —cada uno con su propio modelo de lenguaje, herramientas y memoria— intercambian información, instrucciones o resultados para resolver una tarea que ninguno podría completar solo. En la práctica, defines un formato de mensaje (generalmente JSON con esquema), un canal de transmisión (memoria, cola o pizarra compartida) y un protocolo de coordinación (handoff, subasta o votación). Dominar estos tres niveles es lo que separa una demo de juguete de un sistema multi-agente en producción.

Tip Pro: Si estás empezando con agentes, no implementes comunicación desde cero. Frameworks como LangGraph, CrewAI o AutoGen ya traen estos patrones incorporados. Aprende primero a usarlos, luego personaliza.

¿Qué es?

Cuando hablamos de comunicación entre agentes de IA nos referimos al intercambio intencionado de datos entre entidades autónomas que usan un LLM como núcleo de decisión. Cada agente puede tener:

• Un rol distinto (investigador, revisor, redactor, validador)
• Herramientas diferentes (acceso a web, base de datos, APIs)
• Una memoria separada (historial de conversaciones, contexto de tarea)
• Un sistema de prompt único (instrucciones de comportamiento)

La comunicación no es un chat entre bots. Es un intercambio estructurado donde el emisor y el receptor acuerdan de antemano el formato, el propósito y el flujo del mensaje.

Nota: No confundas "agente" con "herramienta". Un agente toma decisiones autónomas basadas en un LLM. Una herramienta es una función que un agente invoca. La comunicación entre agentes implica decisiones, no solo ejecución.

Modelo mental

Imagina un equipo de desarrollo trabajando en un feature complejo. No todos hacen de todo: una persona escribe el backend, otra el frontend, otra revisa el código. Para coordinarse usan tickets en Jira (mensajes estructurados), comments en PRs (revisiones) y Slack (comunicación rápida). Los agentes de IA funcionan igual: se pasan mensajes con esquemas definidos, resultados parciales y señales de finalización.

Los cuatro patrones fundamentales de comunicación:

¿Cómo se usa?

Implementar comunicación entre agentes requiere definir tres capas. Aquí las desglosamos paso a paso.

1. Definir el formato del mensaje

El formato más usado es JSON con un esquema estricto. Cada mensaje debe tener: quién lo envía, quién lo recibe, el tipo de mensaje, la carga útil y metadatos.

{
  "from": "agent-investigador",
  "to": "agent-redactor",
  "type": "task_result",
  "payload": {
    "query": "Arquitecturas de agentes en 2026",
    "findings": "...",
    "sources": ["url1", "url2"],
    "confidence": 0.92
  },
  "metadata": {
    "timestamp": "2026-06-01T10:00:00Z",
    "trace_id": "abc-123",
    "priority": "high",
    "retry_count": 0
  }
}

Tip Pro: Usa Pydantic (Python) o Zod (TypeScript) para definir y validar el esquema de cada mensaje. Si los agentes pueden modificar el formato sobre la marcha, tendrás bugs imposibles de rastrear por diferencias sutiles en los campos.

2. Elegir el canal de transmisión

Hay tres estrategias principales, ordenadas de menor a mayor sofisticación:

Canal en memoria (síncrono)

El orquestador llama funciones directamente y espera el resultado. Ideal para prototipos.

# Ejemplo conceptual con LangGraph
investigador = create_agent(tools=[search_tool])
redactor = create_agent(tools=[write_tool])
 
resultado_investigacion = investigador.run("buscar datos sobre X")
articulo_final = redactor.run(f"escribe articulo basado en: {resultado_investigacion}")

Ventaja: Simple, rápido de implementar. Desventaja: Si un agente falla, todo el flujo muere. No escala.

Cola de mensajes (asíncrono)

Cada agente escucha una cola y procesa mensajes cuando llegan. El estándar para producción.

1. Orquestador publica tarea en cola "research.tasks"
2. Agent-investigador consume la tarea, ejecuta búsqueda
3. Agent-investigador publica resultado en cola "review.tasks"
4. Agent-revisor consume, valida calidad
5. Agent-revisor publica en cola "writing.tasks"
6. Agent-redactor consume y escribe el documento final
7. Agent-redactor publica en cola "results"
8. Orquestador recibe el resultado y responde al usuario

# Pseudocódigo con Redis/SQS
from agent_queue import QueueAgent
 
class ResearchAgent(QueueAgent):
    def process(self, message):
        findings = self.search(message["query"])
        self.publish("review.tasks", {
            "query": message["query"],
            "findings": findings,
            "from": "research"
        })

Advertencia: Con colas asíncronas, el orden de procesamiento no está garantizado. Si tu flujo requiere ejecución secuencial estricta, usa un estado compartido (DAG state) o un orquestador que trackee progreso. LangGraph resuelve esto con su grafo de estados.

Pizarra compartida (blackboard)

Todos los agentes leen y escriben en un almacén común. Ideal para trabajo paralelo.

# Pseudocódigo con base de datos vectorial como pizarra
blackboard = VectorStore(collection="project-alpha")
 
class ResearchAgent:
    def run(self, task):
        results = self.search(task)
        blackboard.add("research_results", results)  # escribe
        blackboard.set_flag(f"task_{task['id']}", "research_done")  # señal
 
class WriterAgent:
    def run(self):
        if blackboard.get_flag("research_done"):  # espera señal
            data = blackboard.get("research_results")  # lee
            article = self.write(data)
            blackboard.add("drafts", article)

3. Definir el protocolo de coordinación

El protocolo determina cómo se inicia, mantiene y finaliza la comunicación:

Tip Pro: El protocolo de votación es especialmente útil para reducir alucinaciones. Envía la misma pregunta a 3 agentes con system prompts distintos, y usa un cuarto agente para sintetizar la respuesta más consistente. Esto se conoce como "ensamble de agentes".

¿Cuándo usarlo / cuándo no?

Úsalo cuando:

• La tarea requiere habilidades de múltiples dominios (ej. investigar en web + escribir + traducir)
• Necesitas especialización: cada agente tiene un rol, herramientas y contexto distintos
• Quieres escalar horizontalmente: añadir más agentes del mismo tipo para manejar más carga
• El problema es descomponible en pasos independientes que pueden ejecutarse en paralelo
• Necesitas resiliencia: si un agente falla, otro puede retomar su trabajo desde el último estado conocido

No lo uses cuando:

• Un solo agente resuelve la tarea con un prompt bien diseñado (empieza siempre por lo simple)
• El overhead de coordinación supera el beneficio de la especialización —medirlo antes de escalar
• La latencia es crítica: cada salto entre agentes añade tiempo de LLM + transmisión
• No tienes un esquema claro de mensajes ni un protocolo definido (vas a crear un sistema frágil)
• El número de agentes es muy pequeño y la comunicación introduce complejidad artificial

Tip Pro: La regla de oro: empieza con un solo agente, añade más solo cuando tengas evidencia de que el agente único no puede resolver el problema. La comunicación entre agentes resuelve complejidad, no la crees sin necesidad.