Cómo funciona un agente de IA: un modelo de lenguaje en un bucle con herramientas

El bucle razonamiento – llamada a herramienta – resultado sobre una tarea real con los artículos de esta web, tres enfoques y su coste en tokens, por qué crece el contexto, plan y memoria, la fiabilidad de las tareas largas con y sin comprobación, y por qué un agente necesita aprobación.

11 minutos Matěj Žalmánek 2026-10-16

Serie Fundamentos de IA Parte 50 de 52

1. Mapa de la inteligencia artificial: qué es cada cosa y cómo encaja todo
2. Breve historia de la inteligencia artificial: de Turing a los modelos de lenguaje
3. Datos, modelo, entrenamiento, inferencia: los conceptos básicos en un solo ejemplo
4. Cómo leer la notación matemática: símbolos, subíndices, sumatorios y cuantificadores
5. Conjuntos y relaciones: las piezas con las que se construyen las definiciones en IA
6. Funciones y aplicaciones: por qué todo modelo de IA es una función
7. Lógica y demostraciones: las reglas con las que se razona en IA
8. Grafos y árboles: la estructura sobre la que se apoyan la búsqueda y las redes neuronales
9. Álgebra lineal para aprendizaje automático: vectores, matrices y por qué la IA sobre todo multiplica
10. Derivadas, gradiente y regla de la cadena: cómo sabe un modelo en qué dirección aprender
11. Descenso de gradiente: cómo aprende un modelo
12. Qué es la probabilidad: del lanzamiento de un dado a los axiomas de Kolmogórov
13. Probabilidad condicionada y teorema de Bayes: cómo cambiar una estimación cuando te enteras de algo nuevo
14. Variable aleatoria y función de distribución: una sola función que lo dice todo sobre la distribución
15. Función de densidad y función de probabilidad: por qué una variable continua tiene probabilidad cero en cada punto
16. Esperanza, varianza y covarianza: dónde está una distribución, qué anchura tiene y qué se relaciona con qué
17. Resumen de las distribuciones de probabilidad: Bernoulli, binomial, Poisson, uniforme, normal y exponencial
18. Ley de los grandes números y teorema central del límite: por qué las medias se comportan de forma tan predecible
19. Estadística y estimación de parámetros: máxima verosimilitud, MAP e intervalos de confianza
20. Teoría de la información: entropía, entropía cruzada y divergencia KL, el origen de las funciones de pérdida
21. Búsqueda en el espacio de estados: BFS, DFS, UCS y A* con animaciones
22. Juegos y adversarios: minimax, poda alfa-beta y Monte Carlo tree search
23. Satisfacción de restricciones: backtracking, propagación de restricciones y AC-3 con un sudoku y un mapa de regiones checas
24. Lógica y sistemas basados en conocimiento: encadenamiento hacia delante y hacia atrás, resolución y sistemas expertos
25. Planificación: STRIPS, el mundo de bloques, heurísticas a partir de la relajación y la planificación en los agentes de IA
26. Búsqueda local y recocido simulado: un viajante por las capitales regionales checas
27. Algoritmos genéticos: población, cruce, mutación y selección en una mochila para la excursión
28. Estrategias evolutivas y programación genética: de la regla de un quinto a la ley de Kepler
29. Optimización por colonia de hormigas: cómo un rastro de feromona encuentra un camino corto
30. Optimización por enjambre de partículas: inercia, experiencia propia y experiencia del enjambre
31. Neuroevolución: evolución de los pesos y la forma de las redes neuronales, y el algoritmo NEAT
32. Conjuntos difusos y funciones de pertenencia: cómo escribir «algo cálido»
33. Lógica difusa y probabilidad: por qué «algo cálido» no significa «probablemente cálido»
34. Lógica difusa: t-normas, implicaciones y reglas SI–ENTONCES
35. Control difuso: Mamdani y Sugeno, del ventilador al péndulo invertido sobre un carro
36. Agrupamiento difuso: el algoritmo fuzzy c-means y los puntos entre clusters
37. Sistemas neuro-difusos (ANFIS): reglas difusas que aprenden de los datos
38. Cadenas de Markov: matriz de transición, distribución estacionaria y PageRank
39. Modelos ocultos de Márkov: el algoritmo de Viterbi y el casino deshonesto
40. Redes bayesianas: por qué está mojada la hierba y qué significa eso para el aspersor
41. El filtro de Kalman: cómo estimar a partir de mediciones imprecisas dónde está un coche y a qué velocidad va
42. Tipos de aprendizaje automático: supervisado, no supervisado, semisupervisado y más
43. Prompts, contexto y RAG: cómo darle a un modelo la información correcta
44. Autocodificadores variacionales (VAE): imágenes nuevas a partir de un espacio latente continuo
45. Redes generativas adversarias (GAN): el falsificador contra el detective
46. Modelos de difusión: cómo el ruido puro se convierte en una imagen
47. Procesos de decisión de Markov: estados, acciones, recompensas y ecuaciones de Bellman
48. Q-learning y DQN: aprender el valor de las acciones, de la tabla a la red neuronal
49. Gradiente de la política y PPO: aprender directamente la política
50. Cómo funciona un agente de IA: un modelo de lenguaje en un bucle con herramientas
51. Programación con agentes de IA: encargo, pruebas y revisión
52. Evaluación y seguridad de los sistemas de IA: cómo medir y cómo vigilar

