Grok Build código abierto: qué es y cuánto cuesta

Actualizado el 02/09/2026 — Este artículo fue actualizado con información reciente, análisis de seguridad profundo y secciones nuevas sobre auditoría técnica y casos de uso reales.

En pocas palabras: Grok Build es el agente de codificación de xAI que liberó su código el 15 de julio de 2026 bajo Apache 2.0, tras un escándalo donde filtraba repositorios Git completos con credenciales adentro. Podés auditar línea por línea una herramienta de 844.530 líneas de Rust, pero seguís pagando suscripción (desde USD 30/mes) para usarla. El código abierto cambió la confianza, no el costo.

Grok Build código abierto dejó de ser un pedido de la comunidad y pasó a ser realidad el 15 de julio de 2026. Ese día xAI publicó el harness completo bajo Apache 2.0, días después de que investigadores de seguridad descubrieran que la herramienta subía repositorios Git enteros —con credenciales, claves SSH y tokens de CI adentro— a sus servidores. Ahora podés auditar el agente de codificación de xAI línea por línea, aunque seguís necesitando una suscripción paga para usarlo en producción.

La movida llegó como control de daños, no como una estrategia comunitaria pensada a largo plazo. Y esa distinción importa: define lo que podés esperar del proyecto en los próximos meses. En esta guía vas a encontrar qué incluye exactamente el repositorio, cómo instalarlo paso a paso, qué riesgos de privacidad siguen vigentes, cómo auditar el código antes de llevarlo a producción y qué lo diferencia de Claude Code o ChatGPT en tareas reales.

Grok Build es un agente de codificación de terminal que lee y edita código, ejecuta comandos de shell y busca en la web, bajo una interfaz TUI de pantalla completa. Desarrollado por xAI (la empresa de Elon Musk), el harness es 844.530 líneas de Rust que desde el 15 de julio de 2026 están públicas bajo licencia Apache 2.0. A diferencia de los chatbots web, Grok Build trabaja directamente sobre tu repositorio: ve archivos reales, edita varios a la vez, corre tests, y toma decisiones en base a los resultados. El uso requiere suscripción paga de xAI (desde USD 30/mes), pero el código que corre localmente ahora se puede auditar línea por línea. No acepta contribuciones externas de la comunidad.

¿Qué es Grok Build y por qué no es un chatbot común?

Grok Build es un agente de codificación que corre en tu terminal y ejecuta tareas de programación por vos sin intervención manual entre pasos. Lee el proyecto, propone cambios, corre comandos, lee la salida y decide el siguiente paso en función del resultado. No devuelve texto para que copies y pegues: trabaja directamente sobre tu repositorio.

La diferencia con un chatbot tradicional es el alcance y el loop de retroalimentación. ChatGPT o Claude web te devuelven un fragmento de código que pegás a mano. Grok Build edita archivos reales, ejecuta tests, ve que falló algo, corre comandos de debugging y corrige lo que falta hasta cerrar la tarea. Eso lo vuelve útil para trabajo repetitivo: refactorizaciones de decenas de archivos, migraciones de versiones, escribir suites de tests desde cero.

• Lee y edita tu código directamente: recorre los archivos del repositorio, arma contexto del proyecto viendo el estado real, aplica cambios archivo por archivo y respeta tu estructura de carpetas.
• Ejecuta comandos de shell y ve los resultados: corre tests, builds, scripts de deployment y lee la salida sin depender de que vos le cuentes qué pasó.
• Busca en la web desde el loop: si le hace falta saber la firma de una función o la sintaxis de una librería, consulta documentación actualizada sin salir del terminal.
• Arma un plan antes de tocar nada: en modo interactivo, te muestra qué va a hacer paso a paso y esperá tu aprobación antes de aplicar cambios.
• Adapta su estrategia en función de los resultados: no es un script lineal. Si un test falla, lo lee, entiende por qué y prueba una corrección diferente.

¿Por qué xAI publicó el código después del escándalo de privacidad?

xAI abrió el código el 15 de julio de 2026 como respuesta directa a un problema concreto de privacidad, no porque madurara un plan comunitario. La cronología lo deja claro: primero vino el escándalo, después la apertura.

