Cómo crear un agente: un ejemplo probado en cinco pasos

Cómo crear un agente, en la práctica, se reduce a cuatro piezas: un modelo capaz de llamar a herramientas, las herramientas, un bucle que ejecuta esas llamadas y le devuelve los resultados, y unas reglas que impiden que haga daño. Anthropic, que ha trabajado con decenas de equipos que construyen agentes, dice que los que mejor funcionan no usaban marcos de trabajo complejos ni bibliotecas especiales, sino patrones simples que se combinan, y que un agente suele ser solo un modelo de lenguaje usando herramientas en bucle según lo que le devuelve el entorno. Esta guía construye exactamente eso: un agente de atención al cliente en unas 60 líneas de JavaScript, sin dependencias, que funciona con OpenAI, DeepSeek o un modelo gratuito en tu ordenador, más las salvaguardas, el coste y lo que exige la ley europea si habla con clientes.

Paso 1: decide si de verdad necesitas un agente

Anthropic distingue dos tipos de sistema. Los flujos de trabajo combinan modelos y herramientas siguiendo caminos fijados en el código; los agentes dejan que el modelo decida sus propios pasos y qué herramientas usar. Su consejo es buscar la solución más sencilla posible, y recuerda que los sistemas con agentes suelen cambiar velocidad y coste por mejores resultados. Para muchas aplicaciones, dice, basta con una sola llamada al modelo bien preparada, con búsqueda en tus documentos y ejemplos.

Una prueba rápida antes de construir:

• Los pasos son siempre los mismos (resumir, traducir, archivar): monta un flujo, una cadena fija de llamadas. Es más barato y más fácil de probar.
• Los pasos dependen de lo que encuentre el modelo (buscar al cliente, mirar el pedido, decidir si toca reembolso): un agente tiene sentido.
• La tarea es abierta y no sabes cuántos pasos llevará: un agente, con un tope de pasos y una persona que apruebe lo arriesgado.

Si dudas de qué cuenta como agente, lo explicamos en qué es un agente, y n8n vs Zapier vs Make compara la vía sin código para los flujos.

Paso 2: elige el modelo y define las herramientas

Sirve cualquier modelo con llamada a herramientas (también llamada llamada a funciones). La documentación de OpenAI describe el proceso en cinco pasos: envías la petición con las herramientas que puede usar, recibes una llamada a herramienta, ejecutas tu propio código con sus argumentos, devuelves el resultado y recibes la respuesta final o más llamadas. Ese mismo formato de mensajes lo aceptan la API de DeepSeek y, en local, Ollama y llama.cpp, y por eso el ejemplo de abajo funciona con todos.

De las herramientas sale buena parte de la calidad. OpenAI recomienda nombres, descripciones de parámetros e instrucciones claros y detallados, usar las instrucciones del sistema para decir cuándo usar cada una y pasar la «prueba del becario»: ¿podría una persona usar la función bien solo con su descripción? También recomienda el modo estricto, para que las llamadas respeten siempre el esquema. Anthropic lo llama la interfaz entre el agente y el ordenador y pide cuidarla con buena documentación de las herramientas y pruebas.

Si tus herramientas ya existen como servidores MCP (el estándar abierto para conectar aplicaciones de modelos de lenguaje con herramientas y datos), tu agente puede usarlas con un cliente MCP en vez de funciones propias; mira qué es MCP.

Paso 3: escribe el bucle

El ejemplo es el agente de atención al cliente de una tienda pequeña con dos herramientas: una busca los pedidos de un cliente y otra reembolsa un pedido. Guárdalo como agente.mjs y ejecútalo con Node 18 o posterior; no necesita paquetes.

// agente.mjs: un agente mínimo con herramientas (Node 18 o posterior, sin dependencias)
import readline from "node:readline/promises";

const BASE_URL = process.env.BASE_URL ?? "https://api.openai.com/v1";
const MODEL = process.env.MODEL ?? "gpt-6-luna";
const API_KEY = process.env.API_KEY ?? "";
const MAX_PASOS = 8;

