Agentes y herramientas

El bucle del agente

Un agente es un programa con tres piezas: un modelo que decide, un conjunto de herramientas (funciones) y un bucle que los conecta. En cada vuelta:

1. el modelo recibe el contexto completo (instrucciones del sistema, descripción de las herramientas, tarea e historial) y produce o una llamada (nombre y datos) o la respuesta final;
2. el programa valida la llamada, aplica los permisos y ejecuta la función;
3. el resultado se agrega al historial como un mensaje más y se vuelve al paso 1, hasta que el modelo responde o se agota un límite de pasos.

Es la idea de ReAct (Yao et al., 2022): intercalar razonamiento y acción, de modo que cada observación corrija el razonamiento siguiente. En sus pruebas, con solo uno o dos ejemplos en el prompt, ReAct superó a métodos de imitación y de aprendizaje por refuerzo por 34 y 10 puntos de tasa de éxito en dos entornos interactivos (ALFWorld y WebShop), y en preguntas con una API de Wikipedia redujo las alucinaciones frente a la sola cadena de pensamiento. Desde 2023 las interfaces de los proveedores (por ejemplo, la «llamada a funciones» que OpenAI lanzó el 13 de junio de 2023) hacen que el modelo emita la llamada en un formato estructurado. Antes, Toolformer (Schick et al., 2023) había entrenado a un modelo para decidir por sí mismo cuándo llamar a una API y con qué argumentos.

Una llamada a función, por dentro

Una herramienta se describe con un nombre, una descripción y un esquema de sus datos de entrada (JSON Schema). Los nombres de los campos cambian de un proveedor a otro; la idea es la misma:

// lo que el modelo recibe (como texto) al frente de su contexto
{ "name": "comprar_boletos",
  "description": "Compra boletos para una función. Cobra a la tarjeta guardada. No se puede deshacer.",
  "input_schema": { "type": "object",
    "properties": { "funcion": { "type": "string" }, "cantidad": { "type": "integer", "minimum": 1 } },
    "required": ["funcion", "cantidad"] } }

// lo que el modelo escribe: una petición, no una ejecución
{ "name": "comprar_boletos", "input": { "funcion": "21:30", "cantidad": 2 } }

El modelo no ejecuta nada: produce el texto de la llamada. El programa debe tratar esos datos como entrada no confiable: validarlos, limitarlos y registrarlos. La descripción de la herramienta (por ejemplo, «no se puede deshacer») ayuda al modelo a decidir, pero no protege: el límite de gasto vive en el código que ejecuta.

MCP

El Model Context Protocol (Anthropic, 25 de noviembre de 2024) estandariza esa conexión. Una aplicación (el cliente) se conecta a un servidor MCP que ofrece herramientas; los mensajes son JSON-RPC 2.0: tools/list para descubrir las herramientas y tools/call para invocar una, y el resultado vuelve con un indicador isError. La especificación (versión 2025-06-18) dice que, por confianza y seguridad, debería haber siempre una persona en el bucle con la posibilidad de negar una invocación, que el cliente pida confirmación en operaciones sensibles, muestre los datos de entrada antes de llamar al servidor y registre el uso de herramientas para auditoría. El 9 de diciembre de 2025 la Linux Foundation anunció la Agentic AI Foundation, con MCP entre sus proyectos fundadores, aportado por Anthropic.

Fiabilidad de una cadena

Si cada paso sale bien con probabilidad $p$, de forma independiente, y basta un error para arruinar la tarea, una tarea de $n$ pasos sale bien con probabilidad

Con $p = 0.95$: $P(2) \approx 0.90$, $P(10)\approx 0.60$, $P(14)\approx 0.49$, $P(20)\approx 0.36$ y $P(40)\approx 0.13$. El número de pasos en que el éxito cae a la mitad es

Es un modelo simplificado: supone errores independientes y que cualquier error arruina el intento. En la práctica los errores se correlacionan (un mal plan arrastra los pasos que siguen) y a veces el agente se recupera solo, al leer un mensaje de error. Por eso la tasa de éxito de principio a fin se mide, no se calcula. El simulador de la lección hace exactamente esa cuenta con veinte intentos (semilla fija): la muestra da 12 de 20 con diez pasos, 9 con catorce, 7 con veinte y 3 con cuarenta.

Revisión por tramos

Un tramo de $m$ pasos sale bien con $A = p^{m}$. Al final del tramo, una persona lo revisa y detecta un error con probabilidad $q$; si lo detecta, el tramo se repite. Un intento del tramo se acepta con probabilidad $A + (1-A)(1-q)$, así que

El éxito total es el producto de los $s$ de todos los tramos. Con $p = 0.95$, $n = 20$ y $q = 0.9$ (supuestos de la lección): sin revisar, 35.8 %; revisando cada 5 pasos, 89.1 %, con 5.0 revisiones y 25.1 pasos del agente por intento; cada 10, 87.8 % (3.1 revisiones, 31.3 pasos); solo al final, 84.8 % (2.4 revisiones, pero 47.3 pasos: se repite todo). El techo lo fija $q$: aun revisando cada paso, el éxito queda en 90.0 %, porque de cada diez errores se escapa uno.

Medir la constancia

τ-bench (Yao, Shinn, Razavi y Narasimhan, 2024) pone a un agente con herramientas y reglas de negocio frente a un cliente simulado por otro modelo, y compara el estado final de la base de datos con el esperado. Introduce $\text{pass}^k$: la probabilidad de que una misma tarea salga bien en los $k$ intentos. Con llamadas a funciones, GPT-4o resolvió en el primer intento el 61.2 % de las tareas de la tienda y el 35.2 % de las de la aerolínea (48.2 % en promedio), y en la tienda su $\text{pass}^8$ bajó a menos del 25 %.

