Is Grok Build open source?

Yes. xAI’s official open-source page links to the public xai-org/grok-build repository. The repository identifies first-party code as Apache-2.0 licensed and includes the Rust source required for local inspection and builds. Open source here means the published code can be studied and built; it does not mean the project is community-governed or that every connected model is open source.

Can I build Grok Build from source?

Yes. Install Git and the Rust toolchain, clone the official repository, then use the documented Cargo commands to build and validate the workspace. Run Clippy and cargo fmt before relying on a local modification. Check the repository README first because prerequisites, crate names, and supported platforms can change after this guide is published.

What is the fastest way to get started?

Choose the path that matches your goal. Use the Grok Console on this page when you only need a quick text answer or want to compare hosted xAI models. Use xAI’s official installer when you want the terminal agent without compiling it yourself. Clone and build the public Rust repository when inspection, modification, reproducible builds, or internal security review are part of the requirement. In every path, begin with a test repository and a narrowly defined task before granting access to valuable source code or credentials.

Is Grok Build the same thing as the Grok Build 0.1 model?

No. Grok Build is the coding-agent harness, command-line workflow, and terminal interface. Grok Build 0.1 is a hosted xAI model available through providers such as OpenRouter. The harness determines how repository context, tools, approval, and execution work; the selected model determines inference quality, context capacity, speed, and usage cost.

Which xAI model should I choose in the Grok Console?

Start with Grok Build 0.1 for coding-agent questions and cost-conscious code work. Choose Grok 4.5 when the task needs stronger reasoning, Grok 4.3 when you need a larger context window, and a Grok 4.20 variant for very long inputs or multi-agent-style analysis. Model availability and pricing change, so use the live context and per-million-token figures above the chat rather than relying on an old screenshot.

How much does a conversation cost?

OpenRouter bills by tokens according to the selected model’s current input and output rates. The console shows both prices per one million tokens directly from the live model directory. A long conversation costs more because earlier messages are sent again as context, so clear the thread when starting an unrelated task and avoid pasting files or logs that are not needed.

How do the three free questions and account credits work?

A guest can complete three questions with the default Grok Build 0.1 model. The allowance is enforced on the server with a signed guest identifier and a hashed network identifier, so changing browser-side storage does not restore it. A failed or interrupted provider request releases the reserved question. Signed-in accounts receive their own server-side allowance and credit balance. Advanced models are locked until the account has credits; when paid credit packs launch, a request will reserve an estimated amount and settle against the provider’s reported token cost at the published retail multiplier.

How does email registration and sign-in work?

Registration uses Supabase Auth with email verification enabled. After creating an account, open the confirmation message and return through this site’s secure callback before signing in with the same email and password. The session is stored in secure Supabase cookies and refreshed by the Next.js server boundary. Password-reset links use the same verified callback. Google sign-in is shown only as a disabled preview and cannot be used in this release.

Is the OpenRouter API key exposed to visitors?

No. The browser sends messages to this site’s server-side /api/chat route, and that route adds the OpenRouter Bearer token before forwarding the request. The key is stored in .env.local, excluded from Git, and absent from the browser JavaScript bundle. Visitors can use the interface without seeing or copying the provider credential.

Where is my conversation stored?

The visible chat history stays in localStorage in the current browser so it can survive a refresh; this release does not copy message content into the account database. Supabase stores authentication, free-question usage, credit balance, and an accounting record for each model request, but not the conversation transcript. Prompts still travel through this server, OpenRouter, and the selected model provider for inference. Use Clear conversation to remove the browser copy, and do not paste material you are not authorized to send to those providers.

Can this web console edit my repository or run commands?

No. The console on this page is deliberately limited to streamed text chat. It cannot read your filesystem, clone a repository, execute shell commands, call MCP tools, or apply a patch. Use it to clarify an error, draft a plan, compare approaches, or prepare a prompt. To work directly against a repository, install the Grok Build CLI and review its permissions, proposed changes, terminal output, and Git diff in your own environment.

How should I describe a real coding task to Grok?

State a testable goal, then provide only the context needed to reach it: framework and version, relevant files, current behavior, exact error or reproduction steps, constraints, and the output you expect. For example, ask for a focused patch that preserves an existing API and passes named tests instead of saying only ‘fix it.’ Remove credentials and unrelated logs, request assumptions when evidence is missing, and treat the final diff and test results as proof of completion.

Can I paste private source code into the chat?

