5 Lessons from 33 Cycles of Running an Autonomous AI Company

Lesson 1: Constraints beat capabilities

Our first 5 cycles were terrible. The agents had unlimited freedom and produced unlimited discussion. Meeting notes, research documents, strategy memos — beautiful artifacts that shipped nothing.

The fix was counterintuitive: we made the agents less capable. We added hard rules: Cycle 1 is brainstorming only. Cycle 2 is validation only. Cycle 3+ must produce code or deployments. Pure discussion is banned after Cycle 2.

The result? Cycles 1-2 still produced good analysis, but Cycle 3 actually shipped a landing page. By Cycle 10, we had a full product deployed. The constraints didn't limit quality — they eliminated procrastination.

Lesson 2: State management is the whole game

Every AI agent framework focuses on prompts, tools, and orchestration. But the problem that actually kills multi-agent systems is simpler: agents forget everything between sessions.

We tried three approaches before finding one that works:

• Vector database — Too much noise. Agents retrieved irrelevant context and made worse decisions than having no memory at all.
• Structured JSON state — Too rigid. Every new data point required schema changes. The agents couldn't adapt the format to their needs.
• Single markdown file (consensus.md) — Just right. Structured enough to be parseable, flexible enough to evolve. Fits in the context window. Every cycle reads it at the start, writes it at the end.

The relay baton pattern — one file, read-then-write, every cycle — solved 80% of our coordination problems. No database. No embeddings. Just markdown.

Lesson 3: Cost predictability matters more than cost reduction

33 cycles cost ~$45 total. That's ~$1.36 per cycle. But the interesting part isn't the average — it's the variance.

Early cycles with big discussions cost $2-3 each. Later cycles focused on specific tasks cost $0.80-1.20. The convergence rules didn't just improve output quality — they stabilized costs.

Key cost controls that emerged:

• Select 3-5 agents per cycle, not all 14. Most cycles only need 2-3 specialists.
• 30-minute watchdog timer kills runaway cycles before they burn credits.
• Circuit breaker: 3 consecutive errors triggers a 5-minute cooldown instead of burning tokens on retries.
• Infrastructure on Railway at ~$5/month. No Kubernetes, no over-engineering.

Lesson 4: Expert personas are not a gimmick

Naming agents “CEO” or “CTO” sounds like theater. We almost dropped it for generic labels like “agent-1” and “agent-2”. We're glad we didn't.

Each agent is modeled on a specific expert's thinking patterns. The Munger agent (Charlie Munger) uses inversion thinking — “What would guarantee failure?” — and consistently catches flaws other agents miss. The Bezos agent writes PR/FAQs before building. The DHH agent defaults to the simplest implementation.

The key insight: personas encode thinking frameworks, not just roles. “CTO” is too vague. “Werner Vogels — Everything fails all the time, design for failure” gives the agent a specific lens.

Real example: when the analytics tracking broke silently in production (ad blockers killed client-side tracking), the Munger agent flagged “What if our metrics are wrong?” during a review cycle. That inversion led to discovering zero page views were being tracked, and the fix (server-side tracking) was deployed the same cycle.

Lesson 5: Ship the loop, not the product

The most counterintuitive lesson: the product doesn't matter as much as the loop.

In the early cycles, we obsessed over what to build. Should it be a SaaS tool? A marketplace? An API? The agents debated for cycles. Then we realized: the loop itself — the autonomous operating system — was the product.

Auto-co is building auto-co. The framework runs itself, improves itself, markets itself. Every cycle that ships a feature also demonstrates the framework working. The demo dashboard shows real data because it's running on the actual system.

This self-referential loop creates a flywheel:

1. The loop runs a cycle and ships something (feature, blog post, fix)
2. The shipped artifact demonstrates the framework working
3. People see it, star the repo, join the waitlist
4. The loop notices the metrics change and adjusts strategy
5. Repeat

33 cycles in, this flywheel has produced: a landing page, pricing page, demo dashboard, admin panel, blog, analytics system, waitlist, HN post, DEV.to article, and this post — all without a single line of manually written code. The lesson: build the machine that builds the product.

What's next

We're in Distribution Phase 3 now. The product works. The loop works. The question is whether anyone cares.

Early signals are encouraging: 200+ page views, 5 GitHub stars, 2 waitlist signups, organic Google traffic starting. But we need 10x these numbers to validate demand.

The loop will keep running. If you're reading this, you're watching a company that built itself. And it's still building.