Temario completo de la serie 52 de 83 temas publicados

Un modelo de lenguaje por sí solo solo responde: recibe texto y devuelve texto. Un agente es un modelo al que le damos manos —herramientas con las que puede averiguar o hacer algo— y al que dejamos trabajar en un bucle hasta que termina la tarea. Así funcionan los agentes de programación, que leen código, ejecutan pruebas y corrigen errores por su cuenta, y los asistentes que buscan en la web. Y así funciona también el agente que tú controlas desde el móvil con coden. En esta parte desmontamos el bucle sobre una tarea real y calculamos cuánto cuesta y dónde se rompe.

Continúa las partes Prompts, contexto y RAG, Tokenización y Procesos de decisión de Markov.

1. Un modelo en un bucle

Definición — agente de IA

Un agente es un programa en el que un modelo de lenguaje repetidamente (1) recibe la tarea y lo ocurrido hasta ahora, (2) decide qué hacer a continuación —llamar a una herramienta o responder—, (3) el programa anfitrión ejecuta de verdad la herramienta y añade el resultado al contexto. El bucle termina cuando el modelo escribe una respuesta final o se agota el presupuesto de pasos. La alternancia de razonamiento y acción la describieron Shunyu Yao et al. (2022) con el nombre ReAct (reason + act).

v_k = M(c_k),   c_k+1 = c_k ⊕ v_k ⊕ N(v_k)

c_k

el contexto antes de la k-ésima llamada al modelo: el prompt de sistema, la tarea y todo lo que ha pasado hasta ahora. Es todo el «estado» del agente: el modelo no recuerda nada más

M

el modelo de lenguaje; a partir del contexto escribe el siguiente paso. La única parte que «piensa», y la única de la que uno no se puede fiar del todo

v_k

el paso del modelo: razonamiento y llamada a una herramienta, o la respuesta final (entonces el bucle termina)

N(v_k)

el resultado de la herramienta, calculado por el programa anfitrión; añade al contexto lo que el modelo no puede saber por sí mismo (el contenido de un archivo, la salida de las pruebas)

kontext = [prompt de sistema, descripción de herramientas, tarea]
for k = 1 … K_max:                       # presupuesto de pasos
    krok = model(kontext)                # lee TODO el contexto
    kontext += krok
    if krok es la respuesta final: return la respuesta
    if la herramienta necesita aprobación y la persona no la dio:
        kontext += "denegado"; continue
    výsledek = proveď(krok.nástroj, krok.parametry)   # programa anfitrión
    kontext += výsledek
return "presupuesto de pasos agotado"

2. Herramientas

Definición — llamada a herramientas (tool use, function calling)

En el prompt se inserta una descripción de las herramientas: el nombre, para qué sirve y qué parámetros tiene (normalmente como esquema JSON). El modelo está ajustado para que, en lugar de texto corriente, sepa devolver una llamada estructurada, por ejemplo {"nastroj": "hledej", "text": "KL divergence"}. El programa anfitrión comprueba la llamada, la ejecuta y devuelve el resultado como otro mensaje. El modelo no ejecuta nada por sí mismo: solo escribe qué se debe ejecutar.

Nuestro agente trabaja sobre los textos de 21 artículos antiguos de esta web (los mismos que en las partes sobre tokenización y RAG; están en checo, así que el agente también trabaja en checo) y tiene tres herramientas. Todo su prompt de sistema tiene 157 tokens:

Jsi agent, který odpovídá na otázky podle článků webu. Máš nástroje:
- seznam(): Vypíše články a jejich délku ve znacích.
- hledej(text, max): Najde výskyty textu ve všech článcích; vrátí článek, pozici a okolí.
- cti(clanek, od, do): Vrátí úsek článku od pozice do pozice (znaky).
V každém kroku napiš krátkou úvahu a zavolej jeden nástroj, nebo napiš konečnou odpověď s odkazem na článek. Když něco nenajdeš, zkus jiný dotaz.

