My AI-Managed Home Server in 2026

Two and a half years ago, I turned an old laptop into a home server and documented everything in my Home Server series. This year, I rebuilt it from scratch. This article covers what changed, why it changed, and what I learned. It also kicks off a new series that goes deep on each part.

I Was Wrong About Virtual Machines

#

TL;DR

#

My home server now runs Proxmox with three VMs. Everything is defined in a single Git repository, deploys itself every hour, and backs itself up twice. And practically every line in that repository was written by AI agents, not by me.

Full Story

#

In the first article of the old series, I wrote this about Proxmox:

Second place was Proxmox. I don’t need virtual machines, though, where Proxmox excels in.

That aged well. Two things happened.

First, I started building a lot of software with AI coding agents. The agents need a machine that is always on, has all toolchains installed, and is isolated from my family’s photos and documents. That’s a VM.

Second, I needed Windows for software that only runs on Windows. Another VM.

So Proxmox came back into the picture. And since I had to rebuild anyway, I took the chance to fix everything that bugged me about the old setup: containers created by hand, secrets living only on the box, a monitoring stack I never looked at, and client certificates on my parents’ phones.

The old setup worked. But it depended on me remembering how I did things. The new one doesn’t.

Old vs. New at a Glance

#

Home Server Hardware

#

I still believe laptops are the perfect home servers. They are power efficient, and the battery is a built-in uninterruptible power supply. And when I do have to touch the hardware, keyboard, touchpad, and screen are already there. No need to dig out a monitor and a spare keyboard. So the new server is a laptop again: a Lenovo ThinkPad T14s Gen 4.

• AMD Ryzen 7 PRO 7840U (8 cores, 16 threads)
• 32 GB memory
• 1 TB NVMe SSD

The biggest hardware lesson from the old setup was storage. An external USB drive holding the whole media collection worked, but it was never a great solution: it ties the data to one machine and hangs off a cable next to a laptop. My media now lives on an old TerraMaster NAS that I got for cheap on eBay, mounted via SMB. The NAS also stores the weekly VM backups.

Why Proxmox After All

#

Proxmox VE is a free, open-source hypervisor based on Debian. It runs VMs and containers and comes with a web UI, snapshots, and backups built in.

My host runs three VMs:

The codebox deserves its own article. In short: I run T3 Code on it, an open-source UI for coding agents like Claude Code and Codex. Every toolchain is installed and every cache is warm. When I work on a Rust/Tauri desktop app I’m building, a cloud session spends two minutes installing Rust prerequisites before the build even starts. On the codebox, the build starts immediately. I connect from my Mac or my phone, and I don’t pay for a VPS.

What surprised me: Proxmox made the home server itself better, too. A weekly vzdump backup of the whole homeserver VM goes to the NAS. That’s a second, completely independent safety net next to restic. If the SSD dies, I restore the VM image and I’m back.

The host itself is boring in the best sense. It does nothing but run VMs, and at the time of writing, Proxmox has been up for almost 130 days without a reboot.

Architecture

#

This is how the pieces fit together. Everything revolves around one GitHub repository: the homeserver pulls it every hour, and the codebox sends it pull requests.

The Big Changes

#

Each of the following topics gets its own article in this series. Here is the short version.

Everything in Git, Deployed Automatically

#

In the old setup, Ansible configured the operating system, but I created Docker containers by hand. I argued that this was a one-time step and restic would cover it. That was true, but it also meant the real state of my server lived on the server, not in Git.

Now the repository is the single source of truth. The flow looks like this:

1. Ansible pull runs every hour on the homeserver VM and applies the playbook from the repository.
2. SOPS decrypts the secrets for each stack. They are stored encrypted in Git. The age key to decrypt them sits on the server, in my password manager, and on paper in a safe.
3. Komodo deploys only the stacks whose files changed since the last successful run. No webhooks, no self-hosted runner, no inbound ports.

Every stack has a small manifest, meta.yml, that tells Ansible which directories to create with which owner, what to back up, and what to show on my start page:

# stacks/immich/meta.yml (shortened)
stack: immich
description: Immich photos and videos, OIDC via Authelia
paths:
  - { path: /srv/immich/photos/library, owner: 1000, group: 1000, mode: "0750" }
  - { path: /srv/immich/pgdata, owner: 999, group: 999, mode: "0700" }  # Postgres runs as 999
  - { path: /srv/immich/model-cache, owner: 1000, group: 1000, mode: "0750" }
secrets:
  uid: 1000  # decrypted secrets are owned by the container user
  gid: 1000