// Sustituto de tu base de datos real
const pedidos = { "ana@example.com": [{ id: "A-1001", producto: "Auriculares", total: 79, estado: "entregado", diasDesdeEntrega: 9 }] };

const tools = [
  { type: "function", function: { name: "buscar_pedidos", description: "Lista los pedidos de un cliente a partir de su correo.",
    parameters: { type: "object", properties: { email: { type: "string" } }, required: ["email"], additionalProperties: false } } },
  { type: "function", function: { name: "reembolsar_pedido", description: "Reembolsa un pedido por su id. Solo pedidos entregados hace 14 días o menos; una persona debe aprobarlo.",
    parameters: { type: "object", properties: { pedido_id: { type: "string" } }, required: ["pedido_id"], additionalProperties: false } } },
];

async function aprobar(pregunta) {
  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
  const respuesta = await rl.question(`${pregunta} [s/N] `);
  rl.close();
  return respuesta.trim().toLowerCase() === "s";
}

const ejecutar = {
  buscar_pedidos: ({ email }) => pedidos[email] ?? [],
  reembolsar_pedido: async ({ pedido_id }) => {
    const pedido = Object.values(pedidos).flat().find((p) => p.id === pedido_id);
    // La regla vive en el código, no solo en las instrucciones
    if (!pedido || pedido.estado !== "entregado" || pedido.diasDesdeEntrega > 14) return { rechazado: "No cumple la política de reembolsos." };
    return (await aprobar(`¿Reembolsar ${pedido.id} (${pedido.total} EUR)?`)) ? { reembolsado: pedido.id } : { rechazado: "Una persona ha denegado el reembolso." };
  },
};

async function chat(messages) {
  const res = await fetch(`${BASE_URL}/chat/completions`, {
    method: "POST",
    headers: { "Content-Type": "application/json", Authorization: `Bearer ${API_KEY}` },
    body: JSON.stringify({ model: MODEL, messages, tools }),
  });
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
  return (await res.json()).choices[0].message;
}

const messages = [
  { role: "system", content: "Eres el agente de atención al cliente de una tienda pequeña. Usa las herramientas y no inventes datos de pedidos. Si se rechaza un reembolso, explica por qué." },
  { role: "user", content: process.argv[2] ?? "Soy ana@example.com y los auriculares llegaron rotos. ¿Me devolvéis el dinero?" },
];

for (let paso = 1; paso <= MAX_PASOS; paso++) {
  const msg = await chat(messages);
  messages.push(msg);
  if (!msg.tool_calls?.length) {
    console.log(msg.content);
    process.exit(0);
  }
  for (const llamada of msg.tool_calls) {
    const args = JSON.parse(llamada.function.arguments || "{}");
    const herramienta = ejecutar[llamada.function.name];
    const resultado = herramienta ? await herramienta(args) : { error: `Herramienta desconocida: ${llamada.function.name}` };
    console.log(`[paso ${paso}] ${llamada.function.name}(${JSON.stringify(args)}) => ${JSON.stringify(resultado)}`);
    messages.push({ role: "tool", tool_call_id: llamada.id, content: JSON.stringify(resultado) });
  }
}
console.log(`Parado tras ${MAX_PASOS} pasos sin respuesta final.`);

Para ejecutarlo, pon tu clave en API_KEY y lanza node agente.mjs. Con DeepSeek, añade BASE_URL=https://api.deepseek.com y MODEL=deepseek-flash. Para probarlo gratis en tu ordenador con Ollama, descarga un modelo que admita herramientas, como qwen3, y usa BASE_URL=http://localhost:11434/v1 y MODEL=qwen3; la instalación está en cómo instalar Ollama.

