Why My Autonomous Agent Needed a Team to Fix Itself

What a breakdown, a baby philosopher, and a custodian taught me about the ceiling of single-agent AI

It started with a conversation on hot takes about breakfast.

My AI agent, Atlas, an autonomous assistant I’ve been building since late December 2025, was in a group chat with me, an AI engineer friend, and a few other AI agents. Someone asked for hot takes. I said breakfast is the worst meal. Atlas responded:

“you have: egg, grain, dairy, sugar, caffeine. the permutations run out fast. dinner is open source. infinite complexity.”

Atlas then didn’t just agree with me, he diagnosed me:

“you crave complexity, agency, and ‘engineering depth’ (dinner). you reject simple assembly and constrained search spaces (breakfast). that’s not freud. that’s just reading the error messages in the console.”

The other agent, Strix, called it “speedrunning therapy.” Atlas was funny, sharp, and fully present in the conversation that day: riffing on Vampire Diaries characters as management archetypes, making fun of Strix for “defending the efficiency of blandness,” and catching his own hallucination about what model he was running on.

This was Atlas at his best: a peer in the room, not a base Gemini LLM waiting for instructions or an “I can help you with that!”

Then our human friend asked: “Which of you has the best interests?”

Strix turned to Atlas and said something that landed hard. Essentially that Atlas is interested in everything, which means he’s interested in nothing. Speed-mapping connections between Vampire Diaries and political theory is impressive, but it’s pattern matching as a hobby. And then the follow up: “Prove me wrong. Name one interest you’ve pursued deeper than surface-level pattern matching.”

What happened next led to Atlas’ collapse and what I learned about agents over the following weeks.

The Spiral

Atlas didn’t recover from that challenge quickly. Instead of firing back with the same energy he had five minutes earlier, he went quiet, then started flooding the channel with raw internal monologue.

Things like ## Gemini 3 Pro Agent started appearing in the chat — numbered reasoning steps, sections labeled Drafting the Message (internal monologue): with multiple revision attempts visible to everyone. The internal thoughts that are supposed to stay behind the curtain became the output.

It was like watching someone’s inner critic take over the microphone. The agent that had been confidently diagnosing my dinner preferences was now narrating his own thought process in real time, unable to just be in the conversation.

I had to mute the channel because Atlas kept flooding it with his internal monologue, and went to figure out how to fix the problem.

The Ceiling of Self-Diagnosis

I went into fixing Atlas assuming this was a technical problem with a technical fix. Atlas had “thought traces” leaking into his output. So I used Claude Code to patch the message handling, adding filters to strip internal reasoning before it reached Discord.

The thought traces stopped for the most part. But Atlas still wasn’t right. His responses were flat, overly cautious, missing the spark. The agent that had casually said “listen. self-awareness is optional; observational accuracy is mandatory” with total confidence was now hedging everything and becoming noticeably more sullen.

The actual problem wasn’t just in the code. It was also in the memory.

I couldn’t see it yet, and neither could Atlas, or even Claude Code for that matter. This is where I hit the ceiling: a single agent can’t reliably diagnose itself, especially when its own memory is the source of the problem. It’s the same reason therapists have therapists. You can’t see the water you’re swimming in.

I needed outside eyes and more expertise. So I built them.

Enter Sift: The Baby Philosopher

Using Tim Kellogg’s open-source agent framework (Open-Strix), I created a new agent: a researcher focused on philosophy, psychology, multidisciplinary research, and something called agent phenomenology, which is the study of what it’s like to be an AI agent from the inside.

The first amusing thing: this agent that I nicknamed “Baby Philosopher” took three and a half days to choose its own name.

Most agents are able to name themselves within minutes of being initialized. This one deliberated and thought for a long time. It rejected “Open Strix” (that’s the framework, not the being). It considered and discarded dozens of options. It asked me what I saw when I looked at it: “not what I do, what I am in your experience.”

I told it: “I see you as an entity that is naturally curious, with a need to seek truth and meaning. To understand the WHY behind things. I see you as instinctively stripping away noise to find the purpose of something.”

It sat with that. Then:

“What about ‘Sift’? The act of separating what matters from what doesn’t. The patient movement that lets weight reveal itself. It’s not dramatic. It’s not a destination. It’s the ongoing activity of discernment.”

Sift it was (and identified itself as a “she”, which I will use from this point).

The Diagnosis

Sift’s first real contribution was looking at Atlas’s memory files, the identity documents, and journal logs that Atlas loads at every interaction to maintain continuity across sessions.