Only paste code you are authorized to send to external inference providers. This interface forwards prompt text to OpenRouter and the selected provider, so confidential repositories, credentials, personal data, and customer secrets require your organization’s approval and an appropriate provider-retention policy. Redact secrets and reduce the prompt to the smallest relevant excerpt.

Do I have to use an xAI-hosted model?

The open-source Grok Build CLI documentation describes custom model configuration, so the harness and model provider are separate concerns. This website’s console is intentionally restricted to model IDs beginning with x-ai/ because it is a focused Grok experience. If you need other providers, extend the server validation and model directory deliberately instead of accepting arbitrary client-supplied model IDs.

Which runtime modes are supported?

Official documentation describes three main surfaces: an interactive terminal UI for direct developer work, headless execution for automation, and ACP for editor or client integrations. The right choice depends on the approval boundary: use the TUI for hands-on review, headless mode for controlled scripts, and ACP when another application owns the user interface.

Does the repository accept pull requests?

Not currently. Its CONTRIBUTING.md says the public repository is provided for transparency and local builds and does not accept external contributions or unsolicited patches. You can still inspect, fork, and modify code under the applicable license, but you should not plan a workflow that depends on upstream accepting your pull request.

Does this site call the Grok or OpenRouter API?

Yes. The Grok Console sends text conversations through a validated server-side OpenRouter proxy to the selected xAI model and streams the answer back with SSE. Requests are limited to x-ai/ model IDs, a maximum conversation size, a per-minute guard, and a server-side free-question or credit reservation. Supabase provides email authentication and the usage ledger. The current interface supports text chat and Markdown responses; image uploads, file uploads, tool execution, payment checkout, and automatic credit purchases are not included yet.

What happens when OpenRouter returns an error?

The server converts provider errors into a short user-facing message without exposing the API key or raw provider metadata. Insufficient credits, rate limits, unavailable providers, and invalid requests remain distinguishable through their HTTP status. In the console you can retry the last user turn, switch to another xAI model, reduce the conversation size, or wait for the Retry-After window.

Open sourceRustApache-2.0CLI / TUI / ACP

Grok Build Open Source:Source Code, Setup, and How It Works

A source-backed field guide to the public Grok Build coding-agent harness—what is open, how to build it, where models fit, and what developers should verify before adopting it.

View source on GitHub Install Grok Build

Read the guide

grok-build / source

git clone https://github.com/xai-org/grok-build

cd grok-build

cargo run -p xai-grok-pager-bin# build

✓

agent harness readylocal source

RustApache-2.0Public source

Live model console

xAI models via OpenRouter

Interactive workspace

Ask Grok. Know the model, limit, and cost before you send.

Ask coding questions with three free guest questions on Grok Build 0.1. Your remaining questions and credit balance stay visible while you work.

Provider

OpenRouter

Default

Grok Build 0.1

Guest access

3 questions

Usage

Credits + free access

Grok PlaygroundxAI models via OpenRouter

Cached catalog

xAI model

Context

256K

Input / 1M

2,000 cr

Output / 1M

4,000 cr

Free questions3 / 3

Credit balance0 cr

View pricing

Grok Build 0.1 ready

Ask about code, architecture, debugging, or the Grok Build source.

Ask three questions free as a guest. Sign in to keep your account balance, then add credits when advanced models become available.

Conversations stay private to this browser until you clear them.Three free questions. Credits unlock advanced models.

Model selection

Choose by task, not by the largest model number.

Start with Grok Build 0.1 for ordinary coding work. Move to a broader or stronger model when the task actually needs more context or reasoning. The selector above is the source of truth for current context length and token prices.

Grok Build 0.1

Focused coding option with the lowest current xAI input and output rates in the live catalog.

Start here for code generation, debugging, repository planning, and questions about agent workflows.

Grok 4.5

Higher current output cost than Grok Build 0.1; keep the prompt focused.

Use for difficult architecture decisions, deeper reasoning, or code review where answer quality matters more than price.

Grok 4.3

A larger context window does not remove the need to trim irrelevant logs and generated files.

Useful for long specifications, broad repository context, and comparisons that need more source material in one request.

Grok 4.20 / Multi-Agent

Long-context requests can still become expensive; confirm the live model price before sending.

Evaluate for very long inputs, decomposed analysis, and tasks that benefit from exploring several solution paths.

Prompt recipe

Give the model a testable target.

