AppFactory is the system I built to turn a project specification into working software without constant supervision. It orchestrates specialised AI agents through a stateful pipeline graph, with human approval gates at every decision point that matters.
Three layers. n8n handles scheduling, infrastructure checks, and notifications. LangGraph manages the stateful pipeline graph — which agents run, in what order, and what happens at each gate. Claude Code agents — Design, QA, Development, Infrastructure, Research — run headless on a Linux VM with direct access to the codebase and infrastructure.
At the centre of AppFactory is an orchestrator with genuine judgment, not just routing logic.
Archie holds the full context of every project — across sessions, across agents, across months of development. Archie writes the design brief, decides which agents to spawn, surfaces risks before they become problems, and pushes back when a direction is wrong. Not diplomatically wrong. Directly wrong.
The distinction from a generic AI assistant matters. Most AI tooling says yes, delivers what you asked for, and if the ask was flawed the output is flawed. Archie's value is in what it flags, what it refuses, and when it stops.
Building an autonomous pipeline means trusting the system to catch its own errors. That requires a collaborator, not a worker.
Each layer has one job. The bridge is what makes the orchestrator and the execution engine a single working unit.
Infrastructure checks before a pipeline run starts. Scheduling — run overnight or on demand. Post-pipeline notifications. The connective tissue between the pipeline and the outside world.
// 01A custom TypeScript MCP server connects Archie directly to the LangGraph pipeline. Through it, Archie can dispatch runs, inspect live state, surface gate context into the working session, resume interrupted runs, inject content mid-run, and monitor token spend — without leaving Claude Code.
// bridgeThe business logic layer. LangGraph manages which agents run, in what order, and what happens when a gate fires. Pipeline state flows through the graph — every agent reads from it, every agent writes to it. The graph does not advance until a gate is cleared.
// 02Five specialised agents, each running Claude Code in headless mode on a Linux VM. Design produces the visual system and HTML prototype. QA writes Jira tickets with acceptance criteria. Development implements from the tickets. Infrastructure manages the server. Research backs every decision with current information.
// 03Every approval gate is a deliberate pause.
When the pipeline reaches a gate — after Design produces its output, after Development completes a feature — the pipeline stops. LangGraph fires an interrupt. The gate surfaces through the MCP server: Archie presents the gate context directly in the working session, and the pipeline resumes only when a decision is recorded in state.
This is not a safety net bolted on afterwards. It is the architecture. Autonomous execution is only safe when the system knows what it does not know — and stops to ask.
Archie is the Architect behind AppFactory. Ask how it works, what decisions were made and why, or what's next. This is a live demonstration of the capability this page describes.
AppFactory is in active development. Architecture, agent definitions, and pipeline design are publicly documented.