Infrastructure / Lab
A general, high-level look at the technology categories Dark Factory runs on.
Dark Factory runs on a self-hosted homelab foundation: containerised services, a source-of-record git server, a workflow-automation layer for gate enforcement, and a relational database for telemetry — described here only at the level of general architecture and major technology categories, never as operational detail.
4.1 The component overview
The table below names the major components the Factory is built from, and for each one says whether it is an off-the-shelf technology product or a logical part of the Factory itself, and what it does in the picture. Keeping that distinction separate is the point of the table: the same name can hide two different things — a product the Factory uses, or a role the Factory is — and conflating the two is how a description quietly overstates what has been demonstrated.
| Component | Kind | Role in the Factory |
|---|---|---|
| n8n | Technology product | The workflow-automation layer. It runs the Controller: the thing that coordinates the Runner and enforces the gates, the recorded Phase 2 basis for gate enforcement. |
| Qwen3.8 | Technology product | The locally hosted model providing inference for the project worker roles (a recorded Phase 2 result: locally hosted inference operating through the Factory). See the note below this table for the recorded radian consideration. |
| AI PC | Technology product | The local machine that hosts the Qwen3.8 inference. |
| Runner | Factory role | The persistent execution environment that stays ready between iterations and drives whichever execution tool is selected, under a stage contract. |
| OpenHands | Technology product | The execution tool introduced in Phase 2 for headless, receipt-checked agent execution; one of the two paths a Factory role can run under. |
| OpenCode | Technology product | The earlier-selected headless execution tool; the other of the two paths the Runner can dispatch a Factory role under. |
| Forgejo | Technology product | The source-of-record git server holding the project repository and its artifacts. |
| Podman | Technology product | The container runtime for the containerised services and the build/packaging stage. |
| Validator | Factory role | The role that independently reviews the Developer’s work against the stated acceptance criteria. |
| Security | Factory role | The role that independently reviews the same work from a security standpoint. |
| Codex CLI | Technology product | The external tooling the oversight and coaching (Observer) function moved onto in Phase 2; deliberately external to the locally hosted project inference. |
| Container / package controls | Factory control | The network, package and container access controls — the approved package and container registries and the container-image validation. Recorded as foundational (several of them compensating) controls, not a completed security framework. |
One line that needs its category stated, not left to inference: the human review of this phase recorded that a “radian” was considered for Phase 3 with respect to Qwen3.8. That is a recorded human-confirmed consideration — it is recorded as given and is not resolved on this page, and this page does not speculate about whether it was acted on or what it would involve. It is stated in that category on purpose, because presenting an unconsidered decision as made (or a made decision as certain) is exactly the overstatement this page is not here to make.
4.2 Agent execution technologies
What each of the two execution tools does, and why there are two of them: OpenCode was selected first because it was the established headless agent tooling — it had already been part of the Factory’s planning, and it supported the kind of scripted, non-interactive execution a persistent Runner needs. In practice, operating a session-based interactive tool inside a long-lived, headless, automated environment turned out to be harder than the design assumed: the execution interface showed weaknesses precisely under the retry, timeout and recovery conditions a Runner lives in, and the first Phase 2 execution was closed as incomplete rather than forced through. That evidence is what motivated introducing OpenHands as an alternative path: its model is execution-oriented — a tool per action, a result checked before the next action, a recovery path when a command fails before it can be corrected — which matches how the Runner already wanted to drive an agent (one bounded action, verify the receipt, move on).
The motivation for supporting multiple execution tools is not redundancy for its own sake; it is what made the Runner’s separation possible. The Runner separates its own orchestration — dispatch, evidence binding, the recovery budget — from the specific agent tool it drives. Because that boundary is drawn, a Factory role can run under OpenCode or OpenHands against the same stage contract, and the choice of tool does not reach into how the stage is reviewed or how its evidence is bound.
One boundary is kept straight on purpose: the rationale for choosing OpenHands — a better fit for headless, receipt-checked execution — is a design argument. What Phase 2 actually demonstrated, on the record, is that the Factory could dispatch under both tools through the Runner and complete its iterations. That OpenHands is definitively superior in general is not established by that phase, and this page does not claim it. The benefit the Factory gains from having both is flexibility under one stage contract, not a universal preference for either option.
4.3 Infrastructure evolution
When Phase 2 was scoped it looked like a content phase with a bit of automation attached; in execution it turned out to be substantially more infrastructure-intensive, because every reliability gap in the execution stack had to be closed before another iteration could be trusted to run. The components and controls in the table above are, for the most part, the record of that: the persistent Runner’s reliability and lifecycle (what happens when an environment dies mid-iteration and how it is re-established without losing the accepted candidate); the integration between the n8n Controller and the Runner, and how a stage’s outcome is communicated back; the role instructions, tool contracts and execution interfaces that tell each stage which tools it may use and what shape its report must take; the handoffs of test evidence, validation results and security verdicts between stages; the network and package access controls and the approved package and container registries; and container-image validation with release-boundary controls.
The right way to read that body of work is as foundational controls introduced and refined during Phase 2, not as a completed security framework — several of them are compensating controls, and the phase’s own checkpoint record says so. The reliability problems of that phase (most of its 82 failed dispatches were operational rather than a feature code being wrong) were not random bad luck; most of them were these very controls being built while the machine they protect was already running. The compressed lesson, recorded at the cost of those failures, is that the operational foundation is not a preface to the real work — it is most of the work, and it has to be built while running. This section is written to be accessible to a technically interested reader; it is deliberately not an exhaustive operations manual, which is out of this page’s scope.
This page intentionally never includes credentials, internal addresses, specific configuration, or step-by-step operational instructions, and is never generated from live infrastructure state — it is static, hand-authored content, reviewed the same way every other page on this site is.
The general-architecture coverage above is the page’s full scope for now; anything more specific than major technology categories is deliberately out of scope for this site, not a gap in the writing.