backup:
  exclude:
    - /srv/immich/model-cache  # can be re-downloaded, no need to back it up
  tags: [critical, daily]

Almost nothing runs as root anymore. In the old setup, most containers ran as UID 0. Now every stack has its own user, and the manifest makes sure the permissions match.

AI Runs the Show

#

I was already doing a lot with AI agents, but my home server was the exception. Every change there was still manual work. I didn’t want that anymore, so I set up the new server in a way that lets the agents do the work.

Every commit in the repository was written by an AI agent or by Dependabot.

That doesn’t mean I don’t know what’s going on. It means my job changed. I decide what I want, review what the agent proposes, and merge. Small changes, I ask for directly. For bigger ones, I use plan mode together with Matt Pocock’s grill-me skill. It makes the agent interview me in rounds until every decision is settled, before a single line gets written. Fun fact: this series was planned exactly that way.

GitOps and AI are a perfect match. Because everything goes through Git, every change the agent makes is visible, reviewable, and revertible. And because the server applies whatever is in the repository, the rule is simple: nothing gets changed on the server by hand.

A Public Edge Without Client Certificates

#

In the old series, I exposed Nextcloud and Immich to the internet protected by mTLS client certificates. The idea and the technology are fantastic. The reality: IT support for my parents whenever something doesn’t work. Certificates expire, apps don’t support them, and Android Family Link doesn’t allow installing them at all.

So I replaced mTLS with a hardened public edge:

• Two Caddy instances from one image. The internal one serves everything on the LAN and via WireGuard. The public one only serves services that carry an explicit public label. A service without that label simply can’t be reached from the internet.
• CrowdSec blocks IPs with a bad reputation, and its AppSec component acts as a web application firewall.
• Rate limits on login endpoints and strict security headers.
• Passkeys in Authelia as the default second factor. For my family, logging in is a single tap.

Everything else stays behind WireGuard on my Fritz!Box, like before.

Ransomware-Proof Backups

#

restic still does the heavy lifting, now backing up to Backblaze B2. Two things are new:

• The B2 application key can’t delete anything, and the bucket keeps old versions for 365 days. Even if an attacker gets root on the server, they can’t wipe my backups.
• The Immich database is dumped as plain SQL before each backup. The raw Postgres files are excluded. Plain SQL deduplicates well and restores reliably.

Every successful backup sends a quiet push notification. If it doesn’t arrive, I know something is wrong. Together with the weekly VM backup to the NAS, my target is to restore everything in under two hours.

What Runs on It

#

The last card is my favorite. Because building software got so cheap, I replace off-the-shelf apps with small tools that do exactly what I need. The bookmark service, for example, uses a small local LLM via Ollama to summarize pages and assign tags. I described it in my article about Clawdia. Since then, it has grown notes, too, so I don’t need a separate notes app anymore. And my kids now play a penguin game with three worlds, a shop, and its own music, hosted on our home server.

What I Dropped

#

Lessons Learned

#

Never say never. I was sure I didn’t need VMs. Two years later, I have three. Choosing a hypervisor from the start costs almost nothing and keeps your options open.

Build the monitoring you’ll actually look at. In the old series, I set up a complete monitoring stack with Grafana, VictoriaMetrics, and VictoriaLogs. It was fun to build. I never looked at it. My server is bored most of the time anyway. What I actually need is a real-time view when I’m curious and an alert when something breaks. Komodo’s built-in stats and push alerts cover exactly that.

Good security has to survive real users. mTLS was technically superior. But a security concept that turns me into my parents’ help desk isn’t sustainable. Passkeys are just as strong and much easier to use.

If it’s not in Git, it doesn’t exist. Having the whole server in one repository changed how I think about it. The server is disposable. The repository is what matters.

AI agents need guardrails, not babysitting. An agent that can change anything in a repository that deploys itself is powerful, and it needs clear boundaries. I’ll cover how I set those up in this series.

What’s Next

#

This is the first part of the Home Server 2026 series. These parts follow:

1. My AI-Managed Home Server in 2026 (this article)
2. GitOps for a home server: Ansible pull, SOPS, Komodo, and the self-deploying repository
3. Managing my home server with AI: my daily workflow and the guardrails that keep the agents in check
4. Why I run my coding agents on a Proxmox VM: T3 Code, the codebox, and why it beats cloud sessions for me
5. Securing the public edge: two Caddy instances, CrowdSec, passkeys, and split-horizon DNS
6. Ransomware-proof backups: restic, B2, and disaster recovery in under two hours

Changelog

#

• 2026-09-26: initial version