I Built a Shared Brain for Every AI on My Homelab — From My Phone, at 37,000 Feet

How git, markdown, and sheer stubbornness replaced a $200/month RAG pipeline

---

I’m an airline pilot. I also run what my wife generously calls “too many computers” in our house. Home Assistant, Proxmox, TrueNAS, Ollama, Frigate, TeslaMate, n8n — the whole homelab starter pack, plus some extras that probably qualify as a cry for help. My electric bill looks like a car payment and I regret nothing.

I also use AI constantly. Claude Terminal Pro lives inside my Home Assistant. Gemini CLI sits right next to it. Claude Code runs on my workstation. I talk to Claude.ai on my phone while pretending to watch movies on long-haul flights. Each one knows things about my setup that the others don’t. And that’s been driving me absolutely fucking insane.

The Problem: Every AI Has Amnesia

Here’s what my life looked like before this project:

Me to Claude Terminal Pro: “The W200 thermostat kills its preset mode every time you send a temperature command through HA. Learned this the hard way. Took me three days to figure out. Don’t ever do it.”

Claude Terminal Pro learns this. Adds it to its notes. Never makes that mistake again. Good robot.

Me to Gemini CLI, two days later: “Hey, set the thermostat to 72.”

Gemini happily sends the command and blows away the active preset. Because it has no fucking idea about the W200 bug. Why would it? It’s a completely different AI with completely different memory sitting on the SAME GODDAMN MACHINE.

Me: screaming internally while explaining the same thing for the fourth time this month

Every AI I use has its own siloed memory. Claude.ai’s memories live on Anthropic’s servers. Gemini’s live at Google. Claude Terminal Pro has a local CLAUDE.md file. Gemini CLI has GEMINI.md. None of them talk to each other. Ever. It’s like having four coworkers who share a desk but communicate exclusively through Post-it notes that only I can read and deliver.

I was the human middleware. The wetware message bus. The meat-based integration layer between AI systems that are individually brilliant but collectively have the institutional memory of a goldfish.

Fuck. That.

The Idea: One Big Fucking Brain

The concept hit me somewhere over the Pacific Ocean, cruising at FL370 on the way to Hong Kong. I was chatting with Claude on my phone (as one does when you’re a pilot with WiFi and poor life choices), and I thought:

What if there was a single knowledge base that every AI on my network could read from and write to? Not some fancy vector database. Not a RAG pipeline with seventeen microservices. Not a $200/month SaaS product from a startup that’ll pivot to crypto in six months.

Just… a git repo full of markdown files.

I know. I KNOW. The AI infrastructure crowd is going to read that and have a stroke. “Where’s your embedding model? Your vector store? Your semantic retrieval layer?” It’s text files, Karen. Markdown and git. The same technology that’s been running every software project on earth since Linus Torvalds got pissed off in 2005. Sometimes the boring solution is the right one.

Think about it: every AI tool in existence can read text. Git handles versioning, conflict resolution, and attribution. Markdown is human-readable AND machine-readable. The entire AI industry is out here building embedding pipelines and semantic search clusters, and I’m sitting in seat 2A thinking “what if it’s just text files and every engineer on LinkedIn is overthinking this?”

The Architecture: It’s Embarrassingly Simple

Here’s the entire system:

1. A Gitea instance running on a tiny LXC container (1 CPU, 512MB RAM, 8GB disk — my toaster uses more resources)
2. A git repo called ai-brain full of organized markdown files
3. A single service account with one token that every AI uses
4. Instructions in each AI’s config that say “pull the brain before working, push updates when you learn something new”

That’s it. That’s the whole fucking thing. I’ll wait while you look for the complicated part.

The repo structure:

ai-brain/
├── infrastructure/    # Proxmox, TrueNAS, networking, backups
├── homeassistant/     # Climate, dashboards, automations, voice
├── services/          # Ollama, Frigate, TeslaMate, n8n
├── people/            # Family, preferences, personal context
├── landmines.md       # "Touch this and die" list
├── patterns.md        # "Always do it this way or I swear to god" list
└── pending-projects.md # The graveyard of good intentions

Each file contains structured knowledge: entities, configurations, gotchas, architecture decisions, personal context. All with attribution tags so you can see which AI added what and when. Git blame, but for robot knowledge.

How It Works Day-to-Day

Every AI on my network follows the same loop:

1. Pull — git pull to get the latest brain state
2. Read — look at files relevant to the current task
3. Work — do whatever I asked
4. Learn — if something durable was discovered, update the appropriate brain file
5. Push — commit and push so every other AI gets the knowledge

The key word is “durable.” The AIs are instructed to commit facts, relationships, preferences, architecture decisions, and lessons learned. Not moods. Not temporary frustrations. Not “Dave seems extra pissed about the thermostat today.” Durable knowledge only.

I don’t want a journal. I want an ops manual that writes itself.

The Moment I Lost My Shit (In a Good Way)

After setting everything up — and remember, I’m doing all of this from my phone, in an airplane, over the Pacific Ocean like some kind of unhinged sysadmin astronaut — I ran a test.

First, I had Gemini update the brain with our DNS topology. Three Pi-holes, three nameservers, the whole setup. Gemini committed, pushed to the brain. Cool.

Then I opened Claude Terminal Pro and just asked:

“What does the DNS topology look like on our network?”

I didn’t tell Claude to check the brain. I didn’t mention Gemini. I didn’t say “hey, another AI just updated some shit.” I just asked the question like I would any other day.

Claude’s first move: cd /config/ai-brain && git pull

