The Starting Point
The rebuild was based around a second-hand workstation running Proxmox, with 32 GB of RAM and a single network interface.
I wanted to use it for quite a few different things: media services, home automation, workflow automation, a security lab and somewhere to experiment with development projects. Getting all of that working together on one machine meant thinking carefully about how resources were allocated and how the different parts of the environment would interact.
Networking was one of the more interesting design challenges. I wanted the experimental lab isolated from the rest of the network, but I didn't want the household relying on a virtual firewall running on the same Proxmox host. Otherwise, restarting the server could also mean losing the household internet connection.
Rather than trying to build an unnecessarily complicated setup, the aim was to make sensible decisions around the hardware I already had, keeping everyday services reliable while leaving room to experiment.
Planning the Rebuild
One of the challenges was deciding how to fit everything I wanted onto a single machine. I had ideas for media services, home automation, workflow automation, security testing and development environments, but only so much hardware to work with.
That meant thinking about which services needed to run continuously, which could be started only when needed, and how to keep the different environments separated.
Networking was particularly important. I wanted somewhere to experiment with firewalls, routing and potentially vulnerable systems without disrupting everything else at home.
We settled on keeping the household network independent of the virtual lab firewall, with separate environments for experimental systems and supporting services. That way, I could restart Proxmox or break something in the lab without taking the household internet connection down with it.
The initial plan went through several rounds of review, including a fresh assessment after Claude audited the existing Proxmox environment. I wanted the final architecture to reflect the hardware and systems I actually had, rather than building something unnecessarily elaborate just because I could.
The Implementation
Once the architecture was agreed, it was time to turn the plan into something that actually worked.
The rebuild involved reviewing the existing Proxmox environment, allocating resources, setting up virtual machines and containers, installing applications and then configuring the individual services. It wasn't simply a case of installing everything and hoping for the best. Each part needed to work with the rest of the environment.
The result was a setup with different areas serving different purposes. Everyday household services remained separate from the experimental lab, while supporting infrastructure handled things like automation and monitoring. The more experimental systems could be started when needed rather than consuming resources all the time.
I brought together services including Plex for media, Home Assistant for home automation, n8n for workflows and Wazuh for security monitoring. Remote access was another part of the build, using Tailscale and a reverse proxy to make internal services accessible without relying on publicly exposed application ports.
One of the more interesting challenges was making everything work together reliably. Installing individual applications is one thing, but getting networking, storage, permissions, integrations and monitoring to behave properly across several systems is another.
The documentation also records tests of complete workflows, including media processing, remote access and security alerts reaching a phone. I think that's an important distinction: a service showing as running doesn't necessarily mean it's doing what you actually need it to do.
The rebuild made substantial progress, but there were still unfinished areas. At the time of the documented review, these included improving the backup and recovery arrangements, expanding the security lab and building out the development environment.
The Proxmox environment, its separated networks and three key workflows: media, remote access and security monitoring.
Public reference diagram, September 2026. Sensitive details omitted.
Working with AI Agents
One of the things that made this rebuild particularly interesting was experimenting with how much of the work an AI agent could handle.
I'd used AI for troubleshooting, planning and generating scripts before, but this was my first substantial experience giving an agent access to a real infrastructure environment and letting it carry out a series of connected tasks.
ChatGPT helped me work through the initial requirements and architecture. I then took the plan to Claude for another perspective. Rather than simply implementing what we'd designed, Claude reviewed the proposed approach and audited the existing Proxmox environment so the next steps could be based on what was actually there.
Initially, I wanted Claude to work through the browser wherever possible. Partly because I could see what it was doing, but also because I wanted to understand how it interacted with interfaces intended for humans. There were some interesting moments, including watching it work through a rather convoluted arrangement involving Proxmox, browser sessions and VNC consoles.
As the rebuild progressed, Claude also used tools such as SSH to interact with the environment more directly. I found myself spending quite a bit of time following its progress, reading the logs and seeing how it approached problems.
What I started to appreciate was that working with an agent wasn't necessarily about specifying every individual action. It was often more useful to explain the objective, provide the relevant constraints, discuss possible approaches and then review what happened.
I also learnt more about the limitations of these tools, particularly how their working environments, available integrations and context windows affect what they can accomplish. Giving an agent access to a system is only part of the challenge; making sure it understands the intended outcome is just as important.
Problems & Lessons
As you'd expect with a project involving several interconnected systems, not everything went smoothly. Some of the more interesting problems weren't caused by individual applications being broken, but by the way different parts of the environment interacted.
One example involved the media setup. After moving the Docker host to a different IP address, some of the applications were still trying to communicate using its previous address. Searches weren't working properly and downloads were failing, which initially pointed towards problems with the indexers or VPN.
The actual cause was much simpler, but it took a fair amount of troubleshooting to identify. It was a useful reminder that when something changes in one part of a system, the effects aren't always obvious elsewhere.
Another particularly interesting problem came from improving security. We'd moved systems towards SSH key authentication, but that change unintentionally affected the security monitoring. The existing detection rules were looking for failed password attempts, which no longer occurred in the same way.
As a result, the systems were more securely configured, but the monitoring was less effective. Resolving that meant updating how the events were recognised and then testing the complete alerting process, rather than simply checking that the monitoring software was running.
There were lessons from the AI side of the project too. One of the clearest came from asking Claude to document the rebuild.
It produced a substantial amount of technical documentation and published it to GitHub, but the result wasn't quite what I'd had in mind. The information was useful, but the way it was organised and presented didn't match what I actually wanted.
That experience reinforced something I've been learning through these projects: an AI agent can follow your instructions successfully without necessarily delivering what you intended.
It's made me more conscious of explaining the desired outcome, providing context and reviewing the results, rather than assuming that completing a task means the result is automatically right.
What I'd Do Differently
If I were starting the rebuild again, I'd spend more time preparing the project before giving Claude access to anything.
The first thing I'd improve is how I define the goals. I had a reasonable idea of what I wanted to achieve, but there's a difference between knowing what you want and communicating it clearly enough for an AI agent to understand. I'd spend more time establishing the requirements, constraints and what a successful outcome should actually look like.
I'd also put more effort into setting up the Claude Project itself. Rather than jumping straight into planning and implementation, I'd establish the project instructions, provide the relevant documentation and make sure there was a consistent way of working from the beginning.
Another improvement would be introducing some form of persistent project memory, potentially using Obsidian. With a project this involved, there's a lot of information to keep track of: architecture decisions, configuration changes, problems encountered and work still outstanding. Having a structured knowledge base that the agent could access and update between sessions would help maintain continuity instead of repeatedly rebuilding context.
Finally, I'd give more thought to the agent's working environment. Having the right tools, access and workspace available from the outset could make a substantial difference to how effectively it operates. I learnt quite a bit about these requirements as the rebuild progressed, but I'd approach them more deliberately next time.
None of that takes away from what was achieved. If anything, the experience has made me more interested in what AI agents can accomplish when they're given clear objectives, useful context and an environment designed to support them.
Where Things Stand & What's Next
The rebuild has come a long way from the original collection of experiments. Most of the core infrastructure is now in place, with the main services running and the network organised around the different things I want to use it for.
There's still work to do, though. One of the biggest priorities is improving backups and recovery. Having backups stored on the same machine is better than having nothing, but it doesn't offer much protection if the host or its storage fails. I'd like to establish a more resilient backup arrangement and properly test the recovery process.
I also want to continue developing the security lab, build out the development and CI/CD environment, and improve some of the monitoring and automation. There's plenty of scope to experiment without rebuilding everything again.
The documentation needs another look too. Although Claude produced a substantial technical record, I want to improve how it's organised and presented so it's genuinely useful as a reference for future changes.
Overall, I'm pleased with how much was achieved, particularly given the hardware limitations and how much of the implementation was handled through AI-assisted workflows.
The homelab itself will probably never be completely finished. That's partly the point. It's somewhere I can keep learning, experimenting with new technologies and testing ideas without having to worry too much about breaking things.