Grok Build Arsenal

Web landing page: https://cobusgreyling.github.io/grok-build-arsenal/

The definitive production toolkit and living showcase for Grok Build 0.1.

See what grok-build-0.1 can actually build when given the right harness, skills, MCP servers, and Plan Mode discipline — then use the same utilities in your own projects.

Sole author & maintainer: Cobus Greyling

Why This Exists

Grok Build 0.1 is xAI’s fast, purpose-built coding model for agentic workflows. It shines with:

• Plan Mode + human approval gates
• Parallel subagents
• Deep MCP (Model Context Protocol) integration
• Headless scripting and custom harnesses via the public API

Most people only see toy demos. Grok Build Arsenal ships real, production-minded projects and the exact reusable skills + MCP servers that made them possible.

Everything here was built or refined using Grok Build 0.1 itself.

Quick Start

# Clone the arsenal
git clone https://github.com/cobusgreyling/grok-build-arsenal.git
cd grok-build-arsenal

# One-command install of all production skills (into this project or elsewhere)
bash scripts/install-skills.sh

# Inspect everything Grok discovers (skills, rules, hooks, MCPs)
grok inspect

# Start a session (the repo itself is an exemplary Grok Build workspace)
grok

Install the skills into any project (frictionless):

# Recommended: one-command installer
bash /path/to/grok-build-arsenal/scripts/install-skills.sh

# Or target a specific project
bash scripts/install-skills.sh --target /path/to/your-project

# Or install user-wide for all projects
bash scripts/install-skills.sh --global

After install:

grok inspect   # verify skills are loaded

Example usage evidence (new in v0.2 — try it yourself):

$ python showcase/arena-visualizer/arena_demo.py --plain
# ... 3 subagents with different charters, synthesis, cost tracking ...
# Then in a real Grok Build session: hand the synthesis to plan-mode-orchestrator

Also try the new MCPs and the interactive version on the landing page. The same patterns are incredibly effective inside live Grok Build sessions.

Use the public grok-build-0.1 API directly in your own agents:

from openai import OpenAI

client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1",
)

response = client.responses.create(
    model="grok-build-0.1",
    input="Use the subagent-arena skill pattern to investigate this repo and propose the smallest high-impact PR."
)

Showcase — Real Projects Built with Grok Build 0.1

Each showcase directory contains the original prompts, Plan Mode plans, subagent usage notes, key skills/MCPs used, and transparent build story. The actual shipped code for the flagship lives in a dedicated, polished, installable package (the arsenal is the playbook + reusable parts).

1. Agent Observability Dashboard (Flagship)

Build story + MCP: showcase/agent-observability-dashboard/
Real production deliverable: https://github.com/cobusgreyling/agent-failure-analyzer (PyPI: pip install agent-failure-analyzer)

Full production CLI + TUI + web dashboard + library for ingesting and deeply analyzing agent sessions from 6+ frameworks. Living failure taxonomy (30+ subcategories), cost waste analysis, risk scoring, Grafana/OTLP, GitHub Action, Docker, PR comment integration, LLM-assisted classification.

Built with (arsenal in action): plan-mode-orchestrator, subagent-arena, custom agent-session-analyzer MCP, tdd-intelligence, architecture-reviewer, security-audit, git-discipline.

This is the concrete proof that disciplined use of the skills + MCP patterns in this repo ships real, maintained, depended-on tools.

2. Subagent Arena Visualizer

Location: showcase/arena-visualizer/

Interactive TUI + web UI concepts for running parallel subagents on the same task, scoring approaches, and visualizing consensus vs divergence.

• Real-time arena execution
• Structured comparison output
• Cost/latency tracking
• Exportable reports

Built with: Heavy subagent orchestration, subagent-arena skill, structured outputs, headless mode.

3. MCP Control Center

Location: showcase/mcp-control-center/

A polished control plane vision for discovering, installing, validating, and monitoring MCP servers and skills across projects.

• MCP manifest browser
• One-command install + trust management
• Live health checks
• Skill compatibility matrix

Built with: MCP-heavy workflows, mcp-orchestrator + skill-validator skills, custom browser-qa for UI validation.

4. Smart Test Intelligence Engine

Location: showcase/smart-test-engine/

Production test selection, impact analysis, flakiness detection, and coverage-guided editing for large codebases.