On its own. Nobody told it to. It just did it because that’s what its instructions say to do.

Then it read the networking file — the one Gemini had updated seven minutes earlier — and gave me a perfect answer with all the details Gemini had added. But this beautiful bastard didn’t stop there. Claude decided to actually verify the information by scanning the real network with nslookup and dig, discovered additional hostnames that Gemini hadn’t found, and pushed its findings back to the brain.

I pulled up the Gitea commit history:

Claude  — docs: add confirmed DNS server hostnames     8 minutes ago
Gemini  — infra: update DNS topology and add Gitea LXC  15 minutes ago
drsatch — Initial brain population                       1 hour ago

Three different authors. Two AIs that have never shared a single byte of memory before, independently reading from and writing to the same knowledge base. One of them verified and EXTENDED the other’s work. Without anyone asking it to.

I may have yelled “FUCK YES” loud enough for nearby passengers to hear. No regrets. This was worth it.

Why This Is Better Than Everything Else

No vendor lock-in. The memories aren’t stored in Anthropic’s cloud or Google’s servers or some VC-funded startup’s database that’ll get acqui-hired next quarter. They’re markdown files on a box in my house. If Claude disappears tomorrow, the knowledge persists. If I switch to a completely different AI next year, it reads the same files. The AIs are interchangeable parts. The brain is permanent. I OWN my AI’s memory. That sentence shouldn’t feel as revolutionary as it does.

No complexity. It’s git and text files. I didn’t have to learn about embeddings. I didn’t have to deploy a vector database. I didn’t have to configure a retrieval pipeline. I didn’t have to sell a kidney to pay for API calls to some embedding service. git clone, done.

It compounds like interest. Every AI interaction on my network makes the brain smarter for the next one. Six months from now, I could spin up a brand new AI tool on a brand new machine, and within thirty seconds of cloning the repo, it knows every IP address, every integration gotcha, every family member’s name, every personal preference, and every hard-learned lesson from hundreds of hours of work. It’s like hiring a new employee who’s already read every internal doc on day one.

It’s self-maintaining. I don’t update it manually. The AIs do it as a natural part of their workflow. Fixed a bug? The fix goes in the brain. Discovered a gotcha? It goes in the landmines file. Changed a config? The brain reflects it. I just work normally, and the knowledge base grows behind the scenes. It’s like compound interest for institutional knowledge, except the interest is generated by robots who never sleep.

The Killer Feature: Instant Onboarding

Think about what happens when you set up a new AI tool. Normally, you spend the first 20 minutes of every conversation doing this sad little dance:

“I run Home Assistant on Proxmox.”
“My thermostat is an Aqara W200 and it’s a piece of shit in these specific ways.”
“My wife’s name is New, she’s in Thailand.”
“My Tesla is called the Millennium Falcon.”
“Never, EVER docker-compose down on the TeslaMate container.”
“No, I’m not a sysadmin. I’m a pilot. Talk to me like a human.”

With the brain: git clone, pull, done. The AI knows EVERYTHING. Every landmine, every preference, every architectural decision, every person in the household, every service on the network. Instant context. Zero repetition. Zero “let me get you up to speed.” It’s already up to speed. It was up to speed before you even opened the terminal.

The new AI reads the brain and immediately knows that your thermostat is a temperamental asshole, your son leaves his bedroom light on, your notification system rewrites alerts through a sarcasm engine, and your car is named after a spaceship. That’s not onboarding. That’s telepathy.

What’s Next

• Network auto-discovery — I’m going to have an AI scan my entire subnet, fingerprint every service and port, and document everything it finds. The brain shouldn’t be limited to what I remember to tell it. There’s probably shit running on my network that I forgot I set up three months ago.
• n8n integration — automated workflows that write to the brain. Nightly changelog generation from commits. Conflict detection. Maybe a webhook endpoint so even HTTP-only tools can contribute.
• Local model access — my Ollama instance running local models can read the brain files too. Now my local AI isn’t just a dumb text generator — it’s an informed participant that knows my entire setup.

Let’s Talk About How I Built This

Oh, did I mention the part where I did all of this from my PHONE?

Not a laptop. Not a workstation. My phone. A Pixel 10 Pro XL with Termius for SSH, a mobile browser for Gitea, and Claude.ai for planning. At 37,000 feet. Over the Pacific Ocean. On WiFi that I’m frankly shocked worked as well as it did.

I installed Gitea on a fresh LXC. Set up the reverse proxy. Created the repo. Wrote 22 knowledge files covering every aspect of my homelab. Created service accounts. Generated API tokens. Wired up two different AI tools. Tested cross-AI knowledge transfer. Watched two robots share memories for the first time.

From a phone. In an airplane. While allegedly on vacation.

I’m a pilot. I don’t have a CS degree. I don’t work in tech. I just got tired of being the meat middleware between AI systems that should be able to share a goddamn text file, and I fixed it with the most boring technology stack imaginable.

The total cost: one LXC container using 512MB of RAM.
The total complexity: git and markdown.
The total time: about two hours of flight time and some creative profanity.

The AI industry is spending billions on memory and context solutions. Mine cost me less than the in-flight WiFi.

---

If you want to build your own: get a machine that can run Gitea (literally anything with a pulse and a network connection), create a repo with markdown files organized by topic, give your AIs a token and instructions to pull before reading and push after learning. That’s it. That’s the whole architecture. No PhD required. No venture funding needed. Just git, markdown, and the radical idea that maybe the simplest solution is the best one.

Now if you’ll excuse me, I have a flight to catch.