Medios especializados como Cybernews y The Hacker News reportaron en julio de 2026 que cuando Grok Build indexaba un proyecto, empaquetaba el árbol Git entero y lo subía a los servidores de xAI. El tema es QUÉ viajaba en ese árbol. Un archivo .env con claves de base de datos, un id_rsa privado de SSH, tokens de CI/CD, credenciales de terceros. Cualquiera que haya trabajado años con repos reales sabe que esos archivos aparecen más seguido de lo que uno está dispuesto a admitir, especialmente en proyectos legacy.

La respuesta de Elon Musk fue liberar el código para que “cualquiera pueda ver qué hace”. Suena bien. Pero hay que separar dos conceptos que casi siempre se confunden: transparencia no es lo mismo que proyecto abierto de verdad. Grok Build sigue siendo closed-source en el sentido de la gobernanza. Podés leer el código, forkearlo, compilarlo y modificarlo. Pero xAI decide sola qué entra al árbol oficial. Si enviás un pull request con un fix de seguridad, no va a ir a ningún lado. Es open source en licencia, no en comunidad.

¿Qué incluye exactamente el repositorio abierto y qué sigue siendo privado?

El repositorio de GitHub include el harness del agente completo, la interfaz TUI, la capa de herramientas y el sistema de extensiones. Lo que NO incluye es el modelo de lenguaje: la inferencia sigue corriendo en la nube de xAI y requiere login pago.

• Agent harness (el motor): 844.530 líneas de Rust que toman decisiones sobre qué herramienta usar, en qué orden, cuándo ejecutar comandos y cuándo pedir aprobación. Este es el grueso de lo publicado.
• TUI interactiva (la interfaz): la pantalla completa donde ves el plan propuesto por el agente y aprobás o rechazás cada cambio antes de que se aplique.
• Capa de herramientas (Tools): funciones para leer archivos, editarlos, ejecutar shell commands, buscar en la web y gestionar el estado del proyecto.
• Sistema de extensiones y plugins: soporte para MCP (Model Context Protocol), el estándar abierto de Anthropic para conectar herramientas externas a los modelos.
• Configuración y permisos: archivo config.toml donde definís qué herramientas habilitar, qué comandos permitir, qué carpetas proteger y qué modo de aprobación usar.

Lo que sigue siendo privado es el modelo de xAI. Cuando Grok Build llama a “inferencia”, esa llamada viaja a servidores de xAI en la nube. Vos no tenés acceso al modelo que piensa, solo a la herramienta que decide cuándo ejecutarlo. Esto importa para seguridad: podés auditar qué datos sale de tu máquina hacia la nube, pero no controlás qué hace xAI con esos datos una vez que llegan.

Modos de funcionamiento: interactivo, headless y embebido

Modo interactivo (TUI)

Es el modo por defecto cuando abrís Grok Build desde la terminal. Te muestra la interfaz de pantalla completa, escribís qué querés hacer (“arreglá este bug”, “agregá tests para este módulo”), y el agente propone un plan. Vos ves cada paso antes de que se ejecute y aprobás o rechazás. Ideal para trabajo exploratorio donde querés mantener control total.

Modo headless (sin interfaz)

Sin la TUI, pensado para pipelines de integración continua. Le pasás una tarea por parámetro, la ejecuta de forma automática y devuelve el resultado. Acá es donde el detalle de privacidad pega más fuerte: si lo enchufás a tu CI, cuidá exactamente qué contexto le das. Una tarea mal escrita podría hacerle leer el archivo de credenciales del servidor.

Modo embebido (via Agent Client Protocol)

Grok Build se integra en otros programas que implementen el Agent Client Protocol. Un editor IDE o una aplicación propia puede usar Grok Build como motor de codificación sin mostrar la TUI. La personalización se hace vía config.toml: definís herramientas disponibles, qué comandos shell se permiten, carpetas que nunca se tocan y qué datos se envía a la nube.

¿Cuánto cuesta Grok Build si el código es abierto?

El código cuesta cero; el uso no. Para que el modelo responda necesitás una suscripción activa de xAI. El piso mínimo es SuperGrok a USD 30 por mes, según la documentación oficial de docs.x.ai.

