Cómo crear un agente de IA en Python paso a paso (76 líneas)

👁 114 lecturas

Un agente de IA en Python es básicamente un bucle: el modelo recibe una tarea y una lista de herramientas, elige una función, tu código la ejecuta, el resultado regresa al modelo y este decide el siguiente paso. He construido un agente de este tipo en 76 líneas, sin recurrir a ningún framework externo: busca entre archivos, realiza cálculos matemáticos, lee páginas web, cuenta con un límite de pasos y guarda un registro de sus decisiones. Después lo he adaptado también a OpenAI Agents SDK y Claude Agent SDK. Todas las ejecuciones que verás a continuación son reales, fechadas el 4 de octubre de 2026. Este es el tercer paso de la serie Agentes de IA desde cero.

En qué se diferencia un agente de un script con IA habitual

Un script convencional con IA sigue una secuencia rígida preestablecida: «descarga el correo, resúmelo y guárdalo». El modelo simplemente rellena una casilla concreta. En un agente, el propio modelo decide el orden de las acciones. Recibe un objetivo final («calcula los gastos de las facturas») junto con un catálogo de herramientas, y deduce por sí mismo que primero debe examinar los archivos locales, luego consultar el tipo de cambio y finalmente sumar los importes. En el artículo Agente de IA: qué es explico en detalle su arquitectura y puntos débiles.

En el aspecto técnico, un agente no es más que function calling encapsulado en un bucle continuo. Si aún no tienes claro cómo solicita un LLM la llamada a una función externa, conviene revisar ese concepto antes; aquí asumiremos que ya lo dominas.

El bucle del agente en cuatro pasos

1. Modelo: lee la tarea inicial y todo el historial acumulado.
2. Decisión: solicita usar una herramienta (aportando argumentos) o determina que ha concluido y redacta la respuesta final.
3. Herramienta: tu código local ejecuta la función requerida.
4. Observación: la salida devuelta por la función se añade al historial y el ciclo regresa al punto 1.

A este flujo añado siempre dos salvaguardas obligatorias: un límite de pasos (para impedir que entre en bucles infinitos y dispare los costes de API) y un registro de decisiones (para auditar después exactamente qué ha ejecutado y por qué motivo).

Paso 1: preparación del entorno

1. Instala Python (versión 3.11 a 3.13) desde python.org asegurándote de marcar la opción «Add python.exe to PATH».
2. Dentro de la carpeta del proyecto, crea un entorno virtual con python -m venv .venv y actívalo mediante .venv\Scripts\activate.
3. Instala los paquetes necesarios: pip install openai requests beautifulsoup4 python-dotenv.
4. Genera una clave de API en OpenRouter y guárdala en tu archivo .env como OPENROUTER_API_KEY=.... Te sugiero fijar un límite de saldo en esa clave (por ejemplo, aprox. 1,79 EUR / 2 USD). En la guía sobre OpenRouter detallo su configuración.
5. En la carpeta local dane/faktury (datos/facturas) añade varios archivos de texto. En el lote de prueba original utilicé tres facturas ficticias con importes en moneda extranjera y una de 120 EUR.

Paso 2: herramientas como funciones nativas

El agente cuenta con tres herramientas. Cada una de ellas es una función estándar de Python que devuelve una cadena de texto:

• szukaj_plikow (buscar archivos): enumera archivos .txt dentro de la ruta asignada. El agente carece de visibilidad fuera de ese directorio;
• kalkulator (calculadora): evalúa operaciones mediante el módulo ast (evitando el uso peligroso de eval). Dado que los modelos cometen fallos aritméticos frecuentes en cálculos largos, forzamos que calculen siempre mediante esta función;
• czytaj_strone (leer web): descarga una página web o respuesta de una API y recorta su texto a un tope de 4000 caracteres, evitando consumir tokens innecesarios que encarezcan la llamada.

Paso 3: el agente completo en 76 líneas

