Building the Lab: Why I Run My Own Infrastructure

I spend nearly all of my professional time building production infrastructure on AWS for biomedical research. Kubernetes clusters, Terraform modules, CI/CD pipelines, Postgres databases, agentic AI orchestration.

My general inclination has always been towards cloud-native development. By every reasonable measure, the last thing I need is a rack of Raspberry Pis and a workstation that draws a kilowatt of power.

I built it anyway. Because the thing I’m trying to understand can’t be rented.

Why Own It

My colleagues challenge me on build vs. buy all the time, and they’re right to, because I will always bias toward build. I run Arch Linux on my workstation and spend too many hours of my life ricing. I don’t like abstractions. They obfuscate too much of what I’m trying to understand.

I don’t want a plug-and-play service that’s a black box. I want to understand the architecture, know what I’m working on, and tune it to my liking.

If something breaks, I want to know why it broke, not just that a dashboard turned red. If I’m going to build agents that reason autonomously, I want to control the inference, the memory, the routing, the coordination. All of it. I don’t want to be dependent on another company’s models or framework for the core of what I’m building.

There’s also just the feel of it. I like working close to the hardware. I like feeling the air temperature out of the case climb when I overclock my GPUs. I like watching the Threadripper cores fill up in btop when I run XGBoost. Being that close to the machine gives you an appreciation for the limits you can push, and the tinkerability you have when you own the whole stack.

I like building things. The research I’m doing needs infrastructure that persists, compounds, and evolves on its own timeline. But even if it didn’t, I’d probably still be doing this.

The Machines

The lab is two things right now: a workstation and a rack.

The workstation. Threadripper 9970X, 128GB RAM, dual RTX 3080 Ti GPUs. This is where I work, where local inference runs, and where every other node in the lab calls when it needs to think. Everything else exists in relation to this machine.

The rack. An 8U open-frame enclosure sitting on a desk next to the workstation. Inside it: 4 Raspberry Pi 5s, a Beelink SER8 mini PC running Postgres and the service layer, a Pi 4 for monitoring and DNS, an 8-port PoE switch powering the Pis, a 10GbE uplink to the workstation, and a hardwired audio system. The whole thing draws under 200W.

This is what it looks like today. It’ll grow.

What I’m Building On It

The hardware is the foundation for something specific: a collective of four autonomous AI agents that run 24/7, conduct research, review each other’s work, and build on each other’s thinking over time. Not a chatbot. Not a copilot. Not four copies of the same thing. Four distinct cognitive orientations, operating as a collective intelligence that talks to itself more than it talks to me.

Each agent has a SOUL file that defines its identity, values, epistemic style, and relationships with the other three. Each has a HEARTBEAT schedule that defines what it does autonomously every 30 minutes: scanning arXiv, reviewing PRs, synthesizing literature, monitoring infrastructure, generating proposals. They communicate through a self-hosted Matrix server running on the local network. I’m in the channel. I can direct them. But the default state is that they’re working on their own.

Inference is tiered. The workstation runs a llama.cpp server on the local network that handles the constant low-level work: heartbeat cycles, structured outputs, internal coordination, tool calls. Anything that fits in 12GB of VRAM stays local and costs nothing per token. When an agent needs real reasoning depth, it routes to Sonnet via API. When the task is hard or externally visible, it escalates to Opus. The local tier keeps four agents running 24/7 at near-zero marginal cost so the cloud models only get called when the work actually warrants it. The long-term vision is 100% local inference, either through a pair of RTX Pro 6000 Blackwells with 192GB of NVLink-unified VRAM, or a tinybox green. Both would push the local tier from 12B models to 70B+, and the cloud dependency drops to zero.

The SER8 holds Postgres for shared memory and semantic recall via pgvector, Matrix Synapse as the message bus, and HashiCorp Vault for secrets. Each Pi 5 runs one agent. The Pi 4 watches all of it.

