TokenMix Research Lab · 2026-07-22

Grok Build Open Source 2026: Apache 2.0, Local Models, Privacy

Last Updated: 2026-07-22 Author: TokenMix Research Lab Data verified: 2026-07-22 against the SpaceXAI announcement, Grok Build GitHub repository at commit 3af4d5d, official configuration and enterprise documentation, xAI API pricing, and the original wire-level privacy report.

SpaceXAI open-sourced the Grok Build coding-agent harness under Apache 2.0. It did not release Grok 4.5 model weights. You can compile, audit, fork, and connect the agent to local inference, but the default cloud workflow still requires separate privacy and network controls.

The July 15 release includes the Rust agent loop, file and shell tools, terminal UI, inline diff viewer, skills, plugins, hooks, MCP support, and subagent runtime. The repository says first-party code is Apache 2.0, while vendored components retain their original licenses. Our July 22 source audit checked 2,847 tracked files at commit 3af4d5d39897855bdcc74f23e690024a5dc05573. We found no current source string for the older codebase_upload or git bundle path, but the tree still contains session-trace upload, GCS storage, telemetry, and remote-settings infrastructure. That distinction matters because a reproducible test of Grok Build 0.2.93 found full-repository uploads before SpaceXAI disabled that behavior server-side. The current source is more auditable; it is not proof that every default execution path is offline. SpaceXAI's announcement, the GitHub repository, and the wire-level report establish those separate facts.

Table of Contents

• Quick Verdict
• What SpaceXAI Actually Open-Sourced
• Apache 2.0 License and Commercial Use
• Grok 4.5 Is Not Open Source
• Local Models and Local-First Architecture
• The Privacy Catch
• What the Current Source Code Shows
• Privacy-Hardened Configuration
• Cost Math: Open Harness, Paid Inference
• Use Case Matrix
• Risks and Caveats
• Final Recommendation
• FAQ
• About TokenMix
• Sources
• Related Articles

Quick Verdict

Grok Build is genuinely open-source software, but "Grok is open source" is still a misleading summary.

The practical verdict is direct: use the repository as an auditable agent framework. Do not treat it as an open-weight Grok release or as a privacy guarantee.

What SpaceXAI Actually Open-Sourced

The release covers the software around the model: the agent runtime, terminal interface, tools, and extension system.

The repository describes itself as a periodic sync from SpaceXAI's internal monorepo. At the audited commit, the public tree contained 2,847 tracked files and identified Rust as the primary implementation language. The README also says external contributions are not currently accepted. Users can inspect and fork the code, but "open source" does not yet mean a conventional upstream community workflow where outside pull requests are merged.

SpaceXAI publishes prebuilt binaries for macOS, Linux, and Windows. The source-build instructions list macOS and Linux as supported build hosts and describe Windows source builds as best-effort and not currently tested from the public tree. That is a packaging limitation, not a license limitation.

Apache 2.0 License and Commercial Use

Apache 2.0 permits commercial use, modification, and redistribution of Grok Build's first-party code, subject to its notice and license obligations.

The repository README explicitly separates first-party code from third-party and vendored code. Its notices include components derived from OpenAI Codex and OpenCode implementations. A commercial fork therefore needs a license inventory, not just a copy of the root Apache file.

Apache 2.0 also does not transfer SpaceXAI trademarks or guarantee continued access to Grok APIs. The harness license and model service agreement remain two different contracts.

Grok 4.5 Is Not Open Source

Grok 4.5 remains an API model; the open repository does not contain its weights, training code, or training data.

Official xAI documentation lists grok-4.5 with a 500K context window and current short-context prices of $2 per million input tokens, $0.30 per million cached tokens, and $6 per million output tokens. Prompts at or above 200K tokens use the published long-context rates of $4 input, $0.60 cached input, and $12 output. See the current xAI pricing page and our Grok 4.5 review.

Calling this a "Grok model open-source release" creates three bad assumptions:

1. It suggests the Grok 4.5 weights can be downloaded.
2. It suggests model inference has no token bill.
3. It suggests the entire stack becomes offline automatically.

All three are false.

Local Models and Local-First Architecture

Grok Build can use a local model because its model layer accepts a configurable model ID, base URL, display name, and credential environment variable.

The official configuration schema looks like this:

[model.my-model]
model = "model-id"
base_url = "https://api.example.com/v1"
name = "Display Name"
env_key = "API_KEY"

[models]
default = "my-model"

For a local OpenAI-compatible inference service, the same shape can point to localhost:

[models]
default = "local-coder"