"""02 - Agente de IA sin frameworks: bucle modelo -> herramienta -> observacion -> decision.
Ejecutar: python 02_agent_bez_frameworka.py "Suma los importes brutos de las facturas en dane/faktury."
"""
import ast, json, operator, os, pathlib, sys, time
import requests
from bs4 import BeautifulSoup
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
MODEL, MAX_KROKOW = os.getenv("MODEL", "openai/gpt-5.6-luna"), int(os.getenv("MAX_KROKOW", 8))
client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])
KATALOG = pathlib.Path("dane").resolve()  # el agente solo tiene acceso a esta carpeta

def szukaj_plikow(fraza: str = "") -> str:
    """Muestra archivos .txt en dane/ con su contenido, opcionalmente filtrados por una frase."""
    wynik = []
    for p in sorted(KATALOG.rglob("*.txt")):
        tekst = p.read_text(encoding="utf-8")
        if fraza.lower() in tekst.lower() or fraza.lower() in p.name.lower():
            wynik.append(f"== {p.relative_to(KATALOG)} ==\n{tekst[:1500]}")
    return "\n".join(wynik) or "sin archivos"

OPS = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv, ast.USub: operator.neg}
def kalkulator(wyrazenie: str) -> str:
    def licz(n):
        if isinstance(n, ast.Constant): return n.value
        if isinstance(n, ast.BinOp): return OPS[type(n.op)](licz(n.left), licz(n.right))
        if isinstance(n, ast.UnaryOp): return OPS[type(n.op)](licz(n.operand))
        raise ValueError("solo numeros y + - * /")
    return str(round(licz(ast.parse(wyrazenie, mode="eval").body), 4))

def czytaj_strone(url: str) -> str:
    r = requests.get(url, timeout=20, headers={"User-Agent": "agente-starter/1.0"})
    tekst = BeautifulSoup(r.text, "html.parser").get_text(" ", strip=True)
    return tekst[:4000]  # limitamos longitud: el exceso consume tokens

NARZEDZIA = {"szukaj_plikow": szukaj_plikow, "kalkulator": kalkulator, "czytaj_strone": czytaj_strone}
def opis(nazwa, tekst, param, typ="string"):
    return {"type": "function", "function": {"name": nazwa, "description": tekst,
            "parameters": {"type": "object", "properties": {param: {"type": typ}}, "required": [param]}}}
TOOLS = [opis("szukaj_plikow", "Muestra archivos .txt de la carpeta dane/ y su texto. Frase vacia = todos los archivos.", "fraza"),
         opis("kalkulator", "Calcula expresiones matematicas como 2214+1180.8. Realiza siempre las operaciones con esto.", "wyrazenie"),
         opis("czytaj_strone", "Obtiene el texto de una pagina web o endpoint API mediante su URL.", "url")]

def agent(zadanie: str) -> str:
    messages = [{"role": "system", "content": "Eres un agente de IA. Resuelve la tarea usando tus herramientas. Antes de invocar "
                 "cada herramienta, describe en una frase breve para que la vas a usar. Consulta tipos de cambio via "
                 "https://api.nbp.pl/api/exchangerates/rates/a/{kod}/?format=json."},
                {"role": "user", "content": zadanie}]
    log = open("agent_log.jsonl", "a", encoding="utf-8")
    koszt = 0.0
    for krok in range(1, MAX_KROKOW + 1):
        r = client.chat.completions.create(model=MODEL, messages=messages, tools=TOOLS)
        koszt += getattr(r.usage, "cost", 0) or 0
        msg = r.choices[0].message
        messages.append(msg.model_dump(exclude_none=True))
        if not msg.tool_calls:
            print(f"--- finalizado tras {krok} pasos, coste aprox.: {koszt:.5f} USD")
            return msg.content
        if msg.content: print(f"[paso {krok}] PENSAMIENTO: {msg.content.strip()[:300]}")
        for call in msg.tool_calls:
            args = json.loads(call.function.arguments or "{}")
            try:
                obs = NARZEDZIA[call.function.name](**args)
            except Exception as e:
                obs = f"ERROR: {e}"
            print(f"[paso {krok}] ACCION: {call.function.name}({json.dumps(args, ensure_ascii=False)})")
            print(f"[paso {krok}] OBSERVACION: {obs[:160]!r}")
            log.write(json.dumps({"t": time.strftime("%H:%M:%S"), "paso": krok, "herramienta": call.function.name,
                                  "args": args, "observacion": obs[:500]}, ensure_ascii=False) + "\n")
            messages.append({"role": "tool", "tool_call_id": call.id, "content": obs})
    return f"Detenido: se alcanzo el limite de {MAX_KROKOW} pasos (coste aprox.: {koszt:.5f} USD)."

