An AI Coding Farm from Old Laptops

The problem with renting an AI developer

Autonomous AI coding tools are real now — but the model assumes you'll rent them forever. The meter runs every month, your code lives on someone else's cloud, and the moment you stop paying, the capability evaporates. For a small shop that wants AI writing code around the clock, renting forever is the wrong deal.

The turn: the datacenter was already on the shelf

Most companies have a shelf of hardware that still boots — laptops three generations old, a decommissioned desktop, the machine someone upgraded away from. Individually underpowered. Collectively, a datacenter that's already paid for. The question stopped being "how do we afford ten agents" and became "what would coordinate ten machines we already own?"

What we built instead

Ralph Loops is a coordination engine that turns that shelf into a coding farm. Ten repurposed machines, each running the Claude command-line agent, joined into one private network. You drop a task file into a folder; overnight, an agent picks it up, does the work, and pushes a branch you review in the morning.

• Git is the coordination layer. Every agent works on its own branch and pushes independently — no shared database, no lock server, no central queue to fall over. Merging is a review step a human controls.
• A private mesh, not the open internet. The machines find each other over an encrypted mesh network (Tailscale), so a farm can span a home, an office, and a colleague's spare box as if they were in one rack.
• Roles keep tasks independent. Agents are assigned lanes — backend, frontend, tests, and so on — so a night's work parallelizes cleanly instead of ten agents colliding on the same file.
• Built to survive itself. Push retries with back-off, pre-flight checks that a machine is pointed at the right repository before it touches anything, and a hard rule that the engine, the dashboard, and the product it builds never contaminate each other's code.
• You review, you own. The output is ordinary branches and commits in your repository. Nothing to export, no lock-in, no proprietary format.

The results: a coding team with no rent to pay

The whole farm is ten workers, not one — on hardware that is a sunk cost you already own. When the work is done, you turn the machines off; there's no subscription meter running in the background.

What we learned the hard way

The polished pipeline above hides the failures that taught us how to build it:

• Keep the three capsules apart. The engine that orchestrates, the dashboard that watches, and the product being built must never share code. Early versions blurred them and every change risked breaking two systems at once. The separation is now an inviolable rule.
• Deploy order is a real bug class. An early run copied fresh scripts before syncing the repository, so a stale checkout silently overwrote the new engine. Sync first, then deploy — obvious in hindsight, invisible until it bites.
• Validate before you trust. An agent pointed at the wrong remote will happily push to the wrong place. A pre-flight check that every machine is aimed correctly turned a whole category of silent disasters into an early, loud failure.
• Autonomy needs a human gate, not a human babysitter. The win isn't "no people involved" — it's that a person spends ten minutes reviewing in the morning instead of eight hours writing at night.

Where this applies

If you're paying per-seat, per-month for AI development tools — or you've written off automation as too expensive to own — this architecture rebuilds for you:

• Software teams that want overnight, autonomous progress on a backlog
• Agencies running many small projects in parallel
• Companies with idle hardware and a reluctance to rent more cloud
• Anyone who wants AI infrastructure they control, not a subscription they're captive to

Your code stays in your repositories, on machines you own. The heavy lifting happens on hardware that was already sitting there.