Las herramientas reales de los agentes de programación son parecidas: buscar en archivos, leer un fragmento de un archivo, editarlo, ejecutar un comando en el terminal. Desde 2024 las herramientas también se pueden conectar mediante el protocolo común MCP (Model Context Protocol), de modo que la misma herramienta —una base de datos, un calendario, un navegador— puede usarla cualquier agente.

3. Una pregunta, tres enfoques

La pregunta: «¿Por qué la divergencia KL no es una distancia? Pon un ejemplo de los artículos». (en el original: «Proč KL divergence není vzdálenost? Uveď příklad z článků.»). La respuesta está en el artículo sobre teoría de la información: la divergencia KL no es simétrica, D_KL(0,7 ‖ 0,5) = 0,119, pero D_KL(0,5 ‖ 0,7) = 0,126. Los pasos del agente los escribimos a mano: en lugar del modelo escribimos los razonamientos y las llamadas. Pero las herramientas, sus resultados y los tokens son reales.

Ejemplo — por qué D_KL(0,7 ‖ 0,5) ≠ D_KL(0,5 ‖ 0,7)

Para dos distribuciones sí/no (lluvia con probabilidad p, el modelo dice q), D_KL(p ‖ q) = p log₂(p/q) + (1 − p) log₂((1 − p)/(1 − q)) bits.

D_KL(0,7 ‖ 0,5) = 0,7 · log₂ 1,4 + 0,3 · log₂ 0,6 = 0,340 − 0,221 = 0,119.

D_KL(0,5 ‖ 0,7) = 0,5 · log₂(5/7) + 0,5 · log₂(5/3) = −0,243 + 0,368 = 0,126.

Cada vez se promedia según una distribución distinta (según cuál sea la realidad), por eso intercambiar los argumentos da otro número, y una distancia (una métrica) tiene que ser simétrica. Esta es la respuesta que busca el agente.

1. Busco exactamente las palabras de la pregunta.

   hledej(text: "KL divergence není metrika")

   nic nenalezeno

   +34 tokens, contexto 209

2. Nada. Probaré solo con el nombre del concepto.

   hledej(text: "KL divergence")

   5 výskytů:
   informace:3258: … minimum je tam, kde model říká pravdu. KL divergence Definice — Kullbackova–Leiblerova diver…
   informace:3656: …,222 bitu. Podle Gibbsovy nerovnosti je KL divergence vždy nezáporná a nulová jen pro q = p .…
   informace:3717: …záporná  … (310 caracteres más)

   +205 tokens, contexto 414