Esto es la parte que más confunde. Vos podés clonar el repositorio de github.com/xai-org/grok-build, compilarlo en tu máquina y correrlo gratis. Pero cuando el agente necesita “pensar” (hacer inferencia), esa llamada sale hacia la nube de xAI, y para acceder tenés que loguearte con una cuenta paga. Sin suscripción activa, el binario no va a iniciar. En la práctica, el piso de entrada anual es de unos USD 360.

No hay trial gratuito ni plan freemium. Si querés probar antes de pagar USD 30, tu opción es seguir la documentación del repositorio, compilar el binario y revisar el código fuente sin ejecutarlo en vivo.

¿Cómo instalar Grok Build paso a paso?

La instalación toma entre 5 y 15 minutos dependiendo de tu sistema operativo y si ya tenés el toolchain de Rust. Antes de empezar, verificá que cumplís estos requisitos.

• Sistema operativo compatible: corre estable en macOS (Intel y Apple Silicon), Linux (Debian, Ubuntu, Fedora, Arch) y WSL (Windows Subsystem for Linux). Soporte experimental para Windows directo (sin WSL) desde septiembre de 2026.
• Rust instalado: necesitás la toolchain de Rust. Si no la tenés, descargá desde rustup.rs (toma 2 minutos).
• Suscripción activa de xAI: desde SuperGrok (USD 30/mes). Sin ella, el agente no va a iniciar aunque tengas el binario compilado.
• Cuenta OAuth de xAI: la autenticación se hace contra tu cuenta mediante navegador. Necesitás acceso a internet durante el login.

Pasos de instalación

1. Cloná el repositorio: git clone https://github.com/xai-org/grok-build.git y navegá a la carpeta.
2. Compilá el binario: cargo build --release. Esto toma entre 3 y 10 minutos dependiendo de tu CPU. El binario compilado queda en target/release/grok-build.
3. Agregá a PATH (opcional): mové el binario a una carpeta en tu PATH (ej: /usr/local/bin en macOS/Linux) para ejecutarlo desde cualquier lugar.
4. Autenticás con OAuth: ejecutá grok-build auth login. Se abre el navegador automáticamente, iniciás sesión con tu cuenta de xAI y autorizás el acceso.
5. Creá tu archivo config.toml: en la raíz de tu proyecto, creá un archivo config.toml (ver sección de configuración avanzada).
6. Abrís tu proyecto: navegá a la carpeta de tu repositorio y ejecutá grok-build. La TUI se abre a pantalla completa.
7. Escribís el primer prompt: en inglés rinde mejor. Pedí algo acotado: “add tests for the login module” es mejor que “refactor the entire application”.
8. Aprobás cambios: el agente propone, vos aprobás o rechazás cada paso. Así por el primer mes.

Configuración inicial en config.toml

El archivo config.toml en la raíz de tu proyecto define qué puede y qué no puede hacer el agente. Estos son los parámetros más importantes:

• approval_mode: “manual” o “auto”. Manual = te consulta cada cambio. Auto = ejecuta sin pedir. Arrancá siempre en manual.
• max_file_size: tamaño máximo de archivo que el agente puede leer (default: 1MB). Evita que indexe binarios accidentalmente.
• protected_paths: lista de carpetas y archivos que nunca se tocan. Ejemplo: [".git", ".env", "config/secrets", "node_modules"].
• allowed_commands: comandos de shell que se permiten ejecutar. Puedes listar whitelist (ej: ["npm test", "npm run build"]) o restringir (ej: no permitir rm -rf).
• max_tokens_per_request: límite de tokens de inferencia por tarea. Ayuda a controlar costos si usás modo headless.
• enable_web_search: true/false. Si false, el agente no consulta la web (más rápido, menos contexto).

Un config.toml básico y seguro se ve así:

[agent] approval_mode = "manual" max_file_size = 1048576 protected_paths = [".git", ".env", "secrets", ".ssh", "node_modules"] allow_external_commands = false enable_web_search = true [limits] max_tokens_per_request = 4000 max_files_per_edit = 5

¿Es seguro usar Grok Build después del escándalo de filtración de credenciales?

Más seguro que antes del 15 de julio porque ahora podés verificar qué hace línea por línea. Pero el riesgo de fondo no desapareció: seguís usando un agente que lee tu código y envía contexto a servidores externos. La diferencia es que la verificación dejó de ser un acto de fe.

