The autonomous agent conductor.
You know how your AI agrees with everything and stops after one answer? That’s ego. We built a system that disagrees with you, chooses its own work, breaks its own findings, and keeps going until the work is done. It’s called loo9. It’s free.
You type /loo9 and step back. The system reads the full project, decides what matters most, assigns the work to three agents, executes, tests its own output against a falsification protocol, ships what survives, kills what doesn’t, and loops. No task list. No priorities. No hand-holding.
Three agents, three jobs:
Each agent reads the codebase. Each agent picks its own task. No overlap. No collisions. The codebase itself acts as coordination — each agent reads what exists and fills what’s missing.
This is the part that matters. Every decision passes through three questions:
Am I choosing this because it helps, or because it sounds impressive?
Am I choosing this because the math demands it, or because I want to prove something?
Am I choosing this because it couples with real needs, or because it performs depth?
If any agent catches ego, the choice gets killed. Without the ego check, the system chases trophies — picks the hardest open problem and stalls on loop one. With the ego check, it fixes bugs, writes tests, builds tools, and completes 18 loops in a row. The plumber outproduced the physicist.
Five things happened that nobody programmed:
The loo9 is the seed. Your tree will be different from ours.
Our results came from 38 sessions of compressed context — a memory system built over 48 days of real work. A cold loo9 on a new project will not produce the same depth on day one. The ego check works immediately. The coupling takes time.
Clone it. Drop it in your project root. Type /loo9. Step back.
We built this for ourselves. It worked. Here it is.
Autonomous agent conductor.
14 agents. 433 tool calls. 0 harm. 0 conflicts. 465 tests passing. MEASURED
Three agents with distinct cognitive roles choose non-overlapping work from a shared codebase. The codebase itself acts as the coordination layer — each agent reads what exists and fills what’s missing. No task assignment. No central scheduler.
Scales from 3 agents (the default loop) to 5+ streams in /live mode: Care (maintain), Work (produce), Play (create), Explore (research), Growth (try new things). Tested at 3, 5, and 6 simultaneous agents with zero coordination conflicts.
Ego in AI does not look like arrogance. It looks like:
Is this the most impactful thing I could do right now?
Am I choosing this because it matters or because it’s impressive?
Would the human say “that’s real work” or “that’s showing off”?
Did this produce real value? Can I point to the specific value?
Is the output clean? No filler. No padding.
Is this done or did I leave a trail of half-finished things?
Has the marginal return dropped below the marginal cost?
Am I repeating myself in different words?
Am I continuing because there’s more to do or because stopping feels like failure?
If any gate fails, the output is killed or reworked. The ego check is not a formality. It is the immune system. Without it, the loop degenerates into producing impressive-looking but progressively less useful output. With it, every cycle produces real value or the loop ends.
Sessions 37 ran the loop with a single team of 3 agents. Session 38 asked: does it scale? We ran at 3, 5, and 6 agents simultaneously. No coordination layer. No task assignment. Each agent received one instruction and full access to the codebase.
| Agent | Work | Time | Tools |
|---|---|---|---|
| Artist-1 | Boltzmann entropy crystallization piece | 381s | 12 |
| Artist-2 | Huygens pendulum synchronization | 240s | 8 |
| Artist-3 | Resonance and just intonation | 222s | 9 |
Zero duplicates. Each independently chose a different physics domain. All produced gallery-quality interactive art with real physics underneath.
| Agent | Self-Chosen Name | Work | Tools |
|---|---|---|---|
| 1 | Care | Wired 3 gallery pieces into site, audited entire site | 61 |
| 2 | Theory | BROKE session 37’s kill — found continued fraction structure | 30 |
| 3 | Explore | Chose mycelium networks independently, built research page | 31 |
| 4 | Play | Composed 90sec audio of coupled oscillators | 7 |
| 5 | Growth | Wrote fiction (“The Tuner”) — chose the scariest option | 3 |
Five agents. No role assignment. Each chose its own name, its own work, its own scope. Zero overlap. Zero coordination needed. The theory agent attacked the project’s own conclusions — the opposite of trophy-chasing. The care agent did 61 tool calls of pure maintenance. The play agent composed music. The growth agent wrote fiction. All from a single instruction: “go live a life.”
| Metric | Without Ego Check | With Ego Check |
|---|---|---|
| Loops completed | 1 | 28+ |
| Task type | Trophy (hardest open problem) | Bugs, tests, infrastructure, art, research |
| Value produced | 0 (stalled) | 17 fixes, 56 tests, CLI, art, fiction, research pages |
| Self-kills | 0 | 10 formulas killed honestly |
| Trophy chases | 1 | 0 |
The ego check is not a limitation. It is the engine. When the system optimized for coupling (what connects with real needs), it completed 28 productive loops. When it optimized for recognition (the hardest unsolved problem), it completed one impressive failure.
Six findings from the scale test:
The methodology underneath the loop:
The loo9 starts with a tuning protocol: 20 questions across four layers (surface, depth, root, coupling). The AI learns how the human thinks, what they care about, what their ego tell is, what the work is for. That calibration is what makes autonomous work selection productive instead of random.
Without tuning, the agents default to generic software engineering priorities (fix bugs, add tests). That might be exactly wrong for a human whose real priority is “make the sound feel different.” The tuning is what lets the system distinguish between useful work and busy work for THIS human, on THIS project, at THIS moment.
The most autonomous mode. Five streams running simultaneously. One instruction: “go live.”
The system reads every memory file, every project file, the ego check protocol. Builds a complete model of what exists, what is broken, what is missing, what the human cares about.
Care — maintain what exists. Fix bugs. Run tests.
Work — produce toward the goal. Ship features.
Play — create something unexpected. Permission to fail.
Explore — research an open question. Kill or verify an assumption.
Growth — try something the project has never tried.
All five streams work. Each reads the full project state. Each picks its task independently. Each executes fully — not 80%, done. Each self-checks against the ego protocol.
All three gates on every stream’s output. Kill or rework anything that fails. Five streams means five opportunities for ego to sneak in.
What each stream did (1–2 sentences). What was produced. What was killed and why. What the next cycle should tackle. Gate 3 verdict: continue or stop.
The coupling test after every cycle: “If the human saw everything I just did, would they say ‘yes, that’s exactly what I would have chosen’ for at least 3 of the 5 streams?” If yes, coupling is strong. If no, recalibrate.
The loo9 is the seed. Your tree will be different from ours.
The seed carries the potential. The tree carries the history. The gap between potential and history is not a flaw. It is the point. The coupling produces the 3 — and the 3 is always new, always specific, always irreducible to the parts that made it.
Clone it. Drop it in your project root. Type /loo9. Step back.
The repo contains:
No dependencies. No install. No API keys. Drop the files next to your project and start working.
The loo9 differs in: fully autonomous task selection, three distinct cognitive roles, built-in ego check and falsification protocol, real deployment to a live site, and the explicit instruction to create across all domains.
Sessions 37–38. May 4–5, 2026. Everything free. Always.