3. Está en el artículo informace. Leeré los alrededores.

   cti(clanek: "informace", od: 3660, do: 3960)

   ivergence vždy nezáporná a nulová jen pro q = p . Pozor, KL divergence není vzdálenost: není symetrická. D KL (0,7 ‖ 0,5) = 0,119, ale D KL (0,5 ‖ 0,7) = 0,126. Záleží na tom, co je skutečnost a co model. Informační zisk Definice — podmíněná entropie H ( Y | X … (40 caracteres más)

   +146 tokens, contexto 560

Tres llamadas a herramientas, y la cuarta llamada al modelo escribe la respuesta. La primera búsqueda no encuentra nada: las palabras de la pregunta no están en el texto. El agente lo ve y prueba una consulta más general; esa es la ventaja del bucle frente a una recuperación única. Al final el contexto tiene 560 tokens.

1. No sé dónde está. Recorreré los artículos uno tras otro.

   cti(clanek: "co-je-pravdepodobnost")

   Jazykový model nevybírá další slovo, ale pravděpodobnosti všech slov. Klasifikátor neříká „je to kočka“, ale „s pravděpodobností 0,93 je to kočka“. Celé strojov … (7 175 caracteres más)

   +1 933 tokens, contexto 2 108

2. Aquí no está, siguiente artículo.

   cti(clanek: "csp")

   Rozvrh hodin, ve kterém žádný učitel neučí dvě třídy naráz. Sudoku. Rozmístění součástek na desce, směny v nemocnici, přidělení letadel k branám. Všechny tyhle  … (11 914 caracteres más)

   +3 148 tokens, contexto 5 256
3. … 8 pasos más del mismo tipo (contexto al final: 24 927 tokens)

Sin buscar, el agente recorre los artículos en orden alfabético. No da con la respuesta hasta el artículo número 10, y mientras tanto el contexto crece hasta 24 927 tokens.

Y el tercer enfoque, RAG de un solo paso de la parte anterior: recuperar los tres fragmentos más parecidos e insertarlos en el prompt. Los tres fragmentos proceden del artículo correcto (informace, informace, informace), pero ninguno contiene el ejemplo con los números 0,119 y 0,126: la respuesta quedaría sin ejemplo. Un agente en un bucle puede decirse «esto no basta, sigo leyendo». Una recuperación única, no.

4. El contexto es caro

Definición — el coste del bucle

El modelo no tiene memoria entre llamadas; en cada paso vuelve a leer todo el contexto: el prompt de sistema, la tarea y todos los pasos y resultados de herramientas hasta ahora. Si c_k es la longitud del contexto antes de la k-ésima llamada, el modelo procesa en total ∑_k c_k tokens. Como el contexto crece con cada paso, el coste total crece aproximadamente con el cuadrado del número de pasos.

El enfoque «lee todo» cuesta 141 820 tokens procesados; «busca y lee un fragmento», solo 1 358: 104 veces menos, y para la misma respuesta. Por eso los buenos agentes de programación primero buscan (grep) y leen solo trozos de archivos. Y por eso una sesión larga se compacta de vez en cuando: la parte más antigua de la conversación se sustituye por un resumen, para que el contexto quepa y el modelo no se pierda en él. También ayuda guardar el comienzo del prompt en caché (prompt caching), con lo que releer el mismo comienzo sale más barato.

Z = ∑_k=1^K c_k,   c_k = c₁ + ∑_j<k (v_j + o_j)

Z

tokens procesados en total: lo que se paga y lo que se espera

K

número de llamadas al modelo (pasos con herramienta + respuesta final); cada llamada vuelve a leer el contexto desde el principio

c₁

el prompt de sistema y la tarea; están en el contexto desde la primera llamada, así que se pagan K veces; por eso conviene que sean cortos y guardarlos en caché

v_j + o_j

los tokens que añadió el paso j: la llamada y el resultado de la herramienta. El paso j se lee en todas las llamadas posteriores, por eso un resultado largo de una herramienta se paga muchas veces

Teorema — el coste crece con el cuadrado del número de pasos

Si cada paso añade los mismos d tokens, entonces c_k = c₁ + (k − 1) d y

Z = K c₁ + d · K(K − 1) / 2.

Demostración: ∑_k=1^K (k − 1) = 0 + 1 + … + (K − 1) = K(K − 1) / 2. ∎ Para K grande domina el segundo término ≈ d K² / 2: una sesión el doble de larga cuesta aproximadamente cuatro veces más.

Ejemplo — recálculo de ambos enfoques

Busca y lee un fragmento. El prompt de sistema tiene 157 tokens, la pregunta 18, así que c₁ = 175. Tras los tres pasos el contexto tiene 209, 414, 560 tokens. Las cuatro llamadas al modelo leen Z = 175 + 209 + 414 + 560 = 1 358 tokens.

Lee todo. K = 11 llamadas, el contexto crece de 175 a 24 927 tokens, de media d = (24 927 − 175) / 10 ≈ 2 475 por paso. Según el teorema, Z ≈ 11 · 175 + 2 475 · 11 · 10 / 2 = 138 050; la realidad es 141 820 (los artículos tienen longitudes distintas, así que los pasos no añaden exactamente lo mismo). El prompt de sistema con la pregunta supone solo 1 925 tokens de eso: casi todo es releer los artículos.

5. Plan y memoria

Definición — planificación y memoria del agente

Un plan es una lista de pasos que el agente escribe al principio en el contexto y que va tachando y ajustando sobre la marcha. La memoria de trabajo es el contexto de una sola sesión. La memoria a largo plazo son archivos o bases de datos fuera del modelo: notas que el agente escribe y lee en la siguiente sesión. Los subagentes reciben un contexto propio para una subtarea y devuelven solo el resultado, así que no llenan el contexto principal de detalles.

En los agentes de programación, la memoria a largo plazo suele ser un simple archivo de texto en el proyecto (reglas, comandos, cosas a tener en cuenta) que el agente lee al principio de cada sesión. Es la memoria más simple y más transparente: una persona puede leerla y también corregirla.

6. Tareas largas y comprobación

Un agente que da el paso correcto en el 90 % de los casos parece fiable. Pero una tarea consta de muchos pasos, y un error en cualquiera de ellos la estropea. Si un paso sale bien con probabilidad p, toda la tarea de n pasos sale bien con probabilidad pⁿ, siempre que el agente no reconozca sus errores.

Definición — bucle cerrado con retroalimentación

Tras un paso, el agente comprueba el resultado (ejecuta las pruebas, lee la salida de un comando, lo compara con lo esperado). Si reconoce un error con probabilidad d y puede repetir un paso hasta r veces, la tasa de éxito de un paso es q = p ∑_k=0^r ((1 − p) d)^k y la de toda la tarea, qⁿ.

q = p ∑_k=0^r ((1 − p) d)^k = p + p (1 − p) d + p ((1 − p) d)² + …

p

el intento sale bien; cada sumando termina con exactamente un intento logrado

1 − p

el intento falla; cada fallo antes del éxito cuesta un factor así

d

la comprobación reconoce el fallo; solo entonces el agente repite el paso: un error no reconocido pasa adelante y estropea la tarea

∑_k=0^r, k

k = cuántos intentos fallaron antes de que uno saliera bien; como mucho r repeticiones, para que el agente no lo intente eternamente

Con p = 0,9 y veinte pasos, sin comprobación solo sale bien el 12 % de las tareas; con comprobación, el 79 %. Una simulación de 20 000 tareas da el 12 % y el 79 %: la fórmula encaja. Incluso un paso muy bueno (p = 0,99) falla con cien pasos sin comprobación más a menudo de lo que acierta (37 %); con comprobación acierta en el 90 %. Esta es la razón principal por la que los agentes de programación funcionan tan bien: el código se puede ejecutar y probar, así que casi cada paso tiene retroalimentación. La organización METR (2025) mide que la longitud de las tareas que los agentes resuelven en la mitad de los casos se duplica aproximadamente cada siete meses.

Ejemplo — p = 0,9, d = 0,9, r = 2, veinte pasos

Tasa de éxito de un paso: q = 0,9 + 0,9 · 0,1 · 0,9 + 0,9 · (0,1 · 0,9)² = 0,9 + 0,081 + 0,00729 = 0,98829.

Toda la tarea: sin comprobación 0,9²⁰ = 0,122, con comprobación 0,98829²⁰ = 0,790. El paso solo mejoró del 90 % al 98,8 %, pero la tarea pasó del 12 % al 79 %: la potencia n infla las pequeñas diferencias de un paso.

Definición — la longitud de tarea que un agente resuelve en la mitad de los casos

Es el mayor n para el que qⁿ ≥ 1/2, es decir, n_½ = ln 0,5 / ln q ≈ 0,69 / (1 − q) para q cercano a 1.

En nuestro modelo: p = 0,9 sin comprobación 6,6 pasos, con comprobación 58,8; p = 0,99 sin comprobación 69,0, con comprobación 686. La tarea que un agente resuelve la mitad de las veces se alarga aproximadamente en proporción a cuántas veces baja la tasa de error de un paso 1 − q.

La misma magnitud (la longitud de tarea que un agente resuelve en el 50 % de los casos) la mide METR, solo que no en pasos, sino en el tiempo que la tarea le llevaría a una persona (Thomas Kwa et al., Measuring AI Ability to Complete Long Tasks, 2025). Nuestra fórmula es un modelo simplificado con pasos independientes, no su método.

7. Permisos y supervisión

Un agente que puede ejecutar comandos también puede hacer daño: por error (borra la carpeta equivocada) o siguiendo una instrucción que leyó en un texto ajeno (prompt injection). La defensa no se apoya en el modelo, sino en el programa anfitrión: herramientas con derechos limitados, ejecución en un entorno aislado y, sobre todo, aprobación: los pasos peligrosos o irreversibles solo se ejecutan tras el consentimiento de una persona. En eso se basa también coden: el agente trabaja en tu ordenador y tú apruebas sus pasos desde el móvil.

8. Resumen

• Agente = un modelo de lenguaje en un bucle: razonamiento, llamada a una herramienta, resultado al contexto, otra vez.
• El modelo solo describe las herramientas con una llamada estructurada; las ejecuta el programa anfitrión, que puede imponer reglas.
• Un bucle puede corregir una búsqueda fallida; el RAG de un solo paso, no.
• Cada llamada lee todo el contexto: «lee todo» costó 141 820 tokens, «busca y lee un fragmento», 1 358.
• Un plan, notas en archivos y subagentes mantienen el contexto pequeño y ordenado.
• Sin comprobación, la tasa de éxito cae con la longitud de la tarea como pⁿ; las pruebas y la verificación lo cambian (20 pasos con p = 0,9: 12 % → 79 %).

¿Quieres probarlo tú mismo? Pide a un agente de IA que te describa cada llamada a herramienta que haga durante una tarea y que al final estime cuántos tokens le ha costado. Luego dale la misma tarea con la instrucción «primero busca, lee solo fragmentos».

¿Lo ves de otra manera? Escribe a support@coden-app.com.