Agentes de IA

Definición

Un agente de IA (AI agent) es un sistema en el que un modelo de lenguaje decide por sí mismo los pasos para cumplir un objetivo y usa herramientas para ejecutarlos: buscar información, consultar una base de datos, calcular, escribir un archivo o enviar un mensaje. Un chatbot responde un mensaje; un agente recibe un objetivo («atiende esta queja») y trabaja en un ciclo hasta terminarlo.

Anthropic distingue dos patrones en su guía Building effective agents: los flujos de trabajo (workflows), donde el código fija los pasos y el modelo ejecuta cada uno, y los agentes, donde el modelo dirige su propio proceso y elige qué herramienta usar en cada momento. Los agentes convienen cuando el camino no se puede prever; cuando sí se puede, un flujo fijo es más barato, más rápido y más predecible.

Un caso conocido: Klarna puso un asistente de IA a atender a sus clientes (pagos, reembolsos, devoluciones) y, según la empresa, en su primer mes atendió dos tercios de los chats de servicio al cliente (comunicado del 27 de febrero de 2024). Más tarde lo reconstruyó como un sistema multiagente con LangGraph (día 12).

El ciclo de un agente

Todos los agentes repiten el mismo bucle, a veces llamado ReAct (razonar y actuar):

1. Pensar: el modelo recibe el objetivo, las instrucciones, la lista de herramientas disponibles y todo lo que ha pasado hasta ahora, y decide la siguiente acción.
2. Actuar: pide ejecutar una herramienta con argumentos concretos. Quien la ejecuta es tu código, no el modelo.
3. Observar: el resultado vuelve al contexto del modelo.
4. Repetir hasta que el modelo declare que terminó, o hasta que un límite lo detenga.

Uso de herramientas (tool use)

Las APIs de los principales proveedores permiten describir herramientas con un nombre, una descripción y un esquema JSON de sus parámetros. Cuando el modelo quiere usar una, no responde con texto: devuelve una petición estructurada (nombre de la herramienta + argumentos). Tu aplicación la valida, la ejecuta y le devuelve el resultado en el siguiente mensaje.

El Model Context Protocol (MCP), un estándar abierto que publicó Anthropic, define cómo una aplicación expone herramientas y datos a cualquier modelo compatible, para no reescribir cada integración.

Barandales: límites de seguridad

Un agente con más libertad puede hacer más cosas mal. Los barandales (guardrails) son límites que el sistema impone fuera del modelo, en código, porque un prompt se puede ignorar o manipular:

Revisión humana en el proceso (human in the loop)

Para las acciones de alto riesgo, el agente se detiene, muestra exactamente qué va a hacer y espera la aprobación de una persona: el monto y el destinatario del pago, el texto del correo, los archivos a borrar. Frameworks como LangGraph (día 12) guardan el estado en ese punto para reanudar después de la aprobación. Una buena práctica es aumentar la autonomía de forma gradual: empezar con aprobación en todo, medir errores y relajar solo lo que demuestre ser seguro.

Cuándo usar un agente

Patrones más avanzados: multiagente (un orquestador reparte subtareas entre agentes especializados) y evaluador-optimizador (un agente propone y otro revisa). Añaden capacidad, pero también costo y puntos de falla.

Práctica: un agente mínimo con barandales

Este script implementa el ciclo completo con la biblioteca estándar de Python: un registro de herramientas, una lista de herramientas permitidas, un límite de monto, un máximo de pasos y aprobación humana para la acción irreversible. decidir() simula al modelo con reglas fijas para que el resultado sea reproducible; en un agente real es una llamada a la API con las herramientas descritas.

1. Guarda el script como mini_agente.py:

"""Un agente mínimo: ciclo pensar -> usar herramienta -> revisar, con barandales y aprobación humana.

`decidir()` simula al modelo con reglas fijas para que el ejemplo sea reproducible sin llaves ni internet.
En un agente real, esa función es una llamada al LLM con la lista de herramientas (tool use).
"""

