H Heuristics

Informational Resource · Volume I

AI Coding Agents — The Hybrid Paradigm

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.

H Heuristics Nottingham, UK July 2025
01

Foundations

What Are AI Coding Agents

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.

Orchestration

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.

Delegation

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.

Verification

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.

02

Architecture

The Hybrid Approach

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.

Model Routing by Task Type
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

Why Single-Model Agents Fall Short

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.

03

The Systems

Veles & Veles Forge

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.

System I

Veles

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: Veles
System II

Veles Forge

Open-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 Forge
4
Sub-Agent Roles (Veles)
4
Pipeline Phases (Forge)
2
Model Providers
5+
Projects Shipped
04

Decision Framework

When to Use Which System

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.