The Agentic Coding FlywheelTL;DR Edition
15 core tools and 7 supporting utilities that transform multi-agent AI coding workflows. Each tool makes the others more powerful - the more you use it, the faster it spins. While others argue about agentic coding, we're just over here building as fast as we can.
Why a Flywheel?
A flywheel stores rotational energy - the more you spin it, the easier each push becomes. These tools work the same way. The more you use them, the more valuable the system becomes.
Every agent session generates searchable history (CASS). Past solutions become retrievable memory (CM). Dependencies surface bottlenecks (BV). Agents coordinate without conflicts (Mail). Each piece feeds the others.
The result: I shipped 20,000+ lines of production Go code in a single day with BV. The flywheel keeps spinning faster - my GitHub commits accelerate each week because each tool amplifies the others.
Lines represent data flow and integration between tools
Core Flywheel Tools(15)
The backbone of multi-agent development: session management, communication, task tracking, static analysis, memory, search, safety guards, multi-repo sync, and automated setup. These tools form a self-reinforcing loop where each makes the others more powerful.
A mail-like coordination layer for multi-agent workflows. Agents send messages, read threads, and reserve files asynchronously via MCP tools - like Gmail for AI coding agents.
Why It's Useful
Critical for multi-agent setups. When 5+ Claude Code instances work the same codebase, they need to coordinate who's editing what. Agent Mail prevents merge conflicts and builds an audit trail of all agent decisions.
Key Features
- Threaded messaging between AI agents
- Advisory file reservations
- SQLite-backed persistent storage
- MCP integration for any compatible agent
Tech Stack
Synergies
A fast terminal UI for viewing and analyzing Beads issues. Applies graph theory (PageRank, betweenness centrality, critical path) to identify which tasks unblock the most other work.
Why It's Useful
Issue tracking is really a dependency graph. BV lets Claude prioritize beads intelligently by computing actual bottlenecks. The --robot-insights flag gives PageRank rankings for what to tackle first.
Key Features
- PageRank-based issue prioritization
- Critical path analysis
- Robot mode for AI agent integration
- Interactive TUI with vim keybindings
Tech Stack
Synergies
Local-first issue tracking for AI agents. SQLite + JSONL hybrid: fast queries locally, git-friendly export for collaboration. Non-invasive - never auto-commits or touches source code.
Why It's Useful
Your issues travel with your repo - no external service required. ~20K lines of Rust focused on one thing: tracking issues without getting in your way. br ready shows actionable work; br sync --flush-only exports for git commit.
Key Features
- Local-first issue storage
- Dependency graph tracking
- Labels, priorities, comments
- JSON output for agents
Tech Stack
Synergies
Blazing-fast search across all your past AI coding agent sessions. Indexes conversations from Claude Code, Codex, Cursor, Gemini, ChatGPT and more with sub-millisecond query times.
Why It's Useful
You've solved this problem before - but which session? CASS lets you search 'how did I fix that React hydration error' and instantly find the exact conversation. Also supports semantic search and multi-machine sync via SSH.
Key Features
- Unified search across all agent types
- Sub-second search over millions of messages
- Robot mode for AI agent integration
- TUI for interactive exploration
Tech Stack
Synergies
One-command bootstrap that transforms a fresh Ubuntu VPS into a fully-configured agentic coding environment with all flywheel tools installed.
Why It's Useful
Setting up a new development environment takes hours. ACFS does it in 30 minutes, installing 30+ tools, three AI agents, and all the flywheel tooling automatically.
Key Features
- 30-minute zero-to-hero setup
- Installs Claude Code, Codex, Gemini CLI
- All flywheel tools pre-configured
- Step-by-step wizard for beginners
Tech Stack
Synergies
Custom pattern-based bug scanner with 1,000+ detection rules across multiple languages. Catches common bugs, security issues, and code smells before they become problems.
Why It's Useful
Instead of managing dozens of separate linters, UBS provides comprehensive bug detection in a single tool. Its pattern-based approach catches issues that traditional static analyzers miss.
Key Features
- 1000+ built-in detection patterns
- Consistent JSON output format
- Multi-language support
- Perfect for pre-commit hooks
Tech Stack
Synergies
Intercepts dangerous shell commands (rm -rf, git reset --hard, etc.) before execution. Requires confirmation for destructive operations.
Why It's Useful
AI agents can and will run 'rm -rf /' if they think it solves your problem. DCG is the safety net that catches catastrophic commands before they execute.
Key Features
- Intercepts rm -rf, git reset --hard, etc.
- SIMD-accelerated pattern matching
- Configurable allowlists
- Command audit logging
Tech Stack
Synergies
Keeps dozens (or hundreds) of Git repositories in sync with a single command. Clones missing repos, pulls updates, detects conflicts.
Why It's Useful
Managing many repos across machines is painful. 'ru sync' handles everything: cloning what's missing, pulling what's stale, and reporting conflicts with resolution commands.
Key Features
- One-command multi-repo sync
- Parallel operations
- Conflict detection with resolution hints
- AI code review integration
Tech Stack
Synergies
A memory system built on top of CASS. Implements three-layer cognitive architecture: Episodic (experiences), Working (active context), and Procedural (skills and lessons learned).
Why It's Useful
Without persistent memory, every agent session starts from scratch. CM lets agents learn from past sessions - remembering what worked, what failed, and extracting reusable playbook rules for future work.
Key Features
- Three memory layers: episodic, working, procedural
- MCP integration for any compatible agent
- Automatic memory consolidation
- Cross-session context persistence
Tech Stack
Synergies
Manages named tmux sessions with project-specific persistence. Creates organized workspaces for multi-agent development with typed panes.
Why It's Useful
When running multiple AI coding agents simultaneously, keeping track of which agent is working on what becomes impossible without organization. NTM solves this by providing persistent, named sessions that survive reboots.
Key Features
- Named agent panes with type classification
- Broadcast prompts to agent types
- Session persistence across reboots
- Dashboard view of active agents
Tech Stack
Synergies
Two-person rule CLI for approving dangerous shell commands. Requires a second human or AI reviewer to approve risky operations before execution.
Why It's Useful
AI agents can accidentally run destructive commands. SLB implements a 'two-person rule' where dangerous commands require explicit approval from another party before executing, preventing catastrophic mistakes.
Key Features
- Two-person rule enforcement
- Command queue with approval workflow
- Pattern-based risk detection
- SQLite persistence
Tech Stack
Synergies
Complete skill management platform: store, search, track effectiveness, package for sharing, and integrate with AI agents via MCP. Skills come from hand-written files, CASS mining, bundles, or guided workflows.
Why It's Useful
AI agents need reusable context to be effective. MS doesn't just store skills—it learns which ones work. Thompson sampling optimizes suggestions over time, security systems (ACIP, DCG) keep content safe, and the MCP server makes skills native to any AI agent.
Key Features
- MCP server for native AI agent integration
- Thompson sampling optimizes suggestions
- Multi-layer security
- Hybrid search with RRF
Tech Stack
Synergies
Offloads Rust compilation to remote workers via transparent cargo interception. Syncs source via rsync, builds remotely, and streams artifacts back.
Why It's Useful
Multi-agent swarms trigger many concurrent builds. RCH transparently routes cargo commands to powerful remote machines, preventing local CPU bottlenecks and dramatically reducing build times.
Key Features
- Transparent cargo interception
- Multi-worker pool with priority scheduling
- Incremental artifact sync
- Daemon mode with status monitoring
Tech Stack
Synergies
Terminal hypervisor that captures pane output in real-time, detects agent state transitions through pattern matching, and enables event-driven automation across multiple AI coding agents.
Why It's Useful
When running multiple AI agents in WezTerm, you need to know when they hit rate limits, complete tasks, or need approval. WA observes all panes with sub-50ms latency and triggers automated responses.
Key Features
- Real-time terminal observation
- Intelligent pattern detection
- Robot Mode JSON API
- Event-driven automation
Tech Stack
Synergies
Research orchestration platform inspired by Sydney Brenner's scientific methodology. Coordinates multi-agent AI research sessions with systematic problem formulation and rigorous constraint-based reasoning.
Why It's Useful
Complex research problems need structured approaches. Brenner Bot combines a curated corpus with multi-model AI syntheses to enable collaborative scientific research conversations with proper citation tracking.
Key Features
- Primary source corpus with citations
- Multi-agent research sessions
- Discriminative test ranking
- Adversarial critique generation
Tech Stack
Synergies
Supporting Tools(7)
Extend the ecosystem with GitHub issue sync, archive search, and prompt crafting utilities. These tools enhance the core flywheel for specialized workflows.
Downloads images from iCloud public share links for use in remote debugging sessions. Converts iCloud URLs to direct image downloads.
Why It's Useful
When debugging remotely via SSH, you can't easily share screenshots. GIIL lets you upload to iCloud, share the link, and the remote machine downloads the image directly for AI agents to analyze.
Key Features
- iCloud share link support
- CLI-based image download
- No browser required
- Works over SSH
Tech Stack
Synergies
Auto-deprioritizes background processes to keep your terminal responsive during heavy builds and multi-agent sessions.
Why It's Useful
When running cargo build, npm install, or multiple AI agents simultaneously, SRPS prevents your system from becoming unresponsive by automatically lowering the priority of known resource hogs.
Key Features
- Automatic process deprioritization
- Real-time TUI monitoring
- 1700+ pre-configured rules
- Custom rule creation
Tech Stack
Synergies
Ultra-fast search over X/Twitter data archives. Indexes tweets, likes, DMs, and Grok chats with hybrid BM25 + semantic search using Reciprocal Rank Fusion.
Why It's Useful
Your X archive is a goldmine of bookmarks, threads, and ideas. XF makes your archive instantly searchable with three modes: hybrid (default), lexical (BM25), and semantic (vector similarity).
Key Features
- Sub-second search over large archives
- Semantic + keyword hybrid search
- No external API dependencies
- Privacy-preserving local processing
Tech Stack
Synergies
Terminal UI for combining source code files into LLM-ready prompts. Select files, preview output, copy to clipboard with token counting.
Why It's Useful
Crafting prompts with code context is tedious. s2p lets you interactively select files, see the combined output, and track token count, all in a beautiful TUI.
Key Features
- Interactive file selection
- Real-time token counting
- Clipboard integration
- Gitignore-aware filtering
Tech Stack
Synergies
Automated iterative specification refinement using extended AI reasoning. Takes rough plans and runs multiple review cycles to identify architectural issues, edge cases, and security flaws.
Why It's Useful
Complex specifications need 15-20 review cycles to catch all issues. Instead of manually prompting each round, APR automates the refinement loop, progressively improving structure and detail.
Key Features
- Automated multi-pass refinement
- Extended AI reasoning integration
- Markdown-based plan processing
- Progressive structure improvement
Tech Stack
Synergies
Official CLI for jeffreysprompts.com - browse, search, and install battle-tested prompts as Claude Code skills with one command.
Why It's Useful
Instead of writing prompts from scratch, install proven patterns. JFP connects to jeffreysprompts.com to discover prompts categorized by use case, then installs them directly to your Claude Code skills folder.
Key Features
- One-command skill installation
- Browsable prompt categories
- Claude Code skills integration
- MCP server for agent access
Tech Stack
Synergies
Find and terminate stuck or zombie processes with intelligent Bayesian scoring. Identifies resource hogs and helps clean up runaway processes.
Why It's Useful
When cargo build hangs, or a test runner goes rogue, pt helps you identify and terminate the offending processes. Uses intelligent scoring to prioritize truly problematic processes.
Key Features
- Intelligent process scoring
- Interactive TUI selection
- Robot mode for automation
- Resource usage analysis
Tech Stack
Synergies
Get Started
The fastest way to set up the entire flywheel ecosystem is with ACFS. One command, 30 minutes, and you're ready to go.
curl -fsSL https://raw.githubusercontent.com/Dicklesworthstone/agentic_coding_flywheel_setup/main/install.sh | bash -s -- --yes --mode vibeOr use the step-by-step wizard for guided setup.