Transcript
00:00:00Hay un nuevo término circulando y puede que ya lo hayas escuchado. Se llama ingeniería de bucles
00:00:04y, al igual que cualquier otro término de moda, todos hablan de ello como si fuera algo nuevo. No lo es,
00:00:09pero cuando lo combinas con un agente que siempre está en ejecución como Hermes, deja de ser solo publicidad.
00:00:13La mayoría de las personas que intentan configurarlos aciertan con el bucle pero pasan por alto lo que realmente
00:00:17hace que funcione. Y si ya sabes que hay dos tipos de bucles, hay una configuración específica dentro
00:00:22de uno de ellos que casi nadie está haciendo. Una vez que la ves, tu forma de pensar sobre construir con agentes
00:00:27cambia por completo. Al final de este video entenderás exactamente qué es y lo tendrás
00:00:31ejecutándose en Hermes e incluso en Claude Code sin que tengas que intervenir en absoluto. Con la ingeniería de bucles
00:00:36la idea central es simple. Dejas de ser la persona que escribe el prompt que dirige al agente y
00:00:41en su lugar, dejas que el agente se dirija a sí mismo. Pero para ver por qué es un cambio, primero debes
00:00:46compararlo con lo que vino antes. La habilidad que solía importar era la ingeniería de prompts, donde toda nuestra atención
00:00:51se centraba en escribir la serie correcta de instrucciones para manejar adecuadamente al agente de programación, pero la ingeniería de bucles
00:00:56le da la vuelta a eso. En lugar de escribir el prompt tú mismo, diseñas el sistema que hace la
00:01:01ingeniería de prompts por ti y dirige al agente por sí solo, por lo que el enfoque se aleja de crear
00:01:05instrucciones y se dirige hacia el diseño de sistemas que funcionan por sí mismos. Todo esto comenzó cuando el creador
00:01:10de OpenClaw dijo que ya no deberías estar dando prompts a tus agentes de programación y que deberías enfocarte
00:01:15en diseñar bucles que den prompts al agente por ti, y no es el único. Boris, que es el creador de
00:01:20Claude Code, también hizo la misma afirmación en la conferencia anual de desarrolladores de Anthropic, donde dijo que
00:01:25ya no le da prompts a Claude. Tiene bucles ejecutándose que dan prompts a Claude y este averigua por sí mismo
00:01:30qué es lo que se debe hacer. Entonces, la pregunta es, ¿cómo empiezas con ellos? Todo se reduce a
00:01:34qué tan bien puedes configurar sistemas donde no tengas que preocuparte por darle prompts al agente en absoluto.
00:01:39Tú defines lo que necesitas y el agente hace el resto. Ahí es exactamente hacia donde se dirige el desarrollo impulsado por IA.
00:01:45Antes de ver cómo construirlos realmente, debes tener claro qué es un bucle. Un bucle es
00:01:50básicamente un proceso donde defines el objetivo final y el agente averigua los pasos para alcanzarlo por su
00:01:56cuenta. Se corrige a sí mismo en el camino y trabaja en torno a los problemas hasta que alcanza el objetivo que estableciste.
00:02:01Hace unos meses, antes de que los modelos fueran lo suficientemente capaces para mantener tareas largas, esto no era posible. Si
00:02:06necesitabas construir una aplicación, le dabas un prompt al agente, monitoreabas lo que estaba haciendo, verificabas el resultado tú mismo,
00:02:11encontrabas los problemas y volvías a dar un prompt para solucionarlos. Tú eras el bucle. Tú eras la parte que hacía la
00:02:16verificación de errores y la corrección de rumbo entre cada paso. Así es como todavía se ve el desarrollo para la mayoría
00:02:20de las personas y eso es exactamente lo que la ingeniería de bucles está a punto de quitar de tu plato. Ahora, esto podría
00:02:25sonar como un concepto nuevo, pero los bucles han existido desde hace tiempo. Los trabajos cron (cron jobs) son
00:02:30un buen ejemplo de un bucle que probablemente ya hayas visto. Son solo tareas programadas para ejecutarse repetidamente
00:02:35y automáticamente sin que tengas que activarlos cada vez. La única diferencia real es que un
00:02:39trabajo cron se ejecuta a una hora fija. Así que con los bucles en su lugar, el trabajo deja de ser escribir el prompt.
00:02:44El rendimiento de tu agente en una tarea se reduce a qué tan bien defines el objetivo final. Para algunos de ustedes, este
00:02:49proceso sonará mucho al aprendizaje por refuerzo. Si no te has encontrado con él, el aprendizaje por refuerzo
00:02:54es básicamente una forma de entrenar un modelo donde no le muestras las respuestas correctas. En su lugar, solo le dices
00:02:59cuándo lo hizo bien y cuándo no, y gradualmente averigua cómo mejorar por sí mismo.
00:03:04El modelo encuentra el camino correcto probando diferentes cosas. Recibe una señal positiva cuando se mueve en
00:03:09la dirección correcta y una negativa cuando no lo hace. La misma idea se aplica aquí, excepto que el modelo en sí
00:03:14no es lo que se está entrenando. En su lugar, el agente está trabajando para completar la tarea que deseas,
00:03:19iterando en ella de la misma manera que un modelo mejoraría durante el entrenamiento. Si falla, el bucle que
00:03:23has puesto en el agente no marca la tarea como hecha. Intenta de nuevo, sigue adelante y se corrige a sí mismo hasta
00:03:28que alcanza el objetivo que estableciste. Ahora, después de escuchar todo esto, podrías preguntarte qué queda realmente para ti
00:03:33que hacer si todo se está volviendo autónomo. Pero tu papel no se reduce, se vuelve más importante.
00:03:38Porque es tu conocimiento del dominio y experiencia los que definen el objetivo final en primer lugar y
00:03:43eso termina notándose en todo lo que construyes y lanzas. Esta es exactamente la razón por la que el impulso hacia los bucles
00:03:48autónomos solo está acelerando y se está notando en cada nueva función que sale en este momento. Fable 5 es el
00:03:54ejemplo más claro hasta ahora. Anthropic lo lanzó a pesar de que habían estado pidiendo una desaceleración en el desarrollo
00:03:59de la IA porque los modelos se están volviendo capaces a un ritmo que es difícil de seguir. Y después de
00:04:03lanzarlo durante algún tiempo, incluso lo retiraron. Lo construyeron para tareas largas y complejas y
00:04:08funciona mejor cuanto más larga y compleja se vuelve la tarea, lo cual es básicamente lo opuesto a cómo los modelos
00:04:13solían trabajar. Este cambio realmente comenzó con Opus 4.5. Una vez que salió, las tareas de ejecución larga
00:04:19mejoraron dramáticamente. Y ya no necesitabas configurar agentes con arneses cuidadosamente guiados,
00:04:23básicamente configuraciones estructuradas que guían al agente a través de cada paso. El enfoque se movió en cambio hacia
00:04:28preparar el proyecto para ejecutarse a largo plazo porque los modelos ahora son lo suficientemente capaces de
00:04:33manejar las cosas por sí mismos sin mucha guía paso a paso. Pero el bucle no es lo único que
00:04:38importa. También necesitas estructurar tu proyecto de una manera que permita al agente trabajar por sí mismo durante
00:04:43mucho tiempo sin que tengas que intervenir. Así que muchas personas han estado construyendo y abriendo sistemas de código fuente
00:04:48para exactamente este tipo de configuración. El bucle RALF fue uno de los primeros. Funcionaba definiendo el objetivo final
00:04:53y asegurándose de que el agente no pudiera alejarse de él. Lo hacía a través de ganchos (hooks), que son básicamente
00:04:57scripts que se ejecutan automáticamente cuando sucede algo específico. Así que este script impide estrictamente que el agente marque
00:05:03una tarea como terminada a menos que realmente hubiera cumplido la condición. Pero los ganchos son rígidos, así que Claude introdujo su propio comando de objetivo,
00:05:09que hacía lo mismo pero con más flexibilidad. En lugar de una verificación codificada, permite que
00:05:14otro modelo decida si la tarea realmente está terminada. Cubrimos Goal Buddy 2, que construyó sobre
00:05:19eso haciendo que el agente rastree su progreso en archivos locales y defina exactamente qué significa 'terminado'
00:05:24antes de siquiera comenzar, para que siempre sepa hacia qué está trabajando. El agente Hermes y OpenClaw fueron ambos
00:05:29construidos sobre la misma filosofía. Te sacan de la imagen por completo y dejan que el agente maneje todo
00:05:35por sí mismo. Ahora, si quieres construir estos bucles, tenemos un sistema simple de cinco pasos para ti, y ya que
00:05:40hay dos tipos de bucles, algunos de esos pasos funcionan un poco diferente, pero entraremos en ambos tipos
00:05:45más adelante. Por ahora, comenzaremos en Claude Code y más adelante en el video, veremos cómo hacer lo mismo
00:05:49en el agente Hermes. El primer paso es verificar en qué estado se encuentra el proyecto. A partir de ahí, el modelo
00:05:54decide cuál debería ser la siguiente acción. Luego actúa sobre esa decisión, y aquí es donde el trabajo real
00:05:59sucede. El agente llama a herramientas, escribe en archivos y ejecuta comandos para hacer la tarea. Una vez que eso
00:06:04termina, recopila comentarios para ver qué sucedió realmente y, basado en eso, decide si la
00:06:09tarea está terminada o no. Aquí es también donde la diferencia entre la ingeniería de prompts y la ingeniería de bucles se vuelve
00:06:14obvia. Con la ingeniería de prompts, solo controlas el paso de decisión, mientras que la ingeniería de bucles
00:06:19maneja los cinco juntos. Construir un bucle que funcione bien significa hacer bien un puñado de cosas y
00:06:24cada una está ahí debido a un problema específico que resuelve. Lo primero es la gestión del contexto. Prestas
00:06:29atención a lo que entra en el contexto en cada turno porque eso es lo que determina lo que el agente
00:06:34realmente sabe en cualquier punto dado. No puedes confiar solo en el contexto del chat, incluso con ventanas de contexto
00:06:39tan grandes como un millón de tokens, básicamente cuánto puede retener el agente en memoria a la vez, porque a medida que la
00:06:44conversación crece, tu prompt del sistema y las instrucciones quedan enterrados bajo los resultados recientes de las herramientas. La atención del agente
00:06:50naturalmente se dirige hacia lo más reciente, por lo que las cosas importantes se pierden. Por eso
00:06:55la gestión del contexto importa tanto. Lo siguiente que hay que hacer bien es la calidad de los comentarios (feedback). El feedback es lo que le dice
00:07:00al agente cómo lo hizo y es una de las señales más importantes en todo el sistema. Puede tomar muchas
00:07:05formas, como el resultado de una prueba o una captura de pantalla de la interfaz que acaba de construir, y cualquiera que sea la forma que tome,
00:07:11eso es lo que el agente lee para averiguar su siguiente movimiento. Las puertas de verificación son lo que convierten ese feedback
00:07:16en un veredicto claro. Son los puntos de control que le dicen al agente si una tarea realmente está terminada o
00:07:21no. También necesitas una condición de terminación, básicamente una regla que le diga al bucle cuándo detenerse, y esta
00:07:26debe configurarse explícitamente, de lo contrario el agente renuncia demasiado pronto o sigue adelante sin hacer un progreso
00:07:31real. Lo que la gente suele pasar por alto es el manejo de errores. Tienes que explicar qué debería hacer el modelo
00:07:36cuando una llamada de herramienta falla, para que el sistema lo maneje limpiamente en lugar de dejar las cosas en
00:07:41un estado roto que solo crea más problemas. Y finalmente, necesitas gestionar el estado a través de los turnos,
00:07:46básicamente mantener un registro de dónde está la tarea a medida que crece la conversación. La ventana de contexto no puede retener
00:07:51todo para siempre, por lo que te apoyas en archivos externos que rastrean información para el agente y le permiten seguir
00:07:57trabajando sin perder el hilo. Una cosa a tener en cuenta, sin embargo, dado que estás entregando el trabajo de
00:08:01averiguar el camino al modelo en lugar de hacerlo tú mismo, los bucles se vuelven costosos en tokens,
00:08:06así que debes ser deliberado sobre cuándo los usas realmente. Cuantos más tokens un bucle pueda
00:08:11manejar, mejor tiende a manejar la tarea. Pero antes de seguir adelante, tengamos unas palabras de
00:08:15nuestro patrocinador, Scrimba. La mayoría de los cursos de Python son solo alguien hablando sobre diapositivas. Scrimba es diferente,
00:08:21su reproductor de video es el editor de código, por lo que puedes pausar en cualquier momento, editar el código del instructor directamente,
00:08:26y ver qué sucede. Sin cambios de pestaña, sin copiar y pegar, solo programación práctica desde el principio.
00:08:31Su nuevo curso 'Aprende Python' me llamó la atención porque en lugar de ejercicios aleatorios, realmente
00:08:37construyes algo real. Desde el día uno, estás construyendo PayUp, una aplicación totalmente funcional para dividir gastos,
00:08:42y cada concepto se aplica inmediatamente. Comienzas desde cero absoluto, no se necesita conocimiento previo de Python,
00:08:47y trabajas a través de variables, cadenas, captura de entrada de usuario, operadores aritméticos, conversión de tipos,
00:08:53limpieza de datos y formato de números, todo construyendo características para la aplicación. Al final,
00:08:57has construido un proyecto funcional desde cero que demuestra que realmente sabes Python. Esta es solo la parte
00:09:02uno de varias que estarán disponibles en las próximas semanas, y actualmente, es totalmente gratuito para
00:09:07acceder. Comienza hoy con sus cursos gratuitos, y nuestros usuarios obtendrán un 20% de descuento adicional en sus planes pro.
00:09:12Así que haz clic en el enlace en el comentario fijado, o escanea el código QR, y comienza a construir hoy.
00:09:18Como mencionamos, hay dos tipos de bucles. El primero se llama bucle determinista. Lo usas
00:09:23para tareas que tienen una definición clara de cómo se ve 'terminado', eso podría ser pruebas pasando,
00:09:28código compilando exitosamente, o cualquier cosa por el estilo. Estos bucles son bastante sencillos de trabajar
00:09:33hacia ellos, porque el objetivo final es claro, por lo que el modelo sabe exactamente lo que necesita hacer antes de poder llamar
00:09:38a la tarea como terminada. Como Hermes siempre está en ejecución, es un agente realmente bueno para implementar este bucle. Hemos
00:09:43creado múltiples flujos de trabajo en él antes, y mostramos en nuestro video anterior cómo maneja mucho de nuestro trabajo
00:09:49por sí solo. El núcleo de un bucle determinista es la definición clara del objetivo final, y para las aplicaciones
00:09:54que has alojado, esa definición son tus pruebas. Así que puedes apuntar al agente Hermes a cualquier aplicación que hayas
00:09:59desplegado con casos de prueba y hacer que la monitoree por ti. Ahora, si un cambio o un commit termina rompiendo
00:10:04la producción, puedes configurar una automatización en Hermes para detectarlo. La razón por la que funciona mejor aquí es que
00:10:09viene con la función de habilidades auto-evolutivas, por lo que crea y evoluciona automáticamente habilidades basadas en el
00:10:14flujo de trabajo, lo que mantiene la salud de la aplicación bajo control. Una vez que hayas configurado esa automatización de monitoreo, puedes
00:10:18pedirle que inicie Claude Code en modo no interactivo, básicamente ejecutándolo por sí solo sin que tú tengas
00:10:23que manejarlo y hacer que solucione problemas en un bucle hasta que todos los casos de prueba pasen. Lo que hace a partir
00:10:28de ahí es configurar el flujo de trabajo de automatización y cargar habilidades como la habilidad de desarrollo impulsado por sub-agentes
00:10:34y la habilidad de flujo de trabajo de GitHub PR, que le dicen cómo administrar la aplicación en GitHub. Primero identifica los
00:10:39problemas que estaban rompiendo la producción, luego lanza Claude Code en modo no interactivo, lo cual toma
00:10:44las pruebas y confirma los cambios una vez que todas pasan. Después de haber ejecutado cada prueba y solucionado lo que
00:10:50estaba causando que la producción fallara, utiliza el CLI de GitHub para confirmar (commit) los cambios. La aplicación termina ejecutándose
00:10:55sin fallas porque ha confirmado que todas las verificaciones para un despliegue exitoso están en su lugar.
00:11:00Si te gustan estos desglose, suscríbete al canal, haz clic en la campana de notificaciones y presiona el botón
00:11:05de 'hype' también. En el canal, publicamos contenido que te ayuda a aprender nuevas formas de optimizar diferentes
00:11:10procesos en diferentes negocios con IA. Tu apoyo, ya sea suscribiéndote, la campana de notificación
00:11:15o el botón de 'hype', nos ayuda a crear más contenido como este y llegar a más personas. Significa mucho para nosotros.
00:11:21Ahora, el segundo tipo es el bucle no determinista y estas son tareas donde no puedes simplemente establecer una regla clara
00:11:26para verificar si el trabajo está hecho de la forma en que puedes con los bucles deterministas. Debido a eso,
00:11:31no hay una forma clara de verificar el resultado. Estos son el tipo de cosas que nosotros como humanos podemos mirar
00:11:36y juzgar por nosotros mismos, como construir una interfaz de usuario (UI) o implementar una función que necesita una decisión subjetiva.
00:11:41Así que cuando estás trabajando con un bucle no determinista, el flujo de trabajo es diferente. Si estás aplicando
00:11:46IA a la UI, ya sabes que tiende a caer en los mismos patrones todo el tiempo. Por eso
00:11:51creamos una habilidad llamada 'Detector de Slop de IA', que contiene todas las instrucciones sobre cómo evitar el 'slop' de IA y enumera
00:11:57los patrones que realmente lo delatan. Y la razón por la que usamos a Hermes de nuevo son las habilidades auto-evolutivas.
00:12:02Si todavía encontramos slop de IA en la interfaz después de ejecutar la habilidad, la habilidad puede actualizarse a sí misma para
00:12:07incorporar ese feedback directamente y eso es exactamente por lo que configuramos este flujo de trabajo en Hermes. Así que le pedimos
00:12:13a Hermes que use la habilidad y verifique si la UI tiene alguno de esos patrones. Si los tiene, los corrige
00:12:18y lanza Claude Code en modo no interactivo para ejecutar la habilidad y seguir corrigiendo lo que encuentra hasta que
00:12:23no quede nada por corregir. Otro beneficio que obtenemos de Hermes es que el modelo que revisa el trabajo es
00:12:28diferente del que lo está construyendo. Estábamos usando los modelos GPT, que se sabe que están entre los mejores para
00:12:33la revisión de código, por lo que los modelos Claude se convierten en el constructor y el otro agente se convierte en el verificador. Eso es lo que
00:12:38completa el bucle adversarial donde los dos verifican el trabajo del otro. Una vez que ese bucle se ejecutó, generó una
00:12:43interfaz de usuario mucho mejor que la salida genérica que los modelos Opus están produciendo hoy en día. Y si todavía detectas alguna señal de slop de IA
00:12:49en la interfaz después de que el bucle del agente haya terminado, puedes simplemente mencionarlo y actualizará la habilidad para
00:12:54ti, fortaleciendo al verificador que ya tienes. Hemos mejorado esta habilidad para que coincida con múltiples patrones de slop de IA
00:12:59que nosotros y Hermes identificamos colectivamente. Si quieres usar esta habilidad, puedes obtenerla de nuestra
00:13:04comunidad AI Labs Pro. El enlace estará en la descripción. Eso nos lleva al final de este video.
00:13:09Si te gustaría apoyar al canal y ayudarnos a seguir haciendo videos como este, puedes hacerlo usando el
00:13:14botón de 'súper gracias' a continuación. Como siempre, gracias por ver y nos vemos en el próximo.
Community Posts
No posts yet. Be the first to write about this video!
Write about this video