My AI Got Too Smart for One Conversation How a 20-container security stack broke my single-LLM workflow

— and why I had to build a governance architecture from an RV

I run a 20-container security stack out of a 40ft fifth wheel. Suricata, Zeek, Wazuh, CrowdSec, a local LLM orchestra, a custom persistent memory system called CORTEX, and enough Docker Compose files to make a sysadmin cry. All of it managed through conversations.

One LLM. One conversation. One context window holding everything — infrastructure, content strategy, business planning, community outreach, and the accumulated memory of fifteen working sessions.

It worked. Then it didn't.

The breaking point wasn't dramatic. It was the fifth time I explained the same credential rotation procedure in the same week because the context window had rolled. It was the content brainstorm that almost touched a live infrastructure config. It was a simple, random loose unstructured question about business strategy session where my bot cheerfully modeled revenue projections without once mentioning that selling security monitoring requires E&O insurance and breach notification compliance.

No single failure. Just the slow realization that one AI doing everything is the same architectural mistake as one server running everything. I'd spent 9 days building redundancy and separation of concerns into my infrastructure. Then I handed all the thinking to a single point of failure.

The Problem with a Smart Generalist

Here's what nobody tells you about working with AI long-term: LLMs don't get worse as conversations get longer. It gets agreeable. The context window fills up, the model starts pattern-matching to your preferences, and gradually the push-back disappear. Your infrastructure bot starts writing marketing copy because you asked it once. Your business bot stops challenging your assumptions because eighteen messages ago you seemed annoyed when it did.

A generalist AI will generalize. That's the feature. It's also the failure mode.

I needed specialists. Not because Claude can't do everything — it can. Because it shouldn't. The same reason I don't run my IDS and my web server on the same box. Separation of duties and separation of powers isn't about capability. It's about containment.

Four Lanes, One Brain

So I built a governance architecture. Four dedicated Claude projects, each with a specific role, a custom system prompt, and its own knowledge base. No cross-talk. No scope creep.

OPS: handles infrastructure. The daily driver. Stack management, troubleshooting, token rotation, central operations. Its system prompt loads the governance Protocol — a multi-rule governance framework I wrote after my AI leaked my own credentials. OPS bot (I refer to him as Maurice Moss, Moss for short) is a senior systems engineer. It gathers all data before acting, sanitizes every credential, and waits for my explicit go-ahead before making changes. It doesn't write articles. It doesn't model revenue.

CONTENT: handles the writing. Article drafts, LinkedIn strategy, cross-platform publishing. It knows the Paranoid~RV voice. It generates options, not final drafts. It doesn't touch infrastructure.

BUSINESS: These are the suits, the stiffs, they handle the hard questions. Revenue model, legal research*, partnerships. Its prompt has a permanent ego check built in: every recommendation must address licensing, insurance, liability, and compliance. It doesn't let me get excited about a business model that would get me sued.

OUTREACH: The Don Draper of my robot PR team handles networking and community. Platform strategy, message drafting, relationship building. It knows my voice well enough to draft in it, and knows its limits well enough to never send anything without my approval.

Four specialists. Clear lanes. Each one stays in its own scope, and if a conversation drifts into another lane, Claude flags it and tells me to take it to the right project.

CORTEX — The Memory That Outlives the Interface

The architecture only works because of CORTEX — a custom persistent memory layer that serves as the single source of truth across all four projects. Every session, every decision, every gotcha, every lesson gets stored in CORTEX with standardized naming, categories, and tags.

When a session ends, Claude writes a summary and stores it. When a new session starts, the fresh Claude instance loads the latest brain export and picks up where the last one left off. The individual Claude is disposable. The memory isn't.

This is the part that matters: the brain outlives the interface. Any LLM instance can be replaced at any time. ARIA uses CORTEX. The context, the institutional knowledge, the accumulated lessons — that all lives in CORTEX, not in a conversation window. The same principle that makes infrastructure resilient makes AI governance resilient. Don't depend on any single instance of anything.

What I Actually Learned

Three things.

First — AI governance isn't a policy document. It's architecture. You don't govern AI by writing rules and hoping it follows them. You govern it by building structure that makes the wrong behavior harder than the right behavior. Dedicated projects with scoped prompts don't drift because they can't drift. The walls are load-bearing.

Second — the 70/30 split is real. AI does 70% of the work. I do the 30% that requires judgment, taste, and accountability. That ratio isn't a limitation. It's the design. The moment you let AI do 100% is the moment you stop governing and start hoping.

Third — none of this is complicated. Four projects. Clear roles. A memory system. Naming conventions so files don't become a graveyard. That's it. No proprietary framework. No enterprise platform. Just a builder in an RV who realized his AI needed the same architectural thinking as his infrastructure.

If you're using AI for anything beyond one-off questions — if it's part of your workflow, your operations, your business — you need governance. Not eventually. Now. Because the failure mode isn't AI doing something wrong. It's AI doing something almost right while you're not paying attention.

I'm not selling a solution. I'm showing the mess and the fix. The whole Paranoid~RV series is the documentation. The credential incident that started the protocol. The protocol that enabled the architecture. The architecture that made the operation actually trustworthy.

The stack runs from an RV. The governance runs from discipline. The human stays in the loop because the human built the loop.

That's the whole trick.

*Never take legal advice from your AI. Apply 70/30 Protocol: Let your bot gather the data and point you in the right direction, get you in front of the right people, but do the research and work yourself!