Venom

Custom tooling...is usually a tad insane...but that's often because it's poorly placed. I have worked in environments where the entire infra doesn't feel like one cohesive piece of software and rather it feels mismatched\disjointed. As someone who enjoys working on new projects, doing random one off contracts when they come up, and just generally having a cohesive environment I really do value having all of my infra in the same layer\application. I have historically not gotten that feeling when working with Ansible or Terraform (even though I do know both and have used both in my professional career).

A large part of the reason we use existing modules and tooling like this is because it makes sense. When you have a fairly common tech stack yes of course you can just grab and deploy whatever with mostly off the shelf modules. And when you use cloud services you are even more inclined to do this because the systems at play are fairly complex so reimplementing the APIs would be tedious at best and poor engineering at worst.

This dynamic changes when the modules don't exist or just are not what you want. For context take a look at the current homelab architecture as of the last rebuild. Almost all of the infra in deployment is already infrastructure as code so realistically what I would gain from Ansible is just a templating system and standard tooling. The first I can reimplement closer to my needs (a templating system isn't an insanely complex engineering task, this website has it's own built in as a DSL) and the second isn't really relevant because it's a very small number of people on the network.

There's also an additional consideration which is the strange world of AI. Yaml by nature is exceptionally verbose compared to more traditional source code and I would argue more likely for an agent to make a mistake because of the number of files needed to be accessed. I also find it harder to implement safeguards\clear restrictions in a playbook or runbook than I do in a general function with a language like go. Here we can simply expose a function and all the underlying complexity is solved.

What it solves

Automatically handles provisioning for the entire network for K8s, NixOS, and CI\CD. Of note all storage volumes, deployments, storage directories on remote server, DNS configs, reverse proxies, docker registries, and CI\CD pipelines. This is all done by just exposing a handful of functions that a user can automatically or manually fill out.

What's exposed

A high level CLI exposes a handful of tasks which are run during development as well as maintenance for various network tasks. This CLI then calls functions for the following (to list the main ones):

Effectively this is just one massive config to anyone or any AI agent reading this which makes it very easy to deploy custom tooling if it is currently supported by the tooling. Because this is the entire stack of the network this is an ok limitation, but if we did require more tooling (as we are doing with helm currently) then we would just add a module to execute. This wrapping of existing tooling is actually a lot of what Athena does under the hood.

Do I recommend this

No, this is at the end of the day a piece of bespoke tooling written to solve one exact setup. While the decision made sense for me for most users on something like a homelab it simply does not. We keep 69 services running at all times on the network deployed across multiple OSes and regularly add new ones so the overhead on this needs to be light. And yes the ability to have an AI agent open a PR and deploy a service directly to K8s with all the respective domains and infra configured is insanely useful, but most people do not have a network that is big enough to justify deploying that.

Website Stats:

Website Build Version: 2026/11/20 11:46:51 AM (+00:00)

Last Website Update: 62193f6

Site Generator: Serpent Page Generator created by Lucia Smith