Graft: mapa de código para agentes de programação
Veja como o Graft usa tree-sitter e MCP para gerar um mapa persistente do repositório, reduzindo a redescoberta da estrutura a cada sessão do agente.
O que é um mapa da base de código para agentes de programação
Um mapa da base de código para agentes de programação é um índice persistente do seu repositório que o agente consulta, em vez de procurar às cegas desde o início em cada nova sessão. Graft é uma implementação dessa ideia. Analisa o seu código com tree-sitter, escreve uma pasta com nós Markdown interligados e um grafo de ligações por símbolo, e disponibiliza ferramentas de recuperação através de MCP (model context protocol, a interface padrão usada pelos agentes de programação para chamar ferramentas externas).
Graft não é um proxy nem um gateway. Nada fica entre o seu agente e a API do modelo. O mapa é uma pasta no disco que o agente lê. Essa distinção determina qual problema está a resolver: um gateway de tokens autoalojado contabiliza e encaminha os pedidos que já envia, enquanto um mapa altera a quantidade total de pedidos que precisa de enviar.
A técnica é anterior a esta ferramenta e continuará a existir depois dela. Aprenda primeiro a técnica e só depois os mecanismos.
Por que os agentes de programação gastam contexto a redescobrir a estrutura
Observe um agente a começar a trabalhar num repositório que já viu cinquenta vezes. Lista diretórios. Procura um símbolo com grep. Abre três ficheiros para descobrir qual define a função e depois um quarto para descobrir quem a chama. Nada disso faz parte da tarefa. É orientação, paga em tokens de entrada em todas as sessões.
A causa é simples. Um modelo não tem memória entre sessões. Tudo o que o agente aprendeu sobre a sua estrutura ficou numa janela de contexto que foi descartada quando a sessão terminou. Por isso, a mesma descoberta começa novamente do zero, e paga por ela outra vez. O armazenamento em cache de prompts só aplica um desconto a um prefixo de prompt idêntico visto nos últimos cinco minutos, ou na última hora a um custo adicional. Por isso, não consegue transportar a exploração de ontem para a sessão de hoje. Num repositório grande, a fase de orientação custa mais do que a alteração: dez chamadas de ferramentas para localizar o código e uma para o alterar. A orientação representa metade dessa despesa e a alteração representa a outra metade. Por isso, uma skill que obriga o agente a fazer a menor alteração que funcione deve ser combinada com um mapa, em vez de se escolher entre os dois.
Um mapa interrompe esse ciclo ao transferir a descoberta do modelo para o disco. Um parser percorre o repositório uma vez, regista onde cada símbolo é definido e qual símbolo chama qual, e mantém esse registo atualizado à medida que o código muda. O agente faz uma pergunta e recebe uma resposta com o ficheiro e a linha correspondentes. A exploração repetida transforma-se numa consulta barata.
Já utiliza uma versão mais limitada disto. Um AGENTS.md que indica as suas convenções impede o agente de voltar a deduzir as suas convenções em cada sessão. Um mapa gerado impede-o de voltar a deduzir a sua estrutura. A diferença está em quem o escreve. O ficheiro de instruções é escrito manualmente, por isso mantém-se pequeno. Um parser gera o mapa, por isso pode abranger dez mil ficheiros. Para saber como o orçamento é realmente utilizado dentro de uma sessão, como o Claude Code utiliza a sua janela de contexto explica essa contabilização.
O que o Graft realmente compila
Dois artefatos, ambos sob uma pasta graft/ na raiz do repositório.
O primeiro é um grafo de nós escrito como markdown encadeado, um arquivo por nó. Cada nó contém um resumo em linguagem simples, um "ponto central" das linhas de lógica importantes extraídas do código-fonte, os arquivos de origem exatos com um hash de conteúdo, wikilinks tipados para outros nós (depends_on, part_of, uses, implements) e uma seção de notas que sobrevive à regeneração para que você possa registrar o contexto que um parser não consegue inferir.
O segundo é o graft/.graph/wiring.json, o grafo estrutural por símbolo que o tree-sitter extrai: definições, referências e as arestas de chamada entre eles.
A divisão é importante porque apenas uma metade precisa de um modelo. O graft build é puramente tree-sitter e nunca chama um LLM (large language model), portanto é determinístico e não tem custo. O graft build --deep adiciona os resumos escritos e os pontos centrais por símbolo, e essas são chamadas de modelo pelas quais você paga.
O suporte a linguagens é dividido em níveis, e o nível indica o quanto você pode confiar em um grafo de chamadas. TypeScript, JavaScript, Python, Go, Java, Kotlin, PHP, Swift e R possuem resolução entre arquivos com reconhecimento de escopo. Rust, C, C++, C#, Ruby, Scala, Elixir, Solidity, OCaml, Zig, Dart, Clojure, Nix e Lua obtêm símbolos mais arestas de chamada genéricas, o que significa que uma aresta pode ser uma correspondência de nome em vez de uma referência resolvida. Arestas com qualidade de compilador são opcionais com o --lsp e um servidor de linguagem como o rust-analyzer ou gopls.
Instalar o Graft e fixar a versão
O Graft precisa do Node.js 20 ou posterior e é licenciado sob a licença MIT. Em 17 October 2026, a versão atual é 0.23.0, publicada em 15 October 2026, e a primeira versão publicada, 0.1.0, data de July 2026. Trate-o como software recente. A versão 0.22.0, publicada em 14 October 2026, mudou o nome do projeto para Trail-code: o mesmo código agora também é distribuído como @trailhq/trail-code com um comando trail, enquanto @nanonets/graft mantém o comando graft.
Este guia fixa a versão 0.21.1, publicada em 29 September 2026 e última versão antes da mudança de nome, porque as versões 0.22 e 0.23 alteraram comandos usados pelo guia. A partir da versão 0.22, graft check compara o diff da sua branch com os conhecimentos da equipa no repositório e termina com o código 1 em caso de conflito, a deteção de divergências passou para graft build --check e as ferramentas MCP passaram a chamar-se trail_* (o servidor continua a responder aos nomes antigos graft_*). O changelog da versão 0.23.0 também informa que, num repositório configurado com trail, o mapa passa para .trail/cache/ e o Claude Code deixa de receber um servidor MCP, enquanto o README ainda descreve graft/ e .mcp.json. Leia o changelog e execute --dry-run antes de alterar a versão fixada.
npm install -g @nanonets/graft@0.21.1
npm ls -g @nanonets/graftnpm ls -g deve mostrar @nanonets/graft@0.21.1. Fixe essa versão deliberadamente. Um npm install -g @nanonets/graft sem versão resolve a tag latest no momento da execução. Num projeto que publica várias versões secundárias por mês, isso faz com que tenha uma ferramenta diferente na terça-feira daquela que o seu colega instalou na segunda-feira. Uma versão fixada mantém os flags da CLI e o formato do grafo iguais para todos, para que atualize quando decidir.
Depois, configure-o num repositório que controla:
cd /path/to/your/repo
graft init --dry-run
graft initgraft init pergunta com quais dos seus agentes de programação deve ser integrado e depois cria o grafo. Execute --dry-run primeiro e leia a lista de ficheiros que pretende alterar, porque alguns podem estar fora do repositório. graft init é idempotente e não substitui configurações existentes, por isso é seguro executá-lo uma segunda vez. Para reverter as alterações, graft uninstall remove todos os ficheiros e entradas de configuração escritos pelo Graft. Por predefinição, funciona como uma simulação até passar -y.
O mesmo prompt inclui uma opção de telemetria. Desde a versão 0.12.0, o Graft envia por predefinição um ping anónimo de utilização: contagens agrupadas e etiquetas fixas, nunca o seu código, caminhos de ficheiros ou nome do repositório. Os eventos são enviados no máximo uma vez por dia, com uma exceção: o evento de instalação, que o hook postinstall do npm entrega imediatamente ao processo de envio em segundo plano. Desmarque a opção durante graft init, execute graft telemetry disable ou defina DO_NOT_TRACK=1 para a desativar (também é desativada automaticamente em CI). graft telemetry debug mostra o lote que seria enviado sem o enviar.
Na versão 0.21.1, a integração abrange Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf, Grok (xAI), AdaL, Hermes Agent e Google Antigravity. O Hermes Agent é um host graft init de primeira classe desde a versão 0.13.0 e, na versão fixada, graft init --agents hermes e graft init --agents antigravity selecionam esses dois como qualquer outro host. O Grok foi adicionado na versão 0.13.0 e é selecionado com graft init --agents grok. O Claude Code recebe a integração mais completa: uma entrada de servidor MCP, uma statusline que mostra o tamanho e a desatualização do grafo, hooks pós-edição que recriam o grafo e um ficheiro de skill em .claude/. Os restantes recebem um ficheiro de instruções ou regras que informa o agente de que as ferramentas existem (o Hermes Agent e o Antigravity leem ambos a secção AGENTS.md), e o Grok também recebe um bloco MCP na sua própria configuração. Portanto, "suportado" significa que o Graft escreve a integração; se um agente ignorar o próprio ficheiro de regras, também ignorará o mapa. Essa é a razão habitual pela qual os agentes ignoram as instruções que lhes escreve, e aplica-se aqui como em qualquer outro caso.
O que entra no seu repositório e o que fica fora do git
Após graft init, espere o seguinte:
graft/: o grafo de nós em markdown egraft/.graph/wiring.json. Adicionado ao.gitignorepara si..mcp.json: regista o servidor MCP graft para que o Claude Code o inicie..claude/settings.json: fundido no local, adicionando a linha de estado e os hooks de pós-edição.AGENTS.md,GEMINI.md,.github/copilot-instructions.md,.cursor/rules/graft.mdc,.kiro/steering/graft.md,.windsurf/rules/graft.md,.grok/skills/graft/SKILL.mde.adal/skills/graft/SKILL.md: secções delimitadas por marcadores anexadas a quaisquer ficheiros que correspondam aos agentes que escolheu..grok/config.toml: um bloco[mcp_servers.graft]ao nível do repositório, escrito apenas quando seleciona o Grok.~/.codex/config.toml,~/.codex/hooks.jsone~/.codex/hooks/graft/graft-hooks.cjs: ao nível da máquina, escritos apenas quando seleciona o Codex e o~/.codex/já existe. Ograft init --no-globalignora-os e ograft init --no-hooksignora o shim do hook por si só.
O grafo é uma cache, tal como o node_modules. Não o submeta (commit). Ele regenera-se a partir do código em segundos, altera-se em quase todas as edições e submetê-lo transforma uma correção de uma linha num diff de várias centenas de ficheiros que nenhum revisor lerá. Submeta a cablagem, incluindo AGENTS.md e .mcp.json. Um colega de equipa clona o repositório, executa o graft build e obtém o seu próprio grafo local.
Verifique se a regra de ignorar foi aplicada antes do seu primeiro commit:
grep -n graft .gitignore
git status --shortO grep deve imprimir uma linha contendo graft/ e o git status --short não deve listar nada sob graft/. Se aparecerem ficheiros sob graft/ nessa saída, significa que a entrada de ignorar está em falta ou foi substituída noutro local. Corrija isso antes de submeter, porque o git continua a rastrear um ficheiro depois de este ter sido adicionado, e uma edição posterior do .gitignore não deixará de o rastrear.
Se preferir registar o servidor MCP manualmente, ou fixá-lo na mesma versão que instalou, a entrada é pequena:
{
"mcpServers": {
"graft": {
"command": "npx",
"args": ["-y", "@nanonets/graft@0.21.1", "mcp"]
}
}
}As ferramentas de recuperação que o seu agent utiliza em vez de grep
O Graft expõe seis ferramentas através de MCP. graft_find_code devolve nós ordenados para uma descrição de tarefa, com ficheiro e linha. graft_file_api devolve todas as assinaturas de um ficheiro sem os corpos. graft_trace_calls percorre os chamadores ou chamados em vários níveis. graft_find_all devolve correspondências de expressões regulares agrupadas por símbolo. graft_repo_map fornece uma primeira visão de um repositório desconhecido. graft_check_freshness indica se o grafo ainda corresponde ao código.
Cada ferramenta tem também uma equivalente na CLI. É assim que pode verificar o que o seu agent está efetivamente a receber:
graft map .
graft ask "where do we validate the refresh token"
graft skeleton src/auth/session.ts
graft callers validateRefreshToken
graft callers validateRefreshToken --direction out
graft grep "refresh_token" --jsongraft ask deve apresentar nós ordenados com referências file:line, em vez do conteúdo dos ficheiros. Esse é todo o mecanismo: o agent recebe um apontador e abre um ficheiro, em vez de ler dez para encontrar o correto. graft viz abre um visualizador interativo em localhost se quiser consultar o grafo diretamente. Se graft ask não devolver nada útil para uma pergunta que poderia responder em trinta segundos, não reformule a pergunta para a repetir. A recuperação ordenada pode falhar, e o próprio ficheiro de competências do projeto indica que resultados fracos significam mudar para graft grep, graft skeleton ou graft callers. Se também não forem suficientes, verifique se há divergência (graft check . na versão fixada 0.21.1, graft build --check a partir da 0.22) e confirme em que nível a sua linguagem se encontra, porque um grafo desatualizado ou arestas de um nível demasiado amplo farão o seu agent falhar da mesma forma.
Há um custo fácil de ignorar. As seis definições de ferramentas são injetadas no prompt de sistema de todos os pedidos durante toda a sessão. Esse custo existe mesmo que o agent não utilize o mapa. Num repositório suficientemente pequeno para caber no contexto, o custo fixo pode ser superior à exploração que evita.
O que acontece ao grafo quando o código muda
A atualização estrutural é barata e automática. O Graft lê a sua working tree, não o git, por isso uma edição que ainda não foi commitada e uma edição que foi colocada em staging são igualmente visíveis para ele. Cada consulta verifica primeiro a working tree e analisa novamente apenas os ficheiros que mudaram. A documentação da versão 0.21.1 indica cerca de 3 ms quando nada mudou; o README atual fala em algumas dezenas de milissegundos, cerca de 50 ms no próprio repositório do projeto. A reconstrução no fim de cada execução processa apenas os ficheiros onde o código mudou. Defina GRAFT_NO_REFRESH=1 ou passe --no-refresh para obter respostas a partir do grafo em disco, sem analisar novamente os ficheiros. Passe --no-reuse para forçar uma nova análise completa, que é o procedimento indicado depois de atualizar o próprio Graft.
A parte escrita pelo modelo comporta-se de forma diferente e é aí que os problemas podem surgir sem serem detetados. Os resumos e os pontos essenciais ficam em cache. Cada nó regista um hash do conteúdo das suas fontes. Quando um ficheiro de origem muda, o nó é marcado como desatualizado em vez de ser apresentado como atual. Esse sinal só é útil se houver alguma ação sobre ele. Atualize com graft build --deep, que volta a consumir tokens do modelo.
Torne a desatualização visível:
graft check .
echo $?Na versão fixada 0.21.1, o código de saída 0 significa que o grafo corresponde ao código, e o código de saída 1 significa que existe divergência. A partir da versão 0.22, graft check termina com código 1 quando existe um conflito com um team learning; o controlo de divergências passa a ser graft build --check. Altere o comando quando mudar a versão fixada. Execute-o a partir de um hook pre-push, para que um mapa com seis meses não responda com confiança sobre código reescrito em março. O README da versão 0.21.1 descreve graft check como um sinal local de atualização, e o README atual lista build --check para CI. Em ambos os casos, graft/ é ignorado pelo git, por isso um checkout novo de CI começa sem um grafo, a menos que o job crie um.
Leia com atenção os números publicados do benchmark
O README da versão 0.21.1 começava com "até 4x mais barato e 3x mais rápido, com correção igual ou melhor". O README atual remove essa frase e apresenta números menores: "Em 162 execuções do mesmo agente nas mesmas tarefas: custo 32% menor, 42% menos tokens de entrada não armazenados em cache, 60% menos tempo e a mesma proporção de respostas corretas." Esses números vêm dos próprios benchmarks do projeto, publicados no README. A seguir estão, na íntegra, as duas execuções apresentadas.
Os dados por trás deste gráfico
[
{
"label": "Controlled sweep",
"run_count": 162,
"token_saving_pct": 42,
"tool_call_saving_pct": 46,
"correctness_pct": 93,
"baseline_correctness_pct": 93
},
{
"label": "SWE-bench Verified",
"run_count": 50,
"token_saving_pct": 23,
"tool_call_saving_pct": 25,
"correctness_pct": 66,
"baseline_correctness_pct": 54
}
]A varredura controlada inclui 162 execuções em dois repositórios, um deles o próprio Graft, com três testes por tarefa. Ela informa 42% menos tokens de entrada não armazenados em cache e 46% menos chamadas de ferramentas. A execução do SWE-bench Verified inclui 50 instâncias com o mesmo modelo nos dois grupos e informa uma redução menor: 23% dos tokens e 25% das chamadas de ferramentas. Uma terceira execução, com 15 tarefas do PocketBase, dez perguntas de desenvolvedores e cinco pull requests integrados reproduzidos, custou 11.02 dólares americanos no total, contra 13.91 para a linha de base.
Considere tudo isto um benchmark do fornecedor. Dois fatores limitam o que esses números podem indicar. A varredura controlada inclui o próprio repositório do Graft, que é a base de código contra a qual os autores ajustaram a ferramenta. O SWE-bench Verified é um conjunto de dados público com issues de projetos Python open source conhecidos, e as ferramentas são otimizadas para conjuntos de dados públicos, intencionalmente ou não. Nenhum dos dois representa o seu monorepo privado, que tem os seus próprios padrões de nomenclatura e o seu próprio código morto.
A correção exige uma segunda análise. Na varredura controlada, ela não mudou: 93% com o map, contra 93% sem ele. O aumento para 66%, partindo de 54%, aparece apenas no SWE-bench Verified. Uma ferramenta que reduz o custo dos tokens sem diminuir a qualidade continua a ser uma boa troca. Não transfira o resultado de correção do SWE-bench para o resultado de tokens da varredura e apresente ambos como uma única afirmação.
Meça a sua própria variação de tokens antes de acreditar em qualquer resultado
O único número que importa é o do seu repositório. Este método demora uma tarde.
Escolha uma tarefa que possa repetir exatamente. Uma pergunta é melhor do que uma edição, porque uma edição altera o repositório e a segunda execução deixa de ser o mesmo experimento. “Qual módulo aplica o limite de pedidos na rota de login” tem o formato certo.
Ative a telemetria e envie-a para o seu próprio terminal:
export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=console
claudeO exportador de consola imprime os registos de métricas à medida que são recolhidos. O que pretende é claude_code.token.usage, que contém um atributo type com o valor input, output, cacheRead ou cacheCreation. A orientação aparece em input e cacheRead, porque é aí que fica o conteúdo dos ficheiros. Some esses dois valores.
Execute a tarefa três vezes, cada uma numa sessão nova, com o mapa ligado. Em seguida, remova a entrada de graft de .mcp.json e execute-a mais três vezes. Compare as medianas em vez de execuções individuais, porque as execuções do agente variam muito e uma execução azarada pode indicar o oposto da realidade. Registe também o número de chamadas de ferramentas: as chamadas de ferramentas são o mecanismo e os tokens são o efeito. Portanto, uma redução de tokens sem uma redução nas chamadas de ferramentas significa que outra coisa mudou.
Depois, subtraia os custos que o benchmark não apresenta. graft build --deep consome tokens do modelo em cada atualização completa. Os seis esquemas de ferramentas são enviados em todos os pedidos. Se os seus agentes forem executados num servidor alugado, definir um limite rígido para os custos dos agentes transforma uma surpresa num orçamento, e o que a telemetria de um agente de programação realmente comunica explica o que sai da máquina depois de ativar o exportador.
Quando é que um mapa da base de código deixa de ajudar?
- O repositório já cabe no contexto. Um único serviço pequeno não precisa de um mapa, e continua a pagar por seis esquemas de ferramentas em cada pedido. Se o agente encontrar hoje qualquer ficheiro numa ou duas chamadas de ferramenta, não use o mapa.
- A sua linguagem está no nível abrangente. As ligações genéricas entre chamadas podem fazer com que
graft callersnão encontre um chamador ou crie um devido a uma colisão de nomes. Confirme comgraft grepantes de confiar no raio de impacto. - O grafo ficou desatualizado e ninguém reparou. Na versão 0.21.1,
graft checktermina com o código 1 quando deteta divergências (a partir da versão 0.22,graft build --checkfaz o mesmo), mas isso só é útil se alguma coisa o executar. Use um hook de pre-push, não dependa de um hábito. - O monorepo precisa de delimitação. Um monorepo num único repositório git não é dividido, mas
graft builddeteta subprojetos a partir depnpm-workspace.yaml, de workspacespackage.jsonou dego.mod,pyproject.tomlouCargo.tomlpor pacote e usa-os como âmbitos de classificação;graft ask "..." --in services/billing/limita uma consulta a um único subprojeto. O mesmo princípio que leva a usar ficheiros AGENTS.md aninhados por pacote aplica-se ao mapa. - O agente ignora a ligação. Observe as chamadas de ferramentas numa sessão real antes de concluir que o mapa está a ser usado. Se o agente continuar a executar
grep, isso indica que nunca leu o ficheiro de regras.
FAQ
Devo fazer commit da pasta graft/ no git?
Não. graft build adiciona graft/ automaticamente ao seu .gitignore, porque o grafo é uma cache regenerável, tal como node_modules. A pasta muda em quase todas as edições, por isso fazer commit dela oculta as diferenças reais entre centenas de ficheiros gerados. Faça commit da configuração que informa os agentes de que o mapa existe, incluindo AGENTS.md e .mcp.json, e deixe cada membro da equipa executar graft build localmente. Verifique com grep -n graft .gitignore e git status --short antes do primeiro commit, porque o git continua a acompanhar um ficheiro depois de este ser adicionado, e editar .gitignore posteriormente não o remove do acompanhamento.
Executar o Graft custa dinheiro?
A parte estrutural não. graft build, graft ask, graft check e as seis ferramentas de recuperação MCP são operações do tree-sitter que nunca chamam um modelo. graft build --deep é a parte paga: escreve os resumos em inglês simples e os pontos essenciais por símbolo através de um LLM, configurado com GRAFT_PROVIDER, GRAFT_API_KEY e GRAFT_MODEL, além de GRAFT_BASE_URL para qualquer endpoint compatível com OpenAI. Pode executar o Graft apenas com a estrutura e nunca gastar um token no próprio grafo.
Quanto pode um mapa da base de código poupar no meu repositório?
Não é possível responder sem medir. O projeto relata menos 42% de tokens de entrada sem cache na sua própria avaliação de 162 execuções e menos 23% de tokens no SWE-bench Verified, em ambos os casos comparando com uma baseline sem mapa. São benchmarks do fornecedor. Um deles foi executado parcialmente no próprio repositório do Graft, e nenhum descreve o seu código privado. Execute uma pergunta repetível três vezes com o mapa e três vezes sem ele, com CLAUDE_CODE_ENABLE_TELEMETRY=1 e OTEL_METRICS_EXPORTER=console definidos. Depois compare a mediana de claude_code.token.usage para os tipos input e cacheRead.
O que acontece ao grafo quando faço um refactoring?
A estrutura é analisada novamente de forma automática. O Graft verifica a árvore de trabalho e volta a analisar apenas os ficheiros alterados, por isso uma mudança de nome é detetada na consulta seguinte. Quando nada mudou, essa verificação demora aproximadamente 3 ms na versão 0.21.1 e algumas dezenas de milissegundos na versão atual. Também deteta alterações não commitadas, porque lê os ficheiros em vez do histórico do git. Os resumos escritos pelo modelo é que ficam desatualizados: cada nó armazena um hash do conteúdo das suas fontes, e uma fonte alterada marca o nó como desatualizado em vez de o reescrever. Verifique a existência de divergências (graft check . na versão 0.21.1 e graft build --check a partir da versão 0.22) e execute graft build --deep para atualizar a parte escrita.
Que agentes de programação podem utilizar o Graft atualmente?
Na versão fixada 0.21.1, graft init configura Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf, Grok (xAI), AdaL, Hermes Agent e Google Antigravity, num total de onze hosts. O changelog lista o Hermes Agent como host de primeira classe desde a versão 0.13.0, e hermes e antigravity são ids --agents normais na versão fixada. O Claude Code recebe a integração mais completa: uma entrada de servidor MCP em .mcp.json, uma linha de estado, hooks pós-edição e um ficheiro de skill em .claude/. O Codex recebe uma secção AGENTS.md e entradas ao nível de todo o sistema em ~/.codex/, que graft init --no-global não configura. O Grok recebe um ficheiro de skill e um bloco MCP em .grok/config.toml. O Hermes Agent e o Antigravity leem a secção AGENTS.md, e os restantes recebem um ficheiro de regras ou de steering. Qualquer outro cliente MCP pode utilizar diretamente o servidor ao registar o comando npx -y @nanonets/graft@0.21.1 mcp.