Costo

Si cada consulta relee las instrucciones y las definiciones ($B$ tokens) más todo el historial, y cada paso agrega $g$ tokens, lo leído en $n$ pasos es

Crece como $n^2$, como las conversaciones de la lección 30. Con supuestos ilustrativos ($B = 2\,000$, $g = 800$): 10 pasos son 56 000 tokens; 20, 192 000; 40, 704 000. Y un intento fallido se paga igual: el costo por tarea lograda es el costo por intento dividido entre la probabilidad de éxito. Con $p = 0.95$ quedan cerca de 94 000, 536 000 y 5.5 millones de tokens por tarea lograda.

Niveles de autonomía

Feng, McDonald y Zhang (2025) proponen cinco niveles según el papel de la persona: operadora, colaboradora, consultora, aprobadora y observadora, y sostienen que la autonomía es una decisión de diseño, separada de la capacidad del modelo. La lección usa una escala más corta (sugiere, actúa con aprobación, actúa hasta un límite, actúa sola) con la misma idea: más autonomía es más rapidez y menos control, y se concede acción por acción según su reversibilidad. Anthropic (2024) recomienda empezar por la solución más simple: si los pasos se conocen de antemano, un flujo fijo (workflow) suele bastar; un agente se justifica cuando el camino depende de lo que se observa, y su autonomía implica más costo y errores que se acumulan, así que conviene probarlo en un entorno aislado y con salvaguardas.

En código

CARTELERA = {"20:00": {"lugares": 0, "precio": 95}, "21:30": {"lugares": 14, "precio": 95}}
LIMITE = 300   # permiso: por encima de esto, el programa pide aprobación

def buscar_funciones(fecha):
    return {hora: dict(f) for hora, f in CARTELERA.items()}

def comprar_boletos(funcion, cantidad):
    f = CARTELERA[funcion]
    if cantidad > f["lugares"]:
        raise ValueError("no hay lugares suficientes")
    f["lugares"] -= cantidad
    return {"funcion": funcion, "cantidad": cantidad, "total": cantidad * f["precio"]}

HERRAMIENTAS = {"buscar_funciones": buscar_funciones, "comprar_boletos": comprar_boletos}

def modelo(contexto):
    """Guion en lugar de un LLM: decide con lo último que hay en el contexto."""
    ult = contexto[-1]
    if ult["rol"] == "usuario":
        return {"herramienta": "buscar_funciones", "datos": {"fecha": "hoy"}}
    if ult["herramienta"] == "buscar_funciones":
        hora = next(h for h, f in ult["resultado"].items() if f["lugares"] >= 2)
        return {"herramienta": "comprar_boletos", "datos": {"funcion": hora, "cantidad": 20}}  # error: un cero de más
    if ult["resultado"] == "rechazado por la persona":
        return {"herramienta": "comprar_boletos", "datos": {"funcion": "21:30", "cantidad": 2}}
    return {"respuesta": f"Listo: {ult['resultado']}"}

def aprueba(peticion):   # la persona en el bucle (aquí, una regla que imita su decisión)
    print("¿Aprobar?", peticion["datos"])
    return peticion["datos"]["cantidad"] <= 4

def agente(pedido, max_pasos=6):
    contexto = [{"rol": "usuario", "texto": pedido}]
    for paso in range(1, max_pasos + 1):
        decision = modelo(contexto)                          # 1. pensar
        if "respuesta" in decision:
            return decision["respuesta"], paso
        nombre, datos = decision["herramienta"], decision["datos"]
        if nombre == "comprar_boletos":                      # permiso: una regla del programa
            total = datos["cantidad"] * CARTELERA[datos["funcion"]]["precio"]
            if total > LIMITE and not aprueba(decision):
                contexto.append({"rol": "resultado", "herramienta": nombre, "resultado": "rechazado por la persona"})
                continue
        try:
            resultado = HERRAMIENTAS[nombre](**datos)        # 2. actuar: lo ejecuta el programa
        except Exception as e:
            resultado = f"error: {e}"                        # un error también es una observación
        contexto.append({"rol": "resultado", "herramienta": nombre, "resultado": resultado})  # 3. observar
    return "No terminé.", max_pasos

print(agente("Compra dos boletos para hoy en la noche, por menos de 300 pesos."))

# Fiabilidad de una cadena: cada paso sale bien con p = 0.95
for n in (1, 2, 10, 14, 20, 40):
    print(n, round(0.95 ** n, 2))

Salida:

¿Aprobar? {'funcion': '21:30', 'cantidad': 20}
("Listo: {'funcion': '21:30', 'cantidad': 2, 'total': 190}", 4)
1 0.95
2 0.9
10 0.6
14 0.49
20 0.36
40 0.13

Cambia modelo por una llamada a un LLM y tendrás el esqueleto de un agente real. Lo que añade un producto serio es lo que aquí apenas se esboza: validación de los datos, permisos por herramienta, límites de pasos y de gasto, registro de cada llamada y manejo de errores.

Lo que viene

Un agente que lee y actúa se equivoca con aplomo: la lección 33 trata las alucinaciones. La 34 enseña a medir un sistema con tus propias tareas, y la 35, los riesgos que abre dar acceso a herramientas (por ejemplo, instrucciones escondidas en lo que el agente lee) y cómo gobernarlos.