PEDIDOS = {"4821": {"cliente": "Ana", "total": 1450.0, "estado": "entregado incompleto"}}


# ---------- herramientas (tools) ----------
def buscar_pedido(pedido_id: str) -> dict:
    return PEDIDOS.get(pedido_id, {"error": "no existe"})


def calcular_reembolso(total: float, porcentaje: float) -> float:
    return round(total * porcentaje / 100, 2)


def emitir_reembolso(pedido_id: str, monto: float) -> str:
    return f"Reembolso de ${monto:,.2f} emitido para el pedido {pedido_id}"


HERRAMIENTAS = {"buscar_pedido": buscar_pedido, "calcular_reembolso": calcular_reembolso, "emitir_reembolso": emitir_reembolso}
# ---------- barandales (guardrails) ----------
PERMITIDAS = {"buscar_pedido", "calcular_reembolso", "emitir_reembolso"}
REQUIEREN_APROBACION = {"emitir_reembolso"}  # irreversible: mueve dinero
MAX_PASOS = 6
LIMITE_REEMBOLSO = 1000.0


def decidir(objetivo: str, memoria: list[dict]) -> dict:
    # «Modelo» simulado: elige la siguiente acción mirando lo que ya pasó.
    hechos = [m["herramienta"] for m in memoria]
    if "buscar_pedido" not in hechos:
        return {"herramienta": "buscar_pedido", "args": {"pedido_id": "4821"}}
    if "calcular_reembolso" not in hechos:
        total = memoria[0]["resultado"]["total"]
        return {"herramienta": "calcular_reembolso", "args": {"total": total, "porcentaje": 50}}
    if "emitir_reembolso" not in hechos:
        return {"herramienta": "emitir_reembolso", "args": {"pedido_id": "4821", "monto": memoria[1]["resultado"]}}
    return {"fin": "Caso resuelto"}


def ejecutar(objetivo: str, aprobar) -> list[dict]:
    memoria: list[dict] = []
    for paso in range(1, MAX_PASOS + 1):
        accion = decidir(objetivo, memoria)                       # 1. pensar
        if "fin" in accion:
            print(f"Paso {paso}: FIN · {accion['fin']}")
            return memoria
        nombre, args = accion["herramienta"], accion["args"]
        if nombre not in PERMITIDAS:                             # barandal: lista de herramientas
            print(f"Paso {paso}: BLOQUEADO · {nombre} no está permitida")
            return memoria
        if nombre == "emitir_reembolso" and args["monto"] > LIMITE_REEMBOLSO:  # barandal: límite de monto
            print(f"Paso {paso}: BLOQUEADO · {args['monto']} supera el límite de {LIMITE_REEMBOLSO}")
            return memoria
        if nombre in REQUIEREN_APROBACION and not aprobar(nombre, args):  # human in the loop
            print(f"Paso {paso}: EN ESPERA · {nombre}{args} necesita aprobación humana")
            return memoria
        resultado = HERRAMIENTAS[nombre](**args)                 # 2. usar la herramienta
        memoria.append({"herramienta": nombre, "args": args, "resultado": resultado})
        print(f"Paso {paso}: {nombre}{args} -> {resultado}")     # 3. revisar (queda en memoria)
    print("Se alcanzó el máximo de pasos")
    return memoria


if __name__ == "__main__":
    objetivo = "Atender la queja del pedido 4821 (llegó incompleto) y reembolsar la mitad."
    print("== Sin aprobación humana ==")
    ejecutar(objetivo, aprobar=lambda nombre, args: False)
    print("\n== Con aprobación humana ==")
    ejecutar(objetivo, aprobar=lambda nombre, args: True)

2. Ejecútalo: python mini_agente.py. Salida real (Python 3.12, Windows):

