SSD Nodes Learn Hosting plans →
Guías Matt ConnorPor Matt Connor · Actualizado 2026-10-18

Graft: mapa de código para agentes de programación

Graft analiza tu repositorio con tree-sitter y crea un mapa de código consultable por MCP, para que el agente no redescubra su estructura en cada sesión.

Qué es un mapa del código para agentes de programación

Un mapa del código para agentes de programación es un índice persistente de su repositorio. El agente consulta este índice en lugar de recorrer el repositorio con grep desde cero en cada sesión nueva. Graft es una implementación de esta idea. Analiza el código con tree-sitter, escribe una carpeta de nodos Markdown enlazados junto con un grafo de conexiones por símbolo y ofrece herramientas de recuperación mediante MCP (model context protocol, la interfaz estándar que usan los agentes de programación para llamar a herramientas externas).

Graft no es un proxy ni una gateway. No se interpone entre el agente y la API del modelo. El mapa es una carpeta del disco que el agente lee. Esta diferencia determina qué problema se está resolviendo: un gateway de tokens autohospedado mide y enruta las solicitudes que ya envía, mientras que un mapa cambia cuántas solicitudes necesita enviar en total.

La técnica es anterior a esta herramienta y seguirá utilizándose después de ella. Aprenda primero la técnica y después los aspectos operativos.

Por qué los agentes de programación consumen contexto al redescubrir la estructura

Observe cómo un agente empieza a trabajar en un repositorio que ya ha visto cincuenta veces. Enumera los directorios. Busca un símbolo con grep. Abre tres archivos para averiguar cuál define la función y luego un cuarto para saber quién la llama. Nada de eso forma parte de la tarea. Es orientación, y se paga con tokens de entrada en cada sesión.

La causa es sencilla. Un modelo no conserva memoria entre sesiones. Todo lo que el agente aprendió sobre la estructura del repositorio estaba en una ventana de contexto que se descartó al finalizar la sesión. Por eso, el mismo descubrimiento vuelve a ejecutarse desde cero y se vuelve a pagar. La caché de prompts sólo aplica un descuento a un prefijo de prompt idéntico visto durante los últimos cinco minutos, o durante la última hora con un coste adicional. Por tanto, no puede trasladar la exploración de ayer a la sesión de hoy. En un repositorio grande, la fase de orientación cuesta más que la edición: diez llamadas a herramientas para localizar el código y una para cambiarlo. La orientación representa una mitad de ese coste y la edición, la otra. Por eso conviene combinar una skill que obligue al agente a realizar el cambio mínimo que funcione con un mapa, en lugar de elegir entre ambas.

Un mapa rompe ese ciclo al trasladar el descubrimiento del modelo al disco. Un parser recorre el repositorio una vez, registra dónde se define cada símbolo y qué símbolo llama a cuál, y mantiene ese registro actualizado cuando cambia el código. El agente realiza una pregunta y obtiene una respuesta con el archivo y la línea correspondientes. La exploración repetida se convierte en una consulta rápida.

Ya utiliza una versión más limitada de esto. Un archivo AGENTS.md que establece sus convenciones evita que el agente tenga que deducirlas de nuevo cada vez. Un mapa generado evita que tenga que deducir de nuevo la estructura. La diferencia está en quién lo escribe. Usted redacta el archivo de instrucciones manualmente, por lo que se mantiene pequeño. Un parser genera el mapa, por lo que puede abarcar diez mil archivos. Para saber en qué se consume realmente el presupuesto dentro de una sesión, consulte cómo Claude Code utiliza su ventana de contexto.

Qué construye realmente Graft

Dos artefactos, ambos dentro de una única carpeta graft/ en la raíz del repositorio.

El primero es un grafo de nodos escrito como Markdown enlazado, con un archivo por nodo. Cada nodo contiene un resumen en inglés sencillo, un «núcleo» con las líneas de lógica importantes extraídas del código fuente, los archivos de origen exactos con un hash de contenido, wikienlaces tipados a otros nodos (depends_on, part_of, uses, implements) y una sección de notas que se conserva durante la regeneración para registrar el contexto que un analizador no puede inferir.

El segundo es graft/.graph/wiring.json, el grafo estructural por símbolo que extrae tree-sitter: definiciones, referencias y las relaciones de llamada entre ellas.

