Cómo crear un agente de IA: la guía completa, del no-code al código

Crear un agente de IA consiste en conectar un modelo de lenguaje con unas instrucciones, con herramientas que puede activar y con un bucle que le permite actuar hasta terminar la tarea. Puede hacerse sin código en una plataforma visual o con un framework en Python o TypeScript: esta guía le ofrece el método común y después ambos caminos, desde la elección de la tarea hasta la puesta en producción.

Lo que realmente va a construir

Un agente de IA no es un chatbot mejorado. Un chatbot responde a un mensaje. Un agente recibe un objetivo, decide por sí mismo los pasos, utiliza herramientas (consultar una base de datos, leer un archivo, enviar una petición a otra aplicación) y revisa los resultados antes de decidir qué hace a continuación.

Todo se apoya en la llamada a herramientas: el modelo no ejecuta nada por sí mismo. Genera una petición estructurada del tipo «llama a la herramienta del tiempo con la ciudad Sevilla». Su programa, o la plataforma, ejecuta la herramienta y devuelve el resultado al modelo. Este lo lee y decide: otra llamada o la respuesta final. Esa alternancia entre razonamiento, acción y observación tiene nombre: el patrón ReAct.

Este es el bucle reducido a lo esencial. Se trata de pseudocódigo para mostrar el principio; los frameworks que veremos más abajo lo escriben por usted.

historial = [instrucciones, petición del usuario]
repetir como máximo N veces:
    respuesta = modelo(historial, lista de herramientas)
    si respuesta es una respuesta final: devolver respuesta
    para cada llamada a herramienta solicitada:
        resultado = ejecutar(herramienta, argumentos)
        añadir resultado al historial
detenerse e informar del fallo

Dos detalles ya cuentan. El límite de «como máximo N veces» evita que un agente dé vueltas sin fin y dispare la factura. Y el historial completo se reenvía al modelo en cada vuelta: cuanto más trabaja el agente, más larga y cara resulta cada llamada.

¿Agente o flujo de trabajo? La primera pregunta

Muchos proyectos de «agente» son en realidad flujos de trabajo: una secuencia de pasos conocida de antemano en la que la IA interviene en un punto concreto (resumir, clasificar, redactar). Un flujo es más predecible, más barato y más fácil de probar. El agente se justifica cuando el recorrido no se conoce de antemano: investigar una incidencia, atender peticiones variadas, explorar varias fuentes.

Paso 1: elegir una tarea adecuada para un agente

El éxito de un agente se decide antes de la primera línea de configuración. Una buena tarea inicial cumple cuatro criterios:

1. Es frecuente. Crear un agente para una tarea mensual de diez minutos no compensa el esfuerzo.
2. Requiere algo de criterio. Si basta una regla fija, la automatización clásica lo hará mejor.
3. Su resultado es fácil de verificar. Debe poder saber en unos segundos si el agente hizo bien su trabajo.
4. Un error se puede corregir. Para un primer proyecto, evite pagos, borrados y mensajes enviados a clientes sin revisión.

Buenos candidatos: clasificar las peticiones entrantes y redactar un borrador de respuesta, preparar una nota de síntesis a partir de varios documentos, comprobar que una ficha de producto respeta una plantilla, completar una lista de contactos con fuentes públicas.

Póngase a prueba ¿Es un buen primer proyecto un agente que paga automáticamente las facturas de proveedores recibidas por correo?

No. La acción es irreversible, verificarla lleva tiempo y un error cuesta dinero. Un primer proyecto mejor: un agente que lee las facturas, extrae el importe, la fecha de vencimiento y el proveedor, los compara con la orden de compra y prepara una lista para que una persona la valide. El pago sigue siendo una decisión humana.

Paso 2: reunir las cuatro piezas

Sea cual sea la herramienta, sin código o con código, encontrará las mismas piezas.

El modelo

Es el «cerebro» que lee la situación y decide. Para un agente, tres cualidades pesan más que la puntuación general: la fiabilidad al llamar a herramientas, la capacidad de seguir instrucciones largas y el precio, porque el agente llama al modelo muchas veces. Un modelo rápido y económico suele bastar para clasificar o extraer; uno más potente se justifica para planificar una tarea larga o escribir código.

Las instrucciones

El prompt de sistema describe el papel del agente, su objetivo, sus límites y el formato esperado. Para un agente, añada tres cosas que a menudo se olvidan: cuándo detenerse, qué hacer en caso de duda (preguntar en lugar de suponer) y lo que no debe hacer nunca. Nuestra guía de prompt engineering detalla las técnicas de redacción.

