Blog · 9 de julio de 2026

Diferencia entre chatbot, agente y sistema multiagente: guía práctica

¿Chatbot, agente o multiagente? Aprende a distinguirlos con ejemplos prácticos, código funcional y criterios claros para elegir la opción correcta en tu proyecto.

🔥 ¿Qué es esto y por qué te importa?

¿Has visto anuncios que llaman "agentes" a chatbots y terminas sin saber cuál usar? No eres el único. La terminología se ha vuelto confusa: chatbot, agente y sistema multiagente se usan a menudo como si fueran sinónimos, pero no lo son — y elegir mal puede convertir un proyecto viable en un dolor de cabeza técnico y de seguridad.

📚 Contexto: definiciones claras y por qué difieren

¿Por qué esta distinción importa? Porque el diseño, los requisitos de seguridad, integración y coste cambian radicalmente entre uno y otro. ¿Quieres contestar preguntas frecuentes? Probablemente un chatbot basta. ¿Quieres que algo termine una compra, actualice bases de datos y notifique a un equipo? Ahí necesitas un agente. ¿Quieres que varios agentes especializados colaboren en una tarea compleja (p. ej. planificación logística)? Entonces un MAS es la opción.

🛠️ Desarrollo práctico: cuándo elegir cada enfoque

¿Te preguntas cómo se traduce esto a arquitectura técnica? Sigue leyendo: ejemplos y código.

✅ Ejemplo 1 — Chatbot simple con Flask + OpenAI (conversacional)

Este ejemplo crea un chatbot básico con Flask. Recibe un mensaje por HTTP, lo envía a un modelo de OpenAI y devuelve una respuesta en formato JSON.. No ejecuta acciones externas ni guarda memoria persistente.

Ejemplo 1: chatbot simple con Flask + OpenAI

Este ejemplo crea un chatbot básico con Flask. Recibe un mensaje por HTTP, lo envía a un modelo de OpenAI y devuelve una respuesta en formato JSON.

No ejecuta acciones externas.
No guarda memoria persistente.
No crea archivos.
No modifica bases de datos.

1. Crear el archivo app.py

from flask import Flask, request, jsonify
from openai import OpenAI
import os

app = Flask(__name__)

client = OpenAI(
    api_key=os.environ["OPENAI_API_KEY"]
)

@app.post("/chat")
def chat():
    data = request.get_json()

    if not data:
        return jsonify({"error": "Debe enviar un JSON válido"}), 400

    prompt = data.get("prompt", "").strip()

    if not prompt:
        return jsonify({"error": "Debe enviar el campo 'prompt'"}), 400

    response = client.responses.create(
        model="gpt-5.5",
        input=prompt
    )

    return jsonify({
        "reply": response.output_text
    })

if __name__ == "__main__":
    app.run(port=5000, debug=True)

2. Instalar dependencias

pip install flask openai

3. Configurar la API Key

En macOS o Linux:

export OPENAI_API_KEY="tu_api_key"

En Windows PowerShell:

$env:OPENAI_API_KEY="tu_api_key"

4. Ejecutar el servidor

python app.py

5. Probar el chatbot

curl -X POST http://127.0.0.1:5000/chat \
-H "Content-Type: application/json" \
-d '{"prompt":"Explícame qué es un agente de IA en una frase"}'

Respuesta esperada:

{
  "reply": "Un agente de IA es un sistema que recibe un objetivo, razona los pasos necesarios y ejecuta acciones mediante herramientas o servicios externos."
}

Este ejemplo representa un chatbot, no un agente. El sistema recibe texto y responde texto. No planifica tareas, no ejecuta herramientas y no cambia información en sistemas externos.

Comentarios: este patrón es un chatbot, pensado para diálogo. No hay ejecución de acciones ni memoria a largo plazo. Si tu caso requiere ejecutar órdenes (pagar, escribir en la base), pasa al enfoque agente.

✅ Ejemplo 2: agente simple con herramientas simuladas en Python

Este ejemplo muestra un agente mínimo. Recibe una instrucción, identifica una intención básica y ejecuta herramientas simuladas.

En este caso, las herramientas no llaman APIs reales. Son funciones locales que representan acciones como crear un ticket o enviar un correo.

# Python 3.10+
# No requiere librerías externas

from typing import List, Dict, Any


def send_email(to: str, subject: str, body: str) -> bool:
    """
    Herramienta simulada.
    En un sistema real, aquí iría la integración con SMTP, SendGrid, Gmail API u otro servicio.
    """
    print(f"Enviando correo a {to}")
    print(f"Asunto: {subject}")
    print(f"Mensaje: {body}")
    return True