• Predicts which tests matter for a diff
• Runs minimal effective test sets
• Surfaces flaky tests with evidence
• Generates safe edit plans

Built with: Deep repo understanding, test-intelligence MCP, repeated Plan Mode + verification loops.

5. Visible Reasoning Agent Framework (nemotron-think)

Location: showcase/nemotron-think/
Live landing page: https://cobusgreyling.github.io/nemotron-think/

CLI + Python library + self-contained interactive docs page for Nemotron 3 Ultra that makes every reasoning step, tool-call delta, and observation first-class and replayable. Rich JSON traces, color-coded terminal streaming, controllable budgets, pluggable tools, perfect offline demo replay.

Built with: plan-mode-orchestrator, subagent-arena (tool & trace design), tdd-intelligence, git-discipline, showcase page iteration with browser-qa patterns.

6. Secure Agent Runtime (NemoClaw)

Location: showcase/nemoclaw-runtime/
GitHub: https://github.com/cobusgreyling/nemoclaw-runtime

Reference implementation of the "model proposes, runtime disposes" architecture: gateway, explainable JSON policy engine, policy-gated OpenShell sandbox, and Hermes (durable skill capture + replay). Zero hard deps for the core. Includes live stdlib control-plane dashboard.

Built with: plan-mode-orchestrator + architecture-reviewer on the layered design, subagent-arena on policy + skills strategy, tdd-intelligence on the executor that must never lie.

7. Nemotron 3 Ultra Feature Playground

Location: showcase/nemotron-3-ultra-showcase/
GitHub: https://github.com/cobusgreyling/nemotron-3-ultra-showcase

Focused Gradio app (NVIDIA-green) + screenshot assets + BLOG.md that exercises the model's headline agentic features live: reasoning ON/OFF/Low Effort + budget slider, streaming reasoning, streaming tool calls with local execution.

Built with: Plan Mode for the harness around chat_template_kwargs, careful streaming accumulation logic, visual presentation discipline.

Related Projects & Proof

The skills, MCPs, and discipline in this arsenal are not theoretical. They have already produced real, maintained, installable tools used in production workflows.

Flagship Delivered Project

• agent-failure-analyzer (PyPI: pip install agent-failure-analyzer)
  • Full CLI + TUI + web dashboard for AI agent session analysis across 6+ frameworks.
  • Living taxonomy (30+ subcategories), cost waste estimation, risk scoring, OTLP/Grafana export, GitHub Action, Docker, PR comment workflows, LLM-assisted classification.
  • Build story & MCP: See showcase/agent-observability-dashboard/.
  • Built with (arsenal in action): plan-mode-orchestrator, subagent-arena, agent-session-analyzer MCP, tdd-intelligence, architecture-reviewer, security-audit, git-discipline.

In-Arsenal Demos & Prototypes (runnable today)

• Subagent Arena Visualizer (showcase/arena-visualizer/)
  • python showcase/arena-visualizer/arena_demo.py — live, deterministic simulation of the subagent-arena skill (3 charters → synthesis → cost tracking).
  • Zero hard deps (rich optional for beauty). Perfect teaching tool and starting point for real arena runners.