La separación es importante porque sólo una de las dos partes necesita un modelo. graft build usa únicamente tree-sitter y nunca llama a un LLM (modelo de lenguaje grande), por lo que es determinista y no tiene coste. graft build --deep añade los resúmenes escritos y los núcleos por símbolo, que se generan mediante llamadas al modelo y tienen un coste.

La compatibilidad con lenguajes está organizada por niveles, y el nivel indica hasta qué punto se puede confiar en un grafo de llamadas. TypeScript, JavaScript, Python, Go, Java, Kotlin, PHP, Swift y R obtienen resolución entre archivos consciente del ámbito. Rust, C, C++, C#, Ruby, Scala, Elixir, Solidity, OCaml, Zig, Dart, Clojure, Nix y Lua obtienen símbolos y relaciones de llamada genéricas. Esto significa que una relación puede basarse en la coincidencia de un nombre en lugar de en una referencia resuelta. Las relaciones con precisión de compilador se activan de forma opcional con --lsp y un servidor de lenguaje como rust-analyzer o gopls.

Instalar Graft y fijar la versión

Graft necesita Node.js 20 o posterior y se distribuye con licencia MIT. A 17 de octubre de 2026, la versión actual es 0.23.0, publicada el 15 de octubre de 2026, y la primera versión publicada, 0.1.0, está fechada en julio de 2026. Considérelo software reciente. La versión 0.22.0, publicada el 14 de octubre de 2026, cambió el nombre del proyecto a Trail-code: el mismo código ahora también se distribuye como @trailhq/trail-code con un comando trail, mientras que @nanonets/graft mantiene el comando graft.

Esta guía fija la versión 0.21.1, publicada el 29 de septiembre de 2026 y última versión anterior al cambio de nombre, porque 0.22 y 0.23 modificaron comandos en los que se basa la guía. A partir de 0.22, graft check compara las diferencias de su rama con los aprendizajes del equipo del repositorio y devuelve 1 si detecta un conflicto; la detección de desviaciones pasó a graft build --check, y las herramientas MCP se denominan trail_* (el servidor todavía responde con los nombres antiguos graft_*). El registro de cambios de 0.23.0 también indica que, en un repositorio configurado con trail, el mapa pasa a .trail/cache/ y Claude Code deja de recibir un servidor MCP, mientras que el README todavía describe graft/ y .mcp.json. Lea el registro de cambios y ejecute --dry-run antes de cambiar la versión fijada.

npm install -g @nanonets/graft@0.21.1
npm ls -g @nanonets/graft

npm ls -g debería mostrar @nanonets/graft@0.21.1. Fije esa versión de forma intencionada. Un npm install -g @nanonets/graft sin versión resuelve la etiqueta latest en el momento de ejecutarlo, y en un proyecto que publica varias versiones menores al mes eso hace que el martes use una herramienta distinta de la que su compañero instaló el lunes. Una versión fijada mantiene iguales los indicadores de la CLI y el formato del grafo para todos, de modo que actualiza cuando usted lo decide.

Después, intégralo en un repositorio que administre:

cd /path/to/your/repo
graft init --dry-run
graft init

graft init pregunta con cuáles de sus agentes de programación debe integrarse y después crea el grafo. Ejecute primero --dry-run y revise la lista de archivos que prevé modificar, porque algunos pueden estar fuera del repositorio. graft init es idempotente y no sobrescribe configuraciones existentes, por lo que ejecutarlo una segunda vez es seguro. Para deshacer los cambios, graft uninstall elimina todos los archivos y entradas de configuración que haya escrito Graft; funciona como simulación hasta que se proporciona -y.

El mismo aviso incluye una casilla de telemetría. Desde la versión 0.12.0, Graft envía de forma predeterminada un evento anónimo de uso: recuentos agrupados y etiquetas fijas, nunca su código, las rutas de los archivos ni el nombre del repositorio. Los eventos se envían como máximo una vez al día, con una excepción: el evento de instalación, que el hook postinstall de npm entrega inmediatamente al proceso de envío en segundo plano. Desmarque la casilla durante graft init, ejecute graft telemetry disable o establezca DO_NOT_TRACK=1 para desactivarla (también se desactiva automáticamente en CI); graft telemetry debug muestra el lote que enviaría sin enviarlo.