def create_ticket(customer_id: int, text: str) -> int:
    """
    Herramienta simulada.
    En un sistema real, aquí se crearía un ticket en una plataforma de soporte.
    """
    print(f"Creando ticket para el cliente {customer_id}")
    print(f"Detalle: {text}")
    return 1234


class SimpleAgent:
    def __init__(self):
        self.memory: List[str] = []

    def perceive(self, instruction: str) -> Dict[str, str]:
        """
        Analiza la instrucción del usuario y detecta una intención simple.
        """
        instruction_lower = instruction.lower()

        if "reembols" in instruction_lower:
            intent = "refund"
        else:
            intent = "info"

        return {
            "intent": intent,
            "text": instruction
        }

    def plan_and_act(self, perception: Dict[str, str]) -> Dict[str, Any]:
        """
        Decide qué acción ejecutar según la intención detectada.
        """
        if perception["intent"] == "refund":
            ticket_id = create_ticket(
                customer_id=42,
                text=perception["text"]
            )

            send_email(
                to="ops@example.com",
                subject=f"Reembolso solicitado - Ticket {ticket_id}",
                body=perception["text"]
            )

            self.memory.append(f"refund_ticket:{ticket_id}")

            return {
                "status": "done",
                "ticket": ticket_id
            }

        return {
            "status": "no_action"
        }


if __name__ == "__main__":
    agent = SimpleAgent()

    instruction = "Solicito reembolso por la orden #987"

    perception = agent.perceive(instruction)
    result = agent.plan_and_act(perception)

    print("Resultado:", result)
    print("Memoria temporal:", agent.memory)

Salida esperada:

Creando ticket para el cliente 42
Detalle: Solicito reembolso por la orden #987
Enviando correo a ops@example.com
Asunto: Reembolso solicitado - Ticket 1234
Mensaje: Solicito reembolso por la orden #987
Resultado: {'status': 'done', 'ticket': 1234}
Memoria temporal: ['refund_ticket:1234']

Este ejemplo representa un agente simple porque no se limita a responder texto. Analiza una instrucción, decide una acción y ejecuta herramientas.

La memoria existe en RAM. No es memoria persistente. Si el programa se cierra, esa información se pierde.

✅ Ejemplo 3: mini-sistema multiagente para priorizar tickets de soporte

Este ejemplo muestra un sistema multiagente simple. Tres agentes trabajan en conjunto:

  1. Agente Buscador: recibe tickets pendientes.
  2. Agente Evaluador: calcula la prioridad del ticket.
  3. Agente Ejecutante: asigna una acción según la prioridad.

No requiere librerías externas.
No llama APIs reales.
No modifica sistemas externos.
Sirve para entender coordinación entre agentes.

# Python 3.10+
# No requiere librerías externas

from queue import Queue
from threading import Thread
from dataclasses import dataclass
from typing import Optional
import time


@dataclass
class Ticket:
    id: int
    usuario: str
    descripcion: str


@dataclass
class TicketEvaluado:
    ticket: Ticket
    prioridad: str
    motivo: str


class AgenteBuscador(Thread):
    """
    Agente encargado de obtener tickets pendientes.
    En un sistema real, esta información vendría de una base de datos,
    una API de mesa de ayuda o un archivo.
    """

    def __init__(self, salida: Queue):
        super().__init__()
        self.salida = salida

    def run(self):
        tickets = [
            Ticket(
                id=1,
                usuario="Ana",
                descripcion="No puedo ingresar al sistema de firma digital"
            ),
            Ticket(
                id=2,
                usuario="Luis",
                descripcion="Solicito cambio de contraseña"
            ),
            Ticket(
                id=3,
                usuario="María",
                descripcion="El servidor de teleconsulta no responde"
            )
        ]

        for ticket in tickets:
            print(f"Buscador: ticket encontrado #{ticket.id}")
            self.salida.put(ticket)
            time.sleep(0.5)

        self.salida.put(None)


class AgenteEvaluador(Thread):
    """
    Agente encargado de evaluar la prioridad del ticket.
    """

    def __init__(self, entrada: Queue, salida: Queue):
        super().__init__()
        self.entrada = entrada
        self.salida = salida

    def run(self):
        while True:
            ticket: Optional[Ticket] = self.entrada.get()

            if ticket is None:
                self.salida.put(None)
                break

            texto = ticket.descripcion.lower()

            if "servidor" in texto or "no responde" in texto:
                prioridad = "alta"
                motivo = "Afecta disponibilidad del servicio"
            elif "firma digital" in texto:
                prioridad = "media"
                motivo = "Afecta un flujo operativo importante"
            else:
                prioridad = "baja"
                motivo = "Solicitud operativa sin impacto crítico"

            ticket_evaluado = TicketEvaluado(
                ticket=ticket,
                prioridad=prioridad,
                motivo=motivo
            )

            print(
                f"Evaluador: ticket #{ticket.id} clasificado como prioridad {prioridad}"
            )

            self.salida.put(ticket_evaluado)


