Una de las pruebas más útiles que hicimos con Kilo Code fue separar dos responsabilidades que muchas veces se mezclan demasiado: ejecutar y aconsejar.
La idea vino de mirar el patrón del Advisor Tool de Claude Code. No lo usamos directamente en esta máquina, ni Kilo lo soporta de forma nativa. Lo tomamos como referencia conceptual: un executor Claude puede apoyarse en un advisor server-side para revisar dirección y estrategia.
En Kilo lo emulamos con subagents read-only.
La hipótesis
No todo trabajo necesita el mismo tipo de inteligencia.
Modificar archivos, producir un HTML, correr pasos o seguir instrucciones claras es trabajo de ejecución.
Detectar si el resultado va en la dirección correcta, si hay riesgo, si falta estructura o si conviene cambiar el enfoque es trabajo de advisor.
Si mezclás todo en un solo agente, pagás de más y además cuesta entender qué falló.
Primer setup: GLM ejecuta, MiniMax aconseja
La primera configuración fue:
- Worker/executor:
ollama/glm-5.2:cloud
- Advisor: subagent
advisor con minimax/MiniMax-M3
- Modo advisor: read-only
Lo configuramos en ~/.config/kilo/config.json y agregamos una regla global en ~/.config/kilo/AGENTS.md: consultar al advisor casi siempre antes de writes no triviales.
La idea era que GLM hiciera el trabajo operativo y MiniMax actuara como capa de revisión estratégica.
Reverse advisor: MiniMax ejecuta, GLM aconseja
Después dimos vuelta la arquitectura:
- Worker/executor:
minimax/MiniMax-M3
- Advisor: subagent
advisor-glm con ollama/glm-5.2:cloud
- Modo advisor: read-only
Este setup era interesante porque iba contra la intuición inicial. En vez de poner a GLM como executor principal, lo dejamos como advisor. MiniMax quedó haciendo el trabajo pesado.
Qué medimos
No queríamos medir solo “terminó o no terminó”.
Usamos benchmarks con screenshots de Playwright y QA visual con visión para mirar calidad real del output:
- estructura;
- jerarquía visual;
- assets;
- dirección estética;
- tiempo total;
- utilidad del resultado.
En esta segunda comparación ignoramos tokens. La pregunta era calidad + tiempo.
Resultados
GLM_MAIN_M3_ADVISOR
- Executor:
ollama/glm-5.2:cloud
- Advisor:
minimax/MiniMax-M3
- Tiempo: 735.7s
- Visual QA: 3/10
- Output: un HTML
- Assets: OK
- Problema: estructura más débil, página más vacía
M3_MAIN_GLM_ADVISOR
- Executor:
minimax/MiniMax-M3
- Advisor:
ollama/glm-5.2:cloud
- Tiempo: 343.8s
- Visual QA: 8/10
- Output: un HTML
- Assets: OK
- Resultado: mejor jerarquía, mejor rider, mejor match premium
El ganador fue claro:
minimax/MiniMax-M3 como executor + ollama/glm-5.2:cloud como advisor.
La parte interesante
La conclusión no fue “este modelo es mejor que este otro”.
La conclusión fue más útil:
El rol importa.
MiniMax M3 funcionó mejor como executor. Avanzó más rápido y produjo una salida más sólida.
GLM 5.2 Cloud funcionó mejor como advisor. Aportó dirección sin tocar archivos.
Separar esos roles hizo que el sistema fuera más fácil de operar.
El worker ejecuta.
El advisor corrige dirección.
El verifier mide.
El router decide cuándo escalar.
Lo que aprendimos
Copiar el patrón de Advisor de Claude no significó copiar una feature interna.
Significó adaptar una idea de arquitectura:
un agente trabaja, otro mira desde afuera.
Esa separación baja el costo de razonamiento innecesario, reduce desperdicio de contexto y mejora los modos de falla.
Si algo sale mal, podés distinguir mejor:
- falló el executor;
- falló el advisor;
- falló el routing;
- falló la validación;
- o el benchmark estaba mal planteado.
Eso es mucho más operable que un agente gigante haciendo todo.
Cierre
Para mí, esta es la diferencia entre usar IA como demo y usar IA como infraestructura.
Una demo puede tener un modelo enorme resolviendo todo.
Un sistema real necesita roles, límites, validación y medición.
En nuestro caso, el mejor resultado no vino del setup obvio. Vino del reverse advisor:
MiniMax-M3 ejecutando.
GLM-5.2:cloud aconsejando.
Menos dogma, más benchmark.