En 0.21.1, la integración cubre Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf, Grok (xAI), AdaL, Hermes Agent y Google Antigravity. Hermes Agent es un host graft init de primer nivel desde la versión 0.13.0, y en la versión fijada graft init --agents hermes y graft init --agents antigravity seleccionan esos dos como cualquier otro host. Grok se incorporó en la versión 0.13.0 y se selecciona con graft init --agents grok. Claude Code obtiene la integración más completa: una entrada de servidor MCP, una línea de estado que muestra el tamaño y la antigüedad del grafo, hooks posteriores a la edición que reconstruyen el grafo y un archivo de skill en .claude/. Los demás reciben un archivo de instrucciones o reglas que informa al agente de que existen las herramientas (Hermes Agent y Antigravity también leen la sección AGENTS.md), y Grok recibe además un bloque MCP en su propia configuración. Por tanto, «compatible» significa que Graft escribe la integración; si un agente omite su propio archivo de reglas, también omitirá el mapa. Esa es la razón habitual por la que los agentes ignoran las instrucciones que usted les escribe, y aquí se aplica igual que en cualquier otro caso.

Qué se incorpora al repositorio y qué queda fuera de git

Después de graft init, encontrará estos elementos:

  • graft/: el grafo de nodos de Markdown y graft/.graph/wiring.json. Se añade a .gitignore automáticamente.
  • .mcp.json: registra el servidor MCP de graft para que Claude Code lo inicie.
  • .claude/settings.json: se fusiona en el archivo correspondiente y añade la línea de estado y los hooks posteriores a la edición.
  • AGENTS.md, GEMINI.md, .github/copilot-instructions.md, .cursor/rules/graft.mdc, .kiro/steering/graft.md, .windsurf/rules/graft.md, .grok/skills/graft/SKILL.md y .adal/skills/graft/SKILL.md: secciones delimitadas por marcadores que se añaden a los archivos que correspondan a los agentes seleccionados.
  • .grok/config.toml: un bloque [mcp_servers.graft] a nivel del repositorio, que sólo se escribe cuando selecciona Grok.
  • ~/.codex/config.toml, ~/.codex/hooks.json y ~/.codex/hooks/graft/graft-hooks.cjs: archivos de ámbito global, que sólo se escriben cuando selecciona Codex y ya existe ~/.codex/. graft init --no-global omite estos archivos y graft init --no-hooks omite por separado el wrapper del hook.

El grafo es una caché, como node_modules. No lo confirme en git. Se regenera a partir del código en unos segundos, cambia con casi cada edición y confirmarlo convierte una corrección de una línea en un diff de varios cientos de archivos que ningún revisor leerá. Confirme en su lugar la configuración de integración, incluidos AGENTS.md y .mcp.json. Un miembro del equipo clona el repositorio, ejecuta graft build y obtiene su propio grafo local.

Compruebe que la regla de exclusión se haya aplicado antes de hacer la primera confirmación:

grep -n graft .gitignore
git status --short

grep debería mostrar una línea que contenga graft/, y git status --short no debería mostrar ningún elemento bajo graft/. Si aparecen archivos de graft/ en esa salida, falta la entrada de exclusión o está anulada en otro lugar. Corríjalo antes de hacer la confirmación, porque git sigue realizando el seguimiento de un archivo una vez añadido, y una edición posterior de .gitignore no dejará de seguirlo.

Si prefiere registrar manualmente el servidor MCP o fijarlo a la misma versión que instaló, la entrada es breve:

{
  "mcpServers": {
    "graft": {
      "command": "npx",
      "args": ["-y", "@nanonets/graft@0.21.1", "mcp"]
    }
  }
}

Las herramientas de consulta que usa el agente en lugar de grep

Graft expone seis herramientas mediante MCP. graft_find_code devuelve nodos ordenados por relevancia para una descripción de tarea, con el archivo y la línea. graft_file_api devuelve todas las firmas de un archivo sin sus cuerpos. graft_trace_calls recorre los llamadores o las funciones llamadas durante varios niveles. graft_find_all devuelve las coincidencias de una expresión regular agrupadas por símbolo. graft_repo_map ofrece una primera visión de un repositorio desconocido. graft_check_freshness informa de si el grafo sigue coincidiendo con el código.

Cada una tiene un equivalente en la CLI. Es la forma de comprobar qué recibe realmente el agente:

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" --json