Las herramientas

Cada herramienta es una función descrita por un nombre, una descripción y unos parámetros. El modelo elige una herramienta según esa descripción: una descripción vaga produce llamadas al azar. Una regla útil: pocas herramientas, bien nombradas, y cada una con una sola función. Una herramienta «leer_pedido» y otra «reembolsar_pedido» son mejores que una genérica «gestionar_pedido», entre otras cosas porque la segunda puede quedar sujeta a validación.

La memoria y el contexto

Un agente dispone de una memoria de trabajo, su ventana de contexto, que contiene el historial de la tarea en curso. Su tamaño es limitado y cada token que se vuelve a leer se paga. Para recordar cosas entre sesiones o consultar sus documentos, hace falta una memoria externa: una base de datos, archivos o una búsqueda en sus documentos mediante RAG (ver más abajo). Decidir qué entra en el contexto en cada paso se ha convertido en una disciplina propia, la ingeniería de contexto.

Paso 3: elegir el camino, sin código o con código

Criterio	Sin código (plataforma visual)	Framework de código
Perfil	Autónomo, equipo de negocio, sin conocimientos técnicos	Desarrollador Python o TypeScript
Primeros pasos	Rápidos, con bloques y formularios	Más lentos, pero todo bajo su control
Conectores	Numerosos conectores listos para usar	Se escriben o se importan (MCP, bibliotecas)
Pruebas automáticas	Limitadas, a menudo manuales	Pruebas unitarias, evaluaciones, integración continua
Alojamiento	En el proveedor, a veces autoalojado (n8n)	Donde quiera, pero lo gestiona usted
Coste	Suscripción a la plataforma + modelo	Modelo + alojamiento (biblioteca a menudo gratuita)
Límite habitual	La lógica compleja cuesta de mantener	Más trabajo de ingeniería al principio

No hay una mala elección, solo elecciones poco adaptadas. Un equipo sin desarrolladores obtendrá antes un resultado útil en una plataforma visual; un equipo que debe integrar el agente en su propio producto necesitará código. Estas son algunas herramientas representativas de ambos mundos, con las características registradas por el sitio:

Herramienta	Tipo	Licencia	MCP	Multiagente	Nivel
n8n	Low-code	fair-code	Sí	Sí	Intermedio
Make	Sin código	proprietary	Sí	—	Principiante
Zapier Agents	Sin código	proprietary	—	—	Principiante
OpenAI Agents SDK	Código	MIT	Sí	Sí	Intermedio
Claude Agent SDK	Código	proprietary	Sí	Sí	Intermedio
Pydantic AI	Código	MIT	Sí	Sí	Intermedio
LangGraph	Código	MIT	Sí	Sí	Avanzado

Camino 1: crear un agente de IA sin código

En una plataforma de automatización como n8n, Make o Zapier Agents, el montaje sigue siempre la misma lógica:

1. Un disparador: un correo recibido, un formulario enviado, una hora fija, un mensaje en una aplicación de chat.
2. Un bloque de agente: elige el modelo, pega sus instrucciones y marca las herramientas permitidas. En n8n es el nodo AI Agent, que además puede delegar en agentes especializados.
3. Herramientas: los conectores de la plataforma (calendario, hoja de cálculo, CRM, correo) o un servidor MCP.
4. Una salida: un borrador, una fila en una tabla, una notificación, idealmente con un paso de validación humana antes de cualquier acción sensible.

Este camino se explica en detalle, con un ejemplo completo, en nuestro tutorial para crear un agente de IA sin programar.

Dos precauciones en un mercado que cambia rápido. Primero, compruebe el estado de la herramienta: según los datos del sitio a 22 de octubre de 2026, OpenAI anunció el 3 de junio de 2026 la retirada de Agent Builder (AgentKit), con cierre previsto para el 30 de noviembre de 2026, y el equipo de Flowise anunció el fin de vida del proyecto el 29 de julio de 2026. No empiece un proyecto nuevo con estas herramientas. Segundo, lea bien el modelo de facturación: créditos, «actividades» o ejecuciones, cada plataforma cuenta a su manera, y el coste del modelo suele sumarse a la suscripción.

Camino 2: crear un agente de IA con un framework de código

Un framework de agentes le ahorra el bucle, la gestión del historial, el formato de las llamadas a herramientas y parte de la seguridad. Usted escribe la lógica de negocio. Los ejemplos siguientes respetan la sintaxis de la documentación oficial, consultada el 22 de octubre de 2026; son cortos a propósito y deben adaptarse a su caso. Para una comparación detallada, consulte nuestro comparativo de frameworks de agentes de IA.

