The Lab That Started It All

Date: August 11, 2023 (but really, circa 2011) Duration: 12+ years and counting Issue: Wanted a media server, got an infrastructure obsession Result: ArgoBox - from seedbox to distributed homelab empire

The Real Beginning: ~2011

ArgoBox didn’t start with pentesting labs or VLANs. It started the way a lot of homelabs do: I wanted to watch my stuff.

The first iteration: A bare metal server running seedbox scripts. ruTorrent for downloads. Plex for streaming. The classics.

argobox.com was just a domain pointing at a box in a closet. Nothing fancy. It worked.

Phase 1: The Seedbox Script Era (2011-ish)

One machine. Managed by scripts that promised to handle everything.

The progression:

seedboxfromscratch - The first one. Did what it said. Got me running.
Quickbox - More polished. Better UI. More apps. The “I’ve made it” feeling of having a dashboard.
Swizzin - Tried it when Quickbox felt stale. Different maintainers, similar concept.
Saltbox - The Ansible-based evolution. More “proper” infrastructure-as-code vibes. Felt like the future.

Each script was someone else’s opinion about how a media server should work. Each one centralized everything on one box, one way, one vision.

argobox (bare metal, managed by $SCRIPT_DU_JOUR)
├── ruTorrent
├── Plex Media Server
├── Sonarr/Radarr/whatever-arr
├── The dashboard that made it feel official
└── Config files I was afraid to touch

The scripts worked. Until they didn’t. Until I wanted something they didn’t support. Until an update broke something and I had no idea why because I didn’t understand what the script had done.

After Saltbox, I made a decision: no more centralized solutions. No more trusting someone else’s automation to manage my infrastructure. Time to go my own way.

Phase 2: ESXi - Breaking Free

After Saltbox, I wanted control. Real control. Understanding what was running and why.

VMware ESXi was the answer. Virtualization meant I could experiment without risking the whole system.

ESXi Host
├── VM: Media Server (Plex, ruTorrent - MY config, not a script's)
├── VM: File Server
├── VM: Whatever experiment I was running
└── VM: The thing that broke last week (but I could snapshot-restore)

No more monolithic scripts. Each service in its own VM. Break one, the others survive. Learn by doing, not by trusting someone else’s Ansible playbook.

This was the first taste of real infrastructure. The realization that I could build it myself.

Phase 3: Distributed - Nothing Centralized

The next evolution: why have one box when you can have many?

One hypervisor became two. Then a NAS. Then another location entirely. Services spread out based on what made sense, not what one script decided.

Location A (Jove)              Location B (Kronos)
├── argobox                    ├── titan
├── argobox-lite               ├── masaimara
├── synology-jove              └── casablanca
└── various VMs

Nothing centralized. No single point of failure. No one script managing everything. Each system configured individually, for its specific purpose.

The domain was the thread. argobox.com pointed at things. VPNs connected locations. But each node was independent. If one died, the others kept running.

This was the opposite of the seedbox script philosophy. Instead of “one box does everything,” it became “many boxes, each doing one thing well.”

Phase 4: Unified (Now)

This is where August 2023 comes in. Not the beginning - the inflection point.

The question changed from “how do I run stuff” to “how do I make it all work together.”

Tailscale mesh connecting all locations as one network
Proxmox clusters replacing standalone ESXi
K3s for container orchestration
GitOps so config lives in repos, not in my head
Build swarm distributing compilation across 62 cores
Gentoo because I wanted to understand every package

The domain isn’t just pointing at things anymore. It’s the identity of a system that spans physical locations but operates as one.

August 2023: The Documentation Begins

This month wasn’t the start of the lab. It was the start of writing things down.

151 conversations with ChatGPT. Questions about:

Pentesting lab architecture
VPN isolation
GPU passthrough
Security certifications
Obsidian for knowledge management

I’d been building infrastructure for over a decade. I finally started documenting it.

The Evolution

Era	Approach	What I Learned
Seedbox scripts	Let someone else manage it	Convenience has limits; I didn’t understand my own system
Post-Saltbox	Do it myself	Breaking things is how you learn
ESXi	Virtualization	Isolation matters, snapshots save lives
Distributed	Nothing centralized	Each service where it belongs, not where a script puts it
Unified	Mesh + orchestration	Independence + coordination = real infrastructure

The seedbox scripts taught me what I wanted. ESXi taught me virtualization. Going distributed taught me that centralization was the problem all along. Unification brought it together without sacrificing independence.

What ArgoBox Means Now

The name stuck around for 12+ years. The meaning evolved.

2011: A box that hosts stuff, accessible via argobox.com

Now: An identity for a distributed infrastructure spanning:

Multiple physical locations (Milky Way + Andromeda in the sanitized naming)
Hypervisors, containers, and bare metal
Build infrastructure, media services, development environments
62 cores of distributed Gentoo compilation
Custom OS builds (Argo OS)

The domain is still the common denominator. But now it represents something coherent, not just a collection of things.

The Lesson

Homelabs don’t start with architecture diagrams and VLANs. They start with “I want to watch my movies” or “I want to download faster.”

The sophistication comes later. After you’ve outgrown the scripts that got you started. After you’ve realized that someone else’s “perfect setup” isn’t yours. After you’ve decided that understanding your infrastructure matters more than convenience.

seedboxfromscratch → Quickbox → Swizzin → Saltbox → my own way.

That progression isn’t failure. It’s education. Each script taught me something. And when I finally went independent, I knew why I was making every decision.

ArgoBox started as a seedbox managed by someone else’s scripts. It became a distributed system where nothing is centralized because I chose it that way - not because a playbook decided.

And in August 2023, I finally started writing it down.

Every infrastructure empire started with someone else’s script. The question is: do you stay there, or do you build your own?