⚖️ La comparación de verdad

"Agentic" describe una forma de usar un modelo, no una arquitectura. Describes el objetivo, le das un conjunto de herramientas (búsqueda, terminal, editor de archivos) y dejas que el modelo decida, paso a paso, qué hacer a continuación. No hay un diagrama previo del camino: el camino se descubre en tiempo real, dentro de la propia conversación.

Esto no es un defecto, es la característica. Sirve justamente para tareas abiertas y exploratorias —"investiga este bug extraño", "lee este repositorio y cuéntame qué hace"—, cosas que se ejecutan una vez y en las que no sabes de antemano qué pasos vas a necesitar. Intentar dibujar el diagrama de flujo antes sería una pérdida de tiempo: todavía no sabes cuál será el flujo.

En el loop dejas de escribir prompts y empiezas a diseñar ciclos. En vez de confiar en que el modelo recordará verificar su propio trabajo, lo escribes en código: descubrir → planear → actuar → verificar → detenerse. La estructura sale de la cabeza del modelo y se convierte en algo que puedes leer, versionar y probar.

Sirve para tareas repetibles con un criterio de éxito verificable: generar un informe cada mañana, corregir un bug hasta que las pruebas pasen, escribir un texto hasta que cumpla una lista de calidad. Si ejecutas lo mismo más de una vez y sabes decir cuándo salió bien, el loop es la estructura adecuada.

Un grafo (en este sentido de arquitectura de agentes) son varios loops conectados por aristas escritas antes de ejecutar. Cada nodo del grafo es, por sí mismo, un loop, con su propio modelo, sus propias herramientas, sus propios permisos y su propia instrucción. El camino entre los nodos y lo que agrega el grafo.

Qué observar: el cuadro punteado es nuevo, pero el contenido de adentro no lo es: cada nodo todavía tiene su propia vuelta (el "loop" escrito dentro de él). El grafo no reemplaza el loop, lo compone bucles. Y lo que el siguiente tema va a construir con un caso real.

El caso es un resumen diario de investigación: cada mañana el sistema lee algunas fuentes sobre un tema, escribe un resumen de una página y verifica que sea correcto antes de enviarlo. Vamos a construir ese mismo objetivo tres veces y comparar qué pasa en cada versión.

Qué observar: tres cosas cruzan las aristas — notas, borrador e críticas — y ninguna de ellas es el HTML sin procesar de las fuentes. Eso es lo que distingue la versión con grafo de la versión de loop único: cada nodo recibe solo lo que necesita, nunca la transcripción completa del nodo anterior. (Transcripción = el historial completo de una conversación/ejecución, con todo el razonamiento intermedio — útil para depurar, demasiado pesado para pasarlo como entrada.)

Son tres cosas concretas, no una sensación de «más avanzado». Primero: nodos paralelos especializados con contextos limpios y separados — el investigador no arrastra el vocabulario del revisor, el revisor no arrastra el ruido de la búsqueda. Segundo: fan-out y fan-in como movimiento de primera clase — abrir una tarea en N ramas, ejecutarlas al mismo tiempo y reunir el resultado. Tercero: flujo de control explícito y auditable — el camino es un diagrama que puedes leer, no algo que reconstruyes leyendo un transcript de 40 mil tokens.

Qué observar: los dos lados resuelven "hacer más cosas" de maneras opuestas. El loop crece para bajo — más vueltas en el mismo nodo. El grafo crece para afuera — más nodos ejecutándose al mismo tiempo. No se puede hacer un fan-out real dentro de un único loop; solo sabe repetir, no dividir.

Nada de esto es gratis. Pasas a mantener tres prompts en vez de uno — cada nodo tiene su propia instrucción, y las tres tienen que evolucionar juntas sin romper las aristas entre ellas. Necesitas definir un esquema de estado: el formato exacto de lo que el investigador le entrega al escritor y de lo que el escritor le entrega al revisor. Sin este contrato escrito, los nodos empiezan a discrepar sobre qué significan «notas» o «borrador».

// grafo.json — VERSAO DEGENERADA (1 no, todas as ferramentas, todas as instrucoes)
{
  "nodes": [
    { "id": "faz-tudo", "model": "<seu-modelo>",
      "tools": ["buscar", "escrever", "revisar"],
      "prompt": "Busque as fontes, escreva o resumo e revise ate ficar bom." }
  ],
  "edges": []
}
// isto NAO e um grafo funcional — e um loop com nome de grafo.
// zero arestas = zero coisa que a estrutura de grafo esta fazendo.

// grafo.json — VERSAO DE TRES NOS (grafo de verdade)
{
  "nodes": [
    { "id": "pesquisador", "model": "<modelo-rapido>", "tools": ["buscar"],
      "prompt": "Para cada fonte em paralelo, extraia so os fatos relevantes ao tema." },
    { "id": "escritor", "model": "<modelo-de-escrita>", "tools": [],
      "prompt": "Com base APENAS nas notas recebidas, escreva um resumo de 1 pagina." },
    { "id": "revisor", "model": "<modelo-critico>", "tools": [],
      "prompt": "Compare o rascunho com as notas originais. Aprove ou reprove com criticas especificas." }
  ],
  "edges": [
    { "from": "pesquisador", "to": "escritor", "carrega": "notas" },
    { "from": "escritor", "to": "revisor", "carrega": "rascunho" },
    { "from": "revisor", "to": "escritor", "quando": "reprovado", "carrega": "criticas", "limite_voltas": 2 }
  ]
}