• MCP Implementations: agent-session-analyzer, repo-graph, test-intelligence, and skill-validator now ship with working server.py skeletons (see mcps/*/server.py and their READMEs). These are the exact patterns used to build the flagship.

Nemotron / Runtime Harnesses (delivered, public)

• nemotron-think — Visible reasoning agent framework + CLI + rich replayable traces + beautiful standalone landing page (https://cobusgreyling.github.io/nemotron-think/). Build story in showcase/nemotron-think/.
• nemoclaw-runtime — Secure gateway + policy + sandbox + durable skills runtime with live control plane. Build story in showcase/nemoclaw-runtime/.
• nemotron-3-ultra-showcase — Gradio playground exercising reasoning modes, budgets, and tool calling on the live model + screenshots + analysis. Build story in showcase/nemotron-3-ultra-showcase/.

Future / In-Progress (using the same discipline)

• MCP Control Center and Smart Test Intelligence Engine showcases will receive runnable prototypes as they reach the production bar of the flagship.
• New skills and MCPs are added only after they have been used to ship something real (dogfooding).

When you use bash scripts/install-skills.sh and follow the skills, you are using the exact same toolkit that produced the above artifacts.

All original work by Cobus Greyling using Grok Build 0.1 + the patterns documented here.

Skills Library

High-signal, narrowly scoped, production-grade skills. All include Plan Mode guidance, subagent patterns, verification steps, and git discipline.

Copy any into .grok/skills/ in your repo.

See the full catalog in the skills/ directory.

MCP Servers

Custom, narrowly-focused MCP servers optimized for agentic coding workflows. These are the highest-leverage additions for Grok Build 0.1 users.

Each MCP directory contains a README with setup, manifest, example server implementation (where available), and the skill that knows how to drive it. As of v0.2 we now ship working skeletons for agent-session-analyzer, repo-graph, test-intelligence, and skill-validator. browser-qa remains the thinnest (intentionally narrow scope).

Project Templates

Ready-to-use project roots with .grok/ configuration, AGENTS.md, .grokignore, and pre-seeded core skills for common stacks. Copy the folder contents into a fresh project and you're immediately in a high-discipline Grok Build environment.

• templates/python-fastapi-grok/ — Richest example. Full AGENTS.md, .grok/config + hooks + seeded skills, .grokignore. FastAPI + testing + security-first.
• templates/nextjs-grok/ — Next.js App Router focused starter.
• templates/rust-cli-grok/ — Rust CLI with testing/release discipline.

After copying:

bash /path/to/this-arsenal/scripts/install-skills.sh
grok inspect

These templates + the installer turn "start a new Grok Build project" into a 30-second operation.

Using grok-build-0.1 via the Public xAI API

This repo contains examples in examples/ for calling the model directly (no Grok Build CLI required):

• Python (OpenAI SDK + Responses API)
• TypeScript / AI SDK
• curl examples for headless agent loops
• Subagent orchestration patterns via API

See examples/api-usage.md.

The Repo Itself Is a Grok Build Project

This entire repository is configured as an exemplary Grok Build workspace (and is continuously improved using its own skills):

• Excellent AGENTS.md at root (the single source of truth for agent behavior)
• Production skills in skills/ + .grok/skills/ (use bash scripts/install-skills.sh)
• Custom hooks for reminders (post-edit verification, session start)
• .grokignore tuned for agent work (avoids committing huge session logs)
• grok inspect is the source of truth
• CI that validates skills, MCP READMEs, the installer, and templates

Clone it, run the installer, grok inspect, then grok. You will immediately feel the difference high-discipline configuration + skills make.

This repo dogfoods its own patterns (the v0.2.0 release — installer, arena demo, new MCP servers, interactive landing page, honest docs — was planned and executed using plan-mode-orchestrator, subagent-arena thinking for design choices, tdd-intelligence on the runnable demo, skill-validator + CI, and git-discipline).

Using the Discipline Beyond Grok Build (Portability)

The core ideas — Plan Mode first, parallel subagent arenas for exploration, narrowly-scoped reusable skills, MCP servers for new capabilities, tdd-intelligence + verification before declaration of done, and git-discipline — are not tied exclusively to grok-build-0.1.

They transfer extremely well to:

• Claude Code / Cursor (use the same trigger phrases as CLAUDE.md or .cursorrules, or as custom instructions)
• Aider, Continue.dev, or other agentic coding tools (the structured output templates from subagent-arena and plan-mode-orchestrator work great as system prompts)
• Your own custom harnesses using the public xAI API or other model providers

The prompts/high-signal-examples.md file and the skill frontmatter (when-to-use + example triggers) are deliberately written to be copy-pasteable.

If you adapt these patterns successfully to another stack or tool, a short note or PR with the exact prompt/config you used is very welcome (credited in the changelog).

The goal of the arsenal has always been to raise the floor for what "serious agentic coding" looks like, regardless of the specific model or harness.

Author

Cobus Greyling — sole author and maintainer.

All original work, skills, MCP designs, showcase projects, and documentation in this repository were created by Cobus Greyling using Grok Build 0.1.

License

MIT © 2026 Cobus Greyling

Acknowledgments

• xAI for building grok-build-0.1 and the Grok Build harness
• The broader agentic coding community for pushing the frontier

Start here: grok inspect → pick a skill or showcase → ship something impressive.

Built with Grok Build 0.1. Maintained by Cobus Greyling.