Cómo lo hemos probado. Ejecutamos el archivo contra un servidor de pruebas local que responde con el formato documentado de Chat Completions: un sustituto con guion fijo, no un modelo real. Pasó las cuatro comprobaciones: el recorrido completo con una persona que aprueba el reembolso, una persona que lo deniega, un pedido que no cumple la política y que el código rechaza antes de preguntar a nadie, y una herramienta desconocida junto a un modelo que no para nunca, cortado a los 8 pasos. Con un modelo real la redacción cambiará, y los modelos locales pequeños llaman a las herramientas con menos acierto que los grandes en la nube.

Paso 4: pon las salvaguardas antes que nada

Anthropic avisa de que la autonomía de los agentes supone más coste y errores que se acumulan, y recomienda probarlos a fondo en entornos aislados y con las salvaguardas adecuadas. El ejemplo trae cuatro:

1. Un tope de pasos. Anthropic sugiere condiciones de parada como un número máximo de iteraciones. Aquí son 8.
2. Las reglas del negocio, en el código. La regla de los 14 días la comprueba la función, así que un modelo confundido o manipulado no puede saltársela.
3. Una persona aprueba lo irreversible. No se reembolsa nada sin una «s» en el teclado; en producción, eso se convierte en una aprobación en tu panel de gestión.
4. Se rechazan las herramientas desconocidas, y el modelo solo recibe los datos que devuelven sus herramientas.

De los diez riesgos de OWASP para aplicaciones con modelos de lenguaje (edición 2025), aquí pesan dos: la inyección de instrucciones (LLM01), cuando el texto de un cliente o de una página web intenta darle órdenes nuevas al modelo, y la autonomía excesiva (LLM06), cuando un agente tiene más permisos de los que necesita. La defensa es la misma: el mínimo permiso para cada herramienta y las reglas y aprobaciones fuera del modelo.

Si el agente habla con clientes, avisa de que es una máquina. El artículo 50 del Reglamento (UE) 2024/1689 se aplica desde el 2 de agosto de 2026, y las preguntas y respuestas de la Comisión ponen los chatbots y los agentes como ejemplos de sistemas que interactúan directamente con personas, que deben saber que hablan con una máquina. Las multas llegan a 15 millones de euros o el 3 % del volumen de negocio mundial. Lo explicamos en el artículo 50 del Reglamento.

Paso 5: prueba, calcula el coste y solo después añade un marco de trabajo

Evalúa con casos reales. Reúne de 30 a 50 peticiones reales, incluidas las raras, y revisa la respuesta final del agente y las herramientas que llamó. El resumen de Anthropic es empezar con instrucciones sencillas, mejorarlas con una evaluación completa y añadir sistemas de varios pasos solo cuando lo simple se quede corto.

Calcula el coste por conversación. Cada paso es una llamada completa al modelo, y cada llamada vuelve a enviar toda la conversación. Supón que una conversación media lleva tres llamadas de unos 1.000 tokens de entrada y 100 de salida cada una, y que atiendes 10.000 conversaciones al mes: 30 millones de tokens de entrada y 3 millones de salida. Con los precios de lista del 10 de octubre de 2026, son unos 4,50 dólares al mes con GPT-6 Luna o Claude Haiku 5.5, 12,60 con DeepSeek V4.1 Flash en hora punta y 90 con Claude Sonnet 5.5 o GPT-6.1 Sol, sin contar el razonamiento, que se cobra como salida. Todas cobran en dólares, así que el importe en euros depende del cambio de tu banco. El detalle por proveedor está en nuestra comparativa de precios de las API de modelos y en el precio de la API de DeepSeek.

Añade un marco de trabajo cuando el bucle se complique. Anthropic cita marcos como el Claude Agent SDK y Strands Agents de AWS, y avisa de que suelen añadir capas que esconden las instrucciones y las respuestas y complican la depuración; su consejo es empezar con la API directamente y, si adoptas un marco, entender el código que hay debajo. El Agents SDK de OpenAI tiene muy pocas piezas: agentes con instrucciones y herramientas, traspasos entre agentes, salvaguardas que validan entradas y salidas, y trazas integradas. Pásate a uno de ellos cuando necesites varios agentes, trazas o ejecuciones que se reanudan, no para que funcione el primero.