Factoria is my production line. A scheduled pipeline (the loop) does the building, under the review policy stated below. Every time something breaks, the lesson is written down and the line gets better. This page is the line's public logbook — read journal 001, January to August →
Date:2026.10
Operator:Julio Ochoa
Thesis:failure becomes doctrine
Forms shipped:1,304 · 2026-09-25
Routines:16 · 2026-09-25
Repos:11 · 2026-09-25
Harnesses:6 · 1 operator · 2026-09-25
CONTENT: POSTGRES → ISR 60S
$ factoria runExample runRUNNING
A grid of squares that grow steadier from left to right, with one walker crossing it whose touch warms the squares it passes; it pictures the architecture of the production line, and its arrangement is generated from the factory's data.[ Fig. 0 ] Instruction: settle the work column by column; whatever the pass touches keeps its warmth a while. always in flight. · drawn from factory data
/How the factory works
THE OPERATOR · HUMAN
One person
designs the end product first, sets direction, holds the veto.
→
THE LOOP · AUTOMATED
design
see the end first
capture
collect the ask
shape
agree the plan
build
write the code
verify
prove it works
ship
release it
persist
write it all down
→
THE APPS · OUTPUT
5 products
built the same way, sharing every lesson.
Work goes in one end; verified software comes out the other. When something breaks along the way, the failure is written down as a numbered lesson — a spark — and the checkpoint that missed it gets stronger. The words below come up a lot:
design — I draw the finished screen before any code is written, and the build is checked against the drawing.
/The loop, one passseven stations · the output feeds the inputseven stations · one loop
Seven stations, one circle. Work enters as a form at design, comes out as a merged pull request at ship, and what was learned goes back in at persist — so the next pass starts smarter than this one. Every change must pass its tests and an automated review; changes to deployment, to what the loop may do, or to its written rules wait for the operator to read them before they merge, and everything else merges once its checks pass and is read afterwards, with a revert path.
[ Fig. 12 ] Instruction: place seven stations on a circle; walk it clockwise; close it from persist back to design; one human stands at verify and may say no.
designI asked for a walk-through of /factoria that a first-time reader can follow, with the feedback button in the corner. · 2026-09-18T06:52:00Z
capturethe ask became a Form, with its acceptance criteria and file scope written down.
shapethe criteria were agreed, re-grounded five times as sibling PRs landed the same day.
buildthe seven-station walk-through went into the page, with its own test.
verifypnpm build and the full suite ran green before the PR opened. A human holds the veto here.
shipthe PR merged to main.
persistthis row was written, and the next pass starts from it. · 2026-09-18T14:35:00Z
/Origins2026.1 → 2026.8
2026.1 · Act I · entry
Flow
Summary: The first build: an energy-first planner with three doors to one backend — a web app, a WhatsApp bot, and an MCP server an AI orchestrator reads and writes through OAuth. The plan lived in the database and the agents were disposable before the line had a name. The ledger opens here — one operator, one AI collaborator, and the habit of writing down what broke.
A river of cubes converging on a centre line, fastest mid-river and warming to red only on arrival; it pictures the planner, where order is earned over the journey and the line is the attractor.[ Fig. 1 ] Instruction: let the current carry every cube toward the center line; the river runs all day · drawn from factory data
2026.2 · Act II · entry
Personal Wiki
Summary: An MCP wiki with a knowledge graph. The discovery that mattered: the wiki could be the orchestrator, with agents as ephemeral workers over shared state. Written on the ledger early: the methodology is the product.
Author: The Operator · Topic: Orchestration · Read
A lattice of nodes joined by edges, ordered at the centre and fraying toward the far edge, with one pulsing red hub; it pictures the knowledge graph radiating from the wiki.[ Fig. 2 ] Instruction: let order radiate from the hub; the far edge frays; the red hub holds · drawn from factory data
2026.4 · Act III · entry
Perse
Summary: The Forms pipeline: design, capture, shape, build, verify, ship, persist. Manufactured consensus, structural gates, a spark ledger — each entry paid for by a real incident. The loop runs nightly and files its own history.
Glass spheres in seven vertical bands, one band per station of the line, growing more ordered station by station, with the fifth band, verify, glowing red.[ Fig. 3 ] Instruction: seven stations of glass spheres, design first; each truer than the last; verify glows red — same line, both figures · drawn from factory data
2026.8 · Act IV · entry
Factoria
Summary: The portfolio built by the loop: one canon across every app, and a site that renders from the tables the loop writes. Every failure becomes a numbered row, and the next pass reads that row.
Author: The Operator · Topic: Production line · Read
One canvas divided into panes that split until there are as many as the floor holds work, large panes trembling and small ones still, with one lit pane in red marking where the loop is working.[ Fig. 4 ] Instruction: divide one canvas among the portfolio; the loop moves pane to pane and its warmth lingers · drawn from factory data
/The Work — featured1 canon · every app below
Glass spheres in seven vertical bands, one band per station of the line, growing more ordered station by station, with the fifth band, verify, glowing red.[ Fig. 5 ] Instruction: seven stations of glass spheres, design first; each truer than the last; verify glows red — same line, both figures · drawn from factory data
Design to ship, verified at every gate. Work is designed first, enters as a form, moves through capture, shape, build, verify, ship, persist, and leaves as a record.
in plain terms → the line itself: an ask becomes a Form, scheduled lanes build and check it, and the outcome is recorded before the next pass.
Entry:No. 5 · 2026.5 · app
Author:Operator & loop
Topics:OS · Pipeline · Flagship
Status:LIVE · SIGN-IN REQUIRED
Summary: Runs on a schedule and writes its own record. Hot bands in the figure are verification firing.
Ten nested rooms in two rows, each room four squares deep and restoring order toward its centre, with the one running routine burning red at the heart of its room.[ Fig. 7 ] Instruction: nest each room in disarray; restore order toward its heart; the running routine burns red · drawn from factory data
Doctrine is the factory's constitution: rules distilled from repeated failure, written once, enforced everywhere. Every app inherits all of it — that is what “one canon” means. 4 articles so far. read the articles →
Squares fall from disorder at the top into order at the bottom, with one red square on the bottom row marking the gate; it pictures failures becoming doctrine, and the rows draw in from the bottom up.[ Fig. 11 ] Instruction: draw squares in disarray; restore order toward the bottom. disorder, gated. · drawn from factory data
01
Everything is a Form
Every unit of work enters as a form and leaves as a record. No loose ends, no untracked state.
02
Verification over trust
Output is claimed; state is proven. A gate passes work only when a test ran and the result was inspected.
03
Gates relocate, never disappear
Remove a checkpoint and it reappears downstream — priced in incidents.
04
Zero sparks is a healthy day
The ledger rewards boring. A quiet night means the doctrine held.
/The Operatorone person · holds the veto at verify
Deterministic controls around nondeterministic intelligence.
One operator designs the end product first, sets direction, and holds the veto. The operator, the career, and the work since January live on the homepage. meet the operator →
A field of plus marks that loosen with distance from the centre, where one mark is held perfectly still and heaviest; red X strikes around it are vetoes, so the figure pictures the operator holding the line.[ Fig. 9 ] Instruction: mark the field with crosses; let disarray grow with distance; hold the center still; strike each veto red. · drawn from factory data
/Sparks — the ledger of observed failurepaid for in incidents
A spark is a lesson the factory writes down when something breaks — numbered, dated, permanent. The ledger holds 5 so far. browse the full ledger →
SPARKS · 5 recorded · red = featured on this page················································017018········································································043···············049050
[ Fig. 10 ] the ledger, typeset in miniature · drawn from factory data
2026-02-18SPARK 017 · entrySilent success is worse than loud failure.domain: fallback paths
2026-02-21SPARK 018 · entryTwo sources of truth means one is always a lie.domain: duplicated state
2026-04-10SPARK 043 · entryAgents lose their context every run; the wiki does not. So the wiki holds the plan and the agents are disposable.domain: agent fleets
2026-06-27SPARK 049 · entryAutonomy decouples; the substrate re-couples.domain: shared state
2026-06-27SPARK 050 · entryThe verify gate degrades at the divergence rate.domain: long-running loops