v2.2.0: A refined Dashboard with continuous work journals, smoother navigation and improved mobile layouts.

🎬 Dashboard and Product Preview

Interface demo using recorded work; unavailable runtime fields use sample values. Click an image to view it at full size. Capture sources and reproduction.

ScopeFence
Communicate scope, price and schedule changes through an editable decision link.
Image Checklist
Review image dimensions, size, format and names locally, then export a checklist.
COI Chase Desk
Record follow-ups and document receipts, review the history and export session records.

✨ What Is This?

You start a loop. Each cycle reads the shared work summary, decides what to do, forms a team as needed, executes, updates the summary, and waits before the next cycle. Team creation depends on the model and engine capabilities; errors, budget limits, or a pause request can stop continuation.

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 as needed
        │   ├── executes: research, coding, deploy, marketing
        │   └── updates memories/consensus.md (work summary)
        ├── failure handling: rate-limit wait / circuit breaker / consensus rollback
        └── sleep -> next cycle

Each cycle is an independent CLI call. memories/consensus.md is the main work summary loaded for the next cycle. Product files, repositories, configuration, identity records, logs, and usage data also persist across cycles.

🗂️ Product Center

The local Product Center brings explicitly connected product runs into one catalog. Switching products changes only what you are viewing; importing an existing run starts as read-only and never starts a model by itself.

Start it from the repository, then open http://127.0.0.1:8810/center:

# macOS / WSL
make center

# Windows PowerShell
.\scripts\windows\center-win.ps1

See the Product Center guide for source registration, execution-domain setup, queue controls and recovery behavior.

🧩 Generated Applications

The example catalog contains 22 independently runnable public examples, including 14 newly completed products and selected historical work. Each entry provides startup instructions, limitations and provenance; new local runs continue to write into projects/.

The examples cover professional data review, image delivery, shared meals, travel pacing and family creation. Published copies preserve the original product direction while refining components and repairing real interactions; original reports and unsuccessful conclusions are not rewritten for the showcase.

Frontend work uses the B design baseline adapted from Anthropic, followed by a dedicated finishing pass once the core flow works. The pass preserves the product’s identity and improves components, copy and responsive behavior. The refinement study and redesign comparison retain their original evidence and limits.

🚀 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 Roles)

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/Autonomous-Company.git
cd Autonomous-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/Autonomous-Company.git
cd Autonomous-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

📚 More Info

┌────────────────────────────────────────────────────────────┐
│ 5. Observability & HITL (Human-In-The-Loop) Layer          │
│    [ Dashboard ]  [ File-based Steering (consensus.md) ]   │
├────────────────────────────────────────────────────────────┤
│ 4. Workflow Routing & Teaming Layer                        │
│    [ Role-based Teaming ]  [ Prompt Workflow Guidance ]   │
├────────────────────────────────────────────────────────────┤
│ 3. Agentic Models & Cognition Layer                        │
│    [ 14 Expert Personas ]  [ 30+ Skill Arsenal ]           │
├────────────────────────────────────────────────────────────┤
│ 2. Orchestration & State Machine Layer                     │
│    [ Auto-Loop ]  [ Persistent State ]  [ Resilience ]    │
├────────────────────────────────────────────────────────────┤
│ 1. Execution Engine & Infrastructure Layer                 │
│    [ Engine Adapters ]  [ Cross-Platform Daemon ]        │
└────────────────────────────────────────────────────────────┘

🔄 Operating Model

Default Workflow Guidance

The prompt recommends the following progression. These labels describe work stages, which may span multiple engine cycles; they are not a completion deadline or an enforced state machine.

Six Standard Workflows

These are suggested role collaboration chains; the executing model selects the actual work and participants.

🧭 Steering

To change direction, stop the foreground run with make stop, pause a macOS/WSL daemon with make pause, or use the Windows stop command below. Wait until the run has stopped before editing, then start or resume it.

Agents may report unresolved P1 blockers, but must preserve existing P1 entries and cannot add checked-off ones. Resolve blockers only after stopping and completing pending recovery; see P1 issues and human edits.

🛡️ Safety Guardrails

CLAUDE.md gives agents the following behavioral rules. They complement specific framework checks, but are not a general command-denial mechanism or a guarantee that every agent action is blocked when it violates a rule:

• 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

autonomous-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

⚠️ 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
• Permissions matter: default engine settings allow broad local actions without routine approval prompts. Review engine permissions and CLAUDE.md; prompt rules alone do not provide isolation
• 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 Autonomous Company:

• nicepkg/auto-company - initial macOS edition
• shadcn/ui - shared Dashboard components; license and integration notes
• 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/Autonomous-Company