Dicklesworthstone/agentic_coding_flywheel_setup: 30-Minute Agentic Coding VPS Bootstrap

Setting up a productive remote development environment is still harder than it should be. You rent a VPS, then spend hours installing runtimes, configuring shells, authenticating with cloud APIs, and wrestling with SSH keys before you can even start coding. When you want to run multiple AI coding agents in parallel—each with their own session management, safety guardrails, and coordination tools—the complexity multiplies. Dicklesworthstone/agentic_coding_flywheel_setup (ACFS) solves this with a single idempotent command that transforms a fresh Ubuntu VPS into a complete agentic coding environment in about 30 minutes.

What is Dicklesworthstone/agentic_coding_flywheel_setup?

ACFS is an open-source bootstrap system maintained by Dicklesworthstone that automates the entire setup of a multi-agent AI development environment on Ubuntu VPS instances. With 1,545 GitHub stars and 179 forks as of its last commit on July 13, 2026, it has gained meaningful traction among developers who want to run AI coding agents remotely without manual configuration drudgery.

The project is primarily written in Shell and released under an MIT license with an OpenAI/Anthropic rider—a notable detail that explicitly addresses the licensing complexities of distributing tools that integrate with proprietary AI services. This matters because many agentic coding tools sit in legal gray areas regarding API terms of service.

ACFS targets three audiences simultaneously: complete beginners who need hand-holding through their first VPS setup, experienced developers who want reproducible environments, and teams that need identical agentic workflows across multiple machines. The project ships with a wizard website at agent-flywheel.com for beginners and a one-liner installer for everyone else.

The architecture centers on a manifest-driven design: acfs.manifest.yaml serves as the single source of truth for all 30+ tools, their installation commands, and verification logic. A TypeScript generator with Zod validation produces installer scripts from this manifest, ensuring consistency between what gets installed and what gets verified.

Key Features

Idempotent, Resumable Installation. The installer tracks progress in ~/.acfs/state.json and automatically resumes from the last completed phase if interrupted. Re-running the same command picks up where it left off without prompts (with --yes). This matters for long-running setups, especially when automatic Ubuntu upgrades trigger reboots mid-install.

Three AI Coding Agents Pre-Configured. ACFS installs and configures Claude Code, Codex CLI, and Antigravity CLI with "vibe mode" aliases that enable maximum velocity: cc for Claude with --dangerously-skip-permissions, cod for Codex with --dangerously-bypass-approvals-and-sandbox, and agy with a pinned Gemini 3.1 Pro High model. These are explicitly dangerous configurations designed for throwaway VPS environments, not production systems.

Complete Dicklesworthstone Stack. Beyond the agents themselves, ACFS installs 10 coordination and safety tools: Named Tmux Manager (ntm) for session orchestration, MCP Agent Mail (am) for inter-agent messaging, Ultimate Bug Scanner (ubs), Beads Viewer (bv) for task management, CASS (cass) for unified agent history search, CASS Memory (cm) for procedural memory, Coding Agent Account Manager (caam), Simultaneous Launch Button (slb) for two-person-rule dangerous commands, Destructive Command Guard (dcg) as a Claude Code hook, and Repo Updater (ru) for multi-repo automation.

Security-Verified Upstream Installers. ACFS uses checksums.yaml with SHA256 hashes for all downloaded installer scripts. The security.sh library enforces HTTPS, verifies content before execution, and provides tools to detect and investigate upstream changes. This is defense in depth for the inherently risky curl | bash pattern.

Automatic Ubuntu Upgrades. The installer detects your current Ubuntu version and performs sequential do-release-upgrade operations to reach 25.10, with automatic resume via systemd service after each reboot. A full chain from 24.04 takes 1.5–3 hours but requires no manual intervention.

Use Cases

Solo Developer, Multiple Parallel Projects. Run Claude Code in one tmux session working on your API, Codex CLI in another building the frontend, and Antigravity CLI in a third handling DevOps^{↗ Bright Coding Blog} scripts. NTM provides the cockpit view; Agent Mail coordinates handoffs; CASS lets you search across all agent histories when you need to recall why a decision was made.

Team Onboarding Standardization. New team member joins? Provision a VPS, run the one-liner, and they have an identical environment to everyone else—including the same agent configurations, shell aliases, and safety tools. The acfs doctor command verifies everything is correctly installed, eliminating "works on my machine" for agentic workflows.

