El colofón de la intervención de Olivier Perard (Distinguished ACE en Oracle) en el 4º Congreso de Inteligencia Artificial de Andalucía (#AndalucIA26) supuso una vuelta de tuerca a la ingeniería del software. Tras mostrar la resolución exprés de bugs y la generación de aplicaciones tácticas en cuestión de minutos, Perard presentó su tercer caso de estudio: un ecosistema multiagente distribuido para gobernar el simulador de Fórmula 1, concebido, programado y orquestado en apenas seis horas.
La clave técnica de este desarrollo radica en la descomposición algorítmica: en lugar de saturar un único modelo monolítico con múltiples instrucciones complejas, el sistema se divide mentalmente en miniagentes de propósito específico que trabajan en paralelo y de forma coordinada bajo la batuta de un agente orquestador principal.
La división en miniagentes: De la ontología al commit en Git
La diapositiva proyectada bajo el título «Mi nuevo sueño para el Simulador de F1» desglosa con detalle la estructura de funciones y entregables que cada agente especializado ejecuta en el entorno:
+----------------------------------------------------------------------------------------------------------------+
| ARQUITECTURA DEL ENJAMBRE DE AGENTES EN EL SIMULADOR DE F1 |
+----------------------+-----------------------------------------------+-----------------------------------------+
| AGENTE | QUÉ HACE SOBRE F1SIM | QUÉ VE EL PÚBLICO / AUDITOR |
+----------------------+-----------------------------------------------+-----------------------------------------+
| Ontólogo | Lee código y esquema BD (vía wallet); extrae | Grafo de conocimiento dibujándose |
| | ontología implícita (piloto, escudería, etc.).| en directo. |
+----------------------+-----------------------------------------------+-----------------------------------------+
| Gobierno del dato | Glosario de negocio, linaje tabla-código | Catálogo de datos generado en 3 minutos |
| | en APEX, clasificación sensible y comentarios.| sin documentación previa. |
+----------------------+-----------------------------------------------+-----------------------------------------+
| Auditor Python | Revisa complejidad ciclomática, bugs, | Hallazgos y vulnerabilidades ordenadas |
| | seguridad y deuda técnica en scripts. | por gravedad. |
+----------------------+-----------------------------------------------+-----------------------------------------+
| Auditor APEX | Exporta la app APEX (SQLcl), analiza PL/SQL, | Fallos reales de inyección SQL o |
| | inyecciones SQL y brechas de autorización. | accesos no autorizados en la app. |
+----------------------+-----------------------------------------------+-----------------------------------------+
| QA (Testing) | Genera tests con pytest y utPLSQL; ejecuta las| Batería de pruebas pasando de rojo |
| | pruebas y corrige el código roto. | a verde automáticamente. |
+----------------------+-----------------------------------------------+-----------------------------------------+
| Ingeniero Desarrollo | Implementa en directo nuevas funcionalidades | Código nuevo generado con su commit |
| | votadas por el público en una rama aislada. | registrado en el repositorio Git. |
+----------------------+-----------------------------------------------+-----------------------------------------+
| Dashboard | Genera cuadro de mando (página APEX/Streamlit)| La carrera simulada visualizada |
| | integrando la nueva funcionalidad creada. | en tiempo real con datos frescos. |
+----------------------+-----------------------------------------------+-----------------------------------------+
(Esquema funcional de responsabilidades y artefactos presentado por Olivier Perard)
La topología de orquestación
El flujo de trabajo se organiza mediante una estructura en árbol gobernada por un agente central denominado Team Principal:
- El Team Principal distribuye tareas a los agentes de Ontólogo, Gobierno del dato, Auditor Python, Auditor APEX, QA y Analista visual.
- Los agentes de auditoría y gobierno se conectan a la base de datos central (Oracle DB en modo solo lectura) para evitar corrupciones de estado.
- El agente de Desarrollo trabaja de manera estanca sobre una rama de Git aislada.
- Ninguna línea de código llega a producción sin pasar por un nodo de validación: el agente QA ejecuta los tests y, tras la aprobación final del usuario humano (TÚ), se autoriza el despliegue hacia la pantalla principal de la carrera.
El «Gran Premio de los Agentes»: 0 intervenciones humanas y bandera a cuadros
Para evidenciar la viabilidad de la orquestación paralela sin bloqueos, Perard mostró el panel de telemetría de ejecución bautizado como «Gran Premio de los Agentes». En este cuadro de mando se monitorizó en tiempo real el avance de cada agente sobre los distintos «sectores» de la pista de software:
- Sector 1 (Ontólogo): Completado en 2:33.6 consumiendo 59k tokens.
- Sector 2 (Gobierno del dato): Finalizado en 1:09.0 con 48k tokens.
- Sector 3 (Auditor Python): Análisis de deuda técnica y bugs en 4:04.0 con 53k tokens.
- Sector 4 (Auditor APEX): Auditoría de inyecciones y PL/SQL en 1:45.8 con 52k tokens.
- Sector 5 (QA): Generación y corrección de tests en 0:28.4 con 23k tokens.
- Sector 6 (Desarrollo): Implementación de código nuevo en 0:24.4 con 6k tokens.
- Sector 7 (Analista visual): Integración de dashboards y visualización en 1:25.5 con 25k tokens.
El reporte emitido por el Team Principal confirmó el cierre de la ejecución: «Basta de explorar, Analista visual entrega ya. Main intacto: los cambios viven en carrera-20260925-035506. Bandera a cuadros».
El balance consolidado arrojó cero intervenciones humanas requeridas, un consumo total de 268k tokens y la resolución íntegra de la cadena de ingeniería en un tiempo neto de apenas trece minutos de ejecución en paralelo, frente a los meses que requeriría coordinar manualmente a siete especialistas humanos en bases de datos, QA, ciberseguridad y frontend.
La jerarquía militar entra en el desarrollo de software
El caso expuesto por Oracle ilustra la madurez del paradigma agéntico: abandonar la fantasía del «agente todoterreno» para adoptar una disciplina de división del trabajo estricta.
Asignar a cada miniagente una tarea hiperacotada (un agente que solo audita PL/SQL, otro que únicamente escribe tests en pytest y un supervisor que decide cuándo se baja la bandera a cuadros) reduce drásticamente las alucinaciones y los bucles infinitos. Además, aislar al agente programador en una rama temporal de Git con bases de datos en solo lectura solventa el miedo corporativo a que una IA sobrescriba entornos de producción.
El mensaje para la industria en este cierre de jornada de #AndalucIA26 es rotundo: quien intente resolver flujos empresariales complejos con una única ventana de chat está perdiendo el tiempo. El futuro inmediato de la ingeniería consiste en diseñar organigramas de miniagentes orquestados en paralelo, donde el ser humano deja de programar funciones para convertirse en el director que valida el resultado final antes del despliegue definitivo.
Déjanos tu opinión en los comentarios y únete a la discusión en Instagram, Facebook y YouTube.