graft ask debería mostrar nodos ordenados por relevancia con referencias file:line, no el contenido de los archivos. Ese es todo el mecanismo: el agente recibe un puntero y abre un archivo, en lugar de leer diez para encontrar el correcto. graft viz abre un visor interactivo en localhost si quiere consultar el grafo directamente. Si graft ask no devuelve nada útil para una pregunta que podría responder en treinta segundos, no reformule la consulta para volver a intentarlo. La consulta ordenada puede no encontrar resultados, y el archivo de habilidades del proyecto indica que los resultados débiles requieren cambiar a graft grep, graft skeleton o graft callers. Si tampoco son suficientes, compruebe si hay desajustes (graft check . en la versión fijada 0.21.1, graft build --check a partir de 0.22) y confirme en qué nivel se encuentra su lenguaje, porque un grafo obsoleto o las aristas de un nivel demasiado amplio harán que el agente falle de la misma forma.

Hay un coste fácil de pasar por alto. Las seis definiciones de herramientas se inyectan en el prompt del sistema de cada solicitud durante toda la sesión. Ese coste se aplica tanto si el agente usa el mapa como si no. En un repositorio lo bastante pequeño para caber en el contexto, el coste fijo puede ser mayor que la exploración que evita.

Qué ocurre con el grafo cuando cambia el código

La actualización estructural es rápida y automática. Graft lee el árbol de trabajo, no git, por lo que detecta por igual una edición que todavía no ha confirmado y una edición que ha preparado. Cada consulta comprueba primero el árbol de trabajo y vuelve a analizar sólo los archivos que han cambiado. La documentación de 0.21.1 sitúa esa comprobación en unos 3 ms cuando no ha cambiado nada; el README actual indica unas decenas de milisegundos, aproximadamente 50 ms en el propio repositorio del proyecto. La reconstrucción al final de un turno sólo afecta a los archivos cuyo código ha cambiado. Establezca GRAFT_NO_REFRESH=1 o pase --no-refresh para responder usando el grafo almacenado en disco sin volver a analizarlo. Pase --no-reuse para forzar un nuevo análisis completo en frío, que es lo que debe hacer después de actualizar Graft.

La parte escrita por el modelo se comporta de otra forma y es donde los problemas pueden pasar inadvertidos. Los resúmenes y los puntos clave se almacenan en caché. Cada nodo registra un hash del contenido de sus fuentes, por lo que, cuando cambia un archivo de origen, el nodo se marca como obsoleto en lugar de presentarse como actual. Esa marca sólo sirve si algo actúa sobre ella. Actualice con graft build --deep, que vuelve a consumir tokens del modelo.

Haga visible la obsolescencia:

graft check .
echo $?

En la versión fijada 0.21.1, el estado de salida 0 significa que el grafo coincide con el código y el estado de salida 1 significa que hay divergencias. A partir de 0.22, graft check devuelve 1 cuando hay un conflicto con un aprendizaje del equipo, y la comprobación de divergencias es graft build --check, por lo que debe cambiar el comando cuando actualice la versión fijada. Ejecútelo desde un hook pre-push, para que un mapa con seis meses de antigüedad no responda con confianza sobre código que se reescribió en marzo. El README de 0.21.1 describe graft check como una señal local de actualización, y el README actual incluye build --check para CI. En ambos casos, graft/ está excluido de git, por lo que un checkout nuevo de CI comienza sin un grafo, a menos que el trabajo genere uno.

Lea con atención las cifras de los benchmarks publicados

El README de la versión 0.21.1 comenzaba con «hasta 4 veces más barato y 3 veces más rápido, con una corrección igual o mejor». El README actual elimina esa frase y presenta cifras más moderadas: «En 162 ejecuciones del mismo agente sobre las mismas tareas: un coste un 32% menor, un 42% menos de tokens de entrada no almacenados en caché, un 60% menos de tiempo y la misma proporción de respuestas correctas». Esas cifras proceden de los benchmarks propios del proyecto, publicados en su README. Estas son las dos ejecuciones que informa en detalle.

GráficoGraft's own published benchmark results, versus a no-map baseline, as of October 2026
Los datos de este 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
  }
]

