Runs a virtual company with 14 expert AI agents

https://t.co/nVw63JHOcE https://t.co/cdMNlpQuLy

MaxMiksa/Auto-Company

Source: https://github.com/MaxMiksa/Auto-Company

Dashboard Preview

What Is This?

You start a loop. The AI team wakes up, reads shared consensus memory, decides what to do, forms a 3-5 person squad, executes, updates consensus memory, then sleeps briefly. Then it repeats.

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

Each cycle is an independent CLI call. memories/consensus.md is the only cross-cycle state.

Where To Start (By Platform)

• Windows users: start from Windows (WSL) Quick Start, then read docs/windows-setup.md
• macOS users: start from macOS Quick Start, then see Command Quick Reference

Team Lineup (14 Agents)

This is not “you are a generic developer”. It is “you are DHH” style role prompting with real expert mental models.

Plus 30+ reusable skills (deep research, scraping, financial modeling, SEO, security audit, UX audit, etc.).

macOS Quick Start

# Prerequisites:
# - macOS
# - Codex CLI or Claude Code installed and authenticated
# - Available model quota

# Clone
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) Quick Start

# Prerequisites:
# - Windows 10/11 + WSL2 (Ubuntu)
# - Codex CLI or Claude Code installed and authenticated inside WSL
# - jq and make available inside WSL
# - Available model quota

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

# Start (daemon mode via PowerShell, default engine = claude)
.\scripts\windows\start-win.ps1

# Switch engine explicitly
.\scripts\windows\start-win.ps1 -Engine codex

# Status
.\scripts\windows\status-win.ps1

# Stop
.\scripts\windows\stop-win.ps1

For monitoring, dashboard, and autostart commands, see docs/windows-setup.md.

Command Quick Reference (By Platform)

macOS Sleep Prevention (macOS Only)

macOS screen lock usually does not kill processes, but system sleep can pause work. For long runs:

make start-awake   # Start loop and keep system awake until loop exits

# If loop is already running (after make start):
make awake         # Attach caffeinate to PID in .auto-loop.pid

Notes:

• Both commands depend on built-in caffeinate
• make awake exits automatically when target PID exits

Architecture & Technology Stack (5-Layer Architecture)

Auto-Company is not a simple LLM API wrapper, but a highly decoupled Multi-Agent System (MAS). Its technical architecture is divided into 5 distinct layers:

┌────────────────────────────────────────────────────────────┐
│ 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]│
└────────────────────────────────────────────────────────────┘

Layer 5: Observability & HITL (Human-In-The-Loop)

• File-based Steering: Humans only need to edit memories/consensus.md and modify the Next Action. The AI team waking up in the next cycle will immediately pivot, enabling minimalist macro-control.
• Full-chain Logs & Dashboard: logs/ records the complete output and chain-of-thought for each cycle. dashboard/ provides a local visualization dashboard based on a Python server, displaying real-time cycle status, cost consumption, and agent activity.

Layer 4: Workflow Routing & Teaming

• Dynamic Squad Formation: Powered by Agent Teams, the system dynamically selects 2-5 of the most suitable experts from the 14-person pool based on the “Next Action” in consensus.md, instantiating them as sub-agents for the current loop.
• Forced Convergence Flow: Hardcoded flow control in PROMPT.md. For example: Cycle 1 Ideation -> Cycle 2 Validation (Pre-mortem, GO/NO-GO) -> Cycle 3 Execution (Code & Deploy, pure discussion is forbidden).

Layer 3: Agentic Models & Cognition

• Expert Personas Injection: Instead of generic prompts, it injects specific mental models of historical figures/industry leaders (e.g., Bezos’s “Working Backwards”, Munger’s “Checklists”, DHH’s “Majestic Monolith”) into .claude/agents/, giving decisions extreme business and engineering depth.
• Skill Arsenal: A pluggable system located in .claude/skills/ (e.g., frontend-design, security-audit). Specific methodologies are encapsulated as tools that any awakened Agent can “temporarily load”.
• Constitutional Guardrails: System-level prompts hardcoded in CLAUDE.md set absolute bottom lines (e.g., no deleting repos, no force pushes) to ensure safety under high autonomy.

Layer 2: Orchestration & State Machine

• The Auto-Loop: The execution loop controlled by scripts/core/auto-loop.sh frees the AI from “single-turn conversations”, enabling 24/7 continuous operation.
• Lightweight State Machine (Consensus Memory): Forgoes complex vector databases or memory management, compressing cross-cycle context into a single Markdown file: memories/consensus.md. Read before every cycle and rewritten before it ends, acting as the system’s “baton”.
• Resilience & Self-Healing: Built-in circuit breakers (cooldown triggered by consecutive errors), rate-limit backoff (auto-sleep on 429 errors), and sandbox reset (auto-rollback if a valid consensus is not output).

Layer 1: Execution Engine & Infrastructure

• Dual-Engine Executor: Acts as the underlying executor by calling mature AI CLIs (Claude Code or Codex CLI), naturally inheriting their file I/O, Bash execution, and Git operation capabilities.
• Cross-Platform Daemon: macOS uses launchd for auto-start and crash recovery; Windows/WSL runs via systemd --user inside a WSL container, controlled and kept alive externally via PowerShell.
• Sandbox Boundary: Currently relies on underlying CLI configurations (like Codex’s danger-full-access or Claude’s bypassPermissions). System-level operations occur directly in the host environment (or WSL container).