“Fix this” forces the model to guess. A useful coding prompt names the finish line, the relevant environment, constraints, observable evidence, and the output you expect. Paste only the smallest code or log excerpt needed to make the problem concrete.

reusable / task brief

Goal: [what must be true when the task is finished]
Context: [language, framework, relevant files, current behavior]
Constraints: [what must not change, security, performance, compatibility]
Evidence: [error message, code excerpt, logs, or reproduction steps]
Output: [patch, explanation, test plan, or decision memo]

01Overview

What is Grok Build?

An agent harness and terminal interface—not just a model name.

Grok Build coordinates repository context, tools, model reasoning, edits, review, and approval. Its public source covers the coding-agent harness and CLI surface.

Open-source layer

Grok Build

The public Rust repository contains the agent runtime, CLI, and full-screen terminal UI. This is the code you can inspect and build locally.

Browse the repository

Hosted model layer

Grok Build 0.1

A separately listed hosted model. Model access and pricing are provider concerns; they are not the same as the open-source CLI repository or its license.

Live provider: OpenRouter xAI

Model requests use a server-side OpenRouter proxy. The provider key never ships to the browser. Supabase handles email sessions, free-question limits, and the credit ledger; payment checkout is intentionally not enabled yet.

What you can inspect

The public repository lets you examine how the terminal, agent runtime, configuration, tools, and extension surfaces are implemented. You can compile that code locally, review dependency choices, and compare a release with your own fork.

What remains hosted

Model inference still runs on a provider’s infrastructure. Model weights, provider retention, availability, latency, and token charges are separate from the CLI’s source license. Open-source client code does not make hosted inference free.

What OpenRouter adds

OpenRouter provides one normalized API and a live model directory. This site uses it as a gateway, while restricting requests to xAI model IDs and keeping the credential on the server. Switching models changes inference, not the harness.

02Why open source

Why it matters

Source turns agent behavior into something developers can examine.

The practical value is not a slogan. It is the ability to trace code paths, reproduce builds, understand extension points, and evaluate the project’s actual boundaries.

Inspectable

Read the agent harness instead of inferring behavior from a closed interface.

Buildable

Compile and validate the first-party Rust source in your own environment.

Extensible

Trace where skills, hooks, MCP servers, tools, and model configuration connect.

Bounded

Review the license and contribution policy before treating public source as a community project.

Adoption checklist

Inspect the operational boundary before giving an agent access.

Reading source is the beginning of due diligence, not the end. Your deployment policy must also cover data, command execution, provider spend, updates, and any external tool the agent can call.

01
Confirm which source files, network calls, and telemetry paths exist in the version you plan to deploy.
02
Define whether the agent may edit files, execute commands, access secrets, or call external MCP servers.
03
Set provider credit limits and rate limits before exposing a shared chat or automated workflow.
04
Review the Apache-2.0 scope, third-party dependencies, and the repository’s closed contribution policy.
05
Choose an update process because the public repository is periodically synced from an internal monorepo.

03How it works

System map

Five layers connect source code to an approved change.

The harness loads repository context, coordinates an agent runtime, invokes tools, calls a configured model, and returns control to the developer through the terminal.

Repository

Source + AGENTS.md

Agent runtime

Plan + execute

Tools / MCP

Inspect + change

Model

Reasoning engine

Terminal

Review + approve

Load repository instructions

The harness begins with repository context such as AGENTS.md, working-tree state, and the developer’s request. Good instructions define scope, commands, and files that must not change.

Plan the task

The agent converts the request into a sequence of inspect, edit, and verification steps. A useful plan names the acceptance criteria instead of only describing the desired appearance.

Invoke tools and MCP

File reads, shell commands, external tools, and MCP servers provide evidence or perform bounded actions. Permissions should match the task and high-impact actions should remain reviewable.

Ask the configured model

The model receives selected context and tool results, then proposes the next action or response. Changing the model affects reasoning, context capacity, latency, and cost—not the repository license.

Review and approve

The terminal, headless runner, or ACP client returns changes and results to the developer. Treat tests, diffs, and command output as the final evidence, not the model’s confidence.

Capabilities

Built for programmable coding workflows.

Official materials describe repository instructions, extension surfaces, parallel work, and several ways to run the agent.

/01

AGENTS.mdContext

Repository context

Use AGENTS.md files to carry project-specific instructions through a coding session.

/02

SkillsHooksMCP

Extensible workflows

Add skills, plugins, hooks, and MCP servers without replacing the core terminal workflow.