== Sin aprobación humana ==
Paso 1: buscar_pedido{'pedido_id': '4821'} -> {'cliente': 'Ana', 'total': 1450.0, 'estado': 'entregado incompleto'}
Paso 2: calcular_reembolso{'total': 1450.0, 'porcentaje': 50} -> 725.0
Paso 3: EN ESPERA · emitir_reembolso{'pedido_id': '4821', 'monto': 725.0} necesita aprobación humana

== Con aprobación humana ==
Paso 1: buscar_pedido{'pedido_id': '4821'} -> {'cliente': 'Ana', 'total': 1450.0, 'estado': 'entregado incompleto'}
Paso 2: calcular_reembolso{'total': 1450.0, 'porcentaje': 50} -> 725.0
Paso 3: emitir_reembolso{'pedido_id': '4821', 'monto': 725.0} -> Reembolso de $725.00 emitido para el pedido 4821
Paso 4: FIN · Caso resuelto

3. Interpreta el resultado. El agente busca el pedido, calcula el reembolso y, al llegar a la acción irreversible, se detiene si nadie la aprueba. Con aprobación, termina el caso. Los barandales viven en el código de ejecutar(), no en el «modelo»: aunque decidir() pidiera otra cosa, la lista de permitidas, el límite de monto y el máximo de pasos lo impedirían.

4. Prueba los barandales. Cambia "porcentaje": 50 por 100 en decidir(): el reembolso sería de 1,450 y el límite de 1,000 lo bloquea. Quita "emitir_reembolso" de PERMITIDAS y verás BLOQUEADO. Para convertirlo en un agente real, sustituye decidir() por una llamada a la API de tu proveedor con las herramientas descritas en JSON (ver referencias).

Skill gratis para Claude: disena-agente convierte una tarea repetitiva tuya en un agente de Claude Code con este mismo enfoque: mapa de la tarea con el riesgo de cada acción, herramientas mínimas, barandales y aprobación humana; valida el archivo del agente con un script y lo ensaya con datos de prueba y una trampa antes de entregártelo.

Preguntas frecuentes

¿Qué es un agente de IA en palabras simples?

Es una IA que, en lugar de solo responder, decide los pasos para cumplir un objetivo y usa herramientas para hacerlos: buscar, calcular, escribir o enviar.

¿Cuál es la diferencia entre un chatbot y un agente?

El chatbot responde mensajes. El agente actúa: trabaja en un ciclo de pensar, usar una herramienta y revisar el resultado hasta terminar la tarea.

¿Es peligroso dejar que un agente actúe solo?

Puede serlo si tiene más permisos de los necesarios. Por eso se le dan solo las herramientas indispensables, límites en código y aprobación humana para lo irreversible, como pagar, borrar o enviar.

¿Qué empresas usan agentes de IA?

Klarna usa un asistente de IA para atención a clientes; según la empresa, en su primer mes atendió dos tercios de sus chats. También se usan en programación, soporte técnico e investigación.

En el reel lo explicamos así

Un chatbot te responde; un agente hace el trabajo. Es como un asistente que revisa tu agenda, redacta los correos, los manda y te avisa al terminar: tú solo diste el objetivo. Trabaja en un ciclo: piensa qué sigue, usa una herramienta, revisa el resultado y repite. Klarna lo puso a atender clientes y su asistente atendió dos de cada tres chats en el primer mes. Pero más libertad es más riesgo: por eso lleva barandales y, para lo delicado, como pagar o borrar, pide permiso a una persona (human in the loop).

Referencias

• Anthropic, «Building effective agents»: flujos de trabajo contra agentes y patrones recomendados.
• Anthropic, Tool use: cómo se describen y se usan herramientas en la API.
• OpenAI, Function calling.
• Model Context Protocol: el estándar abierto para conectar herramientas y datos.
• Yao et al., «ReAct: Synergizing Reasoning and Acting in Language Models» (2022).
• Klarna, comunicado del 27 de febrero de 2024 sobre su asistente de IA.
• OWASP, Top 10 for LLM Applications: LLM06 Excessive Agency.