Self-Improving AI Infrastructure: How Your Homelab Wiki Updates Itself

I spent three days trying to get my homelab wiki to update itself. Every time I added a new agent or changed a deployment, the wiki would show the old version. It was like watching a broken clock that never caught up.

The problem wasn't in the agents or the wiki itself. It was in how they talked to each other. I was using a system that claimed to be self-improving, but it wasn't. It just didn't know when to stop pretending it was learning.

This is for anyone who's tried to build an AI agent that updates its own documentation and failed. You're not alone. You're just one of the people who ran into the gap between what the documentation says and what actually happens in practice.

What I tried first was the standard setup: a cron job that ran a script to fetch logs from the agents and update the wiki. It worked for a while — until I added a new agent that used a different logging format. Then the script would parse the logs wrong and break the wiki. I tried making the script more flexible, but every time I added a new agent, I had to update the script again. That's not self-improving — that's just more work.

I also tried using a generic parser that could handle any log format. That failed even harder. The parser would misinterpret some logs as errors when they were just informational messages. It didn't know the difference. I ended up spending hours debugging why the wiki kept showing random error messages that weren't actually errors.

The actual solution came from looking at how the agents themselves handled their own logging. They used a format that included the agent name, the log level, the timestamp, and the message. It was simple but consistent. I rewrote the cron job to parse that format and only update the wiki when the agent explicitly told it to.

Here's what the cron job looked like after I fixed it:

#!/bin/bash

# Fetch logs from all agents
AGENT_LOGS=$(curl -s http://agent-api/logs)

# Parse logs for wiki updates
while read -r line; do
    if [[ $line == *"wiki-update"* ]]; then
        AGENT_NAME=$(echo $line | awk -F' ' '{print $1}')
        WIKI_SECTION=$(echo $line | awk -F' ' '{print $3}')
        WIKI_CONTENT=$(echo $line | awk -F' ' '{print $4}')
        sed -i "/^$WIKI_SECTION:/c\\$WIKI_SECTION: $WIKI_CONTENT" /wiki/agent-wiki.md
    fi
done <<< "$AGENT_LOGS"

This script fetches logs from the agent API, loops through each line, and looks for lines that include "wiki-update" — which is how the agents signal that they want to update the wiki. It then extracts the agent name, the wiki section, and the content, and updates the corresponding section in the wiki file.

The reason this works is because the agents are in control of what gets written to the wiki. They decide when to update it, what to update, and how. The cron job doesn't have to guess or interpret — it just follows the instructions the agents give it.

This setup is more reliable than anything I've tried before. It's also easier to maintain. When I add a new agent, I don't have to update the script. The agent just needs to send the right signal. That's the kind of self-improving system I was looking for.

There are a few caveats. First, the agents have to be configured to send the right signals. That means adding a small bit of code to each agent that writes a "wiki-update" line whenever it wants to change the wiki. That's not hard, but it's something I had to do manually for each agent.

Second, the cron job runs every 5 minutes. That's fast enough to keep the wiki up to date, but not so fast that it's a performance problem. If I wanted to make it even faster, I could use a webhook instead of a cron job. But for now, the 5-minute interval works well enough.

Third, the wiki file is stored locally. That means if the server goes down, the wiki gets lost. I could fix that by storing the wiki in a version control system like Git, but that's a bit more work. For now, I'm okay with the local file as long as I back it up regularly.

What I'd do differently next time is build this into the agent framework from the start. Instead of adding the wiki update logic to each agent individually, I'd create a standard interface that all agents can use to update the wiki. That way, I don't have to modify each agent separately.

Another thing I'd change is the way the wiki is stored. A local file is simple, but it's not ideal for a system that's supposed to be self-improving. I'd prefer to use something like a database or a version control system that can handle multiple users and track changes over time.

I also wouldn't rely on a single cron job to update the wiki. That's a single point of failure. Instead, I'd use a distributed system that can handle updates from multiple sources at once. That would make the wiki more resilient and more scalable.

If you're trying to build a self-improving AI infrastructure, don't be afraid to fail. I did. And I learned from it. The key is to focus on the parts that actually work and ignore the parts that don't. The agents in my system are getting better at updating the wiki every day. I just need to keep making sure the system around them is as good as it can be.

If you're interested in learning more about how to build self-improving systems, you might want to check out some of the work I've done with agent credential management or how to automate infrastructure with GitOps. Those posts cover some of the same principles — just applied to different parts of the system.

For now, my homelab wiki is updating itself. It's not perfect. It's not even close to being smart. But it's working. And that's more than I can say for most of the systems I've tried to build before.