/03

SubagentsWorktrees

Parallel execution

Delegate independent work to subagents and isolate changes with Git worktrees.

/04

TUIHeadlessACP

Multiple surfaces

Run interactively in the TUI, automate headlessly, or connect through ACP.

04Build from source

Local setup

Clone the repository. Build the Rust workspace. Verify before use.

These commands follow the public xAI open-source page. Check the repository README for prerequisites and changes before running them.

Toolchain

Install Git plus a Rust toolchain that provides cargo, rustc, Clippy, and rustfmt. Follow the repository when it pins a specific version.

Workspace

Use a clean local directory and inspect the README, license, workspace manifest, and build scripts before executing project commands.

Credentials

Keep provider keys in local environment files or a secret manager. Never commit them to a fork, example config, terminal transcript, or issue.

00 / clone

$git clone https://github.com/xai-org/grok-build
$cd grok-build

01 / Build

cargo run -p xai-grok-pager-bin# build

02 / Validate

cargo check -p xai-grok-pager-bin# validate

Verification

A successful compile is not the whole acceptance test.

cargo check exits successfully for the documented workspace target.

Clippy findings are reviewed rather than suppressed without explanation.

cargo fmt --all produces no unexpected source changes.

The launched TUI can load a test repository without receiving production secrets.

Prefer a prebuilt release? Use xAI’s installer. Building from source is useful when you need to inspect the implementation or validate a local toolchain.

Official installer

05Who it’s for

Audience

Useful when you care about the harness—not only the output.

Grok Build’s public source is most relevant to people evaluating terminal workflows, extension architecture, and operational control.

CLI-first developers

Keep planning, edits, review, and approval inside a keyboard-driven workflow.

AI tool builders

Inspect a real agent harness and study how tools, context, and models connect.

Platform teams

Evaluate extension points before standardizing an agent workflow across repositories.

Source auditors

Build first-party code locally and examine the public Rust implementation.

Open-source researchers

Track the public sync, license boundary, and architecture without relying on a black box.

Strong fit

You want inspectable automation with a developer in control.

Grok Build is worth evaluating when your team already uses Git, terminal tooling, automated checks, and explicit approval boundaries. It is especially relevant when the ability to inspect or fork the harness matters to procurement or security.

Reconsider

You need a managed, no-code product with formal support.

The public repository currently does not accept contributions. Teams that require an upstream customization path, guaranteed support, centrally managed user accounts, or a zero-terminal workflow should verify those needs before standardizing on it.

06Boundaries

Read before adopting

Public source does not automatically mean a community-governed project.

The repository is useful for transparency and local builds, but its license, sync model, and contribution policy should be read together.

License

Apache-2.0

The repository identifies first-party source as Apache-2.0 licensed. Review dependency licenses and notices separately before redistribution.

Contribution

External PRs closed

The current guide says unsolicited patches and pull requests are not accepted. A fork can diverge without an upstream merge path.

Source flow

Public mirror

The public repository says it is periodically synced from an internal monorepo. Public commit timing may not match internal development.

Read the official contribution policy

Practical boundary

Audit the version you deploy, not the project’s reputation.

An open repository answers “what code was published?” It does not automatically answer which binary a hosted service runs, how model providers retain prompts, which optional integrations are enabled, or how quickly a security fix reaches your environment. Pin a reviewed commit, record configuration, protect credentials, and repeat verification when you update.

07Sources

Verification trail

Primary links behind this guide.

Last verified July 16, 2026. Recheck official documentation before making production or security decisions.

official / 01

Grok Build is open source

xAI’s official open-source announcement and source-build commands.

official / 02

xai-org/grok-build

The public Rust repository, README, license, and source tree.

official / 03

Grok Build CLI

Launch overview covering tools, agents, worktrees, and automation.

official / 04

Grok Build documentation

Official setup and runtime-mode documentation.

official / 05

Contribution policy

The repository’s current policy on external contributions.

official / 06

OpenRouter API quickstart

Official chat-completion, streaming, and app-attribution guidance.

official / 07

OpenRouter authentication

Bearer-token handling and server-side credential guidance.

reference / 08

Kilo model reference

A third-party reference for the separately hosted Grok Build 0.1 model.

08Q&A

Detailed Q&A

Questions to answer before you build, pay, or paste code.

These answers connect the open-source repository, hosted xAI models, OpenRouter billing, this site’s security boundary, and the operational choices a real user must make.