🔵 Fundamentos: el grafo

El nodo es una cosa de tu mundo: una persona, una tarea, un paso del proceso, un agente de IA. En el código aparece como n o node.

Elegir qué se convierte en un nodo es la primera decisión de modelado — y la que más suele fallar. Si el nodo es demasiado grande, el grafo no ayuda en nada; si es demasiado pequeño, te ahogas en detalles.

Nodo = sustantivo. Un nodo tiene identidad (puedes señalarlo) y puede contener datos (etiqueta, costo, responsable, estado).

La arista es la relación entre dos nodos. En código, e o edge. «Depende de», «se convierte en», «conoce», «pasa el resultado a».

En un sistema de agentes, la arista es donde reside la decisión: «si se aprobó, va por aquí; si se rechazó, vuelve por allá». Y el valor está más en las aristas que en los nodos.

Arista = verbo. Puede tener tipo (arista tipada), dirección y peso. Un grafo sin aristas es solo una lista de cosas sueltas.

En un grafo dirigido, aquí, la arista tiene una flecha: va de A hacia B y no vuelve por ahí. En un grafo no dirigido, la conexión funciona en ambos sentidos (la amistad, por ejemplo).

Todo flujo de trabajo de agentes es dirigido: el investigador entrega al escritor, no al revés. La dirección es lo que da orden al sistema.

Dirigido = flecha = orden. Si quieres volver, eso es otra arista (y puede tener su propia regla: «solo vuelve si se rechazó»).

Un número colgado de la arista: minutos, reales, tokens, probabilidad, distancia. Es lo que convierte un «dibujo» en una «estructura calculable».

Sin peso solo sabes si se puede avanzar; con el peso, lo sabes qué camino vale la pena. Y ahí entran la búsqueda y la optimización.

El peso puede ser costo (minimizar) o beneficio (maximizar). En un grafo de agentes, el peso suele ser latencia, costo en tokens o confianza.

Un camino que sale de un nodo y vuelve a él. Si un grafo dirigido no tiene ningún ciclo, es un DAG (grafo dirigido acíclico).

Este es el punto de inflexión de todo el curso: un bucle es un ciclo. El bucle es el grafo más simple que existe — un nodo con una arista que vuelve a sí mismo.

DAG = sin vuelta = termina solo. Con ciclo = puede repetirse = necesita una condición de parada; si no, se ejecuta para siempre.

Lista = cada elemento tiene un siguiente. Árbol = cada nodo tiene un solo padre, sin ciclos. Grafo = cualquier cosa se conecta con cualquier cosa. Las listas y los árboles son casos particulares de grafos.

Mucha gente dibuja un árbol (epic → story → task) y cree que con eso lo resolvió — hasta que aparece la dependencia cruzada entre dos ramas. Ahí el árbol se convirtió en grafo.

Si existe una dependencia cruzada, es un grafo. No fuerces un árbol en un problema que es un grafo: solo ocultarás la dependencia real.

Despertar → levantarse → cepillarse los dientes → café. Cada etapa es un nodo; el tiempo entre ellas es el peso de la arista (2 min, 5 min, 3 min).

Y el ejemplo más pequeño que ya lo muestra todo: nodos, aristas dirigidas, pesos en minutos y un camino alternativo (alguien te lleva el café a la cama) que salta un nodo.

Modelar = elegir qué es nodo y qué es peso. Camino alternativo = otra arista, no otro grafo.

Cada persona es un nodo; cada relación es una arista con peso (amistad, trabajo, temas en común). “Estás a 3 conexiones de Lucas” = 3 aristas de distancia.

Y el ejemplo que muestra que el algoritmo navega el grafo para decidir qué mostrarte. La misma idea se aplica a tu agente mientras navega por la documentación.

Distancia en aristas = «grados de separación». Peso de la arista = fuerza del loop. Recomendación = recorrido con criterio.

Campaña → tráfico → registro → activación → suscriptor → cancelación → LTV. Los nodos son estados del cliente; las aristas son tasas de conversión.

Y el ejemplo que expone el problema central del curso: optimizar una una arista (bajar el CAC) puede empeorar otra (subir el churn) sin que nadie se dé cuenta.