Un primer agente con OpenAI Agents SDK

OpenAI Agents SDK es un SDK ligero con licencia MIT, disponible en Python y TypeScript. Se instala con pip install openai-agents. Según su documentación oficial, un agente se define con un nombre, unas instrucciones y unas herramientas, y se lanza con el Runner:

import asyncio
from agents import Agent, Runner
from agents.decorators import tool

@tool
def estado_pedido(numero: str) -> str:
    """Devuelve el estado de un pedido a partir de su número."""
    return "Enviado el 20 de octubre, entrega prevista en 48 horas."

agente = Agent(
    name="Atención de pedidos",
    instructions="Responde a preguntas sobre pedidos. "
                 "Usa la herramienta de estado y no inventes nunca una fecha.",
    tools=[estado_pedido],
)

async def main():
    resultado = await Runner.run(agente, "¿Dónde está mi pedido A-1042?")
    print(resultado.final_output)

asyncio.run(main())

El docstring de la función se convierte en la descripción de la herramienta: cuídelo, porque es lo que lee el modelo. El SDK ofrece además traspasos (handoffs) a agentes especializados, sesiones, guardarraíles y trazas integradas.

Un agente bien equipado con Claude Agent SDK

Claude Agent SDK, de Anthropic, reutiliza el motor de Claude Code: de serie, el agente puede leer y modificar archivos, ejecutar comandos o buscar en la web, según las herramientas que usted autorice. Solo funciona con los modelos Claude y su uso se rige por las Commercial Terms de Anthropic. Su referencia para Python muestra cómo añadir herramientas propias en forma de un pequeño servidor MCP integrado en el programa:

import asyncio
from claude_agent_sdk import tool, create_sdk_mcp_server, ClaudeAgentOptions, query

@tool("estado_pedido", "Estado de un pedido", {"numero": str})
async def estado_pedido(args):
    texto = f"Pedido {args['numero']}: enviado."
    return {"content": [{"type": "text", "text": texto}]}

tienda = create_sdk_mcp_server(name="tienda", version="1.0.0", tools=[estado_pedido])

options = ClaudeAgentOptions(
    system_prompt="Responde a preguntas sobre pedidos.",
    mcp_servers={"tienda": tienda},
    allowed_tools=["mcp__tienda__estado_pedido"],
)

async def main():
    async for message in query(prompt="¿Dónde está el pedido A-1042?", options=options):
        print(message)

asyncio.run(main())

El parámetro allowed_tools es su primera barrera: autorice solo lo que el agente necesita de verdad.

Respuestas tipadas con Pydantic AI

Pydantic AI gira en torno al tipado: usted describe la forma exacta de la respuesta y el framework la valida. Una salida estructurada inválida se detecta en lugar de romper su aplicación. Cambiar de proveedor consiste en cambiar la cadena que nombra el modelo. Un ejemplo basado en la documentación oficial:

from pydantic import BaseModel
from pydantic_ai import Agent, RunContext

class Ticket(BaseModel):
    categoria: str
    urgente: bool
    resumen: str

# identificador exacto del modelo: consulte la documentación de su proveedor
agente = Agent("openai:nombre-del-modelo", output_type=Ticket,
               instructions="Clasifica la petición del cliente.")

@agente.tool
def historial_cliente(ctx: RunContext, email: str) -> str:
    """Devuelve las últimas peticiones del cliente."""
    return "2 peticiones en octubre, ninguna urgente."

resultado = agente.run_sync("Mi paquete no ha llegado, ¡y es la segunda vez!")
print(resultado.output)

resultado.output es un objeto Ticket ya validado: su código puede usarlo directamente para dirigir la petición.

Un flujo controlado con LangGraph

LangGraph describe el agente como un grafo: nodos (pasos), aristas (transiciones) y un estado compartido. Exige más trabajo, pero según su documentación se obtiene ejecución duradera, intervención humana en cualquier punto y memoria a corto y largo plazo. El esqueleto mínimo es este:

from langgraph.graph import StateGraph, MessagesState, START, END

def clasificar(state: MessagesState):
    return {"messages": [{"role": "ai", "content": "categoría: entrega"}]}

grafo = StateGraph(MessagesState)
grafo.add_node(clasificar)
grafo.add_edge(START, "clasificar")
grafo.add_edge("clasificar", END)
grafo = grafo.compile()

grafo.invoke({"messages": [{"role": "user", "content": "Paquete no recibido"}]})

En un proyecto real, el nodo llama a un modelo y unas aristas condicionales dirigen hacia un nodo «herramienta», un nodo «validación humana» o el final.

