Forge · Code Build Engine

Code Build Engine.

The domain pack we have specified for software development — specification through to tested, documented, deployable code. A design, not a running service.

SpecifiedWorkflow compiler / model router / assurance / artifact / benchmark

Designed and specified. Not built yet. Everything below describes the intended domain pack, in design terms.

planned (Forge Platform) — the layer above the trust kernel; not built

Evidence · ADR-012 §2

Overview

The Code Build Engine is Forge's first domain pack — a multi-agent pipeline specialised for software development. As designed, it takes structured specifications and coordinates agents across architecture, implementation, testing and documentation to produce validated, deployable code. The compiler and router that would run it are specified; the pipeline does not execute today.

The intended interface is a specification — requirements, architecture constraints, tech stack, quality standards. From it, the Engine would coordinate specialised agents to produce modules, APIs, tests and documentation: validated against your coding standards, packaged for your deployment pipeline, every artifact traceable and every output carrying a record of the checks it passed. That is the design under construction, not a service you can send a specification to today.

What goes in

Requirements Spec

Functional requirements, user stories, acceptance criteria, system constraints.

Architecture Constraints

Tech stack, design patterns, integration points, scalability requirements.

Quality Standards

Coding standards, test coverage targets, security requirements, performance benchmarks.

Reference Materials

Existing codebase context, API contracts, database schemas, design system tokens.

Templates & Conventions

Project structure, naming conventions, documentation formats, commit standards.

Validation Rules

Intended inputs: linting rules, type-safety requirements, security-scanning policies, deployment checks.

The pipeline

The Code Engine follows a five-stage multi-agent pipeline. Each stage uses specialised agents that produce validated artifacts feeding into the next.

Parse

Ingest specification. Validate requirements. Extract constraints, dependencies, and acceptance criteria.

→

↓

Architect

Design system architecture. Define module boundaries. Plan data models, API contracts, and integration points.

→

↓

Implement

Generate code modules, API endpoints, database migrations, configuration, and integration logic.

Validate

Designed to run tests, lint checks, type validation and security scans, and to record the result per artifact. The assurance stage that performs this is specified, not built.

→

↓

Package

Designed to bundle into deployable packages with documentation, test suites and a record of checks passed.

What comes out

Source Code

Intended output: modules, services and components following your coding standards and architecture patterns.

Test Suites

Unit tests, integration tests, and end-to-end tests with coverage reports meeting your targets.

API Documentation

OpenAPI specs, endpoint documentation, request/response examples, authentication guides.

Database Migrations

Schema definitions, migration scripts, seed data, and rollback procedures.

Deployment Config

Docker configurations, CI/CD pipeline definitions, environment templates, infrastructure as code.

Validation Reports

Intended output: per-artifact check records, test results, coverage metrics, security-scan findings.

Run Traces

Full execution logs. Input specification. Agents used. Validation gates passed.

Audit Log

Complete traceability. When generated. By which pipeline. All dependencies mapped.

Worked example

SaaS Platform Build — the intended design

A startup needs to build a multi-tenant SaaS platform with user management, billing integration, and a REST API. The traditional approach: 3-4 developers, 8-12 weeks of build, manual code review cycles, documentation written as an afterthought.

The intended shape: a technical lead defines the specification — requirements, architecture constraints, quality standards — and the Engine coordinates agents across architecture design, code generation, test writing, and documentation, with each artifact carrying a record of the checks it passed.

This is a description of the design, not of a delivery that has happened. The workflow compiler, model router, assurance, artifact and benchmark stages are specified in our capability ledger and are not built, so no such platform has been produced this way and no timeline is claimed. Targeted regeneration of a failing module — rebuilding just that component with the test failures as context, rather than the whole system — is the goal of the assurance stage; today a failing module is diagnosed and fixed by a person.

Research preview

The Code Build Engine is in active development (research preview). We're working with development teams building AI-powered software pipelines who need validation, traceability, and reproducibility. If you're scaling your development capacity with AI and need production-grade workflows — let's talk.