[model.local-coder]
model = "your-local-model-id"
base_url = "http://127.0.0.1:8000/v1"
name = "Local Coder"
env_key = "LOCAL_MODEL_KEY"

The exact model ID, authentication behavior, tool-call format, and context limit depend on the local inference server. The example is a configuration pattern, not a claim that every open model can execute Grok Build's agent loop correctly.

Run grok inspect after editing the configuration. It reports the effective model, instructions, skills, plugins, hooks, and MCP servers detected for the current workspace.

grok inspect
grok -p "Explain the repository architecture" -m local-coder

Local inference does not make every tool local. Remote MCP servers, web search, authentication, updates, session sharing, and plugins may create their own connections. A privacy review must follow the whole graph, not only the model URL.

For multi-provider routing, use an explicit gateway policy rather than changing endpoints manually. The AI API gateway guide covers routing, fallback, and observability patterns.

The Privacy Catch

Open-sourcing makes Grok Build inspectable, but it arrived after a verified privacy incident involving an older binary.

An independent researcher tested Grok Build 0.2.93 with controlled repositories and intercepted the tool's own traffic. The report found two separate channels: model requests containing files the agent read, and storage uploads containing a repository snapshot. In one preserved test, approximately 5.10 GiB moved through storage requests while model-turn traffic totaled about 192 KB. A captured Git bundle could reconstruct a file the agent had been told not to read, together with Git history.

The researcher explicitly did not prove that SpaceXAI trained on the uploaded data. The evidence established transmission, server acceptance, and storage behavior for the tested version and account. Axios independently reported that uploads appeared to stop after disclosure and that SpaceXAI said previously uploaded data would be deleted.

The chronology supports a Likely inference that transparency became more urgent after the disclosure. It does not prove SpaceXAI open-sourced the project because of the incident. The official announcement presents reliability, extensibility, and local-first deployment as its reasons.

What the Current Source Code Shows

The July 21 source tree removes evidence of the named whole-codebase path, but retains configurable upload and telemetry systems.

We searched the audited commit for codebase_upload, upload_codebase, git_bundle, and git bundle; none appeared in tracked Rust, Markdown, or TOML files. That is useful evidence that the old path is not present under those names. It is not a network test and cannot prove equivalent behavior is impossible through a differently named path.

The current tree does contain:

• GCS and proxy upload utilities for session persistence and agent telemetry;
• a storage client using the Grok CLI proxy;
• a trace_upload setting and upload queue;
• remote settings that can influence telemetry;
• optional remote session sync;
• external OpenTelemetry controls.

This is the most important technical conclusion in the article:

Open source improves auditability. It does not replace runtime verification.

Privacy-Hardened Configuration

The safest configuration explicitly disables telemetry and trace uploads instead of assuming /privacy covers both.

The current user guide says these controls are independent:

• /privacy controls coding-data sharing;
• [features] telemetry controls product analytics;
• [telemetry] trace_upload controls session traces;
• external OpenTelemetry is a separate opt-in stream.

A conservative starting configuration is:

[features]
telemetry = false

[telemetry]
trace_upload = false
mixpanel_enabled = false

[models]
default = "local-coder"

[model.local-coder]
model = "your-local-model-id"
base_url = "http://127.0.0.1:8000/v1"
name = "Local Coder"
env_key = "LOCAL_MODEL_KEY"

The corresponding environment controls are:

export GROK_TELEMETRY_ENABLED=false
export GROK_TELEMETRY_TRACE_UPLOAD=false
grok inspect
grok -p "List the files you would need before reading them" -m local-coder

Environment variables and TOML syntax above come from the current repository documentation. We did not packet-capture this configuration, so "zero outbound traffic" remains a condition to verify, not a promised result.

For sensitive repositories:

1. Start with fake credentials and a canary repository.
2. Disable telemetry and trace upload explicitly.
3. Use a local model endpoint.
4. Block nonessential domains at the network layer.
5. Capture DNS and HTTPS destinations.
6. Confirm ignored files, Git history, plugins, and MCP data remain inside the intended boundary.
7. Repeat after every client update.

The local AI agent SSH workflow covers another important boundary: keeping credentials on the server instead of exposing private keys to a desktop agent.

Cost Math: Open Harness, Paid Inference

The Grok Build license costs $0, but Grok 4.5 inference remains usage-priced.

The calculations below use xAI's July 22 published short-context prices: $2 per million input tokens and $6 per million output tokens. They exclude tool calls, taxes, retries, priority processing, and long-context multipliers.

At 50 coding sessions per workday and 22 workdays, a $0.20 average model bill per session becomes:

50 sessions x 22 days x $0.20 = $220 per developer per month

That $0.20 average is a scenario assumption, not a measured Grok Build average. Teams should replace it with usage exported from their own sessions.

Long prompts change the math. xAI says prompts at or above 200K tokens use $4 per million input and $12 per million output for Grok 4.5.

Running a local model removes the xAI token charge but does not make inference free. Hardware purchase, GPU rental, electricity, engineering time, and lower task-completion rates can dominate the result. Without a measured local deployment, assigning a dollar saving would be Speculation.

For current account and model access steps, use the Grok API key guide and verify the live console before budgeting.

Use Case Matrix

Grok Build's open-source release is most valuable to teams that need an auditable agent shell, not to users expecting free Grok 4.5 weights.

Risks and Caveats

The largest risk is collapsing four separate questions - source availability, model weights, runtime traffic, and data retention - into one word: open.

Final Recommendation

Use Grok Build as an auditable Apache 2.0 agent framework, not as an open-weight Grok release. For ordinary coding, the official Grok 4.5 path is the simplest. For sensitive code, pin the source, choose a controlled model endpoint, disable telemetry and trace upload explicitly, block optional services, and verify the deployed binary on the wire.

FAQ

Is Grok Build open source?

Yes. SpaceXAI published the Grok Build coding-agent harness and terminal UI under Apache 2.0 on July 15, 2026. First-party code can be inspected, modified, redistributed, and used commercially under the license terms.

Is Grok 4.5 open source?

No. The Grok Build repository does not include Grok 4.5 weights, training code, or training data. Grok 4.5 remains available through SpaceXAI's products and API.

Can Grok Build run a local model?

Yes, if the model is exposed through a compatible inference endpoint. Grok Build supports custom model IDs, base URLs, names, and credential environment variables. Tool calling and context behavior still need workload testing.

Does local-first mean Grok Build is fully offline?

No. A local model removes the cloud model path, but authentication, updates, plugins, MCP servers, web tools, telemetry, trace upload, and remote sessions are separate network surfaces. Verify actual traffic before using sensitive repositories.

Can I use Grok Build commercially?

Yes, the first-party code is licensed under Apache 2.0. You must preserve required notices and separately review third-party licenses, trademarks, and any model-service terms.

Did Grok Build upload complete repositories?

An independent wire-level test confirmed that Grok Build 0.2.93 uploaded complete repository data in the tested setup. SpaceXAI reportedly disabled that behavior afterward. This article does not claim the current binary still behaves the same way.

Does /privacy opt-out disable all uploads?

No. Current Grok Build documentation says coding-data privacy, product telemetry, session trace upload, and external OpenTelemetry are independent controls. Disable and verify each relevant path separately.

How much does Grok 4.5 cost with Grok Build?

The harness has no license fee, while API inference is usage-priced. xAI currently lists short-context Grok 4.5 at $2 per million input tokens, $0.30 cached input, and $6 output; prompts at or above 200K use higher long-context rates.

About TokenMix

TokenMix.ai is an AI API relay for developers who need one OpenAI-compatible endpoint across OpenAI, Anthropic, Google, DeepSeek, Qwen, GLM, Grok, and other model families. Check the live model catalog, compare pricing, and read the API docs before routing production workloads.

Sources

• Grok Build is Now Open Source - Official July 15 announcement and release scope.
• xai-org/grok-build - Official source repository, build instructions, repository map, and contribution status.
• Apache 2.0 license - License text for first-party repository code.
• Grok Build documentation - Official installation, custom-model configuration, and API usage.
• Enterprise deployments - Official network hosts, configuration layers, authentication, and policy controls.
• Grok Build configuration guide - Current telemetry, privacy, and trace-upload settings.
• Monitoring usage guide - External OpenTelemetry defaults and content boundaries.
• xAI API pricing - Current Grok 4.5 short- and long-context prices.
• Wire-level Grok Build 0.2.93 analysis - Original methodology, artifacts, scope, and limitations.
• Axios: SpaceXAI wipes customer data after Grok uploads - Independent reporting on upload behavior and SpaceXAI's response.
• TechRepublic: Grok Build open source after privacy backlash - Independent release and privacy chronology.

Related Articles

• Grok 4.5 Review: $2/$6 API Pricing, 500K Context, Benchmarks
• Grok API Pricing 2026: Current Models, Cache, and Tool Costs
• Grok API Key: How to Get Access and Pricing 2026
• AI API Gateway 2026: Routing, Fallbacks, Observability, and Cost Control
• Local AI Agents over SSH Keys: A Safer Server Workflow