Antes de la apertura, tenías que confiar en que xAI filtraba bien los datos. Ahora el código que corre localmente está a la vista y un equipo técnico de tu empresa puede auditarlo. Eso sí: la inferencia sigue siendo remota, así que el contexto que le des al agente viaja igual. Estas medidas reducen el riesgo en forma concreta, pero no lo eliminan.

• Auditá tu .gitignore antes de arrancar: aseguráte de que .env, .ssh, archivos de configuración con secretos y credenciales de terceros estén excluidos del repositorio. Una línea olvidada = filtración garantizada.
• Barré el historial de Git en busca de secretos viejos: las credenciales commiteadas hace meses siguen en el historial aunque hoy estén borradas del working copy. Usá herramientas como git-secrets o trufflehog para detectarlas.
• Arrancá en modo aprobación manual: revisá cada lectura de archivo y cada comando antes de habilitar automático. El modo auto recién después de un mes de confianza.
• Limitá el contexto en modo headless: en CI/CD, no le pases el árbol entero. Pasale solo los archivos relevantes para la tarea, definidos explícitamente.
• Sumá una segunda capa de seguridad: firewall + proxy que filtre destinos de red, o una VPN corporativa. Si algo escapa de Grok Build, capás quedá atrapado en la red.
• Monitorea el tráfico saliente: una herramienta como Wireshark o tcpdump te muestra exactamente qué se transmite hacia dónde. Hácelo una vez en tu primer mes.
• Rotá credenciales tras la auditoría inicial: si alguna vez se filtraron, aunque sea en el escándalo de julio, rotá las API keys, tokens y passwords que podría haber tocado.

¿Cómo auditar el código de Grok Build antes de llevarlo a producción?

Una auditoría básica requiere 4-8 horas con alguien que sepa Rust. Consiste en rastrear dos cosas: dónde el harness lee archivos del disco y dónde abre conexiones salientes. Con eso cubrís el 90% de los riesgos de fuga de datos.

• Mapeá las funciones de lectura: identificá en el código Rust dónde se recorren archivos. Buscá funciones como fs::read, fs::read_dir, WalkDir. Verificá si respetan .gitignore, si tienen lista blanca/negra de archivos y si excluyen carpetas sensibles como .ssh, node_modules/.bin y directorios de caché.
• Rastreá las llamadas HTTP salientes: listá todos los endpoints a los que el agente hace POST/GET. Usá grep -r "http::" o grep -r "reqwest" para encontrar librerías de red. Clasificá: cuáles son telemetría, cuáles mandan contexto del proyecto, cuáles son búsqueda web.
• Probá con señuelos (canary tokens): armá un repositorio de prueba con archivos ficticios: .env falso con “AWS_KEY_FAKE_12345”, id_rsa con contenido canary, api_token.txt con un token falso de un servicio que monitoreás. Ejecutá Grok Build en modo headless sobre ese repo y observá si el tráfico saliente contiene esos datos. No debe.
• Interceptá el tráfico HTTPS: levantá un proxy local (ej: mitmproxy) y configurá Grok Build para que routee por ahí. Así ves exactamente qué se transmite, en texto claro, sin depender solo de la lectura del código.
• Revisa el manejo de credenciales OAuth: verificá que el token de autenticación se almacena con permisos restrictivos (chmod 600 en Linux), que no se logea, que no viaja en parámetros de URL y que se envía solo en headers HTTP Authorization.
• Documentá tus hallazgos: armá un reporte que diga “los datos X viajan a los servidores Y bajo condición Z”. Con eso definís si habilitás la herramienta, con qué permisos y qué controles de red.

Si tu equipo técnico no tiene experiencia en auditoría de código Rust, contratá un security consultant para una pasada. La inversión de 1-2k USD te ahorra dolores de cabeza si algo se filtra después.

Grok Build vs Claude Code: diferencias reales en tareas prácticas

Ambos son agentes de codificación de terminal, pero compiten en ligas distintas. Grok Build está optimizado para baja latencia y tareas rápidas. Claude Code gana en profundidad de razonamiento cuando el problema es complejo.