Esta semana, Amazon Web Services (AWS) presentó AWS Emulator, una réplica local de AWS que permite a los agentes de programación probar sus códigos contra una versión simulada de más de 200 servicios AWS. Lo sorprendente es que toda esta herramienta fue desarrollada íntegramente por agentes autónomos, utilizando los modelos públicos de API de AWS. Sin embargo, la parte más valiosa de este lanzamiento reside en la historia que Swami Sivasubramanian comparte en el anuncio oficial.
Hace aproximadamente 20 años, Sivasubramanian participó en la creación del motor de replicación dentro de Alf, un servicio de bloqueo basado en Paxos que aún es fundamental para sistemas como S3 y DynamoDB. La construcción inicial de este motor llevó alrededor de cuatro meses. Posteriormente, cuando pidió a Kiro —una herramienta agentic de AWS para programación— que reconstruyera esa misma funcionalidad, supervisó al agente durante cuatro noches hasta identificar un problema crucial: el agente carecía de un método para verificar sus propios resultados. Tras proporcionarle especificaciones y un entorno de pruebas, el proceso de reconstrucción se redujo a apenas dos horas.
Esta experiencia revela un cambio radical: el mismo agente afrontó la misma tarea, pero la incorporación de un bucle de retroalimentación efectivo transformó la duración del trabajo de cuatro noches a dos horas.
“Un agente es tan bueno como su ciclo de verificación, y el ciclo de verificación depende de contra qué se ejecuta.”
Sivasubramanian subraya lo difícil que es testear sistemas distribuidos, algo confirmado por los equipos que actualmente emplean agentes de programación en sistemas de producción. Un agente solo puede ser verdaderamente fiable si tiene un ciclo de verificación adecuado, el cual a su vez depende de la calidad del entorno contra el que se ejecuta. AWS Emulator ocupa este espacio justamente para las API de AWS a las que se conecta el código, aunque no resuelve la verificación de los servicios internos que un equipo posee —y aquí suelen fallar la mayoría de los cambios realizados por agentes.
AWS introduce la infraestructura en el bucle de los agentes
El ciclo de un agente de programación consiste en escribir código, ejecutarlo, analizar el resultado y decidir qué modificar después. En sistemas distribuidos, este proceso ocurre directamente sobre la infraestructura. Si los servicios simulados no replican el comportamiento real, el agente aprende de forma incorrecta y continúa cometiendo errores.
AWS Emulator lleva esta infraestructura al propio portátil del desarrollador. Con simplemente ajustar una variable de entorno, las herramientas y el código existentes de AWS apuntan automáticamente a servicios emulados, permitiendo que las pruebas se ejecuten sin alterar nada.
Cada línea del emulador fue escrita por agentes autónomos, quienes desarrollaron el código a partir de las APIs públicas de AWS. Cada comportamiento se valida con pruebas de fidelidad que primero se ejecutan contra AWS real y luego contra el emulador. Solo tras superar rigurosas revisiones de seguridad se permiten fusiones de código. Según Sivasubramanian, cuando los agentes crean el código, la labor del ingeniero se centra en definir especificaciones, pruebas y requisitos de revisión para asegurar que los cambios sean correctos.
En foros como Hacker News, algunos usuarios cuestionaron la calidad de 30,000 commits realizados en apenas tres semanas, dudando del trabajo de los agentes. Sin embargo, la fiabilidad del código no depende solo de quién lo escribe, sino de la calidad del entorno contra el que se verifica. En este caso, la referencia es el AWS real.
“Una retroalimentación lenta o poco realista supone una carga para las personas. Para los agentes, es lo que determina si el ciclo funciona o no.”
Antes, un desarrollador revisaba los cambios pocas veces al día; ahora, un agente puede verificar en cada iteración. La velocidad y realismo del feedback son factores decisivos para la efectividad del proceso automatizado.
Tipos de entornos contra los que puede validar un agente: mocks, emuladores o sistemas en producción
Los agentes tienen tres formas principales de verificar su trabajo, cada una con limitaciones propias.
Los mocks, que son simulaciones simples y baratos de interfaces, son la opción menos fiable. Como destaca un comentarista, la IA ha facilitado generar mocks rápidamente, lo que aumenta la cobertura de tests, pero no la confianza, ya que el agente puede crear simulaciones ajustadas a sus propias suposiciones, haciendo que las pruebas pasen por diseño.
Los emuladores, como AWS Emulator, son un gran avance porque su comportamiento refleja al servicio real, ya que están validados contra ellos. Sin embargo, siguen siendo modelos imperfectos. Por ejemplo, el emulador no simula tasas de limitación, fallos, ni la disponibilidad regional, aspectos clave para testear lógica de reintentos y tolerancia a fallos.
Finalmente, probar directamente contra un sistema en producción ofrece la máxima fidelidad, pero implica mayores riesgos.
Sivasubramanian señala que en su proyecto Alf, la simulación ayudó a corregir la mayoría de errores de concurrencia, pero la ejecución en servidores reales reveló problemas inesperados, ya que el entorno real expone detalles que las simulaciones no capturan.
No puedes emular tu propio sistema como AWS emuló el suyo
Un participante en la discusión en Hacker News explicó que la mayoría de equipos que emplean agentes hoy tienden a aislar sus sistemas, emular dependencias externas y sólo luego dejar que el agente actúe. Esto funciona cuando las dependencias son APIs en la nube con especificaciones públicas, pero fracasa si el propio sistema es el componente crítico.
AWS pudo crear un emulador porque cuenta con un conjunto completo y legible por máquina de especificaciones para cada operación, además de una referencia estable en el sistema real para comparar resultados. La mayoría de equipos internos no disponen de tales recursos.
Imaginemos una plataforma de pagos compuesta por 60 microservicios cuyos contratos internos están parcialmente dispersos en código, algunos archivos OpenAPI desactualizados y el conocimiento de los ingenieros. No hay una única especificación clara y el sistema cambia constantemente, lo que hace inviable mantener modelos precisos para verificación automática. Este entorno, dinámico y distribuido, es donde suelen surgir los fallos del código generado automáticamente.
El entorno es responsabilidad también del ingeniero
Para Sivasubramanian, el ingeniero debe ocuparse de las especificaciones, pruebas y revisiones. Pero también debe gestionar el entorno de pruebas, porque de él depende lo que el agente puede detectar.
Un ciclo de verificación realista debe correr en un entorno que simule fielmente producción y esté próximo a los servicios, datos y configuraciones destino. Cada cambio necesita un entorno aislado para permitir múltiples agentes trabajando en paralelo sin interferir. Además, ese entorno debe poder arrancar en segundos para evitar que los agentes pierdan eficiencia y que el bucle de trabajo colapse a pruebas unitarias menos relevantes. Idealmente, el agente mismo debe ser capaz de crear el entorno y leer sus resultados sin intervención humana.
El bucle debe ejecutar pruebas de integración y end-to-end ya validadas por el equipo, no sólo tests creados por el agente. También debe generar evidencia confiable para que el revisor humano o sistema automático pueda decidir si el cambio es apto para fusionarse.
El desafío está en combinar alta fidelidad con tiempos rápidos y costes bajos. Clonar una pila completa para cada cambio asegura calidad pero resulta inviable económicamente cuando decenas de agentes generan cientos de solicitudes al día. Empresas como Uber y Lyft han desarrollado entornos donde sólo se despliegan las modificaciones específicas y se integran con un entorno común estable, manteniendo así rapidez y fidelidad.
Emula lo que no controlas y ejecuta en real lo que sí
Los emuladores y los entornos de prueba realistas no son conceptos opuestos sino complementarios en el ciclo de verificación.
Para servicios gestionados en la nube con contratos públicos, un emulador permite un feedback rápido y gratuito. Por ejemplo, si un servicio escribe datos en S3 y lee mensajes de una cola, el emulador detecta en segundos si se están usando mal las APIs, sin consumir recursos reales.
Para el sistema propio, es recomendable desplegar sólo lo que el cambio modifica y usar esquemas o tópicos aislados para garantizar que las pruebas no interfieran entre sí. Así se logran entornos que arrancan rápido y se comportan como producción.
Un control de calidad riguroso debería requerir que un cambio pase pruebas tanto contra el emulador como contra el entorno real antes de ser incorporado, lo que asegura confianza a los revisores.
El futuro depende de la fidelidad del ciclo de verificación de los agentes
Gracias a un bucle de verificación efectivo, el agente de Sivasubramanian pudo pasar de cuatro noches a tan solo dos horas para reconstruir un sistema complejo. Para equipos de desarrollo, el avance crucial radica en el entorno contra el que se comprueban los cambios. Un emulador garantiza la calidad de las APIs externas, pero solo un entorno productivo cubre las complejidades internas propias.
Tener un ciclo de verificación dentro del proceso de desarrollo se ha convertido en el estándar esperado. Sin embargo, la fiabilidad definitiva depende del realismo del entorno en que se ejecuta ese ciclo. Para quienes busquen que sus agentes validen cada cambio en entornos de producción antes de fusionarlos, existen soluciones como Signadot que automatizan y hacen accesible este enfoque.