← Back to home
Core Architecture

The Deterministic
6-Phase Pipeline

Six phases. Strict order. No shortcuts. Every decision logged, every output traceable, every failure understandable. That's the difference between AI you trust and AI you can't.

01
Intent Gate

Classify the task before touching it

The agent reads your prompt and classifies intent: is this a static page, a light interactive app, or a full product system? This single decision determines every downstream choice — scaffold structure, code complexity, deployment target. The gate blocks impossible requests early rather than failing late.

02
Plan

Write the build spec. Approve it first.

The agent generates a structured build specification: file tree, tech stack, dependencies, key decisions, known constraints. You see exactly what will be built before a single file is created. You can push back, redirect, or refine — this is the last checkpoint before execution. No more "surprise, here's 40 files."

03
Scaffold

Build the skeleton. Verify the structure.

The agent creates the project structure: directory tree, config files, entry points, folder conventions. Scaffold is the skeleton — it determines whether the build has a clean foundation or will fight against itself. You see the structure lock into place. You can inspect it before code is written.

04
Code

Write the files. File by file.

Actual code generation. The agent works through the file list from the scaffold, writing each file in dependency order. You watch files appear in real time. Every file creation is logged. Every error is surfaced. No black-box "generating..." — you see the work as it happens.

05
Save

Deploy or save. Your call.

Once code is generated, the Save phase handles deployment: GitHub PR creation, static file upload, or local save. The agent generates a deployment URL. You approve before anything goes live. Catastrophic rewrites are caught and blocked — the system will not destroy working code without explicit consent.

06
Verify

Audit the output. Report, don't decide.

The QA agent audits the output: syntax checks, resource accessibility, consistency verification, edge case review. It produces a structured audit report — severity-tagged findings (critical/advisory), specific issue locations, screenshots where relevant. Verify does not declare success or failure. The Orbit runtime is the sole authority for run state. This is by design: audit and governance are separate from execution authority.

Why order matters

The pipeline is not a suggestion — it's a constraint. Each phase's output feeds the next. Intent Gate determines Plan's scope. Plan determines Scaffold's structure. Scaffold determines how Code executes. Skip a phase and you break the chain. This is what "glass-box" means: the order is the contract. You know what you're getting because the process is the product.