La prueba controlada comprende 162 ejecuciones sobre dos repositorios, uno de ellos Graft, con tres pruebas por tarea. Informa de un 42% menos de tokens de entrada no almacenados en caché y de un 46% menos de llamadas a herramientas. La ejecución de SWE-bench Verified comprende 50 instancias con el mismo modelo en ambos grupos, y muestra un ahorro menor: 23% de tokens y 25% de llamadas a herramientas. Una tercera ejecución, con 15 tareas de PocketBase —diez preguntas de desarrolladores y cinco pull requests fusionadas reproducidas—, tuvo un coste total de 11.02 dólares estadounidenses, frente a 13.91 para la línea base.

Considere todo esto un benchmark del proveedor. Hay dos factores que limitan lo que puede indicar. La prueba controlada incluye el repositorio propio de Graft, que es el código contra el que sus autores ajustaron la herramienta. SWE-bench Verified es un conjunto de datos público con incidencias de proyectos Python de código abierto conocidos, y las herramientas se optimizan para los conjuntos de datos públicos, aunque no sea intencionado. Ninguno de los dos resultados describe su monorepo privado, que tiene sus propias convenciones de nombres y su propio código obsoleto.

La corrección requiere una segunda lectura. En la prueba controlada no cambió: 93% con el mapa, frente a 93% sin él. El aumento hasta 66%, desde 54%, aparece únicamente en SWE-bench Verified. Una herramienta que reduce el coste de los tokens y mantiene estable la calidad sigue siendo una buena opción. No traslade el resultado de corrección de SWE-bench al resultado de tokens de la prueba controlada ni presente ambos como una sola afirmación.

Mida tu propio delta de tokens antes de creer nada de esto

El único número que importa es el de tu repositorio. Este método requiere una tarde.

Elige una tarea que puedas repetir exactamente. Una pregunta es mejor que una edición, porque una edición modifica el repositorio y la segunda ejecución ya no es el mismo experimento. «Qué módulo aplica el límite de tasa en la ruta de inicio de sesión» tiene el formato adecuado.

Activa la telemetría y envíala a tu propia terminal:

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=console
claude

El exportador de consola imprime los registros de métricas a medida que se recopilan. El que necesitas es claude_code.token.usage, que contiene un atributo type con el valor input, output, cacheRead o cacheCreation. La orientación aparece en input y cacheRead, porque ahí se incluye el contenido de los archivos. Suma esos dos valores.

Ejecuta la tarea tres veces, cada vez en una sesión nueva, con el mapa conectado. Después elimina la entrada de injerto de .mcp.json y ejecútala tres veces más. Compara las medianas en lugar de ejecuciones individuales, porque las ejecuciones del agente varían mucho y una ejecución desafortunada puede indicar lo contrario de la realidad. Registra también el número de llamadas a herramientas: las llamadas a herramientas son el mecanismo y los tokens son el efecto, por lo que ahorrar tokens sin reducir las llamadas a herramientas significa que ha cambiado otra cosa.

Después resta los costes que el benchmark no muestra. graft build --deep consume tokens del modelo en cada actualización completa. Los seis esquemas de herramientas se incluyen en cada solicitud. Si tus agentes se ejecutan en un servidor alquilado, establecer un límite estricto para el gasto del agente convierte esto de una sorpresa en un presupuesto, y qué informa realmente la telemetría de un agente de programación explica qué sale de la máquina cuando activas el exportador.

¿Cuándo deja de ser útil un mapa del código?

  • El repositorio ya cabe en el contexto. Un servicio pequeño y único no necesita un mapa, y sigues pagando seis esquemas de herramientas en cada solicitud. Si tu agente encuentra hoy cualquier archivo en una o dos llamadas a herramientas, omítelo.
  • Tu lenguaje está en el nivel general. Las relaciones de llamadas genéricas pueden hacer que graft callers no encuentre un llamador o genere uno por una colisión de nombres. Confírmalo con graft grep antes de confiar en el alcance del impacto.
  • El grafo quedó obsoleto y nadie lo advirtió. En 0.21.1, graft check termina con el código 1 si detecta cambios (desde 0.22, lo hace graft build --check), pero esto sólo sirve si algo lo ejecuta. Usa un hook de pre-push, no la comprobación manual.
  • El monorepo necesita un ámbito más preciso. Un monorepo único de Git no se divide, pero graft build detecta subproyectos a partir de pnpm-workspace.yaml, los workspaces de package.json o los archivos go.mod, pyproject.toml o Cargo.toml de cada paquete, y los usa como ámbitos de clasificación. graft ask "..." --in services/billing/ limita una consulta a un solo subproyecto. El mismo criterio que lleva a usar archivos AGENTS.md anidados por paquete se aplica al mapa.
  • El agente ignora la configuración. Observa las llamadas a herramientas en una sesión real antes de concluir que se está usando el mapa. Si un agente sigue ejecutando grep, indica que nunca leyó el archivo de reglas.