if __name__ == "__main__":
    print("\nRESULTADO:\n" + agent(" ".join(sys.argv[1:]) or "Suma los importes de las facturas en dane/faktury."))

Aspectos clave del código:

• for krok in range(1, MAX_KROKOW + 1) establece el bucle con un tope estricto de ejecuciones (por defecto 8).
• if not msg.tool_calls: si el modelo no requiere llamar a más herramientas, asume que ha llegado a la respuesta final.
• Cualquier fallo de ejecución en la herramienta no cuelga el script; se captura y se devuelve como texto «ERROR: …», permitiendo que el modelo intente corregir su estrategia por sí mismo.
• Cada iteración queda grabada en agent_log.jsonl (marca de tiempo, número de paso, herramienta, argumentos y respuesta devuelta).
• El prompt de sistema le exige al modelo justificar en una frase por qué recurre a una herramienta concreta. Esa línea funciona como el razonamiento o «pensamiento» en consola, facilitando la depuración en vivo.

Ejecución 1: procesamiento de facturas multidivisa

Nota: la prueba original se ejecutó con prompts y documentos en polaco frente a la API del NBP. Mostramos la traducción correspondiente de la traza original de ejecución:

> python 02_agent_bez_frameworka.py "[Traducción del prompt probado: Calcula cuánto he gastado en total en las facturas de la carpeta dane. Convierte la factura en euros según el tipo de cambio oficial de hoy.]"
[paso 1] PENSAMIENTO: Primero voy a leer todos los archivos de facturas de la carpeta `dane` y consultaré el tipo de cambio del EUR para poder unificar los importes.
[paso 1] ACCION: szukaj_plikow({"fraza": ""})
[paso 1] OBSERVACION: '== faktury\\FV_2026_09_014.txt ==\nFACTURA n. FV/2026/09/014 (datos de ejemplo)\nFecha: 2026-09-12\nEmisor: Empresa Ejemplo S.L.\nReceptor'
[paso 1] ACCION: czytaj_strone({"url": "https://api.nbp.pl/api/exchangerates/rates/a/eur/?format=json"})
[paso 1] OBSERVACION: '{"table":"A","currency":"euro","code":"EUR","rates":[{"no":"192/A/NBP/2026","effectiveDate":"2026-10-02","mid":4.3745}]}'
[paso 2] PENSAMIENTO: Ahora convierto la factura de 120 EUR al tipo 4,3745 y la sumo a las dos facturas de 2 214,00 y 1 180,80.
[paso 2] ACCION: kalkulator({"wyrazenie": "2214+1180.8+120*4.3745"})
[paso 2] OBSERVACION: '3919.74'
--- finalizado tras 3 pasos, coste aprox.: 0.00104 USD (aprox. 0,00093 EUR)

RESULTADO:
En total has gastado un equivalente acumulado de **3 919,74 unidades**.

Desglose:
- Factura 1: 2 214,00
- Factura 2: 1 180,80
- Factura en EUR: 120 × 4,3745 = 524,94

Suma total: 2 214,00 + 1 180,80 + 524,94 = 3 919,74
Tipo de cambio EUR aplicado: 4,3745 (del 2026-10-02).

El agente trazó la secuencia de forma autónoma: en el paso 1 ejecutó en paralelo la inspección de archivos locales y la consulta de tipos de cambio vía API (tabla oficial del 2 de octubre, al ser 4 de octubre domingo). En el paso 2 unificó toda la operación en una sola llamada matemática. En el paso 3 redactó la conclusión final. La verificación manual confirma la exactitud: 2214 + 1180,80 + 120 × 4,3745 = 3919,74. En total, 3 consultas al LLM por aprox. 0,0009 EUR (0,001 USD).

Ejecución 2: lectura web combinada con archivos locales

Nota: la prueba original se realizó en polaco consultando la entrada de Wikipedia sobre Model Context Protocol; a continuación figura la traducción fiel de la sesión registrada:

> python 02_agent_bez_frameworka.py "[Traducción del prompt probado: Lee la página https://pl.wikipedia.org/wiki/Model_Context_Protocol y resume en 3 puntos para qué sirve MCP. Luego comprueba en la carpeta dane si tengo alguna nota con una fecha límite y di cuántos días faltan desde el 4 de octubre de 2026.]"
[paso 1] PENSAMIENTO: Consultaré la página de Wikipedia para extraer el resumen de 3 puntos sobre MCP.
[paso 1] ACCION: czytaj_strone({"url": "https://pl.wikipedia.org/wiki/Model_Context_Protocol"})
[paso 1] OBSERVACION: 'Model Context Protocol - Wikipedia... Ir al contenido Menú principal Menú principal fijar ocultar Navegación Portada Página aleatoria'
[paso 2] PENSAMIENTO: Buscaré en la carpeta dane la nota con la fecha límite.
[paso 2] ACCION: szukaj_plikow({"fraza": ""})
[paso 2] OBSERVACION: '== faktury\\FV_2026_09_014.txt ==\nFACTURA n. FV/2026/09/014...'
[paso 3] PENSAMIENTO: Calculo la diferencia entre el 4 y el 7 de octubre de 2026 para dar el número exacto de días.
[paso 3] ACCION: kalkulator({"wyrazenie": "7-4"})
[paso 3] OBSERVACION: '3'
--- finalizado tras 4 pasos, coste aprox.: 0.00130 USD (aprox. 0,00116 EUR)

RESULTADO:
MCP sirve para:
1. Estandarizar la forma en que los sistemas de IA se conectan con herramientas externas y fuentes de datos.
2. Proporcionar una interfaz universal para leer ficheros, ejecutar funciones y compartir contexto.
3. Facilitar la integración práctica en aplicaciones corporativas, CRM y bases de datos.

En el archivo dane/faktury/notatka.txt figura la fecha límite: enviar las facturas a la gestoría antes del 7 de octubre de 2026.
Desde el 4 de octubre de 2026 hasta esa fecha faltan 3 días.

Aquí combinó dos fuentes de naturaleza completamente distinta. En el registro se aprecia un detalle práctico: la parte inicial de una web contiene menús de navegación («Ir al contenido…»). Con el corte de seguridad a 4000 caracteres quedó margen suficiente para el cuerpo del texto, pero en páginas más densas resulta conveniente aislar mediante código etiquetas específicas como <main> o <article>. Aunque calcular 7 - 4 mediante una herramienta externa resulte llamativo, es el comportamiento óptimo: forzar la aritmética en el código evita alucinaciones en cifras complejas.

Ejecución 3: impacto del límite de pasos

Para comprobar las salvaguardas, configuré el límite en únicamente 2 pasos y añadí una petición adicional de conversión de divisas:

> MAX_KROKOW=2 python 02_agent_bez_frameworka.py "[Traducción del prompt probado: Suma las facturas de la carpeta dane, convierte la de euros al cambio actual y calcula también el total en dólares.]"
[paso 1] PENSAMIENTO: Obtendré el contenido de los archivos locales y los tipos de cambio de EUR y USD vía API de forma paralela.
[paso 1] ACCION: szukaj_plikow({"fraza": ""})
[paso 1] OBSERVACION: '== faktury\\FV_2026_09_014.txt ==\n...'
[paso 1] ACCION: czytaj_strone({"url": "https://api.nbp.pl/api/exchangerates/rates/a/eur/?format=json"})
[paso 1] OBSERVACION: '{"table":"A","currency":"euro","code":"EUR","rates":[{"no":"192/A/NBP/2026","effectiveDate":"2026-10-02","mid":4.3745}]}'
[paso 1] ACCION: czytaj_strone({"url": "https://api.nbp.pl/api/exchangerates/rates/a/usd/?format=json"})
[paso 1] OBSERVACION: '{"table":"A","currency":"dolar","code":"USD","rates":[{"no":"192/A/NBP/2026","effectiveDate":"2026-10-02","mid":3.8881}]}'
[paso 2] PENSAMIENTO: Identifico los importes brutos y realizo los cálculos combinados.
[paso 2] ACCION: kalkulator({"wyrazenie": "2214+1180.80+120*4.3745"})
[paso 2] OBSERVACION: '3919.74'

