Graph engineering: deja de poner tus agentes en fila india

Tus agentes van lentos y caros porque los tienes en fila india: cada paso espera al anterior aunque no necesite nada de él. Esta guía es la regla que lo arregla, las 4 formas que cubren casi cualquier flujo y una checklist para revisar el tuyo. Sirve para cualquier sistema de agentes que ya tengas montado, con cualquier herramienta, gratis.

El problema: la fila india

La mayoría diseña sus agentes como una línea recta: investiga → escribe → revisa → publica. Todo en fila. El sistema no se ramifica, no corre nada a la vez, no sabe recuperarse de un fallo. Y va metiendo todo en una sola ventana de contexto hasta que el agente se vuelve lento, se lía y sale caro.

El problema ya no es el prompt. El problema es la forma del trabajo.

La regla nº1: secuencia no es dependencia

Que dos pasos vayan uno detrás del otro no significa que uno dependa del otro. Si B no consume la salida de A, B no tiene ninguna razón para esperar a A.

La pregunta única:

¿El siguiente paso lee de verdad lo que produjo el anterior?

Si la respuesta es no, corta la flecha. Ese solo cambio convierte una cadena lenta en un grafo rápido donde las cosas corren a la vez.

Ejemplo. En fila (mal): recopilar datos de mercado → inspeccionar el repo → mirar precios de la competencia. Ninguno de los tres lee lo que produjo el anterior. Bien: los tres a la vez, y un cuarto paso que sintetiza. Mismo trabajo, una fracción del tiempo.

Vocabulario mínimo (en cristiano)

Nodo — una unidad de trabajo acotada. Un trabajo, no cinco.
Arista — una dependencia real: “este paso lee lo del anterior”.
Estado — lo que sobrevive entre nodos.
Router — la regla que elige el siguiente camino.
Gate — el check que decide si el trabajo continúa o se para.

Y la distinción que lo ordena todo: un bucle ayuda a un agente a mejorar su trabajo; un grafo coordina muchos bucles en un sistema.

Las 4 formas que cubren casi cualquier grafo

Cadena (A → B → C)

Solo cuando cada paso necesita de verdad el anterior. Ejemplo: transcribir → resumir → traducir el resumen. Si entre dos pasos no hay lectura real, no es una cadena: es una fila india disfrazada.

Diamante

Abrir en ramas independientes, correr a la vez, unir al final. El caballo de batalla para research, code review y due diligence. Ejemplo: tres agentes miran mercado, repo y competencia a la vez → uno sintetiza.

Router

Clasificar primero y elegir solo el camino que la tarea necesita. Lo simple por la vía barata; lo arriesgado por el grafo profundo. Ejemplo: el ticket trivial va directo a respuesta; el delicado pasa por análisis + revisión humana.

Ciclo controlado

Trabajo → verifica → ¿pasa? Si falla, feedback y otra vuelta. Siempre con tope de iteraciones y presupuesto: un ciclo sin tope es una factura sin techo. Ejemplo: generar código → correr tests → arreglar → repetir (máximo 3 vueltas).

Buenas prácticas

Cada nodo con contrato: un solo trabajo, input explícito, output estructurado y un estado de fallo claro. Si el siguiente nodo tiene que adivinar, el contrato está roto.
Código para la fontanería, modelo para el juicio. Mover archivos, parsear, llamar APIs: eso es código normal. Las llamadas al modelo, resérvalas para donde hace falta criterio.
Verificación en la arista: un verificador que pare el trabajo flojo antes de que contamine el siguiente nodo.
Estado duradero: entre nodos viajan referencias a artefactos (un archivo, un ID), no transcripciones gigantes.
Ciclos con test de convergencia y presupuesto. Si la vuelta 3 no mejora la 2, para.
El fallo debe ser local: retry, fallback, skip, repair, escalate o stop. Que caiga la rama, no el grafo entero.
La topología es tu modelo de coste. La forma del grafo decide cuántas llamadas pagas y cuánto esperas. Diseñar la forma ES optimizar la factura.

¿Dónde estás tú? La escala

PROMPT → CONTEXTO → HARNESS → LOOP → GRAFO

Si ya afinaste el prompt, el contexto y el harness de tu agente, tu siguiente palanca no es un modelo más listo: es la forma del trabajo.

Checklist: revisa tu grafo antes de enviarlo

¿Cada flecha es una dependencia real? Recórrelas una a una y corta las que no lo sean.
¿Qué puede correr a la vez y hoy está esperando?
¿Cada nodo tiene un solo trabajo y un output que el siguiente puede leer sin adivinar?
¿Hay algún gate antes del paso caro?
¿Los ciclos tienen tope de vueltas y presupuesto?
¿Qué pasa cuando un nodo falla: cae el grafo entero o solo esa rama?
¿El estado que viaja entre nodos son referencias o transcripciones gigantes?

Pásala una vez por tu sistema actual. Con que cortes dos flechas falsas, ya lo notas.

Crédito

El marco original es de un hilo público de @0xwhrrari (10 de agosto de 2026). Aquí está aterrizado a cristiano y convertido en checklist; el mérito del concepto es suyo.

La regla de oro

Si el siguiente paso no lee lo que hizo el anterior, no le hagas esperar. Corta la fila.

Sígueme para más trucos con Claude Code e IA → @pabloinpublic

Únete a la comunidad → pabloinpublic.com