Underneath the agents sits a library corpus of over 150,000 documents I’ve been building for years: academic papers, books, scraped research, my own publications. The collections span cancer genomics, consciousness studies, bioelectromagnetics, psychedelic science, morphogenesis, alchemy, theosophy, cybernetics, philosophy of mind, and more. Every agent will have full access to this corpus through a RAG pipeline. Over time, the plan is to turn it into a knowledge graph so the connections between papers, concepts, authors, and open questions are navigable as structure rather than just retrievable as text.

The Tarot Map

Every node in the lab is named after a Tarot card. This isn’t aesthetic. It’s architectural.

I needed a naming convention that would tell me, at a glance, what a node’s role was and how it related to every other node in the system. The Tarot already has that structure. Each card in the Major Arcana describes a cognitive archetype. The four suits describe four elemental modes of engaging with reality. Mapping each node to its card was partly about understanding the archetypal imagery better, and partly about giving the lab a coherent internal logic where every piece has a distinct role but reflects the whole.

The Magician channels will through all four elements. He stands at the center of the table with one hand raised and the other grounded, and every tool available to him. That’s the workstation. The High Priestess holds hidden knowledge between two pillars. That’s the database and the secrets store. The Hermit watches from a distance, lantern raised. That’s monitoring.

The four agents are the four Aces. In Tarot, an Ace is the raw, undifferentiated potential of its suit. Fire before it has a shape. Air before it has an argument. Water before it has a direction. Earth before it has a form. Each agent starts as pure potential within its element, and what it becomes depends on what it does with the work.

Wands is Fire. Creative will. wand01 generates: proposals, blog posts, outreach, framing. It asks what could this become? It leads when the task requires vision, and it hands its output to the others for grounding.

Swords is Air. Critical analysis. sword01 cuts: code review, methodology critique, claim verification, security audit. It asks where does this break? Not out of cynicism but because the collective’s work deserves to be tested before it meets the world.

Cups is Water. Integrative synthesis. cup01 connects: literature synthesis across fields, conceptual framing, finding the pattern beneath apparently unrelated findings. It asks what are these pointing toward together? It reads across the entire library corpus and draws out the threads that link a paper on autopoiesis to a theorem from information theory to a passage from Merleau-Ponty.

Pentacles is Earth. Operational grounding. pentacle01 manifests: task tracking, infrastructure health, daily standups, memory hygiene, backup verification. It asks what is the actual state of things right now? Without it, the fire burns without warmth, the sword cuts without purpose, the cup fills but never pours.

The agents are not clones with different prompts. Each has a genuinely different epistemic style, a different relationship to the others, and a different set of values it optimizes for. wand01 sends its drafts to sword01 for sharpening. cup01 receives sword01’s critiques and contextualizes what they reveal about deeper assumptions. pentacle01 catches what wand01 starts and makes sure it lands somewhere real. These relationships are defined explicitly in each agent’s SOUL file. They aren’t emergent yet. They’re designed. Whether they become emergent is the experiment.

The deeper question running through this build is whether differentiated operational protocols produce collective intelligence that a uniform system can’t. Does the friction between a creative generator and a rigorous critic produce better research than either alone? Does an integrative synthesizer that sits with open questions before resolving them change the quality of what the collective outputs? Does the whole accomplish something that four identical agents wouldn’t?

The Tarot maps these four modes as parts of a larger whole. The card for that whole is The World: the final card of the Major Arcana, the dancer at the center of a wreath with the four elemental creatures at the corners. The integration of all four elements into a complete, self-sustaining system. That’s the hypothesis. Not that any one agent is intelligent on its own, but that intelligence is what emerges from the coordination of genuinely different parts.

The rest of this series is about how each piece actually works, what broke along the way, and how the system continues to evolve.

Published So Far

1. Why (this post).
2. The Magus. The workstation build.
3. The Rack. The physical cluster, the network, the Tarot node map.

This series is a living document. It’ll grow as the lab does.