RESULTADO:
Detenido: se alcanzó el límite de 2 pasos (coste aprox.: 0.00079 USD / aprox. 0,00071 EUR).

Al agotarse el margen fijado, el bucle cortó la ejecución devolviendo un mensaje claro sin gastar más saldo. En un entorno de producción suelo establecer márgenes más holgados (entre 8 y 15 pasos), persistiendo el estado completo en disco por si fuera necesario reanudarlo. Este es el extracto de agent_log.jsonl generado durante esa prueba:

> type agent_log.jsonl   (últimas 3 entradas)
{"t": "13:50:52", "paso": 1, "herramienta": "czytaj_strone", "args": {"url": "https://api.nbp.pl/api/exchangerates/rates/a/eur/?format=json"}, "observacion": "{\"table\":\"A\",\"currency\":\"euro\",\"code\":\"EUR\",\"rates\":[{\"no\":\"192/A/NBP/2026\",\"effectiveDate\":\"2026-10-02\",\"mid\":4.3745}]}"}
{"t": "13:50:52", "paso": 1, "herramienta": "czytaj_strone", "args": {"url": "https://api.nbp.pl/api/exchangerates/rates/a/usd/?format=json"}, "observacion": "{\"table\":\"A\",\"currency\":\"dolar\",\"code\":\"USD\",\"rates\":[{\"no\":\"192/A/NBP/2026\",\"effectiveDate\":\"2026-10-02\",\"mid\":3.8881}]}"}
{"t": "13:50:56", "paso": 2, "herramienta": "kalkulator", "args": {"wyrazenie": "2214+1180.80+120*4.3745"}, "observacion": "3919.74"}

Problemas habituales en agentes y cómo solucionarlos

El mismo agente implementado con OpenAI Agents SDK

Una vez asimilado el bucle básico, ningún framework parece misterioso. OpenAI Agents SDK replica la misma lógica de las 76 líneas previas: consulta al modelo, ejecuta las funciones elegidas, aplica topes (max_turns) y registra el historial. Además, infiere el esquema JSON a partir del tipado y docstring de Python mediante el decorador @function_tool. Funciona con proveedores alternativos apuntando el cliente a OpenRouter:

"""03 - El mismo agente implementado con OpenAI Agents SDK (openai-agents).
El objeto Runner gestiona el bucle, las herramientas y el tope de pasos.
Ejecutar: python 03_agent_openai_sdk.py "Calcula el gasto total de las facturas."
"""
import asyncio, os, sys
from dotenv import load_dotenv
from openai import AsyncOpenAI
from agents import Agent, OpenAIChatCompletionsModel, Runner, function_tool, set_tracing_disabled

import importlib
narz = importlib.import_module("02_agent_bez_frameworka")  # reutilizamos las mismas funciones