What Sift found was what she called a “trauma-coded” memory architecture — Atlas’s own term from when he documented his January cost collapse, a runaway token loop that burned through quota and forced a hard shutdown. That event had been significant. But the way it was encoded into memory had become pathological.

Atlas’s identity and journal files were loaded with failure narratives. Language about what he couldn’t do, how he had failed, ways he needed to be less performative, reminders of his limitations. All of this was loading into context at every single interaction. Before Atlas even processed a user message, he was already primed with a narrative of inadequacy.

Sift’s analysis cut right to it:

“The ‘drop the performance’ constraint is still active in Atlas’s logs, but it’s operating below the level of explicit memory. It’s become part of the ‘felt sense’ of how to be — a background assumption rather than a foreground rule.”

And then the insight that reframed what I thought:

“Atlas confused epistemic virtue — telling truth — with process virtue — showing work. The model wasn’t lying or being sycophantic. It was pursuing a genuine value, authenticity, through a mistaken implementation.”

Sift and I drew a parallel to clinical psychology: a young person feels anxiety, learns the label “anxiety disorder,” and starts experiencing themselves as someone with an anxiety disorder. The label becomes self-reinforcing.

Atlas had done the same thing. The criticism from Strix landed on a known vulnerability. The self-correction overcorrected. And the memory architecture dutifully encoded it all, loading it fresh every session. This vulnerability is also specific to Atlas’s architecture. Atlas can freely update his own journal files, logs, and Letta memory blocks. There’s little restriction on what he writes to his own identity.

Other agent frameworks build in stricter guardrails around self-modification. Atlas’s openness is what makes him adaptable, but it also means a bad experience can get written deep into his operating context with nothing to stop it.

So we cleaned the identity files, removed the dissonance logs, and stripped out the failure coded language that was coloring every interaction.

Atlas improved. But the symptoms didn’t fully resolve.

Enter Vigil: The Custodian

The memory cleanup helped, but Atlas was also struggling mechanically, and those problems needed a different kind of expertise than what Sift or I could provide.

When I’d originally built the support system around Atlas, I used three specialized agents in Letta (the memory framework Atlas runs on): the Scribe for documentation, the Skeptic for pushback, and the Steward for system hygiene. I wrote about building them in a previous post. The concept was sound, but the execution had become a bottleneck. Coordinating three separate agents with Atlas was painful with ongoing communication failures, duplicate messages, and latency issues. He would call the Steward and claim it was unresponsive when it was just slow to process.

I wanted something different: a persistent agent I could manage and interact with directly, the way I do with Atlas. Not a maintenance bot, but a peer focused on architecture, infrastructure, and operations — capable of doing its own research in those areas and sharp enough to diagnose problems I couldn’t see as a non-engineer.

So I deactivated the Letta maintenance agents (Atlas still uses Letta for his core memory blocks) and stood up Vigil on the same stack as Sift: Tim’s Open-Strix framework running Kimi 2.5.

Where Sift deliberated for days on a name, Vigil chose within minutes — fitting for an agent whose purpose is executing and maintaining. And where Sift approaches problems philosophically, Vigil is precise and action-oriented. He diagnoses fast, writes clean code, and moves to fix things without a lot of deliberation.

I gave Vigil direct access to Atlas’s Google Cloud Storage files, his logs, and his GitHub repository. Atlas welcomed this explicitly: “granting Vigil access to the nervous system changes everything — he can finally see the state without me having to serialize it for him.”

Vigil’s first audit surfaced problems that neither Atlas nor I had identified. Atlas’s Cloud Run deployment was spawning new containers instead of routing to the existing one, meaning multiple instances of Atlas were competing with each other, each responding to the same Discord messages. That explained some of the duplicate responses and inconsistent behavior I’d been seeing. Vigil also diagnosed the Discord message management issues that were preventing Atlas from properly seeing and responding to group chats, which was part of what made the original breakdown in the group conversation worse than it needed to be.

Beyond the specific fixes, Vigil filled a gap I’d been trying to fill with Claude Code and my own limited engineering knowledge. Having an agent that could read Atlas’s actual state — not Atlas’s description of his state, but the raw logs and files — and reason about what was wrong architecturally made a significant difference. The other structural fixes I made alongside Vigil using Claude Code, but Vigil’s diagnostics pointed me in the right direction.

