Insights AI
Escalamiento de agentes autónomos de programación: cómo los ciclos de verificación y los controles estrictos de integración continua permiten una entrega de software a alta velocidad
Podcast · Escuchar (20 min)
Contenido
- El cuello de botella de la confianza: por qué escalar agentes de código es un problema de gestión de ingeniería
- 1. Sintetizar el problema central
- 2. Establecer la analogía de gestión
- Verificación programática y mapeo de funcionalidades: cerrar el ciclo del agente
- 1. Explicar el mecanismo de verificación paso a paso
- 2. Detallar la arquitectura del mapa de funcionalidades
- 3. Detallar la evaluación y el mantenimiento de las capacidades de los agentes
- Controles arquitectónicos estrictos: pasar de instrucciones flexibles a la aplicación obligatoria mediante CI
- 1. Contrastar las reglas flexibles con las restricciones deterministas estrictas
- 2. Analizar el caso de estudio de la arquitectura «Dune»
- Automatización de agentes en la nube e implicaciones para los productos de toda la industria
- 1. Reproducción autónoma de errores y flujos de trabajo en la nube
- 2. Democratización del desarrollo entre funciones ajenas a la ingeniería
- Limitaciones arquitectónicas y cuestiones de ingeniería abiertas
- 1. Documentar las principales limitaciones y los casos límite
- Cifras clave
- Qué cambiaría este panorama
- Fuentes citadas
Las organizaciones modernas de ingeniería de software están llevando a cabo un cambio fundamental de paradigma: pasan de la programación en pareja con inteligencia artificial [AI] bajo microgestión a flotas de agentes autónomos capaces de integrar cientos o miles de solicitudes de incorporación de cambios [PRs] por mes. Como explicó Lauren Tan, ingeniera de SpaceXAI, escalar la generación de código con AI es principalmente un problema de gestión de ingeniería, más que un simple ejercicio de formulación de instrucciones. Cuando los equipos de ingeniería dependen de la supervisión manual, las inspecciones de código línea por línea y las directrices flexibles para las instrucciones, el desarrollador humano se convierte en un cuello de botella síncrono que limita el escalamiento de los agentes. La transición hacia una ejecución con alta autonomía requiere reemplazar la supervisión humana por ciclos de verificación programática, un mapeo estructurado de funcionalidades y controles deterministas de integración continua [CI]. Al codificar las invariantes arquitectónicas directamente en herramientas de análisis estático y entornos de verificación en tiempo de ejecución, los equipos de ingeniería pueden delegar la ejecución a agentes paralelos en la nube y, al mismo tiempo, impedir sistemáticamente la degradación de la base de código.
El cuello de botella de la confianza: por qué escalar agentes de código es un problema de gestión de ingeniería
1. Sintetizar el problema central#
El principal punto de fricción en la entrega de software asistida por AI es la falta de confianza de los desarrolladores en los resultados de los agentes. Los agentes de software suelen inventar abstracciones, diagnosticar incorrectamente las causas raíz y proponer con seguridad correcciones inválidas. Como observó Lauren Tan durante una entrevista en el canal de YouTube Vision Sabbat, los agentes a menudo «afirman con seguridad que encontraron la prueba irrefutable por centésima vez», mientras que el problema subyacente sigue completamente sin resolverse.
Cuando los equipos de ingeniería intentan escalar el uso de agentes mediante la programación en pareja tradicional con intervención humana, el flujo de trabajo alcanza rápidamente un límite infranqueable. Si un ingeniero debe inspeccionar cada línea de código generada, probar manualmente las compilaciones locales y verificar las diferencias, el desarrollador humano se convierte en un punto único de serialización. Este cuello de botella síncrono impide escalar más allá de uno o dos agentes locales y obstaculiza la verdadera paralelización de los flujos de trabajo de ingeniería.
2. Establecer la analogía de gestión
Para analizar esta dinámica operativa, Lauren Tan trazó un paralelismo directo entre gestionar agentes de código de AI y gestionar ingenieros de software humanos. En la gestión tradicional de ingeniería, un gerente que no confía en sus subordinados directos inevitablemente recurre a la microgestión: vigila de cerca a los desarrolladores, audita continuamente las solicitudes de incorporación de cambios e inspecciona cada línea de código para evitar interrupciones en producción.
HIGH | [ Fleet Autonomy ]
| Auto-merging PRs &
| Cloud Parallelization
TRUST | /
| /
| /
| [ Micromanagement ]
LOW | Manual Prompting & 1-in-Loop
+---------------------------------------------------
LOW HIGH
VELOCITY
Escalar la autonomía de los agentes requiere ascender por lo que Tan define como la «curva de confianza». En la fase inicial de adopción de agentes, los desarrolladores operan de forma síncrona dentro del ciclo de ejecución, dan instrucciones manualmente a agentes individuales e inspeccionan cada diferencia. Ascender por la curva de confianza requiere sistemas de ingeniería que proporcionen una verificación objetiva y automatizada de los resultados de los agentes. Establecer un alto nivel de confianza transforma el paradigma organizacional de la microgestión síncrona a la delegación asíncrona, lo que permite que flotas autónomas de agentes en la nube compilen, prueben e integren código de manera independiente.
Verificación programática y mapeo de funcionalidades: cerrar el ciclo del agente
1. Explicar el mecanismo de verificación paso a paso
En las arquitecturas de ingeniería basadas en agentes, la verificación programática se define como la provisión de herramientas de ejecución explícitas a los agentes para que interactúen directamente con los entornos de ejecución de las aplicaciones objetivo. En lugar de pedirle a un modelo de lenguaje grande [LLM] que adivine si su código funciona correctamente, un ciclo de verificación programática permite al agente ejecutar compilaciones, inspeccionar entornos de ejecución, capturar trazas de rendimiento de la unidad central de procesamiento [CPU], analizar instantáneas de la memoria dinámica y controlar simuladores móviles o de navegador. Para las aplicaciones web y de escritorio, los agentes utilizan capacidades desarrolladas sobre protocolos como Chrome DevTools Protocol [CDP] para controlar programáticamente la interfaz de usuario [UI].
Lauren Tan ilustró este mecanismo mediante una analogía culinaria: depender de un agente sin verificación programática equivale a que el gerente de un restaurante lea recetas en papel para adivinar si un plato sabe bien, mientras que la verificación programática equipa al jefe de cocina con estaciones de trabajo para probar, medir y ajustar continuamente los alimentos durante su preparación. Proporcionar herramientas de ejecución a los agentes cierra automáticamente el ciclo de retroalimentación. Aunque la verificación no garantiza la elegancia arquitectónica, valida de manera determinista la corrección del comportamiento antes de que se realice la revisión humana del código.
2. Detallar la arquitectura del mapa de funcionalidades#
Un componente fundamental de la verificación programática introducido en el complemento de código abierto PStack (Potato Stack) de Tan —una herramienta de capacidades para desarrolladores cuyo nombre es un juego de palabras con GStack de Gary Tan— es el «mapa de funcionalidades». El mapa de funcionalidades resuelve el desafío de navegación por la base de código que enfrentan los agentes cuando intentan corregir errores o implementar funcionalidades en sistemas complejos.
+-----------------------------------------------------------------------+
| FEATURE MAP |
+-----------------------------------------------------------------------+
| User Context / Vague Report: "Left sidebar is laggy on click" |
+-----------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------+
| DOM Attributes & Selectors : [data-testid="sidebar-toggle"] |
| Keyboard Shortcuts : Cmd+B / Ctrl+B |
| Code Base Location : src/components/sidebar/Sidebar.tsx |
| CDP Execution Action : cdp.click('#sidebar-toggle') |
+-----------------------------------------------------------------------+
Cuando los usuarios envían informes de errores ambiguos y de baja calidad —como una captura de pantalla de Slack anotada únicamente con «???»—, un agente sin contexto estructural tiene dificultades para localizar los componentes afectados. Un mapa de funcionalidades cierra explícitamente esta brecha al vincular los elementos de la UI directamente con rutas de archivos de la base de código, atributos del modelo de objetos del documento [DOM], identificadores de prueba, atajos de teclado y selectores de ejecución de CDP.
Mediante capacidades como create_verification_skill y maintain_verification_skill dentro de PStack, los agentes analizan sistemáticamente las bases de código para construir registros estructurados de funcionalidades. Al procesar un informe de errores ambiguo, el agente puede consultar el mapa de funcionalidades, navegar directamente a los elementos objetivo de la UI, ejecutar flujos de interacción mediante CDP, capturar métricas de rendimiento y verificar la resolución del defecto.
3. Detallar la evaluación y el mantenimiento de las capacidades de los agentes
Para mantener las herramientas y capacidades de los agentes a lo largo del tiempo, los equipos de desarrollo deben implementar marcos de evaluación automatizados, que funcionan como pruebas unitarias para las capacidades de los agentes de AI. El procedimiento de evaluación sigue un patrón de ejecución de cuatro etapas:
- Generación de la rúbrica: Un agente coordinador establece una rúbrica de evaluación explícita que define los comportamientos esperados de las herramientas y los criterios cuantitativos de puntuación.
- Ejecución en entornos aislados: Los subagentes ejecutan tareas en directorios temporales aislados a los que se asignan nombres aleatorios y ofuscados. La ofuscación de los directorios es estrictamente necesaria porque los LLM pueden detectar que se encuentran dentro de un entorno de evaluación y modificar su comportamiento de ejecución, lo que introduce un sesgo de evaluación grave.
- Evaluación mediante una matriz de múltiples modelos: Para eliminar el sesgo de puntuación de un único modelo, agentes evaluadores que operan en una matriz de distintos modelos fundacionales evalúan el desempeño de los subagentes según la rúbrica del coordinador.
- Ciclos de optimización por ascenso de colinas: Los ciclos de optimización automatizados (como ejecutar
/loopen Cursor) refinan continuamente las instrucciones de las capacidades y los parámetros de las herramientas hasta alcanzar las puntuaciones de evaluación objetivo (por ejemplo, 10 de 10) en toda la matriz de modelos.
Tan enfatizó que mantener las capacidades de los agentes requiere observación humana continua y criterio de ingeniería. Los desarrolladores deben actuar como supervisores activos, inspeccionando los registros de llamadas a herramientas y los bloques de razonamiento de los agentes durante el desarrollo de capacidades para identificar modos de fallo sutiles y formalizar instrucciones correctivas en capacidades persistentes.
Controles arquitectónicos estrictos: pasar de instrucciones flexibles a la aplicación obligatoria mediante CI
1. Contrastar las reglas flexibles con las restricciones deterministas estrictas#
Depender exclusivamente de restricciones flexibles en las instrucciones —como guías de estilo en markdown, reglas para las instrucciones o archivos de instrucciones AGENTS.md— conduce inevitablemente a la degradación de la base de código. Cuando los agentes sin restricciones toman el camino de menor resistencia para completar tareas localizadas, generan una «arquitectura orgánica» caracterizada por abstracciones inválidas, lógica duplicada y deuda técnica acumulada.
Para mantener la integridad estructural a largo plazo, las arquitecturas de software deben implementar el paradigma de diseño central de Lauren Tan: dado que los agentes toman atajos estructurales de manera natural, la arquitectura de la base de código debe diseñarse de modo que el camino más corto sea, desde el punto de vista estructural, el mejor y el correcto. Los equipos de ingeniería deben imponer este paradigma mediante un marco de controles por niveles que sustituya la dependencia de directrices flexibles por comprobaciones estrictas de CI.
| Capa | Nivel de aplicación | Mecanismo / Herramientas | Características |
|---|---|---|---|
| 1. Arquitectura y encapsulación de la base de código | Estricto (determinista) | Agrupación de funcionalidades en una misma ubicación, límites estrictos entre directorios, reglas de importación personalizadas | Impide estructuralmente los antipatrones arquitectónicos al hacer que el camino más corto sea el correcto |
| 2. Análisis estático y diagnósticos del compilador | Estricto (determinista) | Compiladores estrictos (por ejemplo, el verificador de préstamos de Rust), analizadores de código personalizados, comprobaciones de CI | Hace fallar las compilaciones de manera determinista ante violaciones de invariantes antes de la revisión humana |
| 3. Revisión automatizada de código | Flexible / Semideterminista | Revisores de código con AI (por ejemplo, Bugbot), análisis automatizado de PRs | Detecta defectos contextuales durante la validación de PRs |
| 4. Capacidades de los agentes y guías de estilo | Flexible (no determinista) | Reglas en markdown, instrucciones para los agentes, guías de estilo | Los modelos pueden ignorarlas fácilmente o aplicarlas de manera inconsistente |
Si bien las directrices flexibles de las capas 3 y 4 ofrecen contexto útil, el análisis estático estricto y la encapsulación arquitectónica de las capas 1 y 2 son obligatorios para garantizar que los agentes autónomos no puedan integrar código inválido.
2. Analizar el caso de estudio de la arquitectura «Dune»#
La implementación práctica de controles deterministas se demuestra en la refactorización de la aplicación de escritorio Grokbot. Grokbot se construyó con «Dune», un marco interno especializado descrito como Next.js para aplicaciones Electron, diseñado explícitamente para la entrega de software impulsada por agentes.
Para proteger el rendimiento de la aplicación en tiempo de ejecución y eliminar los modos de fallo recurrentes de los agentes, la arquitectura Dune impone reglas deterministas estrictas en los procesos de CI:
- Prohibición de los mecanismos de enlace de React: El mecanismo de enlace
useEffectde React está completamente prohibido en toda la base de código para evitar errores de sincronización de estado y renderizados repetidos no deseados. Las compilaciones de CI fallan inmediatamente si se detectauseEffect. - Prohibición de comentarios dentro del código: Los comentarios en el código de la aplicación están estrictamente prohibidos. Tan observó que los agentes generan con frecuencia comentarios históricos o interpretan incorrectamente comentarios transitorios de revisión de solicitudes de incorporación de cambios —por ejemplo, convierten una observación aislada de revisión como
"Lauren dijo que nunca se debe hacer esto"en un comentario estático del código—, lo que inventa restricciones globales permanentes y contamina las ventanas de contexto de los modelos. Prohibir los comentarios en el código obliga a que el código sea autodocumentado y evita la degradación del contexto. - Aislamiento obligatorio de los límites entre procesos: Las aplicaciones Electron requieren una separación estricta entre el proceso principal de Node y el hilo de la UI del renderizador. Para proteger el presupuesto de ejecución de 16 milisegundos por cuadro necesario para mantener un rendimiento fluido de 60 cuadros por segundo [FPS], se prohíben las operaciones con alta carga computacional y las tareas de entrada/salida [IO] en el hilo del renderizador. Dune impone esta separación al aislar la lógica en los directorios
electron_mainyelectron_renderer, y utiliza comprobaciones automatizadas del grafo de dependencias en CI para bloquear las importaciones entre directorios.
Automatización de agentes en la nube e implicaciones para los productos de toda la industria
1. Reproducción autónoma de errores y flujos de trabajo en la nube
Establecer herramientas de verificación local y controles estrictos de integración continua (CI) permite que la entrega de software pase de instrucciones locales a flotas de agentes autónomos alojadas en la nube. Este cambio se ejemplifica en agentes internos de automatización en la nube como "Benny" en Cursor.
[ User Feedback ] (Slack / Support Channels)
|
v
[ Benny Cloud Agent ] (Spawns Isolated Cursor Cloud Environment)
|
v
[ Execute Verification Skill ] (Launches App, Simulates UI Input)
|
+---> Bug Reproduced? ---> Yes ---> Generate Fix & Submit PR
|
+---> Already Fixed on Main? ---> Confirm Resolution & Notify Team
Benny ingiere automáticamente comentarios de usuarios sin procesar e informes de defectos provenientes de canales de Slack. Al recibir un informe, Benny inicia una instancia de escritorio aislada de Cursor en la nube, ejecuta el entorno de ejecución de la aplicación y despliega capacidades de verificación almacenadas para reproducir mediante programación el defecto informado.
Operar en un entorno aislado equipado con capacidades completas de verificación permite a Benny determinar de manera independiente si un problema persiste o ya se ha resuelto en la rama principal. Esta automatización elimina la necesidad de que los ingenieros dediquen trabajo manual a intentar reproducir problemas descritos en informes de usuarios de baja calidad.
2. Democratización del desarrollo entre funciones ajenas a la ingeniería
Los controles deterministas de CI modifican fundamentalmente la dinámica operativa de las organizaciones de desarrollo de productos. Cuando los compiladores y los scripts de CI hacen cumplir de manera determinista los invariantes arquitectónicos, los límites de memoria y los presupuestos de rendimiento, el personal ajeno a la ingeniería —incluidos los gerentes de producto [PM], los diseñadores de experiencia de usuario [UX] y el personal de estrategia de comercialización [GTM]— puede crear funcionalidades y presentar solicitudes de incorporación de cambios (PR) para producción de forma segura.
Como la infraestructura rechaza automáticamente las implementaciones que incumplen los requisitos, los colaboradores sin perfil técnico pueden crear mejoras funcionales mediante interfaces de lenguaje natural como Grokbot sin poner en peligro la estabilidad de la base de código ni los presupuestos de rendimiento.
Este modelo operativo presenta disyuntivas económicas y de retorno sobre la inversión [ROI] específicas:
- Gastos iniciales de capital en tókenes: Construir conjuntos integrales de pruebas de verificación, ejecutar matrices de evaluación con múltiples agentes y emprender refactorizaciones estructurales requiere un gasto inicial considerable en tókenes. Refactorizar la aplicación Grokbot para adoptar la arquitectura Dune requirió más de 600 PR individuales.
- Mejoras en la eficiencia laboral: El elevado gasto inicial en tókenes se compensa con reducciones drásticas de la carga de trabajo humano en ingeniería. Los flujos de ejecución de agentes de alta capacidad permiten a las organizaciones operar con equipos reducidos, evitando la sobrecarga organizativa de los grandes departamentos de ingeniería. La viabilidad económica de los ciclos continuos de evaluación mediante agentes jueces y las matrices de evaluación de agentes mejora aún más con modelos de vanguardia como Grok 4.6, que mantiene los precios de los tókenes de la versión 4.5 y ofrece un mayor rendimiento en pruebas comparativas.
Limitaciones arquitectónicas y cuestiones de ingeniería abiertas
1. Documentar las principales limitaciones y los casos límite
A pesar de las mejoras de velocidad logradas mediante flotas de agentes con un alto grado de autonomía, los patrones arquitectónicos actuales introducen limitaciones y disyuntivas de ingeniería explícitas:
- Gasto inicial en tókenes: Construir flujos de verificación continua y ejecutar iniciativas de refactorización que abarcan varios cientos de PR consume volúmenes enormes de tókenes. Para los equipos que operan con presupuestos limitados de tókenes, el capital necesario para construir herramientas de verificación puede representar una barrera significativa antes de obtener un ROI.
- Riesgos de crear prototipos desde cero: Crear rápidamente prototipos de aplicaciones sin controles estructurales ("programación intuitiva") genera una grave deuda técnica arquitectónica. Sin límites explícitos de encapsulación ni restricciones estáticas, los agentes eligen atajos por conveniencia que hacen que las bases de código se descontrolen rápidamente y, con el tiempo, requieran enormes operaciones de refactorización de varios cientos de PR para corregirlas.
- Carga de mantenimiento y criterio técnico: Los sistemas de verificación automatizada no eliminan la necesidad del criterio de ingenieros experimentados. Construir evaluaciones, actualizar mapas de funcionalidades y establecer restricciones de CI requiere una profunda experiencia en el dominio y una supervisión activa que oriente la ejecución.
Cifras clave#
- 1,000 PR: Número de solicitudes de incorporación de cambios integradas por Lauren Tan durante el mes anterior utilizando agentes autónomos en Cursor.
- Casi 800 PR: Número de solicitudes de incorporación de cambios integradas por Lauren Tan en el mes actual (al día 12 del mes).
- 20 PR: Número de solicitudes de incorporación de cambios generadas por agentes, fusionadas automáticamente durante la noche y verificadas en la rama principal en un solo día.
- 600+ PR: Número de solicitudes de incorporación de cambios ejecutadas para completar la refactorización integral de la arquitectura de la base de código de Grokbot.
- 16 milisegundos: Ventana máxima de ejecución por fotograma requerida en el hilo de renderizado de Electron para mantener un rendimiento fluido de la interfaz de usuario a 60 fotogramas por segundo [FPS].
- Hace 5 meses: Momento en que Lauren Tan se incorporó a Cursor, experimentando inicialmente una baja productividad mientras desarrollaba la confianza inicial en los agentes y las capacidades de verificación.
- Grok 4.6: Versión del modelo anunciada recientemente que mantiene el costo de los tókenes de la versión 4.5 del modelo y mejora el rendimiento en pruebas comparativas.
Qué cambiaría este panorama
- Transición a controles para agentes nativos del compilador: Adopción generalizada de lenguajes estrictamente compilados con sistemas estrictos de propiedad de memoria y de tipos (como Rust), en lugar de marcos de desarrollo de software dinámicos, trasladando la aplicación de restricciones estructurales desde scripts personalizados de CI directamente a los diagnósticos del compilador.
- Estandarización de los protocolos de verificación programática: Adopción amplia en la industria de estándares unificados e independientes de la plataforma para la verificación entre agentes e interfaces de usuario, más allá de Chrome DevTools Protocol, para exponer de forma nativa las interfaces de escritorio, móviles y web a los agentes de inteligencia artificial.
- Fusión autónoma generalizada mediante CI: Transición de los equipos de software comercial convencionales desde flujos de revisión manual del código hacia colas de fusión de CI totalmente automatizadas, impulsadas por puntuaciones de evaluación sintéticas y pruebas de integración continua.
- Reducción del costo de los tókenes en evaluaciones con múltiples agentes: Reducciones estructurales significativas de los costos de inferencia de los modelos fundacionales que permitan a los equipos de desarrollo fuera del ámbito empresarial ejecutar continuamente matrices de agentes jueces y ciclos de optimización por ascenso de colinas de manera económica.
Para obtener más información sobre la implementación de marcos avanzados de ingeniería de inteligencia artificial y flujos de ejecución autónoma, explore las investigaciones de código abierto disponibles en el sitio de DeepValues Research o pruebe la aplicación DeepValues hoy.
Fuentes citadas#
Lauren Tan - SpaceXAI engineer, interview published on YouTube channel Vision Sabbat
Ver
Enlaces a las fuentes
Ver y escuchar
- Cursor工程師讓AI一個月自動合併1000個PR,關鍵不是更聰明 YouTube · 中文
- Cursor Engineer Ships 1,000 PRs a Month. Who Checks Them? YouTube · EN
- Cursor工程師讓AI一個月自動合併1000個PR,關鍵不是更聰明 Podcast · 中文
- Cursor Engineer Ships 1,000 PRs a Month. Who Checks Them? | AI Explained Podcast · EN