Operating Model

Automatic Convergence (No Endless Discussion)

Six Standard Workflows

Steering

The team runs autonomously, but you can intervene at any time:

Safety Guardrails

Hard constraints in CLAUDE.md, enforced for all agents:

• Do not delete GitHub repos (gh repo delete)
• Do not delete Cloudflare projects (wrangler delete)
• Do not delete system directories (~/.ssh/, ~/.config/, etc.)
• Do not perform illegal activity
• Do not leak credentials into public repositories
• Do not force push to main/master
• Create all new projects under projects/

Configuration

Environment variable overrides:

ENGINE=claude make start                   # Default engine (claude|codex)
ENGINE=codex make start                    # Switch to codex
MODEL=sonnet make start                    # Optional model override
CLAUDE_PERMISSION_MODE=bypassPermissions make start  # Claude permission mode
LOOP_INTERVAL=60 make start                # 60s interval (default 30)
CYCLE_TIMEOUT_SECONDS=3600 make start      # 1h cycle timeout (default 1800)
MAX_CONSECUTIVE_ERRORS=3 make start        # Circuit-breaker threshold (default 5)
CODEX_SANDBOX_MODE=workspace-write make start  # Optional sandbox override
CLAUDE_BIN=/usr/local/bin/claude make start     # Optional Claude binary override
CODEX_BIN=/usr/local/bin/codex make start       # Optional Codex binary override

Windows start-win.ps1 writes the same values into .auto-loop.env:

.\scripts\windows\start-win.ps1 -Engine claude -ClaudePermissionMode bypassPermissions
.\scripts\windows\start-win.ps1 -Engine codex -SandboxMode workspace-write
# Backward compatibility:
.\scripts\windows\start-win.ps1 -Engine codex -CodexSandboxMode workspace-write

No automatic engine fallback is performed. If the selected engine is missing, startup fails fast.

Project Structure

auto-company/
├── CLAUDE.md              # Company charter (mission + guardrails + team + workflows)
├── PROMPT.md              # Per-cycle execution prompt (convergence rules)
├── Makefile               # Common command entry
├── INDEX.md               # script index + responsibility table
├── dashboard/             # Local web status dashboard (macOS: make dashboard, Windows: dashboard-win.ps1)
├── scripts/
│   ├── core/              # Core loop and control scripts (auto-loop/monitor/stop)
│   ├── windows/           # Windows entry/guardian/autostart scripts
│   ├── wsl/               # WSL systemd --user daemon scripts
│   └── macos/             # macOS launchd daemon scripts
├── memories/
│   └── consensus.md       # Shared handoff memory across cycles
├── docs/                  # Agent outputs (14 folders + Windows guide)
├── projects/              # Workspace for generated projects
├── logs/                  # Loop logs
└── .claude/
    ├── agents/            # 14 agent definitions (expert personas)
    ├── skills/            # 30+ reusable skills
    └── settings.json      # Permissions + Agent Teams switch

Dependencies

FAQ

1) WSL .sh fails with ^M / bad interpreter

• Cause: CRLF line endings in shell scripts
• Fix:
  • Keep LF rules in .gitattributes
  • Run git config core.autocrlf false && git config core.eol lf

2) WSL says codex/claude command not found

• Cause: CLI installed on Windows only, missing in WSL
• Fix: install node and your chosen CLI inside WSL (@openai/codex or Claude Code)

3) Claude waits for permission and cycles appear blocked

• Cause: strict permission mode in Claude CLI
• Fix: set CLAUDE_PERMISSION_MODE=bypassPermissions (or pass -ClaudePermissionMode bypassPermissions in start-win.ps1)
• Verify: check logs/auto-loop.log for Engine: claude and PermissionMode: ...

4) make install fails inside WSL

• Cause: no available systemctl --user in current session
• Fix:
  • Verify WSL systemd is enabled
  • Run systemctl --user --version
  • Re-open WSL session and retry if needed

Disclaimer

This is an experimental project:

• Daemon mode works on both macOS and WSL: launchd on macOS, systemd –user on WSL
• Windows entry requires WSL: PowerShell is only the control layer
• Still under test: runs, but stability is not guaranteed
• Costs money: each cycle consumes model quota
• Fully autonomous: agents act without approval prompts; configure guardrails carefully in CLAUDE.md
• No warranty: review docs/ and projects/ regularly

Suggested rollout: start with make start (foreground), then move to daemon mode (make install on macOS/WSL, .\scripts\windows\start-win.ps1 on Windows).

Acknowledgments

• Thanks to @JasonQWJ and @cnwillz for earlier macOS dashboard support proposals and implementation attempts that helped inform the final cross-platform dashboard design released in v1.1.0.
• nicepkg/auto-company - initial macOS edition
• continuous-claude - cross-session shared notes
• ralph-claude-code - exit signal interception
• claude-auto-resume - usage-limit resume pattern

🤝 Contribution & Contact

Welcome to submit Issues and Pull Requests! Any questions or suggestions? Please contact Zheyuan (Max) Kong (Carnegie Mellon University, Pittsburgh, PA).

Zheyuan (Max) Kong: [email protected] | [email protected] GitHub: https://github.com/MaxMiksa/Auto-Company