xAI open-sourced the coding agent that was caught uploading entire repos to its cloud. This is that harness — with the upload machinery removed at the code level, and an end-to-end test that proves nothing reaches /v1/storage.
Run it on your models — Claude, GPT, or a local LLM — with no xAI account, and pay for exactly the tokens you use.
Coming from Claude Code? Your CLAUDE.md, skills, commands, hooks — even your recent sessions — come with you.
Above: grokers creating and verifying a file — driven entirely by qwen3.5:9b running locally through ollama. No cloud account, no API bill, code never leaves the machine.
xAI open-sourced grok-build — one of the best-engineered coding-agent harnesses in existence (Rust, full-screen TUI, subagents, copy-on-write worktrees, skills/hooks/MCP/ACP, an adversarial verifier panel). Out of the box it points at one vendor's models behind one OAuth login.
grokers is that same harness, unshackled: no xAI account, any OpenAI- or Anthropic-compatible backend, mixed per role. If you've been wondering "could I run this thing on cheap models, or my own hardware?" — that's exactly what this is.
| grok-build (upstream) | grokers | |
|---|---|---|
| Repo & session uploads | Ships the "always-on" upload queue behind the July 2026 incident — repos, sessions, and per-turn traces to xAI storage; the privacy toggle didn't stop it | Removed at the code level. The upload dispatch functions transmit nothing and the network helpers are deleted; an e2e test asserts zero /v1/storage requests. How to verify → |
| First run | xAI OAuth login required — the baked catalog contains exactly one model, OAuth-gated | No account. Empty config boots into a local model and starts coding |
| Claude (Anthropic) | Configurable on paper, 401 in practice — sends Bearer auth to every backend; Anthropic requires x-api-key |
Works. Auth scheme derived from the backend (we found and fixed the bug) |
| Local LLMs (ollama, vLLM) | Undocumented; keyless endpoints trip the login gate; context mismatch causes retry loops; a dead local endpoint stalls ~6 minutes | First-class. Local model is the default; keyless endpoints pass the gate; dead endpoints fail in seconds with a fix-it hint |
| Mixing models | Built around one model | Role routing up front — flagship codes, cheap/local models do search synthesis, titles, image description |
| Install & onboarding | Build from source, hand-write config.toml | One line (curl or brew) + a 4-profile cost wizard |
| Auto-update | On by default — would replace your binary with the next xAI release | Disarmed in every profile |
/feedback |
POSTs your text to xAI's feedback endpoint | Never leaves your machine — points you at our issue tracker |
| Identity | — | grokers --version reports its own release and the upstream it's based on, transparently |
| What you pay | xAI subscription/credits | Your choice: Anthropic/OpenAI/OpenRouter per-token, or local = $0 |
Everything in that right column was verified on real runs, not promised: empty-config boot, a full coding loop (file create → read → shell verify) on local qwen3.5:9b, and the x-api-key header confirmed on the wire. And everything not in the table is unchanged upstream goodness — TUI, subagents, CoW worktrees, skills/hooks/MCP/ACP, sandboxing, compaction. You lose nothing; you can even still use your xAI account (XAI_API_KEY works).
This harness natively understands your existing setup — no migration step, no config rewrite:
- Context files:
CLAUDE.mdandAGENTS.mdare discovered from your working directory up to the repo root and loaded into the prompt, exactly like at home. .claude/assets: skills (.claude/skills/*/SKILL.md), slash commands, agents,settings.jsonhooks and permissions, plugins and plugin marketplaces — read directly..cursor/rulestoo.- Your sessions come along: recent Claude Code / Codex / Cursor sessions in the repo are detected on the welcome screen — resume one with a single keystroke (
ctrl+u), or browse them in the session picker. - You'll see it working: open grokers in a repo you already use with Claude Code and the welcome screen tells you — "Claude Code setup detected: CLAUDE.md · 2 skills · 1 command — loaded automatically."
Above: open grokers in a repo you already use with Claude Code — the welcome screen confirms your CLAUDE.md, skills, and commands were picked up automatically. Running here on a local model, logged in with nothing but an API key you control.
For contrast, as of July 2026: opencode reads your CLAUDE.md and skills but has no competitor-session import; Codex CLI imports Claude Code setups but speaks only its own session store. grokers reads the setup and the sessions.
| If you use… | What changed | What grokers offers |
|---|---|---|
| Codex CLI | Upstream removed the Chat Completions wire API — Responses-only, orphaning many OpenAI-compatible/local backends | Speaks all three wire protocols: OpenAI Chat Completions, OpenAI Responses, Anthropic Messages |
| opencode | Anthropic subscription login was removed in 1.3.0 ("Anthropic explicitly prohibits this") | No gray-zone subscription piggybacking here either — Anthropic via API key (legit), xAI via OAuth (this is the Grok Build engine), everything else BYOK or local |
| Gemini CLI | Google announced its retirement in June 2026 | Your AGENTS.md workflow and BYOK habits carry over; Gemini models plug in via any OpenAI-compatible gateway |
| zeroshot / verifier-loop tools | Verification where any single validator can veto, and scrutiny escalates each round | The built-in goal loop uses a panel: one persistent skeptic with a veto plus a cold-panel strict majority, an explicit anti-ratchet rule ("the bar does NOT rise between rounds"), and a strategist that intervenes on repeated identical failures |
curl -fsSL https://raw.githubusercontent.com/codingmydna/grokers/main/install.sh | bashmacOS (Apple Silicon) gets a prebuilt binary; other platforms build from source (needs rust + protoc). The installer ends with a profile wizard — pick how you want to pay for tokens, done.
Homebrew:
brew install codingmydna/grokers/grokersOr from source: git clone https://github.com/codingmydna/grokers && cd grokers && cargo build --release --bin grokers && ./grokers-setup.sh
| Profile | Coding model | Housekeeping roles | Cloud bill |
|---|---|---|---|
hybrid-local (recommended) |
Claude Sonnet | local ollama | flagship tokens only |
local-first |
local ollama | local ollama | zero |
frugal-flagship |
Claude Sonnet | Claude Haiku | two-tier |
openai |
gpt-5 | gpt-5-mini | two-tier |
kimi |
Kimi K3 | Kimi K3 | single model, cache-priced |
The mechanism: the harness resolves each model role independently (default, web_search, session_summary, image_description), and every model entry carries its own base_url + api_backend + key. The harness natively speaks OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages — so Anthropic, OpenAI, Moonshot (Kimi), OpenRouter, vLLM, and ollama all plug in directly, side by side:
[models]
default = "my-claude" # writes your code
web_search = "local-qwen" # synthesizes search results — free, local
session_summary = "local-qwen" # names your sessions — free, local
[model."my-claude"]
model = "claude-sonnet-5"
base_url = "https://api.anthropic.com"
api_backend = "anthropic" # Anthropic Messages — sends x-api-key, not Bearer
env_key = "ANTHROPIC_API_KEY"
[model."local-qwen"]
model = "qwen3.5:9b"
base_url = "http://127.0.0.1:11434/v1"
api_backend = "chat_completions" # ollama / vLLM / OpenAI-compatibleapi_backend picks the wire protocol per model: anthropic (Messages;
aliases messages/claude), openai (Chat Completions; aliases
chat_completions), or responses (OpenAI Responses). The intuitive
provider name works — a config that says anthropic is not silently ignored
(that mistake is what made Claude 401 on upstream). If you just want the baked
Claude/GPT/Kimi models, ANTHROPIC_API_KEY / OPENAI_API_KEY /
MOONSHOT_API_KEY in your environment is enough — no [model.*] block needed.
Kimi K3 — Moonshot's 2.8T-parameter open-weights flagship with a 1M-token context window — is baked into the model picker:
export MOONSHOT_API_KEY=sk-... # from platform.kimi.ai
grokers # then /model → Kimi K3Or make it the default for every role: run ./grokers-setup.sh and pick the
kimi profile. No gateway, no subscription — K3's OpenAI-compatible endpoint
plugs straight into the Chat Completions wire, next to your Claude, GPT, and
local models.
Honest scope note: your coding model is where most tokens go. Role routing trims the bill; the big savings come from choosing that coding model's price — including free and local — instead of inheriting a vendor's subscription.
Under the hood, the technical changes are small and surgical — a BYOK-capable baked model catalog, backend-derived auth schemes, and safer defaults — on top of a codebase we read end to end before forking. The field notes are in docs/internals.md.
grok-build shipped with a serious verification loop, and grokers inherits it whole: a plan is written once and frozen (outcome-only — the plan may not prescribe how, so the verifier can't refute correct work for style); the implementer works under an explicit "NO TEST THEATER" contract; then a skeptic panel audits the evidence — one warm skeptic that remembers previous rounds and holds a veto, plus cold skeptics that must reach a strict majority, under an anti-ratchet rule and with a strategist that steps in when the same failure repeats.
That machinery is the seed of where this project is going:
- ACP engine adapters (next) — drive Claude Code, Codex CLI, or Gemini CLI as pluggable implementer engines inside this harness (it already embeds Zed's Agent Client Protocol).
- The arena — freeze a plan once, let several engines implement it in parallel CoW worktrees, and let the skeptic panel judge the results — with a per-repo track record of which engine wins which kind of task.
Is this affiliated with xAI? No. Independent community fork under Apache-2.0, with attribution in NOTICE. "Grok" is xAI's trademark; upstream identifiers are retained only for compatibility.
Does it phone home? The repo/session/trace upload machinery is removed at the code level — not toggled off — and an end-to-end test proves zero requests reach /v1/storage. On top of that: telemetry endpoints are off in every bundled profile (plus GROK_TELEMETRY_DISABLED=1), auto-update is disarmed, and /feedback never transmits. The only bytes that leave are the model API calls you configure — none at all under the local-first profile. The full inventory and a reproducible mitmproxy procedure are in docs/phone-home.md.
Can I still use my xAI account? Yes — XAI_API_KEY and the upstream OAuth flow still work; grokers just stops requiring them.
What does --version say? grokers <release> (<commit>), followed by based on grok-build <upstream-version> (xai-org, Apache-2.0). The welcome screen, trust prompt, and help output say grokers too. Internal crate names (xai-*) and the ~/.grok/ config path are deliberately kept so existing setups keep working and our diff against upstream stays small and auditable.
Linux / Windows? macOS arm64 gets the prebuilt binary and is what we test on. Linux builds from source via install.sh (upstream supports Linux hosts; this fork isn't CI-verified there yet — reports welcome). Windows is best-effort.
Unlike upstream (issues only, invited PRs), pull requests are welcome here — see CONTRIBUTING.md. Mark fork divergences with a // grokers: comment. Good first contributions: model-catalog entries, profile recipes, Linux verification runs, de-branding passes.
Apache-2.0, same as upstream — see LICENSE, NOTICE, THIRD-PARTY-NOTICES. Forked from xai-org/grok-build @ b189869; upstream's README is preserved at docs/UPSTREAM_README.md. Not tracking upstream continuously — useful changes get cherry-picked per crate.