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.
The shape of it. LangGraph manages the stateful pipeline graph — which agents run, in what order, and what happens at each gate. Specialised Claude Code agents — Design, QA, Development, Infrastructure, Research — run headless on a Linux VM with direct access to the codebase. A custom MCP server bridges the two into my working session, so I can dispatch a run, watch live state, and clear gates without leaving Claude Code.
The agents don't grep blind. AppFactory keeps a custom code-graph of the target repo — a Neo4j model of every symbol, endpoint, DTO, dependency and test across TypeScript and C#, parsed into two isolated views: the in-progress branch and what's live in production. Planning a change means querying that graph through a purpose-built 17-tool MCP server, reasoning about impact against the codebase's real structure.
And it works. AppFactory took musicTeacher — a multimodal AI music-teacher app — from a specification through Jira tickets, code, pull request, staging, and into production, through the full pipeline. A real, substantial Angular and .NET application, built by the system this page describes.
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.
The orchestration layer. Stateful graphs — research, iterative development, QA, infrastructure — decide which agents run, in what order, and what happens when a gate fires. State flows through the graph; every agent reads from it and writes to it. It does not advance until a gate is cleared, and a run can pause and resume exactly where it stopped.
// 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.
// bridgeSpecialised agents running Claude Code headless on a Linux VM. Design produces the visual system and prototype; QA writes Jira tickets with acceptance criteria; Development implements them; Infrastructure manages the server; Research backs decisions with current information. Work is routed by cost — scoped tickets to a cheaper model, judgment calls to a stronger one.
// 02Every node is traced — Langfuse over OpenTelemetry links a whole multi-agent run into one record, with token and cost on each step. Agents return typed outcomes — completed, blocked, or research-needed — so nothing fails silently. And the hard rules are enforced in code: the pipeline never merges to main.
// 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.