System II · Open-Source Reimplementation
A faithful open-source reimplementation of xAI's Grok Build multi-agent coding orchestrator. Preserves the agent/persona/role/skill architecture and the Plan → Design → Implement → Review pipeline, while swapping in DeepSeek API (V3 + R1) as the LLM backend.
Origins
Veles Forge is NOT the Grok binary — it is a Python reimplementation of the orchestration layer that mirrors the agent/persona/role/skill structure from Grok 4.5 Build. The original uses xAI's Grok models; this hybrid version swaps in DeepSeek API while preserving the same battle-tested agent architecture.
Grok 4.5 Build introduced a distinctive architecture for multi-agent coding: agents defined as markdown files with YAML frontmatter, personas injected as TOML configuration, roles setting capability mode and reasoning effort, and skills orchestrating multi-agent loops. It was designed for extensibility — anyone could add an agent by writing a markdown file, or define a new persona by writing a TOML file. The system was powerful but locked to xAI's model ecosystem.
Veles Forge breaks that lock. By reimplementing the orchestration layer in Python and swapping in the OpenAI-compatible DeepSeek API, it makes the Grok Build architecture available to anyone with a DeepSeek API key. The agent definitions, persona files, and skill orchestrators remain structurally identical — they are configuration, not code. The only change is the model that executes them.
Markdown files with YAML frontmatter defining system prompts and permissions. Agents are the worker units — plan, explore, general-purpose. Adding a new agent is as simple as writing a markdown file.
TOML files with detailed instructions injected into agent prompts. Personas shape behaviour — implementer, reviewer, design-doc-writer. They are the "how" layer, distinct from the agent's "what."
Orchestrators that run multi-agent loops: write → review → revise → repeat. Skills are the workflow layer — design, implement, review. They compose agents and personas into complete pipelines.
Architecture
Four layers of abstraction, each independently configurable. Agents define what can be done. Personas define how. Roles set capability boundaries. Skills compose them into workflows.
# grok-deepseek-hybrid/ grok_build_hybrid/ # Python package ├── agents/ # Agent definitions (plan, explore, general-purpose) ├── personas/ # Persona definitions (implementer, reviewer, etc.) ├── roles/ # Role definitions ├── skills/ # Skill orchestrators (design, implement, review) ├── cli.py # CLI entry point (Click + Rich) ├── config.py # Config & model catalog ├── deepseek_client.py # OpenAI-compatible API client ├── agent_runner.py # Agent loader & execution loop └── orchestrator.py # Multi-agent skill workflows
Pipeline
The Grok Build pipeline is a four-phase sequential workflow. Each phase has a designated agent and reviewer. The design and implementation phases include review-revise loops that iterate until zero open issues remain.
The plan agent explores the codebase and produces a step-by-step plan. Read-only. Identifies affected files, dependencies, and risks before any code is touched.
The design-doc-writer writes DESIGN.md. The design-doc-reviewer audits it. Writer revises until the reviewer finds zero open issues.
The implementer writes code. The reviewer finds issues. Same review-revise loop as design, but operating on code rather than documentation.
Final audit. The reviewer evaluates the complete implementation against the design document and acceptance criteria. A final PASS/FAIL with evidence.
“The design-doc review loop is the signature Grok Build innovation. Before a single line of code is written, the design document is iterated until it can withstand scrutiny. Implementation then follows a design that has already survived adversarial review.”
Veles Forge Design Philosophy
The Hybrid
The original Grok Build is locked to xAI's model ecosystem. Veles Forge swaps in DeepSeek API — an OpenAI-compatible provider with V3 (fast, cheap) and R1 (reasoning-heavy) models. The architecture stays identical. The agent definitions, persona files, and skill orchestrators are configuration, not code. The model is a parameter. This makes the Grok Build architecture available to anyone, anywhere, without vendor lock-in.
Comparison
Veles Forge preserves the architecture while changing the engine. The differences are in model access, extensibility, and deployment flexibility — not in the fundamental workflow.
| Dimension | Original Grok 4.5 Build | Veles Forge (Hybrid) |
|---|---|---|
| LLM Backend | xAI Grok models (proprietary) | DeepSeek API — V3 (fast) + R1 (reasoning) |
| Architecture | Agent/persona/role/skill | Identical structure — configuration-compatible |
| Pipeline | Plan → Design → Implement → Review | Identical four-phase pipeline with review loops |
| Agent Definitions | Markdown + YAML (proprietary runtime) | Markdown + YAML (Python runtime, open-source) |
| Personas | TOML (proprietary runtime) | TOML (Python runtime, open-source) |
| Extensibility | Limited to Grok ecosystem | Any OpenAI-compatible provider; pluggable agents |
| Deployment | xAI platform | Any Python 3.10+ environment with API key |
| License | Proprietary | MIT — open source |
# Install & run Veles Forge $ pip install grok-deepseek-hybrid # Set your DeepSeek API key $ export DEEPSEEK_API_KEY="sk-..." # Run the build pipeline $ grok-hybrid build "add rate limiting to the API" # Available commands $ grok-hybrid plan "describe the task" # Planning only $ grok-hybrid design "describe the task" # Plan + Design doc $ grok-hybrid build "describe the task" # Full pipeline $ grok-hybrid review [path] # Review existing code