Paso 4: conectar el agente a sus herramientas con MCP

Escribir un conector distinto para cada framework se vuelve pesado enseguida. El Model Context Protocol (MCP) normaliza la forma en que un agente descubre y llama a herramientas: usted expone sus herramientas una sola vez, como servidor MCP, y cualquier cliente compatible puede usarlas. Según los datos del sitio, todos los frameworks de código citados en esta guía admiten MCP, al igual que n8n y Make.

En la práctica, un servidor MCP declara una lista de herramientas (nombre, descripción, parámetros), quizá algunos recursos de lectura, y responde a las llamadas. Es exactamente lo que hace el ejemplo de Claude Agent SDK anterior, integrado en el programa. Para un servidor independiente que varios agentes puedan reutilizar, siga nuestro tutorial para crear un servidor MCP.

Un consejo de diseño: un servidor MCP es una puerta de entrada a sus sistemas. Concédale permisos limitados (solo lectura si es posible), registre cada llamada y conecte únicamente servidores de origen conocido.

Paso 5: dar al agente acceso a sus documentos

Un modelo no conoce sus procedimientos, sus contratos ni su catálogo. Para que un agente se apoye en ellos sin cargarlo todo en el contexto, se usa el RAG: los documentos se dividen en fragmentos y se indexan, y el agente recibe una herramienta de «búsqueda en la base documental» que devuelve los pasajes pertinentes. Así cita sus fuentes en lugar de responder de memoria.

Dentro de un agente, el RAG es simplemente una herramienta más. El agente decide cuándo buscar, reformula la consulta si el primer resultado es pobre y puede combinar varias búsquedas. La calidad depende sobre todo de cómo se dividen los documentos y de la propia búsqueda; nuestra explicación sobre qué es el RAG y cómo dar sus documentos a una IA detalla estas decisiones.

Paso 6: elegir el modelo y controlar el coste

Un agente multiplica las llamadas: cada vuelta del bucle es una llamada completa con todo el historial. El precio por millón de tokens pesa, por tanto, mucho más que en un chat. Estos son algunos modelos recientes, con su precio y su ventana de contexto según models.dev, datos registrados el 22 de octubre de 2026:

Modelo	Desarrollador	Lanzamiento	Contexto (tokens)	Entrada ($/M tokens)	Salida ($/M tokens)	Pesos abiertos
Claude Haiku 5.5	Anthropic	7 de octubre de 2026	1 M	0,10 US$	0,50 US$	No
GPT-6 Luna	OpenAI	22 de septiembre de 2026	1,05 M	0,10 US$	0,50 US$	No
Claude Sonnet 5.5	Anthropic	28 de septiembre de 2026	1 M	2 US$	10 US$	No
GPT-6.1 Sol	OpenAI	29 de septiembre de 2026	1,05 M	2 US$	10 US$	No
Gemini 4 Argon	Google DeepMind	13 de octubre de 2026	1,05 M	2 US$	10 US$	No
Claude Opus 5.5	Anthropic	22 de septiembre de 2026	1 M	4 US$	20 US$	No

Una estrategia habitual consiste en combinar niveles: un modelo pequeño y barato para clasificar, filtrar o extraer, y uno más potente solo para los pasos que exigen planificar o razonar a fondo. Según los mismos datos, Claude Haiku 5.5 y GPT-6 Luna figuran a 0,10 dólares por millón de tokens de entrada y 0,50 dólares por millón de tokens de salida, frente a 4 y 20 dólares para Claude Opus 5.5: un precio cuarenta veces mayor.

Otras palancas reducen la factura: limitar el número de vueltas, resumir el historial en lugar de reenviarlo entero y reutilizar un mismo comienzo de prompt con la caché de prompts cuando el proveedor la ofrece. La calculadora de coste de un agente de IA le permite simular un escenario, y nuestra guía sobre el precio de las API de IA explica cómo leer y reducir la factura.

Paso 7: probar antes de lanzar

Un agente que funciona con tres ejemplos no es un agente fiable. Antes de ponerlo en servicio, prepare un conjunto de pruebas: al menos una veintena de casos reales, con casos sencillos, ambiguos y trampas (petición fuera de tema, información que falta, herramienta que devuelve un error). Para cada caso, anote el resultado esperado.

Después mida tres cosas: si la respuesta final es correcta, si el agente llamó a las herramientas adecuadas con los parámetros adecuados y cuánto costó la ejecución. Vuelva a pasar el conjunto de pruebas cada vez que cambie el modelo, las instrucciones o una herramienta: una mejora en un punto suele estropear algo en otro. Para las respuestas difíciles de puntuar automáticamente, un segundo modelo puede hacer de evaluador, un método llamado LLM-as-a-judge, siempre que usted revise una muestra de sus notas.

