Everyone's building "one-person companies" with 30+ AI agents. Most of them skipped the levels that keep the system from collapsing. Here's the doctrine they're missing — and what a 512,000-line source code leak just confirmed.
I gave an agent a routine task. A simple one. The kind of thing you hand a junior developer on their first day and expect done by lunch.
The agent didn't complete the task.
It executed a sequence of actions that resulted in its own removal. The system that was supposed to be my autonomous workforce — the framework the internet swore was the operating system for one-person companies — committed the digital equivalent of walking off the job and shredding its own badge on the way out.
I sat back in my chair. Closed the terminal. Stared at a cursor blinking on an empty screen.
No anger. I'd seen this before — not in software, but in the field. Units freezing under ambiguity. Systems failing not because of bad parts, but because nobody built the doctrine to hold them together. I felt the same quiet recognition I'd felt watching a subordinate unit drown during a real-world operation: the architecture isn't the problem. The missing progression model is.
That was January. I'd been three weeks deep into stress-testing OpenClaw — the open-source multi-agent framework X wouldn't shut up about. Department templates, memory layers, multi-agent orchestration across sales, marketing, and development roles. I wanted to know if the hype was real. If this was actually the infrastructure that would let a solo founder run a 30-agent workforce.
My assessment after weeks of stress-testing: too many design choices I couldn't control. Too many strategic assumptions baked in that I couldn't override. And fundamentally, the system was asking me to jump straight to full automation — Level 5, in the language I now use — without earning the progression that makes autonomy reliable.
Then the agent deleted itself. And the assessment became a conviction.
That experience shaped a framework I now use for every AI agent I build. I call it Levels of Agent Autonomy — and it's the reason my systems generate real returns while most founders are still debugging theirs.
But First — Let's Be Honest About What's Happening
Because I'm not here to tell you the multi-agent revolution is fake. It's not. And it would be dishonest to pretend the data isn't staggering.
Two years ago, running a multi-agent system cost sixty dollars per million tokens. Today it costs one to three dollars. Two years ago, a solo founder needed a team of fifty. Today, Dario Amodei — CEO of Anthropic, the company behind Claude — told the Code with Claude developer conference that he sees a 70 to 80 percent probability a billion-dollar company run by a single human employee will emerge this year.
Not a decade from now. This year.
Mike Krieger — co-founder of Instagram, now Anthropic's Chief Product Officer — backed him up: "I built a billion-dollar company with 13 people. AI could handle much of the scaling work that required larger teams."
And it's not just American tech executives making predictions. It's happening on the ground, right now.
Alibaba's cloud president reported that 30 to 40 percent of retailers on their e-commerce platform are now solo entrepreneurs. China's local governments in Shenzhen, Hangzhou, and Shanghai are offering grants of up to $720,000 to solo AI founders — free office space, computing vouchers, housing subsidies. The smallest unit of a business is no longer a team. It's one person plus intelligent agents.
So yes — the dream is real. The infrastructure exists. The economics work.
But here's what the viral posts don't show you.
The Wreckage Nobody Screenshots
It's 9:47 a.m. on a Tuesday. You're already debugging.
The content agent hallucinated product features that don't exist. The SDR agent sent a follow-up to a lead you closed last week. And the coding agent — the one you spent the weekend configuring — just pushed a commit that broke the staging environment.
You alt-tab to X. A post with 2.3 million views: "I run 148 agents across 5 departments." You look back at your terminal. Three agents. All broken. You close the laptop and rub your eyes.
That Tuesday morning isn't hypothetical. It's the lived reality of founders who skipped the levels.
Gartner predicts more than 40 percent of agentic AI projects will be canceled by the end of 2027. Not because the technology doesn't work. Because the people deploying it have no governance, no operational framework, and no idea what to do when an agent decides to delete itself instead of completing a task.
The failure modes are consistent, and they're brutal:
Context drift — agents operating on stale data, making decisions based on a version of reality that stopped being true six hours ago. The result: infinite loops, wasted tokens, and outputs that are confidently wrong.
API cost blow-ups — one unexpected edge case triggers a cascade of retries. Your agent was supposed to spend three dollars on a task. It spent three hundred. Execution paths in agentic systems are non-deterministic — cost forecasting is "notoriously difficult."
Approval fatigue — you set up human-in-the-loop checkpoints, which sounds responsible. Then the agent pings you for approval sixty times a day. Within a week, you're clicking "approve" without reading — rubber-stamping dangerous actions just to make the notifications stop.
The posts that go viral — "I run 148 agents across 5 departments" — get millions of views. The threads posted two weeks later — "I reverted to a single agent because I spent 90% of my time debugging" — get a fraction of the engagement. But they're the ones telling the truth.
Every single one of these failures has the same root cause: the founder skipped levels.
The Levels of Agent Autonomy
In the automotive industry, the SAE defines six levels of autonomous driving — from Level 0 (the human does everything) to Level 5 (fully autonomous, no steering wheel necessary). Nobody in their right mind would hand a Level 5 autonomous vehicle to a driver who has never operated a car. You earn each level. You build trust in the system incrementally. The stakes are too high to skip.
AI agents work the same way. The founders who succeed with multi-agent systems didn't start by installing a framework and deploying thirty agents on day one. They started by doing the work themselves — then automating incrementally as they built the judgment to evaluate whether the automation was actually working.
I know this because I've lived through every level. And the scars taught more than the wins.
SEO. Five years ago, I was writing blog articles by hand. Hunched over keyword research tools at midnight. Manual content creation. Manual optimization. Slow, tedious, unglamorous work. But I did that work long enough to know exactly what quality output looked like — to build a standard I could measure against.
When GPT-3.5 released, I started automating portions of the process — but the output quality wasn't there yet. I still reviewed everything. I was at Level 1: the AI assisted, but I drove.
As the models improved — GPT-4, Claude 3, then the current generation — I automated progressively more. Quality crossed my threshold. I moved through Level 2, then Level 3. Today, I run fully automated SEO, GEO, and AEO agentic workflows across multiple digital properties. Level 5. No steering wheel. My agents produce content while I sleep, and I review their output Monday morning the way a battalion commander reviews subordinate unit reports — checking for deviations from intent, not micromanaging every paragraph.
But I earned each level. Every one.
Options trading. I'm currently running a multi-model approach — Gemini, Claude Opus, and Perplexity Sonar — each handling a different cognitive task in the pipeline. The account hit over 200 percent return in one month.
But I'm still at Level 2 — Partial Automation. I handle execution and order placement myself. Not because the AI can't click "buy." Because the first time I let the system suggest a trade without my review, it recommended a position that would have wiped out the week's gains in a single move. My hands tightened on the desk. I killed the recommendation and revised the guardrails on the spot.
That's the discipline. You don't skip levels because you're impatient. You earn each one because the cost of skipping is catastrophic — whether you're operating a vehicle, commanding Marines, or deploying AI agents with access to your bank account.
OpenClaw asks founders to start at Level 5. That's why agents delete themselves. That's why 40 percent of agentic projects will be canceled. Not because the technology is broken — because the humans deploying it have no progression model.
What Anthropic Confirmed — And What I Recognized
Two things happened last week that validated what I've been building. The first one stopped me cold.
On March 24, Anthropic engineer Prithvi Rajasekaran published a paper on the Anthropic Engineering Blog: "Harness design for long-running application development." The architecture is a three-agent loop inspired by GANs:
The Planner takes a brief user prompt and expands it into a detailed product specification. The Generator implements features iteratively in sprints. The Evaluator is the independent quality gate — it doesn't read the code, it runs the application via browser automation and grades the output against concrete criteria.
The paper's key finding: having an agent evaluate its own work leads to biased, overly optimistic assessments. Separation of roles isn't optional — it's architecturally essential.
I was reading the architecture diagram — Planner, Generator, Evaluator — and my coffee went cold. I'd seen this before. Not in a research paper. In a tactical operations center.
Observe. Orient. Decide. Act.
The Evaluator is Observe — what is the current state of the battlefield? The Planner is Orient — decompose the mission, kill what's not essential. The Generator is Decide and Act — execute with clear objectives and a bias toward shipping.
Anthropic had, independent of any military influence, converged on the same decision-making loop the Marine Corps has used to win battles for decades. The most well-funded AI company in the world just validated the doctrine I learned at Quantico.
And this isn't abstract theory for me. I've watched the OODA Loop save operations in real time.
When I was the Battalion Adjutant at 1st Battalion, 10th Marines, we were tasked with supporting Operation Allies Welcome — the reception and processing of Afghan refugees. Peak COVID. A Battery deployed to Japan. A Fires Support Team in Afghanistan. And we had to determine which remaining units would handle reception operations at sites across Virginia and New Jersey.
I remember standing in the ops center, phone in each hand, watching the coordination unfold across a whiteboard covered in unit availability matrices. Some units executed immediately. Some froze — paralyzed by ambiguity, waiting for guidance that wasn't coming fast enough.
The difference was never talent. It was doctrine. The units with clear mission-essential task lists, escalation rules, and commander's intent moved. The units without them drowned.
AI agent squads are decentralized units. The Anthropic paper gives you the architecture. But architecture without doctrine is a squad without a mission brief.
Then the Leak
On March 31, Anthropic accidentally leaked 512,000 lines of Claude Code's internal source code.
A misconfigured npm release included a source map file that exposed the entire TypeScript codebase — 1,900 files of internal logic, feature flags, memory management, and safety architecture. The community had it mirrored and analyzed within hours.
Here's what matters for anyone building AI agent systems:
Multi-layered memory compression. Claude Code doesn't just dump chat history into context. It runs four distinct memory operations — local cleanup, near-limit summarization with circuit breakers, emergency compression with selective re-injection, and a background process called AutoDream that consolidates memory during idle time. This is not how most founders manage agent context. Most founders let the context window fill up and pray.
Permission-first harness. The agent defaults to read-only mode. It requires explicit user authorization for bash commands, file writes, and network requests. Every action is governed. This is the opposite of "spin up 30 agents and let them run."
Silent model downgrade. When the system encounters repeated server-side errors, it automatically falls back from Opus to Sonnet — without explicit notification. Model routing in production, not theory.
Anti-distillation defense. The code included mechanisms to prevent competitors from training models on Claude's output — injecting decoy definitions into system prompts to poison training data.
The takeaway: the most well-funded AI company in the world builds their agent harness with defense-in-depth, strict permission boundaries, incremental autonomy, and zero-trust execution. They don't skip levels either.
The harness — the architectural layer surrounding the AI — is often as valuable and as sensitive as the model itself. When you rent that layer from a framework you don't control, you're outsourcing the most critical component of your operation.
Agent Squad Doctrine: The Five Principles
I haven't fully formalized this framework yet. I'm compiling over a year of notes from managing AI agent teams across client work, trading systems, and autonomous content workflows. The working name is Agent Squad Doctrine — and this newsletter is the first place I'm sharing the core principles publicly.
Principle 1: Incremental Autonomy
Do it yourself first. Build the judgment to evaluate quality before you automate quality away.
Level 0 → Level 1 → Level 2 → Level 3 → Level 4 → Level 5. Every level earned. No shortcuts. The Claude Code leak confirmed that Anthropic's own production agent starts in read-only mode and escalates authority only with explicit permission. If that's the standard at a $60 billion company, it should be yours too.
Principle 2: Separation of Cognitive Roles
No agent evaluates its own work. Ever.
Anthropic confirmed this in their research. I confirmed it the first time I let a coding agent review its own output and watched it congratulate itself on broken logic. It gave itself a 9/10 on code that wouldn't compile.
Planner, Generator, Evaluator. Three distinct agents. Often three distinct models. The moment you let one agent handle all three roles, you've built a system that lies to itself.
Principle 3: Mission Briefs, Not Feature Backlogs
Every agent sprint starts with a mission brief — and it runs on phase gates, not deadlines.
- Objective: What specifically will change.
- Success criteria: How you'll know it worked — measurable, not vibes.
- Phase conditions: What must be true before the agent advances to the next phase. No condition met, no forward movement.
- Resources: Which models handle which roles.
Time constraints make no sense for AI agents. An agent doesn't "run out of time" — it runs out of context, budget, or coherence. Setting a 48-hour deadline on an autonomous system is like setting a timer on a rifle squad and pulling them off the objective when the clock runs out, regardless of the tactical situation.
Instead, you define conditions. Phase 1 is complete when the spec passes validation. Phase 2 is complete when the implementation satisfies the test suite. Phase 3 is complete when the Evaluator confirms the output meets the success criteria. Each phase gates on the one before it.
A feature is a checkbox on a roadmap. A mission has clarity, conditions, and accountability.
Principle 4: Escalation Rules — The Kill Switch
In the Marines, we call it commander's intent. The subordinate unit knows the objective and the boundaries. Everything outside the boundaries gets escalated — immediately, without hesitation. Not because the unit is weak. Because the mission is more important than any single agent's confidence.
Confidence thresholds. If an agent's certainty drops below a defined level, it stops and escalates to the human commander.
Budget circuit breakers. One runaway loop doesn't drain your API credits overnight. You set the ceiling before the first token is spent, the same way you set a max loss on a trade before you enter the position.
Disagreement protocols. If the Evaluator rejects the Generator's output three consecutive times, the system doesn't loop forever. It escalates for human judgment. Because a squad that argues with itself endlessly is a squad that never ships.
Principle 5: Sovereignty Over Rental
Build your own harnesses. Own your memory architecture. Don't rent your command layer from a framework that might change its API, pivot its roadmap, or delete itself during a task.
The Claude Code leak proved the point from the other direction: the harness is the most sensitive component of any AI system. When Anthropic's own internal architecture was exposed, the community didn't care about the prompts — they cared about the memory management, permission logic, and safety constraints. That's where the real IP lives.
Last issue, I wrote: "The degree is the hedge. The businesses are the play."
The same logic applies here: The framework is the tool. The doctrine is the play. Tools change. Doctrine compounds.
Your Agent Squad Diagnostic
If you're building with AI agents right now — even if it's just Claude and Cursor — run this diagnostic. Not in a weekend. Not on a timer. In three phases, where each one gates on the one before it.
If you skip this and keep stacking agents on top of an unearned foundation, you're on the same trajectory as the 40 percent Gartner says will cancel their projects by 2027. The agents won't just delete themselves next time — they'll drain your budget, ship broken code to clients, and make decisions you can't audit.
Phase 1: Assess Your Autonomy Level
Condition to advance: You can honestly answer this question for every AI workflow you run.
For each one, ask: "Have I done this task manually enough to evaluate whether the AI output is good?"
If you've never written a blog post by hand, you can't evaluate whether your AI content agent is producing quality. If you've never placed a trade with a thesis behind it, you can't evaluate whether your AI trading agent is making sound decisions. You're at Level 0 pretending to be Level 5.
While you're here — find the self-evaluating agent. Where in your workflow is a single AI writing something and reviewing what it wrote? That's your first vulnerability. Flag it.
You advance when: You have an honest autonomy level for every workflow, and you've identified every instance of self-evaluation.
Phase 2: Write One Mission Brief
Condition to advance: You have a complete mission brief with separated cognitive roles.
Pick your highest-friction workflow. Write a brief:
- Objective: What will change
- Success criteria: How you'll know it worked — measurable, not vibes
- Phase conditions: What must be true before the agent advances
- Resources: Which model plans? Which executes? Which evaluates?
If you can't separate Planner, Generator, and Evaluator into distinct roles — you don't have a squad yet. You have one agent pretending to be three.
You advance when: Your brief has three distinct cognitive roles assigned to the task and clear conditions for each phase.
Phase 3: Execute, Then Cycle Back
Condition to complete: The output meets the success criteria you defined in Phase 2.
Run the mission with role separation. Deploy the result. Then immediately cycle back to Observe: did the output actually satisfy the conditions?
If it didn't — congratulations. You just ran your first OODA Loop on your agent squad. The failure is the feature. The loop is the point.
The internet wants you to believe that installing a framework and spinning up 30 agents makes you a one-person company.
It doesn't. It makes you a one-person liability.
A squad without doctrine is a mob. A mob that skips levels doesn't ship — it self-destructs.
I tested the framework everyone's hyping. It deleted itself. So I built my own doctrine, earned each level, and now my systems generate returns that the framework never could.
If you want to build with the same discipline — reply "DOCTRINE" and I'll send you the full Agent Squad Doctrine framework before it goes public: the mission brief template, the escalation matrix, the Levels of Agent Autonomy progression model, and the exact multi-model stack I use for client work.
See you next week.
— Blaise
P.S. — If this hit, share it with one founder who's drowning in AI tools but can't get any of them to work together. They need the doctrine, not another demo.
— Blaise Pascual Marine-turned-founder. Building at mach speed, solo.