The Factory
The organisation and role structure behind Dark Factory -- how it is set up to build and ship software.
There is a difference between building one website and building an organisation that can produce software. The first is a one-off product; the second is a reusable capability. Dark Factory’s name refers to the second, not the first: “the Factory” is the organisational layer behind this site — a defined set of roles, contracts, workflows, and gates that together operate as a software delivery team, with a human retaining final approval authority at every consequential step.
This site is the first product that organisation has shipped. During the work that built it, the effort went into both at once: establishing the organisation — role contracts, a plan of record, gates, and the review process — and building the website itself. Those are two different activities, and the distinction matters, because the site’s existence proves the first of them worked well enough to produce a real deliverable; it is not, on its own, evidence that the second is already complete.
The early phases of this project’s execution were human-mediated — a human initiated the work and stepped in where the process did not yet reach — and the subsequent phases established the coordinated execution they moved toward: the persistent Runner, the Controller, the role and stage contracts, the gated review, and the checkpoints, with human review at the gates and final deployment remaining manual. The phases are one ahead of the published site: the recorded work through the previous complete phase is what this site documents, and the current phase is carrying that out. Nothing on this site should be read as presenting an intended architecture as proven capability.
The structure itself — the roles, how work moves between them, and how separation of duties is enforced — is described on the Roles page, and the working method on the Method page. How the first phase actually went, including the parts that failed, is recorded in the Journal.
Models and coding agents
The Factory’s work is done by coding agents, and how they are constrained is part of the story, so this page says plainly which of the following are recorded facts, which are observations, and which are still only plans.
The recorded Phase 1 architecture constraint is that the Development and Validation work ran on the Factory’s default local capability profile — a Qwen3.8-class local model, with an effective context budget on the order of 250k tokens, conservatively treated as smaller than that for coherent multi-step reasoning. That constraint is why the Phase 1 plan was sized the way it was: every iteration was scoped to fit within one review pass, so that a single agent’s context could hold the whole diff and its criteria at once.
One consequence of that was observed, not measured, during Phase 1: carrying the role’s tool and schema definitions occupies part of that context budget, so the practical working window is smaller than the raw number. The overhead is stated qualitatively here on purpose — the Phase 1 evidence on file does not include a measured figure for it, and this site does not publish numbers it has not recorded.
That observation stays an observation. Nothing on this page is a requirement or a plan to redesign the Factory’s tooling or any model-protocol layer as part of this website’s scope; if the context economics turn out to matter more than they look like, that will be assessed on its own evidence in later phases, not assumed in advance.
Which models are actually used, and whether that choice changes as the project moves toward more coordinated execution, is a Phase 2 question that the Journal will track as it gets an answer.
How one delivery moves
The stages below are not a fixed chain of people and tools in one place; they are the way a single delivery moves through the organisation, with a human retaining final approval authority at the two ends. The dashed steps are the ones that still require human intervention; the rest run on the supporting infrastructure. The working method each step follows is on the Method page, and how a phase of many of these moves comes together is on the Status / Roadmap page.