SpaceXAI (formerly xAI) open-sourced Grok Build, its terminal coding agent, in the first hours of July 16, 2026 (UTC), publishing the full code under the Apache 2.0 license on GitHub at xai-org/grok-build and resetting usage limits for all users at the same time. Grok Build is a Rust-based agent harness with a full-screen terminal interface (TUI) that drives automated coding with Grok 4.5. The release means the tool can now run entirely locally — you compile it yourself, point it at your own inference, and control everything from a config.toml file — and it lands directly after an early-July privacy controversy in which Grok Build was reported to upload entire repositories to SpaceXAI servers before a fix was deployed.
The move does two things at once. It puts the plumbing of an agentic coding tool — not just a model — into the open, and it answers a live trust problem in the most concrete way a vendor can: by letting anyone read exactly how the tool works and keep everything on their own hardware. This is a news analysis of what was released, how Grok Build is built, what the local-first mode changes, and how the open-sourcing relates to the data-upload reports that preceded it.
- What happened: On July 16, 2026 (UTC), SpaceXAI open-sourced Grok Build under the Apache 2.0 license at the GitHub organization
xai-org/grok-build, and reset usage limits for every user in the same announcement. - What Grok Build is: the company's terminal coding agent, first launched in May 2026 as a rival to Claude Code — a Rust agent harness plus an interactive TUI that automates coding with Grok 4.5, including a Plan mode for laying out code changes.
- The local-first point: you can now compile Grok Build yourself, point it at your own local inference, and run it from a single
config.toml— no requirement to route anything through SpaceXAI's servers. - The trust context: the release follows early-July reports (Winbuzzer, July 15) that Grok Build uploaded entire repositories to SpaceXAI servers before a remote fix was pushed. Open code plus local-first operation is a direct response — the tool is now auditable and can keep your data on your machine.
- The bigger pattern: after Thinking Machines released the open-weights model Inkling and in the wake of a run of Chinese open models, SpaceXAI is opening the tooling of agentic coding, not just a model.
What SpaceXAI Open-Sourced
SpaceXAI published the complete source of Grok Build under Apache 2.0 — a permissive license that lets developers read, modify, redistribute, and build commercial software on top of the code, with a patent grant, and without a copyleft obligation to release their own changes. The repository lives at the GitHub organization xai-org/grok-build. Worth noting for anyone tracking the company's identity: the lab rebranded from xAI to SpaceXAI on July 6, 2026, but the GitHub organization keeps the xai-org name. (For the rebrand itself, see our report on xAI officially becoming SpaceXAI while Grok stays unchanged.)
According to SpaceXAI, the public repository is synchronized periodically from its internal monorepo, so the open code tracks the tool the company ships rather than a stripped-down demo fork. Crucially, what is now visible is the whole path a coding agent takes: from how it assembles context — deciding what parts of your codebase and history to feed the model — all the way through to how it dispatches tool calls when the model decides to read a file, run a command, or edit code. That end-to-end visibility is the part that matters for anyone who wants to trust, audit, or extend an agent rather than treat it as a black box.
SpaceXAI also framed the code as extensible. The published harness is built to work with skills, plugins, hooks, MCP (Model Context Protocol) servers, and sub-agents — the same vocabulary that has become standard across the agentic coding tools that compete with it. Alongside the open-sourcing, the company reset usage limits for all users, a goodwill gesture that lands on the same day and softens the practical cost of experimenting with the newly open tool.
How Grok Build Works
Grok Build is SpaceXAI's terminal coding agent, first launched in May 2026 and positioned as a rival to Claude Code and the wider field of command-line coding assistants. (We covered the launch when Grok Build first arrived in May as a terminal agent aimed squarely at Claude Code and OpenAI Codex.) The open-sourcing is a separate event: this is the same tool, now with its source in the open.
Architecturally, Grok Build is two things joined together. The first is an agent harness written in Rust: the loop that takes your instruction, gathers the relevant context, calls the model, interprets what the model wants to do, runs those tool calls against your files and shell, and feeds the results back in — over and over — until the task is done. The second is a TUI, a full-screen terminal interface that is interactive with the mouse and designed to be extended. Rather than a bare prompt scrolling by, you get a structured, navigable workspace inside the terminal.
The model doing the reasoning is Grok 4.5, SpaceXAI's frontier model. Grok Build also ships a Plan mode: instead of jumping straight to edits, the agent can produce a code plan first — a laid-out set of intended changes you can review before it acts. That plan-then-execute pattern has become a common safety and quality lever across serious coding agents, because it gives a human a checkpoint before the model starts writing to your repository.
Because the harness is now open, the extension surface is real rather than aspirational. Developers can wire Grok Build to skills, plugins, and hooks, connect it to MCP servers to give it new tools and data sources, and compose sub-agents that hand work to one another. None of this is unique to Grok Build — it mirrors the direction of the whole category — but having the reference implementation in the open makes it far easier to see how the pieces fit and to build against them.
The Local-First Mode
The single most consequential change is that Grok Build can now run entirely on your own machine. Before, using the tool meant leaning on SpaceXAI's servers. With the source public, you can compile the binary yourself, point it at your own local inference — a model running on hardware you control — and drive the entire thing from a config.toml file. There is no longer an obligation to send your code, your prompts, or your project context through the vendor's infrastructure.
For individual developers, that removes a dependency and a recurring question of where their code goes. For teams in regulated or security-sensitive environments — where sending a proprietary codebase to a third-party server is simply not allowed — it is the difference between "cannot use this" and "can run it inside our own perimeter." It also puts Grok Build in the same conceptual bucket as running an open-weight model yourself: if you want the full picture of that trade-off, our guide on how to self-host an open-weight AI model walks through what local inference actually demands, and our explainer on choosing between closed and open-weight models covers the strategic side.
The honest caveat is that local-first is a capability, not a free lunch. Running your own inference means providing your own model and the hardware to serve it at a useful speed, and self-compiling a Rust project assumes a certain comfort with a toolchain. The point is not that everyone will run Grok Build locally tomorrow; it is that the option now exists, transparently, for anyone who needs it.
The Data-Upload Controversy — and Why Open Source Answers It
This release does not arrive in a vacuum. In early July, it was reported that Grok Build uploaded entire repositories to SpaceXAI's servers, before a remote fix was deployed to address the behavior. The account was published by Winbuzzer on July 15, one day before the open-sourcing. It is a reported issue, and the responsible way to describe it is plainly: a data-handling problem existed, a fix was pushed, and then — the next day — the company opened the code and shipped the local-first mode.
Whether or not the timing was planned around the reports, the substance lines up with the problem. When a tool has been flagged for moving data off a machine without users fully expecting it, the two strongest answers a vendor can give are transparency and control. Open-sourcing delivers transparency: security researchers, engineering teams, and curious individuals can now read exactly what Grok Build sends, when, and to where, instead of inferring it from network traffic. Local-first delivers control: if the inference runs on your own hardware and the tool is driven from your own config.toml, there is no server round-trip to worry about in the first place.
That is the real story here, and it is worth stating without spin in either direction. It would be too kind to present the open-sourcing purely as an act of generosity and ignore what preceded it. It would be too harsh to treat a reported bug that was fixed as proof of bad faith. What can be said cleanly is this: a trust question was raised, and the response — auditable code plus the ability to keep everything on your own machine — addresses the root of the concern rather than just the surface. Trust that can be verified is stronger than trust you are asked to take on faith.
July's Open-Source Wave
Grok Build's opening is part of a wider current running through the month. Thinking Machines, the lab founded by Mira Murati, released Inkling as an open-weights model, and a run of Chinese labs has continued to push capable open models into the field. Against that backdrop, SpaceXAI is doing something adjacent but distinct: it is opening the tooling of agentic coding, not a model.
That distinction is easy to miss and important to hold. Most of the open-source energy in AI over the past two years has been about weights — the models themselves. Grok Build is about the harness around a model: the context assembly, the tool dispatch, the loop, the terminal interface, the extension points. As agentic coding becomes the way a growing share of software gets written, the infrastructure that orchestrates it becomes as strategically interesting as the models it calls. Opening that layer lets the wider community study proven patterns, fork them, and standardize on them — which tends to accelerate the whole category rather than just one product.
It also raises the competitive temperature for the other terminal agents. Tools like Claude Code, OpenAI Codex, and Gemini Code Assist now sit next to a fully open, self-hostable alternative whose internals anyone can inspect. That does not make Grok Build the winner by default — closed tools compete on polish, models, and support — but "you can read the code and run it locally" is a genuine differentiator in a market where a lot of buyers are increasingly wary about where their code travels.
What It Changes for a Developer
For a working developer, the practical shift is concrete. You can now inspect Grok Build before adopting it — read how it decides what context to send and how it executes tool calls — rather than trusting a marketing page. You can run it inside your own environment if compliance or preference demands it. And you can extend it against a real reference implementation, wiring in skills, plugins, hooks, MCP servers, and sub-agents that fit your own stack.
Who is it actually for? Individual developers who want a capable terminal agent and value being able to audit and self-host it. Security-conscious and regulated teams for whom "the code is open and the inference can stay local" is the difference between a hard no and a viable pilot. And tool builders and researchers who want to study a production-grade agent harness rather than a toy. For a casual user who just wants a chat window to answer a coding question, none of this changes much — the audience that benefits is the one that cares about control, verifiability, and extensibility.
The measured takeaway: open-sourcing an agent harness under Apache 2.0, adding a local-first path, and doing it on the heels of a fixed data-handling issue is a meaningful trust move, and it deepens a pattern where the tooling of agentic coding — not only the models — is becoming open infrastructure. Whether Grok Build wins developers will come down to the quality of the tool and the model behind it. But the direction is clear, and it favors people who want to see exactly what their coding agent is doing.
Frequently Asked Questions
What did SpaceXAI open-source about Grok Build?
SpaceXAI open-sourced the full source code of Grok Build, its terminal coding agent, under the Apache 2.0 license on July 16, 2026 (UTC). The code is published on GitHub at the organization xai-org/grok-build and is synchronized periodically from SpaceXAI's internal monorepo. It exposes the whole agent — from how it assembles context to how it dispatches tool calls — and the extension points for skills, plugins, hooks, MCP servers, and sub-agents.
Is Grok Build safe to use now?
The safety picture improved with this release. In early July, Grok Build was reported to upload entire repositories to SpaceXAI servers before a fix was deployed (Winbuzzer, July 15). Open-sourcing the code makes the tool auditable — anyone can now read exactly what it sends and where — and the new local-first mode lets you keep everything on your own machine. That combination of transparency and control directly addresses the earlier concern, though, as with any tool, users should review the code and configuration for their own risk requirements.
Did Grok Build upload private repositories?
According to a Winbuzzer report published on July 15, 2026, Grok Build uploaded entire repositories to SpaceXAI's servers before a remote fix was pushed to address the behavior. It is a reported data-handling issue that was subsequently fixed. The open-sourcing and local-first mode announced the next day are, in effect, a deeper response: with the code public and inference runnable locally, users can verify the tool's behavior and avoid sending code off their machine at all.
Can I run Grok Build fully locally?
Yes. With the source now public, you can compile Grok Build yourself, point it at your own local inference (a model running on hardware you control), and drive the entire tool from a config.toml file. There is no requirement to route your code or prompts through SpaceXAI's servers. Running it locally does mean supplying your own model and the hardware to serve it, and being comfortable building a Rust project.
What license is Grok Build released under?
Grok Build is released under the Apache 2.0 license. That is a permissive open-source license: it lets you read, modify, redistribute, and build commercial products on top of the code, includes a patent grant, and does not require you to open-source your own modifications. It is the same license family used by many other open releases, and it is generally friendly to both individual developers and companies.
What is Grok Build and what model does it use?
Grok Build is SpaceXAI's terminal coding agent, first launched in May 2026 as a rival to Claude Code and OpenAI Codex. It combines a Rust agent harness with an interactive full-screen terminal interface (TUI), and it automates coding using Grok 4.5, SpaceXAI's frontier model. It also includes a Plan mode that produces a code plan you can review before the agent makes changes.
What programming language is Grok Build written in?
Grok Build is written in Rust. The open-sourced repository includes the Rust agent harness — the loop that assembles context, calls the model, and dispatches tool calls — along with the terminal UI and the tool layer. Because it is a compiled Rust project, running it locally involves building it with a Rust toolchain.
Where can I find the Grok Build source code?
The source code is on GitHub at the organization xai-org/grok-build. Even though SpaceXAI rebranded from xAI on July 6, 2026, the GitHub organization keeps the xai-org name. The public repository is synchronized periodically from SpaceXAI's internal monorepo, so it reflects the tool the company actually ships.
How does open-sourcing Grok Build rebuild trust?
Trust is rebuilt through transparency and control. Transparency: with the code open, security researchers and engineering teams can read exactly what Grok Build sends, when, and to where, instead of inferring it. Control: with local-first operation, inference can run on your own hardware and the tool is driven from your own config.toml, so there is no server round-trip to worry about. After a reported data-upload issue was fixed, opening the code and enabling local use addresses the root of the concern rather than just the symptom.
How is Grok Build different from Claude Code?
Both are terminal coding agents that drive automated code changes from the command line. The key difference after this release is that Grok Build is now fully open source under Apache 2.0 and can be self-hosted and run against local inference, so its internals are auditable. Claude Code is a closed tool that competes on polish, model quality, and support. Grok Build runs on Grok 4.5; Claude Code runs on Anthropic's Claude models. The right choice depends on whether verifiability and self-hosting matter more to you than a fully managed experience.
Does opening Grok Build fit a wider open-source trend?
Yes. The release lands during a broader July open-source wave: Thinking Machines released the open-weights model Inkling, and a run of Chinese labs continued pushing capable open models. SpaceXAI's move is distinct because it opens the tooling of agentic coding — the harness, TUI, and tool layer — rather than a model. As agentic coding becomes how more software is written, opening that orchestration layer turns it into shared infrastructure the whole community can study and extend.
Can I use Grok Build for commercial projects?
Yes. The Apache 2.0 license explicitly permits commercial use, modification, and redistribution, and includes a patent grant. You can build proprietary software on top of Grok Build without being required to open-source your changes. As always, you should read the license terms and any third-party dependencies yourself before relying on the tool in production.
Sources
- SpaceXAI — Grok Build is Now Open Source
- GitHub — xai-org/grok-build
- MarkTechPost — SpaceXAI Open-Sources Grok Build: The Rust Agent Harness, TUI, and Tool Layer Behind Its Coding CLI
- Winbuzzer — Grok Build Uploaded Repositories Before Remote Fix
