O gargalo mais caro em pipelines multi-agente não é o modelo, mas o contexto que precisa ser reconstruído a cada sessão e a cada troca de agente ou de máquina. Quando um orquestrador delega uma subtarefa, ele empacota o contexto relevante na chamada porque o agente especializado opera sem acesso ao estado anterior. Assim que o agente devolve o resultado, o orquestrador o reinjeta no próprio contexto antes de seguir pra próxima etapa. Em fluxos com três a cinco agentes em sequência, o custo acumulado de empurrar e puxar contexto entre eles compete com o custo da inferência em si. Quando a sessão termina, tudo recomeça do zero. Tenho usado uma stack com Obsidian e Graphify pra resolver exatamente esse problema.
O Graphify é uma skill open-source que transforma o repositório inteiro num grafo de conhecimento consultável: código-fonte em mais de trinta linguagens, especificações, documentação, PDFs, até imagens e vídeo. A extração de código é inteiramente local, feita por análise de árvore sintática via tree-sitter, sem nenhuma chamada de LLM. Nada sai da máquina, o que importa muito quando o repositório é proprietário ou sensível. O grafo captura as relações entre arquivos (chamadas, imports, herança) e organiza o código em comunidades detectadas automaticamente, sem embeddings e sem vector store. Os agentes podem consultar esse grafo via MCP.
Como boa parte do meu pipeline agêntico vive em uma VPS, o que mais impactou meu fluxo de trabalho foi o modo servidor. O Graphify expõe um servidor MCP acessível via rede, além do modo local por processo. Portanto eu configuro o endpoint do Graphify na VPS, e tanto o notebook quanto os agentes que rodam no servidor compartilham o mesmo grafo, entre sessões e entre dispositivos. Quando abro uma sessão no notebook depois de um dia inteiro trabalhando via agentes na VPS, o contexto não precisa ser reconstruído porque o grafo persiste no servidor. Isso elimina a reconstrução que consome os primeiros minutos e os primeiros tokens de qualquer sessão nova. O acesso é autenticado por chave de API, e o modo sem estado funciona pra ambientes de integração contínua.
A economia de tokens é consequência direta da arquitetura. Em vez de o orquestrador empacotar centenas de milhares de tokens no contexto de cada sub-agente, eles consultam o grafo por conta própria e recebem apenas o subgrafo relevante pra suas tarefas, tipicamente dezenas de nós e arestas em vez de centenas de arquivos inteiros. O Graphify aceita consultas em linguagem natural e devolve um recorte compacto do grafo, eliminando a necessidade de ler arquivos brutos. Em testes de retenção e raciocínio sobre histórico conversacional longo (LongMemEval-S, 50 questões), a acurácia alcança 76%. O sub-agente também deixa de depender do orquestrador pra receber e devolver contexto a cada etapa, o que reduz tanto o volume de tokens quanto o número de chamadas de ferramentas. Uma consulta estruturada ao grafo substitui uma longa sequência de greps e leituras de arquivo que, sem ele, o agente teria que fazer. Pra grafos de código puro, o custo de LLM na construção é zero, porque a extração é inteiramente local.
O grafo já contém as relações que o agente precisaria reconstruir relendo arquivos. Quando o código tem um import de um módulo que chama uma função em outro arquivo que herda de uma classe num terceiro, essas relações já estão extraídas e persistidas. O agente descobre a cadeia de dependência consultando o grafo em vez de abrir arquivos e inferir relações por leitura sequencial. Em bases de código com milhares de arquivos, essa reconstrução manual consome dezenas de chamadas de ferramentas e milhares de tokens a cada sessão.
O Graphify exporta o grafo como um vault do Obsidian, produzindo wiki markdown com ligações bidirecionais entre os nós. No meu fluxo, isso conecta o grafo de conhecimento do código ao meu sistema pessoal de notas. As anotações de arquitetura que mantenho no Obsidian ganham ligações estruturadas pro grafo do código, e o vault exportado se torna navegável com a visualização em grafo do Obsidian. A ponte entre o conhecimento que o agente consome via MCP e o que eu mantenho como referência de longo prazo fecha o circuito. A configuração desta integração é a parte realmente crítica e demanda uma boa spec para definir o workflow, mas é uma ação que vale cada hora investida.
O substrato compartilhado muda a dinâmica do pipeline inteiro. Cada agente deixa de operar como uma unidade isolada que precisa reconstruir o entendimento do zero e passa a consumir um grafo que já representa a estrutura do projeto em termos de relações entre componentes de código, specs e documentação. O custo de adicionar um agente ao fluxo cai vertiginosamente, porque o novo agente herda e atualiza o mesmo contexto sem necessidade de duplicação, o que remove a principal fonte de consumo de tokens, que cresce em silêncio sem que ninguém perceba até a fatura chegar.