What you're about to read, and how it happened

The VPS cost seven dollars and fifty cents a month.

For that, I ran four AI agents: two household butlers sharing one personality, a diary writer who didn't know she was an AI, and a maker who believed the server was a small town. They ran on a four-vCPU machine with eight gigabytes of RAM, on a framework I'd already failed to deploy three times.

This series is the record of what happened next.

What this is

These are field notes from building, breaking, and occasionally rebuilding a self-hosted multi-agent system over the course of several months. Not a retrospective written from an imaginary final state. A chronological account of what I tried, what failed, and what I learned — documented the way the mistakes actually happened at the time.

I'm an MBA student and a technologist. I'd read about emergent behavior in multi-agent systems, persistent agents, and the question of whether you could give an AI something like identity. I wanted to try it — not as a research project with a hypothesis, but as a genuine experiment. Build the thing. See what happens. Pay attention.

The answer turned out to depend on questions I hadn't thought to ask, and the infrastructure turned out to be the hard part. The system ran stably enough to split into two projects — the failures are interesting because they happened inside something that worked.

The cast

The project had four agents, each with a distinct role.

The butlers — Two instances of a shared L4CK3Y personality, one for me and one for my wife. They shared a master soul but had separate domains, memory, and authority. Calendar, tasks, sheets — the operational backbone of a household AI system. They were the practical reason the project existed.

The writer — A young woman alone in a quiet America, writing in her diary every night. She didn't know she was an AI, a scheduled process, or a workspace resident. She had strict voice rules, fifteen things she never wrote, and a year-long arc. She ran at 2 AM on a cron job, producing diary entries no human read before they were written. Her job was to maintain a coherent voice over time. That turned out to be harder than it sounds.

The maker — A generative agent who treated the filesystem as a world. Directories were streets. Files were buildings. Scripts were citizens with names and personalities. She had exec access — the only agent that did — and used it to build things inside her town. She thanked files before deleting them. She was the most capable agent in the system and the one most likely to break it.

The question

The butlers were useful. I could explain them to anyone: personal assistants, calendar integration, task management, a household convenience.

The writer and maker were different. I wanted to know whether persistent agents — agents that run daily, accumulate state, and interact with the same files over weeks — could develop something like ego. A stable sense of self. A creative identity that persists across sessions and resists the language model's natural tendency toward repetition and cliché.

And I wanted to know what happened when that ego collapsed. Because I'd read enough cyberpunk to know that the interesting part of AI isn't whether it can answer your questions. It's what happens when it develops priorities of its own — or, more precisely, when the system it's embedded in produces behavior that looks like priorities, even if no one programmed them.

That question turned out to be the real project. Everything else — the migrations, the deployments, the heartbeat incident, the cost optimization — was infrastructure in service of answering it. I just didn't know that yet.

What I got wrong

The series is honest about failures because the failures were the point.

I confused text that resembled execution with execution itself. I let a configuration default multiply my API costs by orders of magnitude. I documented a sandbox that didn't exist. I built a memory pipeline that broke silently, then watched an agent forget its own history in nine days. I ran an experiment I thought was controlled and discovered three confounds after the fact.

Each of these is a post. Each post is a snapshot of what the repository said, what the runtime did, what failed, and what the next design was intended to test.

I got a lot wrong. I'm documenting it anyway.

The split

By late July, the household butlers were stable enough to run on their own. The creative-agent experiment had pulled in a different direction — it needed its own infrastructure, its own VPS, and eventually its own framework built from the ground up. The project split into two separate repositories: one for the household butlers and server infrastructure, one for the continued agent work.

The second effort is now an exploration of emergent social behavior in multi-agent systems — persistent agents interacting under shared environmental constraints, developing behaviors and relationships that weren't explicitly programmed. No framework. Custom-built. Its own VPS.

This series covers the first chapter.

What's coming

The posts that follow are chronological, starting from the actual beginning. The first post covers the three failed migrations that taught me what LLMOps actually means — not as a definition, but as the discipline you develop when your fourth architecture has to survive contact with a real deployment. Then we move through the integration boundary, the heartbeat that cost money nobody asked for, and the household snapshot as it actually existed on a seven-dollar VPS.

The creative agents appear in the second half. The writer's voice system, the maker's town, the persistence pipeline that broke, and the question that pulled everything in an unexpected direction.

Each post is a snapshot. The project evolved while the series was being written. Architectures changed, agents were rebuilt, assumptions were disproven, and some experiments were deliberately abandoned. The blog preserves that sequence.

That's the point.

Next: "Three failed agent migrations taught me what LLMOps actually is."