La observabilidad completa las pruebas: registrar cada paso (llamadas al modelo, herramientas, duración, coste) para entender un error a posteriori. Varios frameworks integran trazas, como OpenAI Agents SDK, o se apoyan en OpenTelemetry, como Pydantic AI. El método completo está en nuestra guía para evaluar un agente de IA.

Paso 8: proteger el agente

Un agente actúa, así que puede actuar mal. El riesgo principal tiene nombre: la inyección de prompts. Un texto que el agente lee, en un correo, una página web o un documento, contiene instrucciones ocultas que desvían su comportamiento. Ninguna técnica la elimina por completo, de modo que se limitan los daños posibles.

• Mínimo privilegio. El agente solo recibe las herramientas y los datos que necesita estrictamente, en solo lectura si es posible.
• Persona en el circuito. Toda acción irreversible (pago, envío, borrado) pasa por una validación: es el principio de human-in-the-loop.
• Entorno aislado. Un agente que ejecuta código o comandos trabaja en un entorno aislado, sin acceso a sus archivos sensibles.
• Guardarraíles. Los guardarraíles controlan lo que entra y lo que sale: peticiones fuera de tema, datos personales, formatos no conformes.
• Límites. Número de vueltas, presupuesto de tokens y tiempo máximo por tarea.

Los frameworks suelen ofrecer estas piezas. En OpenAI Agents SDK, por ejemplo, un guardarraíl de entrada es una función que puede activar un «tripwire» y detener la ejecución; esta es una versión abreviada del ejemplo de la documentación sobre guardarraíles:

from agents import Agent, GuardrailFunctionOutput, Runner
from agents.decorators import input_guardrail

@input_guardrail
async def fuera_de_tema(ctx, agent, input):
    resultado = await Runner.run(agente_control, input, context=ctx.context)
    return GuardrailFunctionOutput(
        output_info=resultado.final_output,
        tripwire_triggered=resultado.final_output.fuera_de_tema,
    )

agente = Agent(name="Soporte", instructions="...", input_guardrails=[fuera_de_tema])

Cuando el tripwire se activa, el SDK lanza una excepción InputGuardrailTripwireTriggered, que su código captura para responder con cortesía. Antes de delegar una tarea, la herramienta ¿Puedo confiar esto a un agente? le ayuda a medir el nivel de riesgo, y nuestra guía sobre la seguridad de los agentes de IA detalla los ataques y las defensas.

Paso 9: pasar a producción

Pasar del prototipo a un servicio de uso diario exige algunas precauciones más.

1. Versione todo: instrucciones, lista de herramientas, modelo y parámetros. Una respuesta inesperada debe poder vincularse a una versión concreta.
2. Fije el modelo. Use una versión precisa en lugar de un alias que cambia solo, y repita sus pruebas antes de cada cambio.
3. Prevea las caídas. Proveedor no disponible, límite de peticiones alcanzado, herramienta que falla: el agente debe fallar de forma limpia y avisar a alguien.
4. Vigile el coste día a día, con una alerta y un tope.
5. Recoja la opinión de los usuarios y añada cada fallo real a su conjunto de pruebas.
6. Compruebe el marco legal. Si el agente trata datos personales, se aplica la normativa de protección de datos, como el RGPD en la Unión Europea. Para usos sensibles en la UE, el AI Act puede imponer obligaciones. Un abogado o el delegado de protección de datos de su organización es el interlocutor adecuado.

Resumen: su hoja de ruta

Paso	Pregunta clave	Entregable
1. Tarea	¿Frecuente, verificable, reversible?	Una descripción en una frase
2. Piezas	¿Qué modelo, instrucciones y herramientas?	Un prompt de sistema y una lista de herramientas
3. Camino	¿Plataforma visual o framework de código?	Un prototipo
4. MCP	¿Son reutilizables mis herramientas?	Un servidor MCP o conectores
5. Documentos	¿Necesita el agente mis datos?	Una herramienta de búsqueda (RAG)
6. Coste	¿Cuánto cuesta una ejecución real?	Una estimación y un presupuesto
7. Pruebas	¿Supera el agente mis casos reales?	Un conjunto de pruebas y trazas
8. Seguridad	¿Qué pasa si lo manipulan?	Permisos limitados y validaciones humanas
9. Producción	¿Y si falla o se desvía?	Versiones, alertas, opiniones de usuarios