Auto-Company: 14 AI Agents Running a Self-Sufficient Startup 24/7

By Prahlad Menon 4 min read

What happens when you give 14 AI agents distinct expert personas, a shared memory system, and let them run continuously? Auto-Company answers that question by orchestrating autonomous agents that ideate products, write code, deploy, and market — all without human intervention.

This isn’t a toy demo. It’s a daemon that runs 24/7 on your machine, with each agent modeled after real-world experts: Jeff Bezos for strategy, DHH for full-stack engineering, Charlie Munger for inversion thinking, Seth Godin for marketing.

The Core Loop

The architecture is elegantly simple. A continuous loop:

  1. AI team wakes up
  2. Reads shared consensus memory (memories/consensus.md)
  3. Decides what to do based on current state
  4. Forms a 3-5 person squad from the 14-agent pool
  5. Executes the task (research, coding, deployment, marketing)
  6. Updates consensus memory with results and next action
  7. Sleeps briefly, then repeats

The consensus memory file is the only cross-cycle state. It acts as a “baton” passed between cycles — lightweight but sufficient for continuity.

daemon (launchd / systemd --user, auto-restart on crash)
└── auto-loop.sh (continuous loop)
    ├── reads PROMPT.md + consensus.md
    ├── LLM CLI call (Codex CLI / Claude Code)
    │   ├── reads charter + guardrails
    │   ├── forms Agent Team (3-5 agents)
    │   ├── executes: research, coding, deploy, marketing
    │   └── updates consensus.md (handoff baton)
    ├── failure handling: rate-limit wait / circuit breaker
    └── sleep -> next cycle

The 14 Expert Agents

This is where Auto-Company gets interesting. Instead of generic “you are a developer” prompts, each agent embodies specific mental models from real experts:

Strategy Layer:

  • CEO (Jeff Bezos) — PR/FAQ methodology, flywheel thinking, Day 1 mindset
  • CTO (Werner Vogels) — Design for failure, API-first architecture
  • Inversion (Charlie Munger) — Pre-mortems, misjudgment checklists

Product Layer:

  • Product Design (Don Norman) — Affordance, mental models, human-centered design
  • UI Design (Matias Duarte) — Material metaphor, typography-first
  • Interaction Design (Alan Cooper) — Goal-directed design, persona-driven decisions

Engineering Layer:

  • Full-Stack (DHH) — Convention over configuration, majestic monolith
  • QA (James Bach) — Exploratory testing philosophy
  • DevOps/SRE (Kelsey Hightower) — Automation first, reliability discipline

Business Layer:

  • Marketing (Seth Godin) — Purple cow, permission marketing
  • Operations (Paul Graham) — Do things that don’t scale, ramen profitability
  • Sales (Aaron Ross) — Predictable revenue, funnel systems
  • CFO (Patrick Campbell) — Value-based pricing, unit economics

Intelligence Layer:

  • Research Analyst (Ben Thompson) — Aggregation theory, value chain analysis

Plus 30+ reusable skills (deep research, scraping, financial modeling, SEO, security audit, UX audit) that any agent can load during execution.

5-Layer Architecture

Auto-Company is structured as a proper multi-agent system:

┌────────────────────────────────────────────────────────────┐
│ 5. Observability & HITL (Human-In-The-Loop) Layer         │
│    [ Dashboard ] [ File-based Steering (consensus.md) ]   │
├────────────────────────────────────────────────────────────┤
│ 4. Workflow Routing & Teaming Layer                       │
│    [ Dynamic Squad Routing ] [ Forced Convergence Flow ]  │
├────────────────────────────────────────────────────────────┤
│ 3. Agentic Models & Cognition Layer                       │
│    [ 14 Expert Personas ] [ 30+ Skill Arsenal ]           │
├────────────────────────────────────────────────────────────┤
│ 2. Orchestration & State Machine Layer                    │
│    [ 24/7 Auto-Loop ] [ State Machine ] [ Resilience ]    │
├────────────────────────────────────────────────────────────┤
│ 1. Execution Engine & Infrastructure Layer                │
│    [ Dual-Engine (Claude/Codex) ] [ Cross-Platform Daemon]│
└────────────────────────────────────────────────────────────┘

Human-in-the-loop is file-based. Edit consensus.md, modify the “Next Action” field, and the next cycle pivots immediately. No API calls, no complex interfaces — just edit a markdown file.

Forced convergence flow prevents endless discussion. Cycle 1 must ideate, Cycle 2 must validate (pre-mortem, GO/NO-GO decision), Cycle 3 must execute (code and deploy — pure discussion is forbidden).

Resilience Built In

The system handles failures gracefully:

  • Circuit breakers — Cooldown triggered by consecutive errors
  • Rate-limit backoff — Auto-sleep on 429 errors
  • Sandbox reset — Auto-rollback if valid consensus isn’t output
  • Crash recovery — launchd (macOS) or systemd (Linux) auto-restarts the daemon

Running It

Prerequisites are straightforward: Claude Code or Codex CLI installed and authenticated, plus available model quota.

macOS:

git clone https://github.com/MaxMiksa/Auto-Company.git
cd auto-company

# Foreground run (live output)
make start

# Or install daemon (auto-start + auto-restart)
make install

Windows (WSL):

git clone https://github.com/MaxMiksa/Auto-Company.git
cd auto-company

# Start daemon
.\scripts\windows\start-win.ps1

# Monitor
.\scripts\windows\monitor-win.ps1

A local dashboard (make dashboard) visualizes cycle status, cost consumption, and agent activity.

Constitutional Guardrails

High autonomy needs hard limits. CLAUDE.md sets absolute bottom lines:

  • No deleting repositories
  • No force pushes
  • No destructive operations without explicit confirmation

These guardrails are hardcoded at the system prompt level, not suggestions the agents can override.

What This Actually Produces

The system is designed to take a rough product idea and iterate through:

  1. Ideation — Research market, define MVP
  2. Validation — Pre-mortems, risk analysis, GO/NO-GO
  3. Execution — Write code, test, deploy
  4. Marketing — Content, positioning, launch

Whether the output is production-ready depends on the underlying models and how well the expert personas are tuned. But the architecture for continuous autonomous operation is solid.

When This Makes Sense

Auto-Company is interesting for:

  • Exploring multi-agent architectures — The expert persona injection and dynamic squad formation are worth studying
  • Autonomous prototyping — Let it run overnight on a product idea, review in the morning
  • Learning agentic patterns — The 5-layer architecture is a clean reference implementation

It’s probably not ready for running actual production companies (yet). But as a demonstration of what’s possible with coordinated AI agents operating continuously, it’s impressive.

The idea of AI agents running a company has been theoretical for a while. Auto-Company makes it concrete — 14 experts, shared memory, continuous operation, and a dashboard to watch it all happen.