Ephemeral Experimentation Branches. Need to test a risky refactoring or explore a new architecture? Spin up a throwaway VPS in vibe mode, let agents work with full permissions, then destroy it. The SLB two-person rule and DCG guardrails provide safety nets even in maximum-velocity configurations.

Learning Agentic Workflows from Scratch. The 13-step wizard website and interactive onboarding TUI guide complete beginners from "I have a laptop" to "AI agents are coding for me." Lessons cover Linux navigation, SSH, tmux, Git, and each tool in the stack with practical exercises.

Automated Maintenance. The acfs-update command provides unified updates across all tools with category filters (--agents-only, --runtime-only), dry-run previews, and cron-friendly --yes --quiet automation. Logs are timestamped in ~/.acfs/logs/updates/ for auditability.

Installation & Setup

The fastest path is the one-liner with vibe mode for a fresh, throwaway VPS:

# Quick install with maximum velocity settings
curl -fsSL "https://raw.githubusercontent.com/Dicklesworthstone/agentic_coding_flywheel_setup/main/install.sh?$(date +%s)" | bash -s -- --yes --mode vibe

The ?$(date +%s) cache-buster ensures you get the latest version, not a cached copy.

For production-like environments where you want standard agent confirmations and no passwordless sudo:

# Safe mode for persistent environments
curl -fsSL "https://raw.githubusercontent.com/Dicklesworthstone/agentic_coding_flywheel_setup/main/install.sh" | bash -s -- --mode safe

For reproducible, stable installs, pin to a tagged release:

# Pin to v0.5.0 for stability
curl -fsSL "https://raw.githubusercontent.com/Dicklesworthstone/agentic_coding_flywheel_setup/v0.5.0/install.sh" | bash -s -- --yes --mode vibe --ref v0.5.0

Before running, validate your system with the preflight check:

curl -fsSL "https://raw.githubusercontent.com/Dicklesworthstone/agentic_coding_flywheel_setup/main/scripts/preflight.sh" | bash

This checks OS compatibility (Ubuntu 22.04+; auto-upgrades to 25.10), architecture (x86_64 or ARM64), minimum 4GB RAM and 10GB disk, network connectivity, APT lock status, and potential conflicts with existing tools like nvm or pyenv.

After installation, verify everything with:

acfs doctor

And configure agent credentials interactively:

acfs services-setup

Real Code Examples

Idempotent Installer with Resume Capability

The core installer design handles interruption gracefully. Here's how the state tracking works:

# The installer is idempotent—if interrupted, simply re-run it.
# It will automatically resume from the last completed phase without prompts.

# Example: installer interrupted during Phase 5 (Language Runtimes)
# Simply re-run the same command:
curl -fsSL "https://raw.githubusercontent.com/Dicklesworthstone/agentic_coding_flywheel_setup/main/install.sh?$(date +%s)" | bash -s -- --yes --mode vibe

# Resumes from Phase 5, skipping already-completed phases 1-4

The ~/.acfs/state.json file persists progress across SSH disconnections and reboots. For forced full reinstalls, add --force-reinstall.

Security Verification Before Execution

ACFS verifies upstream installer integrity before executing:

# List all upstream URLs and their verification status
./scripts/lib/security.sh --print

# Verify current checksums against stored values
./scripts/lib/security.sh --verify

# Generate new checksums after reviewing upstream changes
./scripts/lib/security.sh --update-checksums > checksums.yaml

The checksums.yaml format is straightforward:

# checksums.yaml
installers:
  bun:
    url: "https://bun.sh/install"
    sha256: "a1b2c3d4..."

  rust:
    url: "https://sh.rustup.rs"
    sha256: "e5f6a7b8..."

Vibe Mode Aliases for Agent Workflows

The shell configuration provides dangerous-but-fast aliases:

# Claude Code with max memory and permission bypass
alias cc='NODE_OPTIONS="--max-old-space-size=32768" claude --dangerously-skip-permissions'

# Codex with full filesystem access
alias cod='codex --dangerously-bypass-approvals-and-sandbox'

# Antigravity CLI with locked model and settings
alias agy='$HOME/.local/bin/agy-locked'