Una métrica nunca es suficiente. El grafo es lo que te permite ver el efecto secundario en vez de solo el efecto principal.

La épica contiene historias, la historia contiene tareas y la tarea contiene subtareas. Parece un árbol, hasta que una historia depende de otra. Ahí se convierte en un grafo.

Así es como un PM decide cuántas personas (o cuántos agentes) pueden trabajar en paralelo: el grafo indica qué ramas no se bloquean entre sí.

Arista de dependencia = bloqueo. Ramas independientes = posible paralelismo. Dividir la tarea y diseñar el grafo para no bloquear a nadie.

En vez de soltar decenas de archivos .md sueltos en carpetas, conectas los documentos entre sí e indicas el tipo de vínculo (“prerrequisito de”, “contradice”, “detalla”).

El agente deja de leerlo todo y pasa a navegar: entra por el nodo correcto y sigue las aristas relevantes. Menos contexto desperdiciado, más precisión.

Atención: esto es grafo de conocimiento, primo, pero no sinónimo, de graph engineering. La Trilha 3 separa los dos.

Módulo A importa B, B importa C. O npm, o make, tu CI: todos construyen un grafo dirigido y deciden el orden a partir de él.

Es el ejemplo más cercano a lo que harás con agentes: el build ya resuelve “qué se ejecuta en paralelo” y “qué espera”, exactamente como un grafo de trabajo.

Dependencia circular = ciclo = error de build. La herramienta detecta ciclos; tu grafo de agentes también tendrá que detectarlos.

En anchura (BFS) visitas a todos los vecinos antes de bajar; en profundidad (DFS) bajas por un camino hasta el final antes de volver.

Es la misma elección que haces con agentes: explorar muchas opciones superficialmente (amplitud) o seguir una línea hasta el final (profundidad).

La anchura encuentra primero lo más cercano. La profundidad encuentra una responde rápido. Marca quién ya visitaste — si no, el ciclo se convierte en un loop infinito.

Encontrar la ruta de menor costo entre dos nodos sumando los pesos de las aristas. El camino con menos saltos no siempre es el más barato.

En un grafo de agentes, el «costo» es en tokens, latencia o riesgo. Elegir la ruta es elegir cuánto vas a gastar para llegar al mismo resultado.

Menos aristas ≠ más barato. Si el peso cambia con el tiempo (latencia de API), la ruta óptima también cambia.

Una secuencia de ejecución válida en un DAG: nada se ejecuta antes de aquello de lo que depende. Es lo que el make calcula.

Es literalmente el planificador de tu grafo de agentes: indica qué ya puede ejecutarse y qué tiene que esperar.

Solo existe un orden topológico si no hay ciclos. Si el algoritmo no puede ordenar, encontró una dependencia circular.

Cuántos nodos están listos al mismo tiempo. Si dos ramas no se bloquean entre sí, caben dos trabajadores: dos devs o dos agentes.

Así dimensionas la flota: no sirve lanzar 20 agentes si el grafo solo libera 3 nodos a la vez.

El paralelismo es una propiedad del grafo, no de tu entusiasmo. Divide la tarea en partes que no se bloqueen entre sí aumenta el ancho.

B espera a A, A espera a B: nadie avanza. En un grafo de agentes, esto se convierte en un enrutamiento que va y viene entre dos nodos para siempre.

Y uno de los modos de falla nuevos que aporta el grafo y que el bucle no tenía. Necesita un límite de repeticiones y una detección explícita.

Todo ciclo necesita una salida: límite de iteraciones, criterio de progreso o aprobación humana. Ciclo sin salida = factura infinita.

En la práctica, un diccionario: para cada nodo, la lista de vecinos. {"pesquisa": ["escrita"], "escrita": ["revisao"]}.

Porque así es como vas a escribir tu grafo de agentes en JSON/YAML y entregárselo al orquestador — sin ningún framework si no quieres.

La lista de adyacencia sirve para casi todo. Guarda también los datos del nodo (modelo, herramientas, prompt) — eso es lo que lo convierte en un grafo agéntico.