for teams. A developer using IntelliJ IDEA for backend work, VS Code for TypeScript, and Slack for async code review authenticates once and reaches grok-build-0.1 across all three surfaces. Cloud agents extend this further — long-running background tasks that don't require an open IDE session, useful for overnight code analysis or automated PR review workflows.
Prior Kilo Code users who were on the grok-code-fast-1 free promotional build — which expired approximately May 6, 2026 — need to re-authenticate under grok-build-0.1 to maintain access past August 2026. Kilo Code has not published a detailed feature parity matrix between the VS Code and JetBrains extensions. Developers depending on specific capabilities in JetBrains should verify behavior in their target IDE before committing Kilo Code to a production workflow.
The CLI Surface: Plan, Parallel Subagents, and Worktree Isolation
The Grok Build CLI is xAI's proprietary terminal coding agent, released in early beta May 14–15, 2026 . Unlike OpenCode and Kilo Code — which plug grok-build-0.1 into an existing provider-agnostic harness — the CLI is built around specific behaviors that differentiate it from Claude Code, Codex CLI, and other terminal agents. Two features drive most of the differentiation: Plan Mode, which inserts a mandatory human-approval checkpoint before any file is touched, and parallel subagents running in isolated git worktrees that prevent concurrent agents from colliding on the main branch.
Plan Mode is the most operationally distinct feature compared to peer tools. The CLI structures a full execution plan and surfaces it for developer review; no file changes occur until the user explicitly approves. Claude Code and Codex CLI act immediately by default when given a task. The checkpoint matters in several contexts: production codebases where unreviewed automated changes are a liability, onboarding workflows where a developer wants to understand the agent's intended strategy before execution begins, and compliance environments where a human approval gate is a requirement before any infrastructure or code change.
Arena Mode runs multiple models in parallel with side-by-side output comparison. The practical use case is prompt calibration: before committing a model or prompt template to a repeating workflow, you run the same task through grok-build-0.1 and another model simultaneously and compare results without switching tools or maintaining separate terminal sessions. For teams that haven't settled on a single model across all task types, Arena Mode provides empirical comparison on actual work tasks rather than external benchmark proxies.
Parallel subagents handle concurrent research, implementation, and review tasks, each operating in its own isolated git worktree. The isolation prevents agents from overwriting in-progress changes made by other agents. For tasks that decompose naturally into concurrent subtasks — researching a library API, implementing against it, and reviewing the implementation — running agents in parallel with worktree isolation reduces wall-clock time and eliminates branch collision risk.
For CI pipelines, grok -p enables headless operation and --always-approve bypasses the per-tool confirmation prompt . The permission model defaults to ask per tool call and is configurable in ~/.grok/config.toml (user-level) or .grok/config.toml (project-level). Built-in tool connectors include Linear, Sentry, and Grafana . The CLI also natively discovers AGENTS.md, MCP servers, hooks, skills, and plugins. The harness exposes a 2-million-token context window — substantially larger than the 256K-token limit on the API model used by OpenCode and Kilo Code, though xAI has not confirmed whether this reflects a distinct model variant or a harness-level context management layer.
| Feature | Grok Build CLI | Claude Code | Codex CLI |
|---|---|---|---|
| Plan Mode (pre-execution approval) | Yes — structured plan, user approves before any file change | No — acts immediately by default | No — acts immediately by default |
| Arena Mode (parallel model comparison) | Yes | No | No |
| Parallel subagents + git worktree isolation | Yes — concurrent agents on isolated branches | Parallel subagents supported (Max tier); no native worktree isolation | No |
| Headless CI mode | grok -p --always-approve |
claude -p --dangerously-skip-permissions |
--full-auto |
| Native tool connectors | Linear, Sentry, Grafana | MCP-based (extensible) | Limited plugin ecosystem |
| Context window (harness) | 2M tokens | Depends on model tier | Depends on model tier |
| Permission default | ask per tool call |
ask per tool call |
Configurable (approve by default in some modes) |
| Config location | ~/.grok/config.toml or .grok/config.toml |
~/.claude/ or CLAUDE.md |
~/.codex/ |
Subscription OAuth vs Direct Key Access: xAI's Distribution Model
xAI routes access to grok-build-0.1 through two paths: subscription-based OAuth for existing X platform subscribers, and direct API key access for everyone else. SuperGrok Heavy and X Premium Plus subscribers at $300/month cover CLI usage without per-token metering. API users pay $1.00 per million input tokens, $2.00 per million output tokens, and $0.20 per million cache-read tokens, per Kilo Code's model documentation .
The cache-read pricing deserves attention for long-running coding sessions. If you repeatedly load the same large codebase context across multiple agent invocations — a common pattern when iterating on a feature over several hours — the $0.20/M rate applies to cached prompt tokens rather than the full $1.00/M input rate . For a 200K-token project context loaded 20 times in a session, the difference across 4M tokens is $3.20 per session — modest individually, but material at team scale across many daily sessions.
The OAuth binding to X Premium or SuperGrok is a genuine tradeoff. On the benefit side: existing subscribers get immediate access without API key management or billing setup. On the cost side: access to a developer tool is coupled to a social platform subscription. If the subscription lapses, tool access lapses with it. The subscription tier is a consumer billing model — it does not offer organization-level API keys, usage caps, or audit logs. For individual developers already subscribed, this is low-friction. For teams managing shared access, it introduces credential management complexity that a standard API key does not.
Non-subscribers authenticate via XAI_API_KEY in their environment. Both OpenCode and Kilo Code support this path alongside the OAuth option. Direct key access is also the only practical route for headless infrastructure deployments where a browser-based OAuth handshake is not feasible. The Grok Build CLI does not currently support API key access — it remains restricted to the $300/month subscriber tier as of the public beta launch.
grok-code-fast-1 Deprecation: Migration Notes
grok-code-fast-1 was deprecated May 15, 2026, with full retirement scheduled for August 15, 2026 — a three-month migration window. The model was a ~314B-parameter mixture-of-experts architecture running at approximately 92 tokens per second with a 256K-token context window, and scored 70.8% on SWE-Bench Verified . There is no automatic migration: any tool, pipeline, or configuration that references the old model ID will stop working when the model is retired.
OpenCode users: If you previously selected grok-code-fast-1 in the model picker and have not switched, open the provider settings and select grok-build-0.1 before August 15, 2026. The existing OAuth connection remains valid — only the model selection needs updating. OpenCode does not auto-migrate pinned model selections.
Kilo Code users: The earlier free allocation ran on a promotional build of grok-code-fast-1 that expired approximately May 6, 2026 . After August 15, 2026, any Kilo Code workflow referencing grok-code-fast-1 will fail. Re-authenticate under grok-build-0.1 now rather than waiting for the retirement deadline.
CI pipelines and scripts: Search configuration files, environment variable definitions, and pipeline definitions for grok-code-fast-1 and replace with x-ai/grok-build-0-1. The migration is a model ID substitution; the API contract structure — endpoint, request format, response format — is not changing between the two models.
One important clarification on benchmarks: grok-code-fast-1's 70.8% SWE-Bench Verified score and grok-build-0.1's 88.9% PinchBench score measure different task distributions on different evaluation frameworks . SWE-Bench Verified tests autonomous resolution of real GitHub issues. PinchBench covers log analysis, CSV processing, writing, and other structured software tasks. The two scores cannot be directly compared and should not be read as an 18-point improvement. SWE-Bench Verified data for grok-build-0.1 has not been published as of this article's date.
Choosing a Surface: CLI, OpenCode, or Kilo Code
Each surface exposes the same grok-build-0.1 model, but the differences in context window, access model, IDE coverage, and supported workflow patterns are substantial. The right choice depends on your existing stack, subscription status, and whether features like Plan Mode or worktree isolation are on your critical path. The comparison below reflects confirmed capabilities as of the public API beta on May 28, 2026 .
| Criterion | Grok Build CLI | OpenCode | Kilo Code |
|---|---|---|---|
| IDE / surface targets | Terminal only | Terminal only | VS Code, JetBrains (IntelliJ IDEA, PyCharm, WebStorm), CLI, cloud agents, Slack |
| Exposed context window | 2M tokens (harness level) | 256K tokens (API model) | 256K tokens (API model) |
| Access model | SuperGrok Heavy / X Premium Plus ($300/mo) only | xAI OAuth or XAI_API_KEY |
X Premium / SuperGrok OAuth or XAI_API_KEY |
| Parallel subagent support | Yes — isolated git worktrees | No native parallel subagents | Via cloud agents (async) |
| Plan Mode | Yes | No | No |
| Arena Mode | Yes | No (multi-provider available, not parallel comparison) | No |
| Slack integration | No | No | Yes |
| Multi-provider flexibility | xAI only | 75+ providers including Claude, GPT, Gemini | Multi-provider (xAI + others) |
| Headless CI | Yes — grok -p --always-approve |
Yes — via XAI_API_KEY |
Yes — via cloud agents |
Choose the CLI if you are already a SuperGrok Heavy or X Premium Plus subscriber, work primarily in the terminal, and need Plan Mode, Arena Mode, or worktree-isolated parallel subagents. The 2M-token context window and built-in Linear, Sentry, and Grafana connectors are additional differentiators. Tradeoffs: terminal-only surface, xAI provider lock-in, and the $300/month requirement is a hard gate as of the beta launch.
Choose OpenCode if you are already in the open-source terminal agent ecosystem and want to add grok-build-0.1 alongside your existing model setup. The OAuth flow takes minutes, no configuration file changes are needed, and you retain full provider flexibility — Claude, GPT-4o, Gemini, or xAI per session. Tradeoffs: 256K context window, no Plan or Arena Mode, and individual-account OAuth is not appropriate for shared team CI credentials.
Choose Kilo Code if your team uses JetBrains IDEs, needs Slack-based async code review, or wants cloud agents for background tasks without keeping an IDE session open. The single OAuth connection spanning VS Code, JetBrains, and cloud agents reduces friction for polyglot teams. Tradeoffs: 256K context window, no Plan Mode, and JetBrains feature parity versus VS Code has not been formally documented by Kilo Code.
xAI launched
grok-code-fast-1simultaneously on GitHub Copilot, Cursor, Cline, Roo Code, Kilo Code, OpenCode, and Windsurf in September 2025 . The May 2026 rollout repeats the multi-platform playbook but inverts the order: proprietary CLI first, open-source harnesses second — a signal that xAI is now prioritizing ownership of the developer relationship over pure distribution reach. — xAI on X
One consideration that cuts across all three surfaces: if your deployment requires a stable, non-personal credential for shared CI pipelines or multi-developer access, the XAI_API_KEY path on OpenCode or Kilo Code is more appropriate than individual OAuth. The CLI does not currently support API key access, which makes it unsuitable for shared team infrastructure until xAI opens that path.
Frequently Asked Questions
Does grok-build-0.1 require an API key in OpenCode or Kilo Code?
Not for xAI subscribers. Both OpenCode and Kilo Code support OAuth-based authentication — run /connect in OpenCode or connect your Grok account in Kilo Code, and credential management is handled without a manual API key. X Premium and SuperGrok subscribers use this path. Developers without a qualifying subscription set XAI_API_KEY in their environment and pay the direct API rate: $1.00/M input tokens, $2.00/M output tokens, $0.20/M cache-read tokens . Both authentication methods are fully supported in both tools.
What is the context window difference between the CLI and the API model?
The Grok Build CLI exposes a 2-million-token context window at the harness level. The API model (x-ai/grok-build-0-1) is capped at 256K tokens . Both OpenCode and Kilo Code use the API model and are therefore limited to 256K tokens, regardless of the CLI's harness-level window. Whether the CLI's 2M-token capability reflects a distinct model variant or a context management layer built into the harness itself has not been confirmed by xAI as of publication.
When does grok-code-fast-1 stop working and what needs to change?
grok-code-fast-1 was deprecated May 15, 2026. Full retirement is scheduled for August 15, 2026 . There is no automatic migration. OpenCode users with a pinned model selection need to manually switch to grok-build-0.1 before the August cutoff. Kilo Code users on the prior grok-code-fast-1 allocation need to re-authenticate under the new model. Any CI pipeline or configuration script referencing the old model ID will fail after August 15, 2026 — run a search for grok-code-fast-1 across your config files and environment definitions and update to x-ai/grok-build-0-1.
Can grok-build-0.1 be used without an X Premium or SuperGrok subscription?
Yes, via direct API key access. Set XAI_API_KEY in your environment and point your client at xAI's API endpoint. Pay-as-you-go pricing: $1.00 per million input tokens, $2.00 per million output tokens, $0.20 per million cache-read tokens . Both OpenCode and Kilo Code support the API key path as a full alternative to the OAuth subscription flow. Note that the Grok Build CLI is currently restricted to SuperGrok Heavy and X Premium Plus subscribers at $300/month — there is no API key access path for the CLI as of the public beta launch.
Does Kilo Code's JetBrains extension support the same features as the VS Code extension?
Both extensions use the same OAuth flow and expose grok-build-0.1 through the same API model. Kilo Code's JetBrains coverage includes IntelliJ IDEA, PyCharm, and WebStorm . However, Kilo Code has not published a detailed feature parity breakdown between the VS Code and JetBrains extensions. Developers who rely on specific capabilities — inline diff views, context inclusion controls, or particular UI panels — should verify behavior in their target JetBrains IDE before committing Kilo Code to a primary workflow.
What to Watch: Access Restrictions, Context Window Clarity, and the August Deadline
Three unresolved questions will determine how this rollout lands in practice over the next 90 days. First: the Grok Build CLI's restriction to $300/month subscribers is the largest adoption constraint for individual developers. If xAI opens CLI access to lower subscription tiers or adds API key support, the surface comparison changes significantly — Plan Mode and Arena Mode become accessible without a premium subscription, which shifts the balance against OpenCode and Kilo Code's provider-flexibility advantage.
Second: the 2M-token context window claim for the CLI has not been attributed to a specific model variant or harness technique by xAI. If the larger context reflects a management technique — chunking, summarization, or selective retrieval — rather than a true extended context model, performance on very long-context tasks may differ from what the number suggests. Worth validating empirically on your own codebase before committing to the CLI specifically for large monorepo work.
Third, and most immediately actionable: the August 15, 2026 retirement of grok-code-fast-1 is a hard deadline, not a soft guideline. Any team using grok-code-fast-1 in OpenCode model selections, Kilo Code configurations, or CI pipeline definitions should run a codebase search for the old model ID now. The replacement is a model ID substitution — there are no API contract changes — so the migration cost is low. The cost of a production failure on August 15 is not.
Last updated: 2026-05-29. Based on xAI public announcements, Kilo Code model documentation, and third-party reporting published through May 28, 2026. grok-build-0.1 is in public beta; capabilities, pricing, and access tiers are subject to change.
