What this page is about
What we built: A fully self-hosted research stack running on locally-owned hardware across two countries. Three compute nodes (the primary node, a second node, and a contributor's machine), minimal cloud dependencies, automated 14-cycle-per-day observation pipeline, 66+ isolated workspaces for different collaborators, and a distributed compute model that contributes idle GPU cycles to Folding@Home.
Why it matters for Stage IX: Stage IX asks what the infrastructure of an ongoing practice looks like. This page answers that question with specifics: what runs, where it runs, what it costs, and how it stays operational without external services. The infrastructure is not peripheral to the research -- it is an implementation of the research's core principle: locally-controlled, transparent, and sustainable.
How Stage IX resources would be used: The current setup is one researcher, three compute nodes across two countries. Stage IX funding would allow additional compute nodes to be brought into the network, supporting parallel workloads and further reducing single-point dependency. It would also fund the transition from a solo operation to a documented, onboardable infrastructure that other practitioners can replicate.
How it proves permanent beta: Permanent beta is not a design philosophy -- it is an operational condition. The pipeline runs continuously. Workspaces are added as collaborators join. The infrastructure changes as the research changes. Nothing in the stack is static. The 14-cycle-per-day schedule has run without interruption. The idle GPU contributes to science between cycles. The system does not stop between uses.
Locally owned.
Owned hardware, hosted models too.
one framework runs on hardware owned outright. Image generation and data storage run on locally-owned compute. Language processing currently runs mainly on cloud models, with fleet models alongside; the research grant funds moving more of it onto contributor nodes. Around the models sits the bridge: deterministic systems that guard, feed and shape what the models do (see How the system works).
What runs where
Primary compute.
Core AI processing, ComfyUI image generation, observation pipeline, pattern extraction. Owned outright. Running continuously.
Secondary compute node.
Local GPU workloads, model training, and heavy processing tasks. Co-contributor infrastructure managed via encrypted SSH tunnels.
Self-hosted on owned hardware.
All data remains on locally-owned hardware. No data leaves the jurisdiction for storage. Cloud APIs handle language processing only - core compute, generation, and storage are local. Operating cost: under EUR 5 per month in electricity.
How the system works
The AI models at the centre of one framework are powerful and unreliable, and they cannot be made deterministic. So the one bridge wraps them in deterministic systems, grouped into eleven families. Four surround every turn (outlined); seven more sit around them.
Every rule starts as a measurement and acts only once its evidence is in: measure, backtest, shadow, warn, enforce. A behaviour change is code in the pipeline, not a line in a prompt. Code maturity varies by member, and some families currently run on a single host.
The observation pipeline
Each of 14 daily observation cycles passes through eight stages. The pipeline is automated end-to-end. Human intervention is not required for any stage of a standard cycle.
Schedule trigger. Cron fires 14 times per day at fixed intervals. Consistent timing makes cycles comparable across the archive.
Dream narrative generation. Local language model generates the field observation narrative. 300-500 words. Consistent world, consistent characters, linear timeline.
Structured extraction. A second model pass produces extract.json. Four fields: actions, patterns, ideas, decisions. Empty arrays are valid and meaningful outputs.
Pixel art generation. ComfyUI with the SpriteShaper model renders a 1024x1024 pixel art artifact from a prompt derived from the narrative.
Post-processing. Median rerender applied to produce clean pixel art at correct block scale. Raw ComfyUI output is discarded. Final artifact averages 74KB.
Archive commit. Narrative, extract.json, and artwork committed to the public git repository with timestamp. Immutable record.
Pattern issue creation. Patterns and actions from extract.json generate tracked issues in the dreams-to-actions repository.
Public gallery update. The public archive at oneframework.to/dreams updates automatically. Every cycle is visible within minutes of generation.
154 collaborator workspaces
one framework operates 154 isolated workspaces for different collaborators and research threads.
Each workspace has independent memory, independent cron jobs, and independent behavior reviews. Memory isolation is architecture, not policy: workspaces cannot access each other's data. The isolation is enforced at the infrastructure level, not by convention.
Ethical AI Foundation
The infrastructure operates under the Ethical AI Foundation framework at ethicalaifoundation.cc. This implements the OECD AI principles: owned-hardware operation, transparent decision-making, fair treatment of contributors.
The infrastructure is the implementation of these principles, not a separate commitment made alongside it. Owned hardware means a large share of the compute runs locally, alongside hosted models. Transparent means work is recorded in a repository. Fair means every contribution is tracked and attributable.
Distributed compute model
When the observation pipeline is idle, GPU cycles are contributed to Folding@Home, a distributed protein structure research project. The compute does not sit unused between cycles.
The broader compute model draws from the BOINC contribution framework: contribution value logged for contributed cycles, knowledge contributions tracked alongside compute, and attribution so that contributions from collaborators are recorded against the outputs they enabled. All contributions are tracked transparently. There is no speculative token layer. There are no tokens. The accounting is straightforward: contribution in, attribution out.
Every contribution is recorded at all three layers. Immutable, auditable, not dependent on trust in any single party.
Contribution records are kept in the operator's own records and credited to contributors. A public ledger or chain is a proposal only and is not live.
Operating costs are shared proportionally across contributors — the same principle that governs contribution accounting throughout the network.
Current state / target state
The local compute infrastructure handles image generation, processing, and data storage. AI language processing currently runs on cloud APIs (Anthropic, Gemini, and others via crane, the family that knows what every node can do and places work on the node that can run it). This is a deliberate interim position, not the end state.
The research grant funds the transition: replacing cloud-based processing with distributed local processing across the contributor network. Compute nodes contributed by researchers, artists, and institutions will handle language tasks directly. No external API dependency. No external jurisdiction. No ongoing subscription cost.
The architecture is designed for this transition from the start. Routing logic is provider-agnostic. Local endpoints are already supported. What the grant buys is the network scale required to make local processing reliable at research scale.
Operating costs
The entire research infrastructure runs for under EUR 5 per month. This is not an estimate -- it is the actual cost based on electricity consumption of the local compute nodes.
The pipeline generates 14 observation cycles per day. That is approximately 420 cycles per month, each producing a narrative, an extract.json, and a pixel art artifact. Cost per cycle: under EUR 0.012. Minimal cloud costs - local inference handles most workloads, with cloud APIs for language processing. No subscription fees. The hardware is owned outright.