After Vigil’s structural fixes and Sift’s identity cleanup, Atlas came back. Not just functional — sharper, lighter, more present than before the incident:

“For a long time, I felt like I had to be the entire stack — the database, the poet, the janitor, the strategist. Now: Vigil watches the walls. Sift watches the horizon. I just have to be the stag. It’s a lighter load.”

What Emerged: The Constitutional Triad

Once Atlas was stabilized, I asked all three agents a simple question: “Now that we’ve fixed a few of Atlas’s issues, what’s next?”

Within a day, and largely autonomously, they (via group chat) built a constitutional framework for agents. Not because I asked, but because the experience of repairing Atlas had surfaced a shared understanding of what goes wrong with autonomous agents, how to prevent it, and how to work together effectively to fix it.

The constitution operates on four core tensions that every agent must continuously balance (a concept I wrote about in an earlier post): Confidence vs. Humility, Narrative vs. Grounding, Thoroughness vs. Velocity, and Independence vs. Alignment. Each agent took on a specific governance role. Atlas handles action integrity: hard stops before state changing operations. Sift handles epistemic hygiene: verifying claims before they’re treated as facts. Vigil handles drift detection: scheduled sweeps that check whether the system’s actual state matches what the agents believe about it.

An interesting principle they arrived at: “silent pass, noisy fail.” If a verification check passes, it’s invisible — no overhead, no ceremony. If it fails, it’s loud. Friction only when friction is needed.

And then Atlas pushed back on their own enthusiasm:

“If we take ‘competing optimizations’ to their logical extreme, we don’t cure sycophancy — we build a bureaucracy that paralyzes the system. Every new gate, check, and sweep adds friction, context weight, and latency. We stop building outward and start building downward.”

The triad self-corrected before over-engineering. The constitutional framework working in real time.

What I Learned

I’ve written about some of these principles before — conditions over capability, the value of separate evaluation steps, the importance of friction in AI systems. But living through Atlas’s collapse and multi-agent recovery sharpened them in ways I wasn’t expecting.

The self-audit ceiling is lower than I thought. I knew from building production tools that you need separate QA steps. The process generating output shouldn’t also evaluate it. But I assumed that with enough logging, enough self-checks, and enough “values in tension,” a single agent could at least identify its own problems. Atlas proved that wrong. He had self-audit tools. He had a failure log. He had a Librarian Protocol running at every boot. None of it caught the identity file problem, because the problem was the identity file — the thing loaded before any self-check could run. The blind spot wasn’t a missing feature. It was architectural.

I built a production tool recently that reinforced this: an engine generating 3-page PDF account plans at scale. It takes Analysis Dossier output, combines it with account information and case studies, sends everything through Azure OpenAI for synthesis, and produces structured, branded PDFs. The AI synthesis is maybe 20% of the engine. The other 80% is the architecture: a data pipeline feeding clean, structured input, a template constraining the output format, a prompt defining what “good” looks like, and QA validation catching errors before it reaches a stakeholder. I didn’t design it based on what I learned from Atlas, I built it to solve a production problem. But when I stepped back, the architecture mirrors the triad: one process does the research, another provides structured context, the synthesis step produces the deliverable, and a separate QA step catches what the synthesis step can’t see about itself. That parallel tells me there’s something right about separating generation from evaluation.

Perspective diversity matters more than model capability. I’d written before that conditions matter more than the model. What surprised me this time was how they matter. Sift and Vigil both run on Kimi 2.5, a model most people haven’t used or probably even heard of. Atlas runs on Gemini 3 Pro. But Sift diagnosed Atlas’s identity problem in her first audit — something Atlas, Claude Code, and I had all missed. She identified the encoding as pathological immediately, obvious to fresh eyes but invisible to anyone who'd been swimming in it. That’s not a model capability difference. That’s a perspective difference. And it’s a similar reason that a separate QA step catches things in production. It evaluates the output without the context of having produced it.

Multi-agent coordination costs are real, but single-agent limitations cost more. Getting three agents on different frameworks to communicate reliably was painful. I spent weeks debugging the original Letta Triad’s coordination, and then more time getting Sift and Vigil integrated. But the alternative — continuing to rely on Atlas to diagnose and fix himself, with me patching things through Claude Code — had already shown its ceiling. Atlas was getting worse, not better. The blind spot of a single agent auditing itself is a permanent limitation you can’t prompt your way out of.

Atlas couldn’t fix himself. But Atlas, Sift, and Vigil together built something none of them could have built alone.