Informational Resource · Volume I
Production-grade software engineering demands more than a single model can deliver. The hybrid paradigm — multi-model, multi-agent architectures — combines the judgment of orchestration models with the speed of execution models. Two systems, one philosophy: Veles and Veles Forge.
Foundations
Not autocomplete. Not a chatbot. AI coding agents are autonomous software engineering systems that plan, build, review, and verify code — operating across multiple files, running tools, and correcting themselves before declaring success.
The leap from AI-assisted coding to AI coding agents is the difference between a co-pilot and an autonomous engineering team. A co-pilot suggests the next line; an agent reads the codebase, formulates a plan, delegates subtasks, writes implementation across multiple files, runs tests, reviews its own output, and iterates until verification passes. It does not ask for permission to take the next step — it takes it, within defined boundaries, and reports evidence of completion.
This shift changes the economics of software production. An agent that can autonomously complete a well-scoped task — building a dashboard, refactoring a module, generating a report — turns hours of human engineering time into minutes of agent execution. But autonomy alone is not enough. The architecture that enables it — multi-agent orchestration, model routing, verification loops — determines whether the output is production-grade or merely plausible.
A lead agent decomposes the task, assigns subtasks to specialist sub-agents (architect, coder, verifier), and synthesises their outputs. The orchestrator never writes code directly — it delegates, reviews evidence, and makes judgment calls.
Sub-agents receive compact design packets: goal, constraints, owned paths, acceptance criteria, and verification commands. Each runs in a fresh context with only the tools and information it needs. No context bloat. No distraction.
Every change is audited by an independent verifier — a sub-agent that runs tests, checks evidence, and returns PASS/FAIL with line references. No change ships without verification. The verifier has no stake in the implementation; its only loyalty is to correctness.
Architecture
Single-model agents hit a ceiling fast. One model cannot be simultaneously cheap, fast, reliable, and tasteful. The hybrid approach routes each task to the model that can meet its acceptance criteria at the lowest cost.
The insight is simple but powerful: different tasks require different cognitive profiles. Mechanical implementation — writing boilerplate, formatting code, running scripts — demands throughput, not judgment. Architecture decisions, API design, and taste-sensitive UI work demand senior judgment and broad context. Verification demands independence and a willingness to say no. No single model excels at all three.
The hybrid approach assigns each task to its optimal model. A slower, more expensive reasoning model (Fable-5, DeepSeek-v4-pro) orchestrates and arbitrates. Faster, cheaper execution models (Sonnet, DeepSeek-chat) handle mechanical work. An independent verifier audits everything. The result: higher quality at lower cost than any single-model approach, because expensive models are used only where they add value.
| Task Type | Model | Why |
|---|---|---|
| Strategy, creative direction | DeepSeek-v4-pro / Fable-5 | Complex reasoning, brand judgment, full context |
| Architecture & API design | DeepSeek-v4-pro / Opus | Taste, maintainability, tradeoff judgment |
| Mechanical implementation | DeepSeek-chat / Sonnet | High throughput, low cost, deterministic |
| Code review & verification | DeepSeek-chat / Sonnet | Structured audit, evidence-backed PASS/FAIL |
| Final arbitration | Fable-5 / DeepSeek-v4-pro | Synthesis across conflicting evidence |
The Ethos
A single model handling orchestration, implementation, and verification is like a surgeon who operates, administers anaesthesia, and audits their own outcomes. Conflicts of interest are structural, not personal. The hybrid approach separates these concerns: one model decides, another executes, a third verifies. Each operates within its competence. The result is not just better code — it is auditable, evidence-backed, and defensible.
The Systems
Two production-grade implementations of the hybrid paradigm. Veles (Fable-5 × DeepSeek) optimises for structured autonomy. Veles Forge (Grok 4.5 Build × DeepSeek) optimises for the build pipeline. Together they demonstrate that the hybrid pattern is not theoretical — it ships.
Fable-5 multi-agent framework powered by DeepSeek-v4-pro. Four specialist sub-agents — Orchestrator, Architect, Coder, Verifier — with persistent SQLite memory and custom H Heuristics tools. Designed for autonomous software engineering with a three-phase pipeline: Bootstrap → Enhance → Ship.
Built and tested across dashboards, websites, interactive maps, and PDF reports. Deployed on Cloudflare Pages. Production-proven.
→ Deep Dive: VelesOpen-source reimplementation of Grok 4.5 Build's multi-agent coding workflow, powered by DeepSeek API (V3 + R1). Preserves the agent/persona/role/skill architecture — Plan → Design → Implement → Review — while swapping in DeepSeek as the LLM backend.
A faithful port of xAI's orchestration layer: agents are markdown files, personas are TOML, skills are multi-agent loops. Designed for extensibility and transparency.
→ Deep Dive: Veles ForgeDecision Framework
Veles and Veles Forge are complementary, not competitive. The choice depends on the task profile: structured vs. creative, autonomous vs. pipeline-driven, persistent vs. stateless.
| Dimension | Veles (Fable-5 × DeepSeek) | Veles Forge (Grok Build × DeepSeek) |
|---|---|---|
| Best for | Autonomous builds, multi-session projects, persistent memory | Pipeline-driven builds, design-first workflows, extensible agent definitions |
| Architecture | Orchestrator → sub-agents (Ar, Co, Ve) with SQLite memory | Agent/persona/role/skill orchestrators with file-based config |
| Verification | Independent Verifier sub-agent with PASS/FAIL evidence | Design-doc review loop with revision until zero open issues |
| Memory | SQLite persistent memory across sessions | Stateless — each run is independent |
| Extensibility | Custom tools, sub-agents, and memory backends | Markdown agents, TOML personas, pluggable skills |
| Deployment | Cloudflare Pages (static sites, dashboards) | Any Python environment with DeepSeek API access |
For a detailed comparison of architectures, model routing strategies, and anti-patterns, see the Architecture → page.