Skip to main content

AI Software Factory: the model never pulls the trigger

An AI software factory that turns product intent into running enterprise software through secure, observable, and recoverable AI build workflows.

The model can propose actions. The control plane decides whether they run.

The system uses a declared workflow to plan, build, validate, and publish software. Model workers are isolated from credentials and irreversible actions.

Four layers separate orchestration, model execution, tool access, and publishing.

AI Software Factory architecture diagram: a workflow engine spawns agent workers per step, workers send tool requests to a policy-enforced tool gateway, and a publisher outside the loop performs irreversible actions only on a proven-complete run

Non-determinism stays inside the loop. Side effects live outside it.

01

Workflow Engine

Deterministic control plane

The build is a DAG, not a script. Steps have real dependencies. Validation can send work backwards to be repaired. A graph lets us retry one step, mark downstream work stale, and resume from a checkpoint without redoing what already passed. Declared in YAML so the pipeline shape is reviewable, diffable, and version-controlled. The same workflow every run.

02

Agent Workers

Model execution boundary

Workers run the model loop. They can request tools but cannot invoke them directly, access credentials, or create external side effects.

03

Tool Gateway

Policy-enforced boundary

Every request is approved or denied. Deny-by-default, path containment, audit logging. The model can ask for anything but only gets what policy allows.

04

Publisher

Deterministic side-effect boundary

The publisher handles irreversible actions such as pushing a branch or opening a pull request. It runs outside the model loop, reads the completed checkpoint, and acts only after validation passes. Re-running the publisher does not duplicate the action.

One boundary out of several. More on how the factory is built coming soon.

Watch It Run

Four walkthroughs of the factory, from the DAG and its boundaries to the control tower that oversees a build.

Part 1

DAG and Boundaries

Why the build is a graph, and where the hard lines between layers sit.

Part 2

TUI-Based Agentic Workflow

Driving the factory from the terminal: watching agents work a run.

Part 3

Control Plane Architecture

Inside the deterministic scheduler: retries, repair, checkpoints, resume.

Part 4

Application Build Control Tower

The operator's view: observing and steering builds in production.

Building agent systems with boundaries?

This is the kind of system I design and ship. Let's talk about yours.