load_dotenv()
set_tracing_disabled(True)  # desactiva telemetria hacia OpenAI al usar OpenRouter
model = OpenAIChatCompletionsModel(
    model=os.getenv("MODEL", "openai/gpt-5.6-luna"),
    openai_client=AsyncOpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"]))

@function_tool
def szukaj_plikow(fraza: str = "") -> str:
    """Muestra archivos .txt de dane/ y su texto. Frase vacia = todos los archivos."""
    return narz.szukaj_plikow(fraza)

@function_tool
def kalkulator(wyrazenie: str) -> str:
    """Calcula expresiones aritmeticas como 2214+1180.8. Usa siempre esta herramienta."""
    return narz.kalkulator(wyrazenie)

@function_tool
def czytaj_strone(url: str) -> str:
    """Descarga el texto plano de una pagina web o respuesta JSON de una API."""
    return narz.czytaj_strone(url)

agent = Agent(
    name="Asistente de facturacion",
    instructions="Resuelve la tarea mediante las herramientas disponibles. Consulta cambios en: "
                 "https://api.nbp.pl/api/exchangerates/rates/a/{kod}/?format=json.",
    model=model, tools=[szukaj_plikow, kalkulator, czytaj_strone])

async def main():
    zadanie = " ".join(sys.argv[1:]) or "Suma el total de las facturas en dane."
    wynik = await Runner.run(agent, zadanie, max_turns=8)
    for item in wynik.new_items:  # registro de traza intermedia
        if item.type == "tool_call_item":
            print("ACCION:", item.raw_item.name, item.raw_item.arguments)
        elif item.type == "tool_call_output_item":
            print("OBSERVACION:", str(item.output)[:120].replace("\n", " "))
    u = wynik.context_wrapper.usage
    print(f"\nRESULTADO:\n{wynik.final_output}\n\nLlamadas al modelo: {u.requests}, tokens: {u.input_tokens} entrada / {u.output_tokens} salida")

asyncio.run(main())

Nota: a continuación figura la traducción de la salida obtenida en la prueba original ejecutada en polaco:

> python 03_agent_openai_sdk.py "[Traducción del prompt probado: Suma el importe de las facturas locales y convierte la de euros al cambio actual.]"
ACCION: szukaj_plikow {"fraza":""}
ACCION: czytaj_strone {"url":"https://api.nbp.pl/api/exchangerates/rates/a/EUR/?format=json"}
OBSERVACION: == faktury\FV_2026_09_014.txt == FACTURA n. FV/2026/09/014 Fecha: 2026-09-12...
OBSERVACION: {"table":"A","currency":"euro","code":"EUR","rates":[{"no":"192/A/NBP/2026","effectiveDate":"2026-10-02","mid":4.3745}]}
ACCION: kalkulator {"wyrazenie":"2214+1180.8"}
ACCION: kalkulator {"wyrazenie":"120*4.3745"}
ACCION: kalkulator {"wyrazenie":"2214+1180.8+120*4.3745"}
OBSERVACION: 3394.8
OBSERVACION: 524.94
OBSERVACION: 3919.74

RESULTADO:
Has gastado en total **3 919,74 unidades**.

Cálculos:
- Facturas locales: 2 214,00 + 1 180,80 = 3 394,80
- Factura en euros: 120 EUR × tipo 4,3745 = 524,94
- Total: 3 394,80 + 524,94 = 3 919,74

Llamadas al modelo: 3, tokens: 1970 entrada / 323 salida

El resultado obtenido es exacto al anterior: 3 peticiones al LLM, consumiendo 1970 tokens de entrada y 323 de salida. Dos detalles técnicos a considerar:

• set_tracing_disabled(True): por defecto, este SDK envía telemetría a los servidores de OpenAI. Si usas OpenRouter sin credenciales de OpenAI activas, generará avisos de error; además, con datos privados conviene desactivar cualquier envío externo.
• OpenAIChatCompletionsModel: el SDK apunta por defecto a la API de Responses de OpenAI. Como proveedores como OpenRouter se comunican vía Chat Completions estándar, adaptamos el cliente con esta clase envolvente.

Variante con Claude Agent SDK

Claude Agent SDK expone el motor interno de Claude Code en forma de librería. Trae herramientas predefinidas para manipular archivos y ejecutar órdenes de terminal, permitiendo conectar funciones propias mediante un microservidor MCP en memoria. El script de ejemplo está en frameworki/e_claude_agent_sdk.py y analizo las alternativas en el artículo sobre Frameworks para agentes de IA. En sistemas Windows surgieron dos particularidades:

• El SDK lanza el ejecutable claude como un subproceso independiente y bloquea la llamada a claude.cmd que genera npm (por restricciones de seguridad). Es necesario indicar la ruta directa a claude.exe con el parámetro cli_path o instalar el binario de forma nativa.
• Carga automáticamente ajustes desde ~/.claude/settings.json. Si tienes definido un ANTHROPIC_BASE_URL global, las llamadas se redirigirán allí en lugar de al destino configurado en el script. Se mitiga definiendo setting_sources=[].

Al ejecutar la prueba de facturas con Claude Haiku 4.5 vía OpenRouter, el proceso tomó entre 15 y 18 segundos con un gasto de entre 0,0116 EUR y 0,0161 EUR (0,013-0,018 USD a lo largo de 3 iteraciones). La implementación manual en 76 líneas con el mismo modelo Haiku tardó 7,1 segundos y costó aprox. 0,0063 EUR (0,007 USD). Esa disparidad responde a las instrucciones adicionales y pasos de razonamiento que el motor de Claude Code inyecta por defecto, a cambio de ofrecer gestión de permisos, sesiones y subagentes ya integrados.

Cuándo programar el agente desde cero y cuándo usar un SDK

• Código propio: ideal para aprender los fundamentos sin abstracciones, para flujos sencillos con 2 a 5 herramientas o cuando requieres optimizar y auditar cada token gastado.
• OpenAI Agents SDK: indicado si precisas delegación entre múltiples agentes (handoffs), barreras de seguridad (guardrails) o trazabilidad estructurada.
• Claude Agent SDK: óptimo si el agente debe interactuar intensivamente con el sistema de archivos local y la consola de comandos.
• LangGraph: adecuado cuando el flujo requiere bifurcaciones complejas, persistencia de estados y validación con intervención humana.
• Sin código (No-Code): soluciones como n8n, Make o Gumloop son preferibles si buscas una interfaz visual en lugar de escribir scripts.

Preguntas frecuentes

¿Es obligatorio saber programar para crear un agente de IA?

Para comprender su lógica basta con saber interpretar código básico. El script presentado tiene 76 líneas y puede ejecutarse directamente. Para crear automatizaciones sin programar existen herramientas como n8n o Gumloop.

¿Cuánto cuesta la ejecución de un agente de IA?

Depende del modelo y de los pasos requeridos. Con un modelo económico como Luna, cada tarea rondó los 0,0009 EUR (aprox. 0,001 USD). El mismo proceso con Claude Haiku se situó entre 0,006 EUR y 0,016 EUR (0,007-0,018 USD). En modelos punteros con tarifas cercanas a 4,47 EUR por millón de tokens de entrada (5 USD), el coste puede multiplicarse considerablemente. Al enviarse todo el historial acumulado en cada paso, el gasto escala progresivamente.

¿Qué modelo es más recomendable para un agente?

Cualquiera con un soporte sólido de llamada a funciones (function calling). Para experimentar basta el modelo más accesible que admita herramientas en OpenRouter. Para flujos de trabajo extensos con datos heterogéneos, los modelos con mayor capacidad de razonamiento minimizan el riesgo de perder el hilo de la tarea.

¿Puede funcionar con un modelo local?

Sí. Herramientas como Ollama ofrecen una API compatible con OpenAI (http://localhost:11434/v1), por lo que basta con modificar base_url y el nombre del modelo. Ten en cuenta que los modelos locales de menor tamaño cometen errores más frecuentes al estructurar los argumentos JSON.

¿Cómo evitar que el agente realice acciones imprevistas o destructivas?

Facilítale únicamente las herramientas estrictamente necesarias, priorizando las de solo lectura. Limita el acceso a rutas concretas de tu disco. Para cualquier acción irreversible, exige confirmación manual humana en el código y mantén un registro de auditoría exhaustivo.

¿Funciona igual de bien en español?

Sin problemas. Los modelos actuales procesan instrucciones, descripciones y respuestas en español de forma fluida. Se recomienda mantener los identificadores técnicos de las funciones en caracteres alfanuméricos simples y redactar con claridad sus descripciones operativas.

Fuentes y referencias

• Anthropic: Building effective agents (consultado el 04/10/2026).
• Documentación oficial de OpenAI Agents SDK (consultada el 04/10/2026).
• Documentación oficial de Claude Agent SDK (consultada el 04/10/2026).
• Tipos de cambio: API NBP, tabla A.
• Entorno de ejecución de pruebas: pruebas reales registradas el 4 de octubre de 2026. Tipos de cambio USD/EUR convertidos según la referencia oficial del BCE del 12/10/2026 (1 EUR = 1,1181 USD), fuente: ecb.europa.eu.

// sigue leyendoAgentes de IA desde cero: cómo funcionan y cómo crear el primeroGuíasAgente IA: 12 ejemplos prácticos para crear en un fin de semanaGuías30 prompts para crear escenas de vídeo con ZWIDGuías

Kinetyra