Capítulo 1
¿Qué es un agente?
En esta página
Este capítulo cumple una promesa hecha en el prefacio: antes de construir nada, fijamos qué es un agente. La necesidad es práctica e inmediata. Los proveedores etiquetan como «agentes» a bots con guion; los investigadores reservan la palabra para sistemas que funcionan de forma desatendida durante horas; y en algún punto intermedio tú tienes que tomar decisiones reales con presupuestos reales. Si el término sigue siendo borroso, recurrirás a un agente autónomo donde un pipeline de tres pasos habría sido más barato y más fácil de depurar, o montarás a mano un pipeline rígido para un problema cuyos pasos de verdad no puedes predecir. El capítulo hace tres cosas. Enuncia la idea misma de agente, explica por qué se volvió práctica cuando lo hizo —deliberadamente sin fechas— y presenta la brújula con la que se orientará el libro. Después traza la distinción práctica entre chatbots, flujos de trabajo y agentes en la que se apoyan todos los capítulos posteriores. Y termina con la pregunta que muy poca gente se hace en voz alta: si necesitas siquiera un agente.
La idea de agente
Quita las demos y el marketing, y la idea es lo bastante pequeña como para caber en una mano. Un agente es un modelo de lenguaje colocado en un bucle. Recibe un objetivo y un conjunto de herramientas, funciones que puede pedirle a tu programa que ejecute: busca esto, lee aquello, ejecuta este comando. Observa el estado de la tarea, elige una acción, ve el resultado y vuelve a empezar, hasta que juzga que el objetivo se ha cumplido o una regla de parada pone fin a la ejecución. Tras años de diálogo de sordos, la comunidad profesional ha convergido en gran medida, en el momento de escribir estas líneas, en una versión de una sola frase: un agente ejecuta herramientas en un bucle para alcanzar un objetivo1 Simon Willison, «I think “agent” may finally have a widely enough agreed upon definition to be useful jargon now», simonwillison.net (septiembre de 2025). La definición citada —«An LLM agent runs tools in a loop to achieve a goal»— es suya, y allí la defiende frase por frase. LLM es la abreviatura que usa el campo para large language model (gran modelo de lenguaje), que este libro llama casi siempre modelo de lenguaje, o simplemente modelo.. En esa frase, cada palabra soporta carga. «Herramientas» es lo que conecta al modelo con el mundo; «bucle» es lo que le permite reaccionar a lo que encuentra; «un objetivo» es lo que pone fin al bucle: un agente tiene una condición de parada, y eso es lo que lo distingue de un proceso desbocado. El capítulo 3 desmenuza el bucle en código.
Lo genuinamente nuevo aquí es dónde vive el flujo de control. En todos los programas que has escrito hasta ahora, la secuencia de operaciones la decidías tú, de antemano, en el código. En un agente, la secuencia la decide el modelo, en tiempo de ejecución, en respuesta a lo que observa. Ese único cambio es lo que hace que los agentes merezcan un libro, y también lo que los hace caros, lentos y, de vez en cuando, alarmantes. El resto del libro trata de las dos mitades de esa frase.
Es razonable que te preguntes por qué esto se volvió práctico cuando lo hizo. Los modelos de lenguaje escribían con fluidez mucho antes de que nadie le confiara un bucle a uno de ellos; la fluidez nunca fue la pieza que faltaba. Tres cosas tenían que madurar. Cada una volverá más adelante en el libro, primero como maquinaria y después como modo de fallo cuando escasea.
La primera: los modelos aprendieron a aceptar instrucciones. Un modelo recién salido de su entrenamiento inicial es un puro continuador de texto: hazle una pregunta y puede que responda con más preguntas, porque esa es una forma plausible de que el texto continúe (el capítulo 2 muestra por qué). Una etapa posterior del entrenamiento, que el campo llama posentrenamiento (post-training), convierte a ese continuador en algo a lo que puedes encargarle un trabajo: sigue indicaciones, trabaja hacia el objetivo planteado y se detiene cuando termina. Un agente es una delegación, y delegar exige un trabajador que acepte el encargo.
La segunda: el texto adquirió un puente hacia la acción. La llamada a funciones (function calling) —el modelo emite una solicitud legible por máquina, «llama a esta función con estos argumentos», que tu código ejecuta antes de devolverle el resultado— dio al modelo un canal disciplinado hacia el mundo. El modelo propone; tu código dispone. El capítulo 2 cubre el mecanismo en detalle. Aquí lo que importa es la consecuencia: un sistema que solo podía escribir sobre el mundo pasó a ser uno que puede pedir, de una forma que un programa puede obedecer con seguridad, que en él ocurran cosas.
La tercera: la memoria de trabajo del modelo creció. Todo lo que un agente sabe en un momento dado tiene que caber en la ventana de contexto del modelo (el tramo acotado de texto que un modelo puede considerar en una sola llamada). Cuando en las ventanas cabían unas pocas páginas, un bucle se moría de hambre: las instrucciones, el historial y el último resultado de una herramienta no cabían juntos. Las ventanas crecieron hasta dar cabida a algo más parecido a una sesión de trabajo, y los bucles se volvieron sostenibles.
Cada una de ellas maduró como una pendiente que cruza un umbral sin hacer ruido, lo cual nos conviene a los dos: la explicación de «por qué ahora» no caduca. También te dice qué comprobar cuando se anuncie alguna capacidad nueva: pregunta cuál de los tres ingredientes acaba de mejorar.
Antes de la taxonomía y la maquinaria, quiero entregarte la brújula con la que se orienta este libro: cuatro rumbos que reaparecerán en casi todos los capítulos. Los enuncio aquí sin su defensa completa; la defensa es el libro.
La verificabilidad va primero. El prefacio enunció la tesis y vale la pena repetirla: un agente solo es tan digno de confianza como la señal con la que puedes verificarlo. La seguridad que muestra el propio modelo no aporta ninguna información sobre si tiene razón, así que la confianza debe venir de fuera: una prueba que pasa, un esquema que valida, una fuente que puedes abrir, una persona que aprueba. La primera pregunta que hay que hacerle a cualquier diseño de agente es la que este libro hará una y otra vez: ¿qué señal te dice que funcionó?
Después viene la escasez de contexto. La ventana de contexto es finita, y lo que sorprende a la gente es que la atención del modelo se degrada antes de que se agote el espacio: un dato enterrado en mitad de un montón largo queda, en la práctica, medio olvidado. Trata el contexto como un presupuesto que se gasta de forma deliberada. La parte III de este libro trata de gastarlo bien.
El error compuesto es el tercero. Un agente encadena muchos pasos, y la fiabilidad se multiplica a lo largo de ellos. Supón, solo a modo de ilustración, que cada paso sale bien el 95% de las veces; una ejecución de veinte pasos encadenados sale bien entonces alrededor del 0.9520 ≈ 36% de las veces. Las cifras concretas varían; la aritmética no, y es implacable. Los bucles largos solo sobreviven con recuperación de errores, puntos de control y verificación por el camino. Este libro dedica capítulos enteros a esa maquinaria.
Y el último rumbo es lo más simple que funcione. El consejo de ingeniería que mejor ha envejecido en este joven campo es tajante: busca la solución más simple posible y añade complejidad solo cuando esté demostrado que compensa, lo que puede significar no construir un agente en absoluto2 Erik Schluntz y Barry Zhang, «Building Effective Agents», blog de ingeniería de Anthropic (2024): «recomendamos buscar la solución más simple posible y aumentar la complejidad solo cuando haga falta. Eso puede significar no construir sistemas agénticos en absoluto». La distinción entre flujo de trabajo y agente que hace ese ensayo vertebra también la sección siguiente.. A veces lo más simple es un único prompt. A veces es una expresión regular. La última sección de este capítulo se toma este rumbo lo bastante en serio como para dedicarle una discusión propia. La figura 1.1 coloca los cuatro rumbos sobre una misma rosa de los vientos, con la aguja apoyada en el primero.
Una brújula es un instrumento modesto; no va a diseñar tu sistema por ti. Pero cada vez que el libro llegue a una bifurcación —más autonomía o menos, otro agente o un simple script, un contexto más rico o más austero— verás que son los mismos cuatro rumbos los que la deciden, y espero que al final estén decidiendo también tus bifurcaciones.
Agentes, flujos de trabajo y chatbots
Déjame ponerte delante tres sistemas. Decide cuál de ellos es el agente antes de seguir leyendo.
El primero es un asistente de preguntas y respuestas. Pegas una función y preguntas qué hace, y te lo explica; pegas un diff y pides un borrador de mensaje de commit, y lo escribe; después espera tu siguiente mensaje. El segundo procesa de la misma manera cada ticket de soporte que entra: una llamada al modelo clasifica el ticket, código ordinario busca el documento de política correspondiente, una segunda llamada al modelo redacta una respuesta, una tercera revisa el borrador con una rúbrica, y el resultado va a parar a una cola de revisión humana; cuatro pasos, en ese orden, siempre. Al tercero se le dice «las pruebas del checkout están fallando: arréglalas» y, sin supervisión, busca en la base de código, lee tres archivos, edita uno, ejecuta las pruebas, lee el nuevo fallo, vuelve a editar y se detiene cuando toda la batería está en verde.
El instinto de casi todo el mundo los clasifica al instante: el tercero parece de otra naturaleza, y el instinto acierta. Lo útil es decir con precisión por qué. Los tres pueden estar construidos exactamente sobre el mismo modelo. Lo que cambia es la pregunta que la sección anterior señaló como lo genuinamente nuevo: quién decide qué pasa a continuación. En el primer sistema decides tú, mensaje a mensaje. En el segundo, tu código; el modelo solo rellena contenido a lo largo de una ruta que quedó fijada antes de que llegara el primer ticket. En el tercero decide el modelo: qué archivo leer, si editar o volver a ejecutar, cuándo parar. Esa pregunta —quién es el dueño del flujo de control— es toda la distinción, y nos da los tres términos de trabajo que este libro usa en todas partes. La figura 1.2 dibuja los tres uno junto a otro; solo se diferencian en quién decide el siguiente paso.
Un chatbot es una conversación turno a turno. La persona dirige cada paso; el modelo genera texto y espera. No hay bucle y no se ejecuta nada. Los chatbots son útiles de verdad y a menudo son la herramienta adecuada, y su superficie de fallo es pequeña de un modo que quiero dejar por escrito: lo peor que puede producir un chatbot es una respuesta equivocada, porque actuar sobre el mundo queda fuera de su alcance.
Un flujo de trabajo (workflow) son varias llamadas al modelo (y llamadas a herramientas) conectadas a lo largo de rutas que tu código define de antemano. El modelo rellena el contenido en cada paso —clasifica esto, redacta aquello—, pero es tu código el que decide qué paso viene después. Las formas recurrentes tienen nombres que volverás a encontrar en el capítulo 10: encadenamiento (la salida de una llamada alimenta la siguiente), enrutamiento (clasificar y después bifurcar) y paralelización (lanzar varias llamadas a la vez y después agregar sus resultados). El pipeline de tickets de antes es un flujo de trabajo, y podrías haber dibujado su diagrama de flujo antes de ponerlo en marcha.
Un agente le entrega al modelo el flujo de control. Un ensayo de ingeniería muy citado traza la línea exactamente aquí: los flujos de trabajo son «sistemas en los que los LLM y las herramientas se orquestan mediante rutas de código predefinidas», mientras que los agentes son sistemas en los que los modelos «dirigen dinámicamente sus propios procesos y su uso de herramientas»3 Erik Schluntz y Barry Zhang, «Building Effective Agents», blog de ingeniería de Anthropic (2024); ambas frases están citadas del ensayo, que también da nombre al bloque básico del LLM aumentado descrito en el párrafo siguiente. Un estudio panorámico anterior —Lilian Weng, «LLM Powered Autonomous Agents», lilianweng.github.io (2023)— describe la misma anatomía desde dentro: un modelo que hace de «cerebro», apoyado en la planificación, la memoria y el uso de herramientas.. El número de pasos, y qué paso viene en qué momento, no figura en ninguna parte de tu código; el modelo va eligiendo sobre la marcha, reaccionando a lo que acaba de observar. Por eso el sistema que arregla las pruebas parece otra cosa: su transcripción se lee como el registro de la tarde de un colega, y solo de lejos como la ejecución de un programa.
Debajo de los dos últimos está el mismo átomo, que merece un nombre porque con él se ensamblan los patrones que encontrarás en el capítulo 10. El LLM aumentado (augmented LLM) es una llamada al modelo reforzada con tres cosas: recuperación (traer información relevante en el momento de la solicitud), herramientas (funciones que puede solicitar) y memoria (alguna forma de llevar consigo lo que importa). Un flujo de trabajo son varios de estos átomos conectados por tu código a lo largo de una ruta fija. Un agente es uno de estos átomos colocado dentro de un bucle, donde decide por sí mismo qué hacer en cada vuelta. (Un chatbot, en esta imagen, es la llamada al modelo a secas, con las ampliaciones casi sin usar.) El mismo átomo, dos disposiciones: quédate con esa imagen y las taxonomías dejan de parecer misteriosas.
Esta es la prueba decisiva que usaré durante el resto del libro. Si puedes dibujar con aplomo el diagrama del flujo de control antes de que llegue la solicitud, tienes delante un flujo de trabajo. Si el diagrama solo puede dibujarse a posteriori, una vez que el modelo ha reaccionado a lo que encontró, tienes delante un agente.
Es tentador tratar chatbot, flujo de trabajo y agente como tres cajas. En realidad es un dial (figura 1.3). En un extremo, el modelo genera texto y una persona lo decide todo. Cerca de ese mismo extremo está el pipeline fijo (el sistema de tickets de hace un momento), en el que el código es dueño de cada paso y el modelo solo rellena contenido. Un pequeño paso más allá, un flujo de trabajo le concede al modelo una decisión: un enrutador elige qué rama fijada en el código atiende la solicitud. Más adelante, un agente itera libremente sobre sus herramientas pero se detiene a pedir aprobación humana antes de cualquier cosa con consecuencias —enviar el correo, gastar el dinero, borrar los datos—; buena parte de lo que hay en producción está aquí. En el extremo opuesto, el modelo es dueño del camino de principio a fin durante muchos pasos, sin confirmación en cada uno: máxima capacidad, máximo radio de impacto (blast radius) —el daño que una acción equivocada podría causar antes de que algo la detenga—, un término que el capítulo 17 precisará. Lo que se mueve a lo largo de este dial es una sola magnitud, cuánta parte del flujo de control está en manos del modelo, y los sistemas maduros eligen una posición deliberadamente en lugar de heredarla de una demo.
Una observación más antes de dejar la taxonomía, porque anticipa adónde llega este libro. Casi nada de lo que sale a producción es un flujo de trabajo puro o un agente puro. La forma dominante en producción es una carcasa de flujo de trabajo con uno o dos pasos genuinamente agénticos dentro: estructura predecible allí donde puedes predecir, y autonomía en manos del modelo solo en los puntos que no puedes enumerar. Estás ajustando un dial, paso a paso, y la siguiente sección trata de cuánto girarlo.
¿De verdad necesitas un agente?
Ahora que sabes distinguir un agente de un flujo de trabajo, te enfrentas a la pregunta que esta sección existe para hacer respetable: ¿necesitas uno siquiera? La planteo tan pronto a propósito. El error contra el que este campo más previene a los recién llegados es recurrir a un agente autónomo cuando un único prompt, un pipeline fijo o cincuenta líneas de código ordinario habrían sido más baratos, más rápidos y más fáciles de depurar. Una demo de un agente es algo seductor. Ves a un modelo planificar, actuar, recuperarse y terminar, y la conclusión natural es que ese poder tiene sitio en todas partes. Resiste la conclusión el tiempo suficiente para ponerle precio.
Frente a una sola llamada al modelo, un agente añade varios costos recurrentes, y llegan en paquete. Primero, el dinero: un agente hace muchas llamadas al modelo por tarea en lugar de una, y cada llamada reenvía la conversación, que no deja de crecer, de modo que el costo escala por partida doble: una vez por el número de llamadas y otra por el tamaño de cada una. Un bucle de diez pasos puede costar un orden de magnitud más que la única llamada a la que sustituyó (el multiplicador es ilustrativo; lo que importa es la dirección). Segundo, la latencia: las llamadas son secuenciales, cada una a la espera del último resultado de una herramienta, así que una respuesta de menos de un segundo se convierte en muchos segundos o en minutos; si hay una persona esperando al otro lado, esto por sí solo puede descartar el diseño. Tercero, el no determinismo: la misma entrada puede tomar un camino distinto y producir una respuesta distinta en cada ejecución, lo que rompe sin hacer ruido tus hábitos de prueba, depuración y auditoría4 Un análisis publicado sobre la fiabilidad de los agentes recoge tasas de éxito en una sola ejecución de alrededor del 60% que caen a aproximadamente el 25% cuando la misma tarea debe salir bien en ocho ejecuciones consecutivas; son cifras que ilustran la brecha de consistencia, no hechos permanentes. Fiddler AI, «AI Agent Failure Rate: Why 70–95% Fail in Production», blog de fiddler.ai (2026).. Y la superficie de fallo cambia de naturaleza, que es el costo que más quiero que sientas: el fallo acotado que la sección anterior le reconoció al chatbot es exactamente aquello a lo que un agente renuncia. Su error es una acción equivocada, seguida de diez acciones más construidas sobre ella, y el error se va componiendo bucle abajo exactamente como predice la aritmética de la brújula.
Hay otros dos costos que es fácil pasar por alto cuando la demo deslumbra. Dar herramientas y autonomía a un modelo amplía tu superficie de ataque; la comunidad de seguridad tiene un nombre para cuando se le da de más: agencia excesiva (excessive agency), es decir, más permisos, funcionalidad o libertad de los que la tarea requiere5 OWASP, «Top 10 for LLM Applications»: la entrada sobre Excessive Agency.. El peligro, además, va más allá de lo que concedes deliberadamente: el texto que un agente simplemente lee puede dirigir lo que hace a continuación, una familia de ataques llamada inyección de prompts (prompt injection) que el capítulo 17 examina. Por último, la carga operativa: un chatbot necesita un prompt, mientras que un agente necesita además el cableado de las herramientas, gestión del contexto, recuperación de errores, condiciones de parada, puntos de aprobación, trazas y evaluaciones. Esa maquinaria que lo rodea se llama harness, y construirla es la mayor parte del trabajo; un modelo brillante en un harness endeble falla en producción.
Así que la opción honesta por defecto es una escalera, que es el cuarto rumbo de la brújula llevado a la práctica, y la disciplina consiste en quedarte en el peldaño más bajo que resuelva tu problema. El peldaño inferior es código corriente —una expresión regular, una consulta SQL, una sentencia if—, gratis, instantáneo, determinista y auditable; si la lógica puede especificarse por completo, no hace falta ningún modelo. El siguiente peldaño es una única llamada al modelo bien trabajada, quizá con recuperación y unos cuantos ejemplos en el prompt; una fracción sorprendente de los «necesitamos un agente» se disuelve en «necesitábamos un prompt mejor». El peldaño de encima es un flujo de trabajo: varias llamadas por rutas que dibujaste de antemano. El peldaño más alto es un agente. Cada peldaño que subes compra adaptabilidad y la paga en costo, latencia e imprevisibilidad. Para un problema cuyos pasos puedes dibujar de antemano, un peldaño inferior es la respuesta correcta de forma permanente; quedarse ahí es la disciplina. La figura 1.4 dibuja la escalera: la adaptabilidad aumenta a medida que subes, y el costo aumenta con ella.
La prueba práctica es la de la sección anterior, usada ahora como ayuda para decidir: ¿puedes dibujar el diagrama de flujo antes de que llegue la solicitud? Si es así, detente en un flujo de trabajo o más abajo: los pasos conocidos, los requisitos de corrección auditables, los presupuestos ajustados de latencia o de costo y las tareas sencillas de consultar, clasificar y transformar apuntan todos escalera abajo. Lo que apunta escalera arriba es el objetivo genuinamente abierto: los pasos dependen de lo que el modelo descubra, y hace falta criterio en bifurcaciones que no puedes enumerar. Incluso entonces, exige el primer rumbo de la brújula en forma concreta: un criterio de éxito claro, una señal de retroalimentación en cada paso y un lugar sensato donde una persona pueda mirar. Un par concreto para calibrar: «enruta cada correo entrante a facturación, soporte técnico o ventas y redacta una primera respuesta» tiene pasos que se pueden conocer y un volumen alto, y pide un flujo de trabajo; «haz que pase esta prueba que falla en una base de código que nunca has visto» tiene pasos imposibles de conocer y un verificador incorporado, y es un auténtico problema de agente.
Una trampa merece párrafo propio, porque defiende con mucha elocuencia el diseño equivocado: «quizá algún día tenga que adaptarse». Eso es una hipótesis, y sale barato ponerla a prueba con honestidad: construye primero la versión más simple, mídela con casos reales y sube por la escalera solo cuando puedas señalar una clase de entradas en la que el sistema simple falla de forma demostrable y confirmar que un agente de verdad lo hace mejor. La trampa inversa es el agent-washing: como la palabra vende, pipelines con guion se reetiquetan como agentes. La pregunta que desactiva ambas es la prueba decisiva que ya tienes, aplicada al sistema que tienes delante, diga lo que diga su etiqueta: ¿decide el modelo el siguiente paso, o lo decide el código? El capítulo 14 vuelve a esta decisión con la ventaja de todo lo que hay en medio; el capítulo 16 muestra cómo hacer la medición.
Un agente, entonces, es un costo que pagas por una adaptabilidad a la que puedes poner nombre. Si no puedes ponérselo, guárdate el dinero. Y si puedes —si de verdad los pasos no se pueden dibujar de antemano y existe una señal que lo verifique—, entonces un agente es la herramienta adecuada, y los próximos capítulos tratan de construir uno bien. Antes, sin embargo, necesitas entender el motor que vamos a poner a dar vueltas: el capítulo 2 trata de lo que es en realidad un modelo de lenguaje.