class AgenteEjecutante(Thread):
    """
    Agente encargado de definir la acción final.
    """

    def __init__(self, entrada: Queue):
        super().__init__()
        self.entrada = entrada

    def run(self):
        while True:
            ticket_evaluado: Optional[TicketEvaluado] = self.entrada.get()

            if ticket_evaluado is None:
                break

            ticket = ticket_evaluado.ticket

            if ticket_evaluado.prioridad == "alta":
                accion = "Asignar al equipo de infraestructura"
            elif ticket_evaluado.prioridad == "media":
                accion = "Asignar al equipo de aplicaciones"
            else:
                accion = "Asignar a mesa de ayuda"

            print("\nEjecutante: acción definida")
            print(f"Ticket: #{ticket.id}")
            print(f"Usuario: {ticket.usuario}")
            print(f"Descripción: {ticket.descripcion}")
            print(f"Prioridad: {ticket_evaluado.prioridad}")
            print(f"Motivo: {ticket_evaluado.motivo}")
            print(f"Acción: {accion}")


if __name__ == "__main__":
    cola_tickets = Queue()
    cola_evaluados = Queue()

    buscador = AgenteBuscador(cola_tickets)
    evaluador = AgenteEvaluador(cola_tickets, cola_evaluados)
    ejecutante = AgenteEjecutante(cola_evaluados)

    buscador.start()
    evaluador.start()
    ejecutante.start()

    buscador.join()
    evaluador.join()
    ejecutante.join()

    print("\nSistema multiagente finalizado")

Salida esperada:

Buscador: ticket encontrado #1
Evaluador: ticket #1 clasificado como prioridad media

Ejecutante: acción definida
Ticket: #1
Usuario: Ana
Descripción: No puedo ingresar al sistema de firma digital
Prioridad: media
Motivo: Afecta un flujo operativo importante
Acción: Asignar al equipo de aplicaciones

Buscador: ticket encontrado #2
Evaluador: ticket #2 clasificado como prioridad baja

Ejecutante: acción definida
Ticket: #2
Usuario: Luis
Descripción: Solicito cambio de contraseña
Prioridad: baja
Motivo: Solicitud operativa sin impacto crítico
Acción: Asignar a mesa de ayuda

Buscador: ticket encontrado #3
Evaluador: ticket #3 clasificado como prioridad alta

Ejecutante: acción definida
Ticket: #3
Usuario: María
Descripción: El servidor de teleconsulta no responde
Prioridad: alta
Motivo: Afecta disponibilidad del servicio
Acción: Asignar al equipo de infraestructura

Sistema multiagente finalizado

Este ejemplo representa un sistema multiagente porque divide el trabajo entre agentes con roles diferentes.

El Buscador obtiene datos.
El Evaluador analiza cada caso.
El Ejecutante decide la acción final.

La comunicación ocurre mediante colas en memoria. En producción, estas colas se reemplazan por herramientas como Redis, RabbitMQ, Kafka o servicios de mensajería en la nube.

Este ejemplo no usa un LLM. Su objetivo es mostrar coordinación entre agentes. Si agregas un LLM al Agente Evaluador, el sistema podría clasificar tickets con lenguaje natural de forma más flexible.

📊 Tabla comparativa rápida

✅ Característica 🤖 Chatbot 🧭 Agente 🤝 Sistema multiagente
Interacción humana directa Sí Puede Puede
Autonomía para actuar Baja Alta Alta (distribuida)
Acceso a sistemas externos Limitado Sí Sí (coordinado)
Memoria persistente Opcional Frecuente Distribuida
Complejidad de diseño Baja Media-Alta Alta
Casos típicos Soporte, FAQ Flujos multi‑paso, automations Logística, planificación, coordinación

(Fuentes: artículos técnicos y revisiones académicas sobre agentes y MAS). (chatbot.com)

⚠️ Advertencias honestas: riesgos y cuándo no usar

🔎 Buenas prácticas para elegir e implementar

Fuentes consultadas y recomendadas (selección): TechTarget, ScienceDirect, enciclopedias y encuestas académicas sobre Multi-Agent Systems. Para profundizar en aspectos teóricos y diseños de coordinación revisa los artículos de revisión en MAS y trabajos recientes sobre agentic AI. (techtarget.com)

Ver todos los artículos →