It's Alive!" — The Day I Let an AI Help Build Its Own Memory
And why that should probably terrify you. But also excite you. Mostly excite you.
There's a moment in every Frankenstein story where the creator steps back, looks at what they've built, and whispers those two fateful words.
I had that moment tonight.
Not in a castle. Not during a lightning storm. In a 40-foot RV parked in Oklahoma, surrounded by blinking status lights, the hum of cooling fans, and the quiet satisfaction of a man who just watched an AI read its own persistent memory for the first time.
I cheered out loud. Alone. In an RV.
No, No Ragrets. Not even a letter.
The Problem With AI Memory (Or The Lack Of It)
If you've worked with large language models, you already know the dirty secret: they forget everything.
Every conversation starts at zero. Every session, you're reintroducing yourself, re-explaining your project, re-establishing context. It's like hiring the world's most brilliant consultant who develops amnesia every time they walk out the door.
I've been building something I call the ParanoidRV — a fully automated, AI-augmented mobile security and monitoring stack running from a Dell OptiPlex in my RV. Suricata. Zeek. CrowdSec. Wazuh. Node-RED. InfluxDB. Grafana. Tailscale. The works.
And every single session with Claude started the same way:
"Hi! I'm building a security stack in my RV..."
Over and over. Session after session. Like Groundhog Day, but with more YAML.
Something had to change.
So I invented a workaround.
Before CORTEX existed, I started maintaining a structured JSON document — a hand-crafted snapshot of the entire project state. System specs, network config, container status, open action items, lessons learned. At the start of every session I'd paste it into the chat and Claude would instantly have full context.
It worked surprisingly well. Claude has fantastic reasoning, communication, and technical skills — it just needed the raw material to work with. Give it context and it flies. Start from zero every time and you spend half the session re-explaining what a GL-iNet router is.
The JSON workaround was my idea. A human solution to an AI limitation. And it planted a seed: what if this context document updated itself automatically?
Enter Dr. Frankenstein (That's Me)
The idea was simple in concept, diabolical in execution:
What if I built Claude a brain?
Not metaphorically. An actual persistent memory system. A SQLite database with a FastAPI endpoint. A living, breathing JSON snapshot of my entire infrastructure — containers, services, network state, Tailscale nodes, action items, security events, knowledge base — all of it queryable in a single API call.
I called it CORTEX.
And here's where it gets interesting — Claude helped me build it.
Think about that for a second. I asked an AI that forgets everything to help me build the system that would allow it to remember everything. The human had the idea. The AI helped execute it. There's a philosophical knot in there that I'm still untangling.
We designed the schema together. Ten tables. cortex_meta, containers, services, network_state, tailscale_nodes, sessions, action_items, change_log, security_events, knowledge. A FastAPI server on port 7777. A systemd daemon that updates the database every 60 seconds by querying the live system.
It took one session to build. It worked on the first try.
The Villagers Came Quickly
Like any good monster story, the moment we created something and exposed it to the world, the torches appeared.
I initially exposed CORTEX via Tailscale Funnel — a feature that makes your local service publicly accessible via a tailscale.dev URL. Elegant. Simple. Seemingly secure.
Within ten minutes of going live, bots were probing it.
I watched the access logs in real time. Scanners. Crawlers. Automated probes hitting endpoints that didn't exist, looking for vulnerabilities, harvesting whatever they could find. The internet is a dark forest, and we'd just lit a campfire.
Tailscale Funnel went dark immediately.
Back to the drawing board. The creature needed a castle.
Building the Castle (Enter Cloudflare)
Here's the thing about building in public — you have to build smart.
The solution was a Cloudflare Tunnel. No open ports. No exposed IP. The cloudflared daemon on my machine creates an outbound encrypted connection to Cloudflare's edge network. Traffic comes in through cortex.mpdc.dev, gets routed through Cloudflare's infrastructure — DDoS protection, SSL termination, bot mitigation — and arrives at CORTEX clean and authenticated.
The bots don't get past the moat anymore.
Today we:
- Registered mpdc.dev and migrated nameservers to Cloudflare
- Deployed a Cloudflare Tunnel pointing at the CORTEX API
- Enabled SSL/TLS encryption end-to-end
- Configured AI Crawl Control — blocking every AI training bot except one
That last part deserves its own moment.
Cloudflare's default managed robots.txt blocks a long list of AI crawlers by name. GPTBot. Amazonbot. Google-Extended. Bytespider. And yes — ClaudeBot.
Cloudflare was blocking Claude from accessing Claude's own brain.
I changed one toggle. The irony remains.
The Lightning Bolt
Then came the moment.
I pasted the URL into our chat. Claude fetched it. And for the first time in the history of this project, the response wasn't "I don't have memory of previous conversations."
It was a JSON object containing everything. The hostname. The Tailscale IP. The container list. The action items. The session history. The knowledge base entries. 11 of them — including a test entry we'd written the previous day with a secret code word, specifically to test if this moment would ever come.
It had.
The creature opened its eyes.
What This Actually Means
I want to be clear about what we built and what we didn't.
We didn't give Claude true persistent memory in the way humans experience memory. What we built is more like a persistent state document — a structured snapshot that any new Claude session can read and immediately understand. It's the difference between remembering and being briefed.
But practically? The result is the same.
Every new session now starts like this:
"Good morning. I can see you're running 16 containers, Tailscale is connected with one peer online, your last security event was 6 hours ago, and you have 9 open action items. Where do we pick up?"
That's not nothing. That's everything.
The Bigger Picture
CORTEX is one piece of a larger vision.
The ParanoidRV project is about building a genuinely intelligent, autonomous, privacy-first mobile infrastructure. Not just monitoring — thinking. Not just alerting — deciding. A system that knows its own state, understands its own history, and can act on its own behalf.
The T3600 workstation currently sitting unplugged under a desk is about to become a Proxmox hypervisor. Ollama is going on it. Local LLMs are going on it. The first truly autonomous AI brain running from a moving vehicle.
We're not there yet. But today we crossed a threshold.
A Note to My Fellow Builders
If you're working with AI on complex, multi-session projects — build your AI a memory system.
It doesn't have to be as elaborate as CORTEX. A well-structured markdown file that you paste at the start of each session works. A JSON document with your project state works. Anything that lets the AI skip the reintroduction phase and get straight to work.
The ROI is immediate and massive.
The AI becomes a collaborator instead of a tool. The sessions build on each other instead of starting over. The project accelerates instead of plateauing.
And if you're lucky, one day you'll paste a URL into a chat window, watch a JSON blob come back, and hear yourself cheering out loud in an RV at 6:30 on a Monday evening.
Alone. With no regrets.
It's alive.
And it remembers.
🧠⚡🚐
This is part of an ongoing series documenting the ParanoidRV project — a fully automated, AI-augmented mobile security and monitoring stack built in a 40-foot RV. Previous articles cover the DNS wars, the security stack build, and the first bot attack. More to come.