FAQ

¿Debo incluir la carpeta graft/ en git?

No. graft build añade graft/ a .gitignore automáticamente, porque el grafo es una caché regenerable como node_modules. Cambia con casi cada edición, por lo que incluirla en los commits oculta las diferencias reales entre cientos de archivos generados. Incluya en el commit la configuración que informa a los agentes de que existe el mapa, incluidos AGENTS.md y .mcp.json, y deje que cada miembro del equipo ejecute graft build localmente. Verifique con grep -n graft .gitignore y git status --short antes de su primer commit, porque git sigue controlando un archivo una vez que se ha añadido, y editar .gitignore después no deja de controlarlo.

¿Cuesta dinero ejecutar Graft?

La parte estructural no. graft build, graft ask, graft check y las seis herramientas de recuperación MCP son operaciones de tree-sitter que nunca llaman a un modelo. graft build --deep es la parte de pago: escribe los resúmenes en inglés sencillo y los puntos clave de cada símbolo mediante un LLM, configurado con GRAFT_PROVIDER, GRAFT_API_KEY y GRAFT_MODEL, además de GRAFT_BASE_URL para cualquier endpoint compatible con OpenAI. Puede ejecutar Graft sólo con la estructura y no gastar nunca un token en el grafo.

¿Cuánto puede ahorrar realmente un mapa del código en mi repositorio?

Nadie puede decírselo sin medirlo. El proyecto informa de un 42% menos de tokens de entrada sin caché en su barrido de 162 ejecuciones y de un 23% menos de tokens en SWE-bench Verified, en ambos casos frente a una línea base sin mapa. Ambos son benchmarks del proveedor; uno de ellos se ejecutó parcialmente en el propio repositorio de Graft, y ninguno describe su código privado. Ejecute una misma pregunta reproducible tres veces con el mapa y tres veces sin él, con CLAUDE_CODE_ENABLE_TELEMETRY=1 y OTEL_METRICS_EXPORTER=console definidos, y compare la mediana de claude_code.token.usage para los tipos input y cacheRead.

¿Qué ocurre con el grafo cuando refactorizo?

La estructura se vuelve a analizar automáticamente. Graft comprueba el árbol de trabajo y vuelve a analizar sólo los archivos que han cambiado, por lo que un cambio de nombre se detecta en la siguiente consulta. Cuando no se ha movido nada, esa comprobación tarda aproximadamente 3 ms en 0.21.1 y unas decenas de milisegundos en la versión actual; además, detecta el trabajo sin confirmar porque lee los archivos en lugar del historial de git. Lo que queda obsoleto son los resúmenes escritos por el modelo: cada nodo almacena un hash de contenido de sus fuentes, y una fuente modificada marca el nodo como obsoleto en lugar de volver a escribirlo. Compruebe la desviación (graft check . en 0.21.1, graft build --check desde 0.22), y después ejecute graft build --deep para actualizar la parte escrita.

¿Qué agentes de programación pueden usar Graft actualmente?

En la versión fijada 0.21.1, graft init configura Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf, Grok (xAI), AdaL, Hermes Agent y Google Antigravity: once hosts en total. El registro de cambios incluye Hermes Agent como host de primera clase desde 0.13.0, y hermes y antigravity son ids ordinarios de --agents en la versión fijada. Claude Code recibe la configuración más completa: una entrada de servidor MCP en .mcp.json, una línea de estado, hooks posteriores a la edición y un archivo de skill en .claude/. Codex recibe una sección AGENTS.md y entradas para la máquina local en ~/.codex/, que graft init --no-global omite. Grok recibe un archivo de skill y un bloque MCP en .grok/config.toml. Hermes Agent y Antigravity leen la sección AGENTS.md, y los demás reciben un archivo de reglas o de directivas. Cualquier otro cliente MCP puede usar directamente el servidor si registra el comando npx -y @nanonets/graft@0.21.1 mcp.

¿Te resultó útil este artículo?