These aliases are designed for throwaway VPS environments where recovery means destroying and recreating the instance, not debugging permission denials.

Manifest-Driven Tool Generation

The generator pipeline produces consistent installer scripts:

cd packages/manifest
bun run generate        # Generate scripts from manifest
bun run generate:dry    # Preview without writing files

This produces category scripts like scripts/generated/install_base.sh, install_agents.sh, etc., plus doctor_checks.sh for verification. The production install.sh sources these generated scripts with feature flags during migration.

Advanced Usage & Best Practices

Pin to releases for anything you care about. The main branch moves quickly. For environments you can't easily recreate, use --ref v0.5.0 or a commit SHA. The README explicitly warns that "tagged releases are tested and stable."

Snapshot before Ubuntu upgrades. The automatic upgrade from 24.04 → 25.10 involves multiple reboots and takes 1.5–3 hours. Create a VM snapshot first. The installer handles resume automatically, but snapshots provide escape hatches.

Use --dry-run before batch updates. The acfs-update command supports --dry-run for previewing changes across all tools. This is especially valuable when agents have pending work—you may want to --no-agents to avoid interrupting long-running tasks.

Monitor with acfs continue after reboots. During Ubuntu upgrades, SSH sessions disconnect. Use acfs continue to check upgrade stage, or monitor via journalctl -u acfs-upgrade-resume -f.

Configure DCG before enabling vibe mode. The Destructive Command Guard blocks dangerous git and filesystem operations in Claude Code. Install it via acfs services-setup even in vibe mode—it provides a hook-based safety net that doesn't slow you down.

Comparison with Alternatives

ACFS occupies a distinct niche: it's not just a dev environment, but an agentic workflow operating system with explicit safety tools, session management, and inter-agent communication. The trade-off is tight coupling to Ubuntu and the Dicklesworthstone stack. If you need macOS support or want to bring your own tools, Nix or devcontainers may fit better. If you want managed infrastructure without setup, Codespaces wins. For running multiple AI agents with coordination and guardrails on your own VPS, ACFS is purpose-built.

FAQ

What Ubuntu versions does ACFS support? Ubuntu 22.04+; the installer automatically upgrades to 25.10. Use --skip-ubuntu-upgrade to stay on your current version.

Is the curl | bash pattern safe? ACFS mitigates risks with HTTPS enforcement, SHA256 checksum verification via checksums.yaml, and auditable version control of those checksums. The README acknowledges this is "defense in depth, not elimination of risk."

Can I run ACFS on macOS or Windows? No—Ubuntu VPS only. The wizard website guides you through renting a remote VPS; local installation is not supported.

What happens if an agent update breaks compatibility? acfs-update --agents-only updates each agent through its native mechanism (Claude's built-in updater, Bun for Codex, agy update for Antigravity). Pin to a release tag for stability.

How do I troubleshoot a failed installation? Run acfs doctor for health checks, acfs doctor --fix for safe auto-fixes, or acfs support-bundle to generate diagnostic artifacts. The preflight script catches most issues before install.

What's the license situation with AI agents? ACFS itself is MIT licensed. The "OpenAI/Anthropic Rider" addresses terms-of-service compliance for distributing integrations with proprietary APIs. Review the license file for specifics.

Can I add my own tools to the manifest? Yes—edit acfs.manifest.yaml, regenerate with bun run generate, and the installer will include them. The generator validates with Zod schemas to catch errors early.

Conclusion

Dicklesworthstone/agentic_coding_flywheel_setup solves a genuinely painful problem: the hours of manual configuration between "I want to use AI coding agents" and "agents are actually productive." Its 30-minute promise holds for fresh Ubuntu VPS instances, and the idempotent, resumable design means you can experiment fearlessly.

The tool is best suited for developers who want to run multiple AI agents in parallel on remote infrastructure, teams needing reproducible environments, and beginners willing to follow the wizard-guided path. The vibe/safe mode dichotomy shows clear intent: this is for environments you can destroy and recreate, not your production database server.

The 1,545 stars and active development through mid-2026 suggest real usage, not just repository hype. If you're currently maintaining a spreadsheet of manual setup steps for your agentic workflow, ACFS is worth evaluating.

Get started at https://github.com/Dicklesworthstone/agentic_coding_flywheel_setup or try the interactive wizard at agent-flywheel.com.