Cuando un equipo de agentes AutoGen se estanca: cómo medirlo y escalarlo a un supervisor.
Un experimento de AutoGen con un árbitro de horario de cambios determinista muestra por qué falla la revisión por pares, cómo detectar un equipo atascado y por qué la escalada requiere un modelo diferente.
Fuentes: AutoGen ile Multi-Agent Eskalasyon: Ekip Takılınca Ne Olur?
Un equipo de agentes económicos puede darse cuenta, mediante mediciones, de que están atascados y pasarle el trabajo a un supervisor más competente. Lo sorprendente fue descubrir qué tipo de supervisor se considera más competente. A continuación se describe un experimento AutoGen de cuatro pasos: un agente individual, un equipo de dos agentes, un validador determinista y, finalmente, la escalada.
La mayoría de las demostraciones con múltiples agentes reproducen una misma escena: los agentes no logran resolver un problema, se consultan entre sí y al final interviene un agente especialista que termina el trabajo. Parece impresionante hasta que se lee el código y se encuentra una línea en el mensaje del sistema que dice algo como “si no puedes resolverlo, pregunta al supervisor”. El agente no pide ayuda porque haya fallado; lo hace porque se le ha ordenado. Toda la escena está preescrita.
No se aprende nada de eso, porque la pregunta difícil no es cómo un agente pide ayuda. La verdadera duda es cómo alguien se da cuenta de que un equipo está atascado. El experimento presentado a continuación fue diseñado para que realmente ocurra ese atasco, y en el proceso dos hallazgos obligaron a realizar cambios en su estructura. Ambos resultaron ser las partes más valiosas del estudio.
Sacar a los agentes de su rol de jueces
Si se desea observar cómo los agentes fracasan de verdad, no pueden ser ellos quienes decidan qué significa el éxito. Por lo tanto, la tarea debe tener un resultado que una máquina pueda verificar: un horario semanal de turnos para una tienda pequeña. Hay siete días con dos turnos cada uno, y cada turno requiere exactamente a dos personas, lo que suma un total de 28 plazas por cubrir. Hay siete empleados disponibles, con una capacidad total de 33 turnos. Se aplican seis reglas estrictas:
- Cada turno cuenta con exactamente a dos personas.
- Nadie trabaja dos turnos el mismo día.
La dificultad radica en la superposición de las reglas tres y seis. Uno de los cajeros certificados es un empleado a tiempo parcial que solo puede trabajar tres turnos a la semana. Si se modifica la regla del descanso, se viola la regla de los cajeros; si se corrige esa, se excede un límite.
La función de verificación es una simple función de Python sin ninguna llamada a un LLM en su interior:
def dogrula(cizelge: dict) -> list[str]:
"""Cizelgedeki butun kural ihlallerini dondurur. Bos liste = gecerli plan."""
Cada veredicto de aprobado/rechazado en el experimento proviene de esta función, y lo que los agentes piensen sobre su propio trabajo es irrelevante. Las pruebas también demuestran que el problema es resoluble, ya que un solucionador de retroceso en el conjunto de pruebas encuentra al menos un horario válido. Los agentes nunca ven ese solucionador. Una vez que el equipo se atasca, nadie puede afirmar que el problema era imposible.
Paso 1: un único agente y cuatro violaciones
La configuración más simple utiliza un AssistantAgent sin herramientas ni asistentes:
planlayici = AssistantAgent("planlayici", model_client=istemci, system_message=...)
sonuc = await planlayici.run(task=brif())
Con gpt-4o-mini como modelo, el resultado fue un horario en JSON bien estructurado y preciso. El supervisor contó cuatro infracciones. A un empleado se le asignó día libre el lunes. La tarde del sábado no había cajero certificado. A un trabajador a tiempo parcial con límite de tres turnos se le asignaron cinco. El agente no tiene forma de saber nada de esto, ya que su configuración no le permite verificar sus propias respuestas.
Paso 2: agregar un compañero empeoró la situación
La solución habitual es contar con un revisor junto al planificador. En AutoGen eso requiere tres líneas de código:
ekip = RoundRobinGroupChat([planlayici, denetci], max_turns=6)
sonuc = await Console(ekip.run_stream(task=brif()))
El revisor cumplió con su tarea, enumerando cinco infracciones, todas ellas bajo el epígrafe de la regla de descanso de 11 horas. El planificador las corrigió. Cuando el supervisor inspeccionó luego el horario, solo encontró una infracción de descanso, por lo que el revisor había inventado cuatro. Al mismo tiempo, pasó por alto por completo las infracciones relacionadas con los días libres, la falta de personal en la caja y los excesos semanales. La cantidad de infracciones aumentó a siete, peor que en el caso del único agente.
Nada de esto es sorprendente. El revisor también es un LLM, por lo que presenta las mismas debilidades y consume el doble de tokens. El equipo también puede aprobar su propio trabajo: una vez que el revisor anuncia que el plan está aprobado, nadie objeta. Es como si un estudiante evaluara su propio examen.
Paso 3: las retroalimentaciones correctas aún no son suficientes
El siguiente paso retira la validación del LLM y la transfiere a la función. AutoGen acepta funciones normales de Python como herramientas, generando el esquema a partir de las indicaciones de tipo y la descripción a partir de la documentación:
denetci = AssistantAgent(
"denetci",
tools=[cizelgeyi_dogrula],
max_tool_iterations=1,
reflect_on_tool_use=False, # <-- kilit satır
)
La configuración reflect_on_tool_use=False es crucial aquí. Con True, el agente resumiría la salida de la herramienta con sus propias palabras, el planificador leería las infracciones a partir de ese resumen y se perderían los detalles. Con False, el informe del validador se incluye en la conversación palabra por palabra. El segundo detalle importante es la regla de detención:
bitis = TextMentionTermination("GECERLI:", sources=["denetci"]) | MaxMessageTermination(12)
Solo el validador puede generar el texto GECERLI:; por lo tanto, el final de la conversación está determinado por una señal determinista en lugar de una oración generada por un LLM. Eso soluciona el problema del “plan aprobado” del paso anterior.
El resultado: el equipo alcanzó su límite de 12 mensajes con nueve infracciones. La situación parece peor. Ahora los comentarios son precisos, sin infracciones inventadas ni reglas omitidas. Pero el modelo pequeño corrige una regla al tiempo que rompe otra, y el proceso nunca converge. Se necesita un feedback correcto, pero es insuficiente. Lo que falta es un mecanismo que mida el progreso y pueda declarar que este equipo no completará la tarea.
Paso 4: medir el estancamiento
La primera pregunta para determinar si se debe escalar la situación es si el equipo realmente está atascado o simplemente lento. Es inútil preguntarles a los agentes, porque esperar un informe honesto de parte de un sistema que no puede juzgar su propio trabajo repite el error del segundo paso. Por lo tanto, el código mide la situación utilizando dos indicadores:
def takildi_mi(self, sabir: int = 2) -> tuple[bool, str]:
son, onceki = self.denemeler[-1], self.denemeler[-2]
# 1. Ayni ihlal seti tekrar ediyor -> dongude donuyorlar.
if son.cizelge is not None and son.ihlaller == onceki.ihlaller:
return True, "Ayni ihlaller iki tur ust uste tekrarlandi."
# 2. Son turlarda ihlal sayisi hic azalmadi -> ilerleme yok.
pencere = self.denemeler[-(sabir + 1):]
if pencere[-1].skor >= min(d.skor for d in pencere[:-1]):
return True, "Ilerleme yok."
return False, ""
Si ninguna de las señales se activa, el equipo está mejorando, aunque sea lentamente, y el bucle continúa. La verificación también permite al sistema escalar antes de que se agote el presupuesto de la ronda, lo cual es importante porque cada ronda desperdiciada representa dinero perdido. La orquestación consiste en un bucle ordinario de Python. AutoGen mantiene el historial de chats del equipo, por lo que volver a llamar al mismo objeto del equipo significa que el equipo recuerda las rondas anteriores:
for tur in range(1, MAX_TUR + 1):
sonuc = await Console(ekip.run_stream(task=gorev))
cizelge = son_cizelge(sonuc.messages)
ihlaller = dogrula(cizelge)
gunluk.ekle(Deneme(tur, cizelge, ihlaller))
if not ihlaller:
break
takildi, sebep = gunluk.takildi_mi()
if takildi:
break
gorev = sonraki_gorev(...)
Qué incluye el paquete de escalada
El equipo está atascado, ¿entonces qué se envía al supervisor? Es más sencillo plantear la pregunta desde cero, pero eso constituye un nuevo intento y no una escalada. Lo que necesita el supervisor no es el problema en sí, sino lo que intentó hacer el equipo y por qué fracasó. El paquete contiene:
- un resumen del problema,
- el informe de incumplimientos del cronograma generado en cada ronda,
- los tipos de incumplimientos que se repiten, con sus cantidades (por ejemplo: días libres: 3 veces, límite: 3 veces),
- los mensajes finales del equipo,
- una definición clara de la tarea.
La columna de incumplimientos recurrentes es un simple contador, pero funciona bien, ya que el supervisor puede ver de inmediato qué regla sigue impidiendo avanzar al equipo.
Conclusión 1: max_tool_iterations es un límite máximo, no una garantía
El supervisor recibió la herramienta de validación con max_tool_iterations=8. La expectativa era un ciclo autónomo de redacción, validación, corrección y validación nuevamente. Lo que realmente sucedió fue lo siguiente: el supervisor llamó a la herramienta una vez, recibió un informe de tres infracciones y luego devolvió un cronograma completamente diferente como respuesta final sin validarlo. Ese cronograma era inválido.
El límite establecido es un tope máximo y nunca uno inferior. En el momento en que el modelo responde con texto en lugar de hacer una llamada a una herramienta, el bucle finaliza. Escribir “nunca responder sin validar” en el mensaje del sistema tampoco ayudó, ya que esa frase ya estaba allí. La solución fue de tipo arquitectónico: dejar la última decisión en manos del árbitro y no del modelo. Ahora el supervisor funciona dentro del mismo bucle de validación externo que el equipo, y su respuesta no se acepta hasta que el árbitro la apruebe. Decirle a un modelo qué hacer no hace que eso suceda. Si necesita una garantía, debe crear el bucle usted mismo.
Conclusión 2: un modelo más potente no fue suficiente
El primer supervisor fue gpt-4o, al frente de un equipo de trabajadores compuesto por gpt-4o-mini. Es la configuración clásica en la que el modelo económico realiza el trabajo y el más caro interviene para resolver problemas. Sin embargo, este último no logró solucionar nada. A lo largo de tres rondas, gpt-4o mejoró gradualmente: pasó de cometer ocho infracciones a cinco y luego a cuatro, sin llegar nunca a cero, y generó 918 tokens de salida. Tras cambiar al modelo de razonamiento o4-mini, el problema se resolvió en la primera ronda misma, sin ninguna infracción, pero a un costo de 3,886 tokens de salida.
En retrospectiva, esto tiene sentido. La tarea consiste en satisfacer restricciones, lo que requiere una búsqueda sistemática. gpt-4o no es significativamente mejor que gpt-4o-mini en esto, ya que ambos funcionan de la misma manera y uno es simplemente más grande. La diferencia en número de tokens tampoco es casualidad, ya que la mayor parte de esos 3,886 tokens son tokens relacionados con el razonamiento. El costo del pensamiento se refleja en la tabla de precios. La lección general es que la escalada no debería significar un modelo más caro, sino uno que funcione de manera diferente. Mida cuál de ellos ayuda con su propio problema y no asuma.
Finalmente, la ejecución tuvo éxito, y el registro muestra cómo se desarrolló:
--- Ekip - tur 1/3 (gpt-4o-mini) ----------------------------------------
[hakem] tur 1: GECERSIZ: 4 kural ihlali var.
--- Ekip - tur 2/3 (gpt-4o-mini) ----------------------------------------
[hakem] tur 2: GECERSIZ: 4 kural ihlali var.
--- Ekip - tur 3/3 (gpt-4o-mini) ----------------------------------------
[hakem] tur 3: GECERSIZ: 6 kural ihlali var.
[karar] Takilma tespit edildi: Son 2 turda ihlal sayisi 4 seviyesinden
asagi inmedi; ilerleme yok.
--- Supervisor - tur 1/3 (o4-mini) --------------------------------------
[hakem] supervisor tur 1: GECERLI: Cizelge butun kurallara uyuyor.
No había ningún script detrás de ello. El equipo realmente se quedó atascado, se midió ese estado de estancamiento y el supervisor resolvió la tarea.
La factura
Al final del paso cuatro, se imprime el gasto de ambos modelos uno al lado del otro:
Asama Model Girdi Cikti Maliyet $
------------ ----------- ------ ----- ---------
ekip (3 tur) gpt-4o-mini 16.566 2.290 0,00386
supervisor o4-mini 5.463 3.886 0,02311
------------ ----------- ------ ----- ---------
TOPLAM 22.029 6.176 0,02697
Los tres ciclos del equipo costaron aproximadamente 0,0039 dólares, mientras que el supervisor costó unos 0,0231 dólares; por lo tanto, la escalación representa un único ítem cuyo costo es aproximadamente seis veces el esfuerzo total del equipo. Esa tabla es la razón de la arquitectura. Si se entrega todo al supervisor, la factura se multiplica por seis. Si se deja todo en manos del equipo económico, el trabajo nunca se termina. La respuesta correcta se encuentra entre ambos, y la medición es la única forma de encontrarla.
Conclusiones
- Mientras se pregunte a los agentes si tuvieron éxito, el sistema es falso. Un árbitro determinista es la base sobre la que se sustenta toda la arquitectura. Si su problema no tiene un aspecto verificable por máquina, primero busque uno.
- No basta con que un LLM audite a otro. El revisor crea sus propias alucinaciones y duplica el costo.
Cómo está organizado el código
El experimento se divide en cuatro archivos que deben ejecutarse en orden, cada uno comenzando con una nota sobre lo que enseña:
01_tek_agent.py AssistantAgent, run(), TaskResult
02_ekip.py RoundRobinGroupChat, max_turns, Console
03_dogrulayici.py tools=[...], reflect_on_tool_use, deterministik termination
04_eskalasyon.py dış döngü, takılma tespiti, eskalasyon paketi, maliyet defteri
Las pruebas no requieren clave API. ReplayChatCompletionClient de AutoGen devuelve las respuestas del modelo en secuencia, por lo que se pueden verificar gratuitamente las dos suposiciones más arriesgadas del proyecto. Las versiones utilizadas fueron autogen-agentchat 0.7.5 y Python 3.11. El comportamiento de los modelos pequeños varía de una ejecución a otra, y gpt-4o-mini se encuentra justo en el límite de este problema, a veces completando la tarea en cuatro rondas.