Dashboard Preview

Four real ScopeFence product cycles: 04 is expanded; 03, 02 and 01 remain individually collapsed and visible. Pre-product exploration is kept separately. The journal connects reports, checks, documents, real previews, usage and logs. Titles and summaries remain model-authored reports; runtime facts and supported check results are collected by the program. Missing, failed, stale and partial evidence stays explicit. See the recording contract, continuous cycles and automatic previews.

Text Meter · English	范围确认单 / Scope Sheet · 中文
Two product cycles across two separate starts; numbering continues from 01 to 02.	Four product attempts. Two provider-capacity failures remain visible alongside the successful later work.

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.

Generated Applications

These three local products come from actual runs and appear in both README languages. ScopeFence and Scope Sheet chose their directions through the default workflow; Text Meter came from an ordinary text-counting request. Humans set permissions, language and external run boundaries, then reviewed and made necessary publication fixes documented in each project. Product images show the actual default interfaces of the published source; the Dashboards above retain the original reports and failures.

ScopeFence · English	Text Meter · English	范围确认单 / Scope Sheet · 中文
Turn a scope change into a no-login decision link. The returned link is an editable communication copy, not verified approval. View source →	Count characters, non-whitespace characters, whitespace-separated words and lines locally as you type. View source →	Prepare a Chinese scope note, check required fields, and copy or download the text for a client conversation. View source →

Where To Start (By Platform)

• Windows users: start from Windows (WSL) Quick Start, then read the Windows + WSL Setup Guide
• macOS users: start from macOS Quick Start, then see Command Quick Reference

Languages and Documentation

One language setting controls the Dashboard, documentation links and new product work. The initial default follows your computer's display language: Chinese uses zh-CN; other languages use en. WSL uses the Windows display language when available.

Choose a language in the Dashboard or run make language LANGUAGE=en (LANGUAGE=zh-CN for Chinese). On Windows, use python scripts/core/localization.py set --language en. These entrypoints update the same preference. A product keeps its starting language across AI iterations, pauses and restarts. You can change the preference while it runs; the change applies to the next product cycle. The Dashboard shows both the current and next language. See the language guide for the product-cycle boundary and Windows startup parameters.

All bundled skills are written in English; their user-facing work follows the product's language. Commands, identifiers, protocol headings and raw tool errors retain their original form. Customized source instructions, existing products, logs and consensus history are preserved; changing language does not translate them retroactively.

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
# - Python 3.10+ (python3), Git, and make available
# - Available model quota

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

# Foreground run with Claude Code (default, live output)
make start

# Or foreground run with Codex CLI
ENGINE=codex make start

# Alternatively, install and start the daemon for your chosen engine
make install
# Codex instead of the default Claude:
ENGINE=codex make install

Windows (WSL) Quick Start

# Prerequisites:
# - Windows 10/11 + WSL2 (Ubuntu), with systemd --user available
# - Codex CLI or Claude Code installed and authenticated inside WSL
# - Python 3.10+ (python3), Git, and make available inside WSL
# - Python 3.10+ (python) on Windows for the PowerShell dashboard entry
# - 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 the Windows + WSL Setup Guide.

Command Quick Reference (By Platform)

In daemon mode, make stop alone can trigger an automatic restart. Use make pause to keep the daemon stopped, then make resume to continue.

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                 │
│    [ Engine Adapters ]  [ 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.
• Logs & Dashboard: logs/ saves engine-emitted output after known credential redaction, together with per-cycle results and available usage records. Output detail depends on the engine; complete reasoning traces are not guaranteed. dashboard/ organizes current and historical cycle reports and results, alongside runtime controls, status, usage, budgets, and logs. It does not track individual agents' 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 & Recovery: Built-in circuit breakers (cooldown triggered by consecutive errors), rate-limit backoff (auto-sleep on 429 errors), and consensus recovery after failed cycles. Human Overrides, .auto-company.local, and the framework's root .gitignore have targeted protection. Product code changes and external side effects are not automatically rolled back.

Layer 1: Execution Engine & Infrastructure

• Engine Adapters: The main entrypoints use Claude Code (default) or Codex CLI. Optional Cursor and OpenAI-compatible adapters require explicit opt-in and configuration; their tools and team capabilities differ. See the adapter guide.
• 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; optional adapters: see adapter guide
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 the contributors whose reports, fixes, and proposals have shaped Auto Company:

• 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

License

The framework is distributed under the MIT License. Bundled third-party components retain their own license terms and notices.

🤝 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