⚖️ The Real Comparison

"Agentic" describes a way to use a model, not an architecture. You describe the goal, provide a set of tools (search, terminal, file editor), and let the model decide, step by step, what to do next. There is no predefined path diagram—the path is discovered in real time, within the conversation itself.

This isn't a defect; it's the defining feature. It's exactly right for open-ended, exploratory tasks — “investigate this strange bug,” “read this repository and tell me what it does” — one-off tasks where you don't know in advance which steps you'll need. Trying to draw the flowchart first would be a waste of time: you don't know the flow yet.

In a loop, you stop writing prompts and start designing cycles. Instead of trusting the model to remember to check its own work, you write that in code: discover → plan → act → verify → stop. The structure leaves the model's head and becomes something you can read, version, and test.

Works for repeatable tasks with verifiable success criteria: generate a report every morning, fix a bug until the tests pass, write a piece until it passes a quality checklist. If you run the same thing more than once and can tell when it worked, the loop is the right structure.

A graph (in this sense of agent architecture) is several loops connected by written-out edges before to run. Each node in the graph is itself a loop — with its own model, its own tools, its own permissions, and its own instructions. The path between the nodes are what the graph adds.

What to look at: the dashed box is new, but its contents aren’t— each node still has its own little loop (the word "loop" written inside it). The graph doesn’t replace the loop; it composes loops. And what the next topic will build with a real case.

The case is a daily research summary: every morning, the system reads a few sources on a topic, writes a one-page summary, and checks that it’s accurate before sending it. We’ll build this same system three times—and compare what happens in each version.

What to look at: three things cross the edges— notes, draft e criticism — and none of them is the raw HTML from the sources. That’s what separates the graph version from the single-loop version: each node receives only what it needs, never the entire transcript from the previous node. (Transcript = the complete history of a conversation/run, including all intermediate reasoning—useful for debugging, too heavy to pass along as input.)

These are three concrete things, not a vibe of “more advanced.” First: in parallel specialized nodes with clean, separate contexts — the researcher doesn’t carry the reviewer’s vocabulary, and the reviewer doesn’t carry the search noise. Second: fan-out and fan-in as a first-class movement — split a task into N branches, run them at the same time, and combine the result. Third: explicit and auditable control flow — the path is a diagram you can read, not something you reconstruct by reading a 40-thousand-token transcript.

What to look at: the two sides solve "doing more" in opposite ways. The loop grows to low — more iterations in the same node. The graph grows to outside — more nodes running at the same time. You can’t do a true fan-out inside a single loop; it only knows how to repeat, not split.

None of this is free. You now have to maintain three prompts instead of one — each node has its own instructions, and the three need to evolve together without breaking the edges between them. You need to define a state schema: the exact format of what the researcher delivers to the writer, and what the writer delivers to the reviewer. Without this written contract, the nodes start disagreeing about what “notes” or “draft” mean.

// 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 }
  ]
}