The Agentic Coding FlywheelTL;DR Edition
16 core tools and 24 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.
Tap or hover a tool to see its connections
Core Flywheel Tools
16The 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. HTTP-only FastMCP transport with static export.
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 via advisory file reservations with pre-commit guard enforcement, and builds an audit trail of all agent decisions via SQLite + Git dual persistence.
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.
bv --robot-triageWhy 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 for fast local queries, JSONL export for git-friendly collaboration. Full dependency graph with blocking/blocked-by relationships, priorities P0-P4.
br ready --jsonWhy It's Useful
Your issues travel with your repo - no external service required. Non-invasive design: never runs git commands automatically. Agents can create, update, and close issues with simple CLI commands. The bd alias provides backward compatibility.
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 11 agent formats: Claude Code, Codex, Cursor, Antigravity/Gemini, ChatGPT, Cline, Aider, Pi-Agent, Factory, OpenCode, Amp. Sub-60ms queries with optional semantic search.
cass search "auth error" --robotWhy 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. Three search modes (lexical, semantic, hybrid), HTML export with encryption, 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. CLI provides doctor (47+ health checks), update (category-specific), cheatsheet (50+ aliases), and session management.
Why It's Useful
Setting up a new development environment takes hours. ACFS does it in 30 minutes, installing 35+ tools, six AI agent CLIs (three by default, three optional), and all flywheel tooling. Post-install CLI provides `acfs doctor` for health checks and `acfs update` for maintenance.
Key Features
- acfs doctor: 47+ health checks across 7 categories
- acfs doctor --deep: Functional tests (auth, DB connectivity)
- acfs update: Category-specific with --dry-run preview
- acfs cheatsheet: 50+ aliases for modern CLI tools
- acfs dashboard: Static HTML dashboard generation
- Update logging to ~/.acfs/logs/updates/
Tech Stack
Synergies
A meta-runner that fans out per-language scanners across 8 languages (JS/TS, Python, Go, Rust, C/C++, Java, Ruby, Swift). Uses ast-grep for AST-based pattern matching with 18 detection categories and 1000+ bug patterns.
ubs file.tsWhy It's Useful
AI coding agents move 10-100x faster than humans. UBS keeps pace with sub-5-second scans and auto-wires guardrails into Claude Code, Codex, Cursor, Antigravity, and Windsurf agents. The --beads-jsonl output creates Beads issues directly from findings.
Key Features
- 1000+ built-in detection patterns
- Consistent JSON output format
- Multi-language support
- Perfect for pre-commit hooks
Tech Stack
Synergies
Claude Code PreToolUse hook that blocks dangerous commands BEFORE execution. 50+ packs across 17 categories: git (reset --hard, force push), filesystem (rm -rf), databases (DROP TABLE), Kubernetes, cloud providers, and more.
dcg doctorWhy It's Useful
AI agents can and will run 'rm -rf /' if they think it solves your problem. DCG catches catastrophic commands before they execute with sub-millisecond latency. Safe directory exceptions (/tmp, /var/tmp, $TMPDIR) allow temp operations without friction.
Key Features
- Intercepts rm -rf, git reset --hard, etc.
- SIMD-accelerated pattern matching
- Configurable allowlists
- Command audit logging
Tech Stack
Synergies
Multi-repo management system: sync 100+ repos, AI-assisted code review with priority scoring, dependency updates across package managers, and agent-driven commit automation.
ru sync --parallel 4Why It's Useful
Managing 100+ repos manually is impossible. 'ru sync' handles clone/pull in parallel. 'ru review' discovers issues/PRs via GraphQL batch queries, scores by priority (security+50, bugs+30, age), and spawns isolated Claude Code sessions in worktrees.
Key Features
- One-command multi-repo sync
- Parallel operations
- Conflict detection with resolution hints
- AI code review integration
Tech Stack
Synergies
Cross-agent procedural memory system. Transforms scattered sessions from all your AI agents into persistent, unified knowledge. Three-layer cognitive architecture: Episodic (raw sessions via CASS) → Working (diary summaries) → Procedural (playbook rules with confidence tracking).
cm context "task" --jsonWhy It's Useful
A debugging technique discovered in Cursor is immediately available to Claude Code. Rules have 90-day decay half-life and 4× harmful weight for mistakes. Bad rules auto-invert into anti-pattern warnings. Every agent learns from every other agent's experience.
Key Features
- Three memory layers: episodic, working, procedural
- MCP integration for any compatible agent
- Automatic memory consolidation
- Cross-session context persistence
Tech Stack
Synergies
A multi-agent tmux orchestration tool with 80+ commands. Spawns Claude, Codex, and Antigravity agents in named panes with type classification (cc/cod/agy). Monitors context windows, detects file conflicts, and provides robot mode for automation.
Why It's Useful
Running multiple AI agents simultaneously creates chaos without orchestration. NTM provides the command center: spawn agents with one command, broadcast prompts to specific types, monitor context usage, and coordinate via Agent Mail. Sessions persist across SSH disconnects and system 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
Nuclear-launch-style two-person rule for dangerous commands. Four risk tiers classify commands via 40+ regex patterns: CRITICAL (2+ approvals), DANGEROUS (1 approval), CAUTION (30s auto-approve), SAFE (skip). Cryptographic signing, rollback support, and outcome analytics.
Why It's Useful
AI agents can and will run destructive commands if they think it solves your problem. SLB intercepts commands like 'rm -rf /', 'DROP DATABASE', and 'terraform destroy' requiring explicit approval from another agent or human reviewer before execution. Watch mode lets reviewing agents stream pending requests.
Key Features
- Two-person rule enforcement
- Command queue with approval workflow
- Pattern-based risk detection
- SQLite persistence
Tech Stack
Synergies
Local-first skill management platform: dual persistence (SQLite + Git), hybrid search (BM25 + semantic + RRF), UCB bandit optimization, multi-layer security (ACIP + DCG), graph analysis via bv, MCP server for AI agents.
Why It's Useful
AI agents need reusable context to be effective. MS doesn't just store skills—it learns which ones work via UCB bandit optimization. Context-aware auto-loading suggests skills based on project type. Pack contracts optimize token budgets. The MCP server makes skills native tools for 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
Claude Code PreToolUse hook that offloads Rust compilation to remote workers. Intercepts cargo commands, syncs source via rsync + zstd, compiles on server-grade hardware, streams artifacts back.
rch statusWhy It's Useful
Multi-agent swarms trigger many concurrent builds. RCH intercepts commands before execution and routes them to remote workers with health probes and priority scheduling. Agent detection coordinates builds across Claude Code, Codex, and Antigravity sessions.
Key Features
- Transparent cargo interception
- Multi-worker pool with priority scheduling
- Incremental artifact sync
- Daemon mode with status monitoring
Tech Stack
Synergies
Manages multiple accounts for Claude Code, Codex CLI, and Antigravity CLI with sub-100ms switching. Vault profiles store auth files for instant activation without browser flows. Smart rotation algorithms automatically select the best profile based on cooldown state, health, and usage patterns.
caam statusWhy It's Useful
When running multiple agents, you'll hit rate limits. CAAM lets you switch accounts instantly - no browser login, no waiting. Profile isolation enables parallel sessions where each agent uses its own credentials. Health scoring (🟢/🟡/🔴) shows which profiles are ready vs. cooling down.
Key Features
- Sub-100ms account switching
- Multi-provider support
- Automatic key rotation
- Session state preservation
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
Multi-agent scientific research orchestration platform based on Sydney Brenner's methodology. Manages full research artifact lifecycle: hypotheses, discriminative tests, anomalies, critiques, and evidence packs with cockpit runtime for parallel agent sessions.
Why It's Useful
Transforms AI agents into a collaborative research group with rigorous scientific discipline. The Brenner approach emphasizes exclusion over accumulation, third-alternative thinking, and discriminative experiments that collapse hypothesis space fast.
Key Features
- Primary source corpus with citations
- Multi-agent research sessions
- Discriminative test ranking
- Adversarial critique generation
Tech Stack
Synergies
Supporting Tools
24Extend the ecosystem with GitHub issue sync, archive search, and prompt crafting utilities. These tools enhance the core flywheel for specialized workflows.
Downloads full-resolution images from iCloud, Dropbox, Google Photos, and Google Drive share links using a four-tier capture strategy with headless Chromium automation.
Why It's Useful
When debugging remotely, users share cloud links but you're SSH'd into a headless server. GIIL's four-tier capture (download button → CDN interception → element screenshot → viewport fallback) ensures maximum quality retrieval for AI agent analysis.
Key Features
- iCloud share link support
- CLI-based image download
- No browser required
- Works over SSH
Tech Stack
Synergies
Installs ananicy-cpp with curated rules to auto-deprioritize background processes. Includes sysmoni Go TUI (Bubble Tea) with IO throughput, FD counts, per-core sparklines, JSON export. Works on Linux and WSL2.
Why It's Useful
When running cargo build, npm install, or multiple AI agents, SRPS prevents unresponsive systems by lowering priority of known resource hogs. Safety-first: no automated process killing. Helper tools for diagnostics.
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 with sub-millisecond latency. Uses hybrid BM25 + semantic search with Reciprocal Rank Fusion. Indexes tweets, likes, DMs, and Grok conversations.
Why It's Useful
Your X archive is a goldmine of bookmarks, threads, and ideas, but Twitter's search is terrible. XF makes your archive instantly searchable (<10ms) with both keyword and semantic matching. DM context search shows full conversation threads.
Key Features
- Sub-second search over large archives
- Semantic + keyword hybrid search
- No external API dependencies
- Privacy-preserving local processing
Tech Stack
Synergies
World-class terminal UI for combining source code files into LLM-ready prompts. Tree explorer with vim-style navigation, live syntax preview, token counting, and structured XML-like output optimized for AI parsing.
Why It's Useful
Crafting prompts with code context is tedious and error-prone. S2P provides visual file selection with sizes and line counts, real-time token/cost estimation, quick file-type shortcuts (1-9,0,r), and produces structured output that LLMs parse reliably.
Key Features
- Interactive file selection
- Real-time token counting
- Clipboard integration
- Gitignore-aware filtering
Tech Stack
Synergies
Iterative specification refinement via GPT Pro 5.2 Extended Reasoning + Oracle. Document bundling (README + spec + impl), convergence analytics with weighted scoring, session management, and robot mode JSON API for coding agents.
Why It's Useful
Complex specs need 15-20 review cycles. APR automates the loop: rounds 1-3 fix architecture, 4-7 refine interfaces, 8-12 handle edge cases, 13+ polish abstractions. Convergence score (≥0.75 = stable) tells you when to stop.
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. Features interactive fzf-style picker and task-based suggestion engine.
Why It's Useful
Instead of writing prompts from scratch, install proven patterns. The interactive mode (jfp i) lets you fuzzy-search the entire library, while jfp suggest recommends prompts based on your task description. Premium features include collections, cross-machine sync, and a skills marketplace.
Key Features
- One-command skill installation
- Browsable prompt categories
- Claude Code skills integration
- MCP server for agent access
Tech Stack
Synergies
Bayesian-inference zombie/abandoned process detection using four-state classification (Useful, Useful-but-bad, Abandoned, Zombie) with evidence-based posterior probability scoring.
pt scan --format jsonWhy It's Useful
When builds hang or test runners go rogue, PT computes P(state|evidence) using process type, age, CPU/IO activity, memory, and past decisions. Confidence levels (very_high >0.99 to low <0.80) guide safe termination with identity validation and staged kill signals.
Key Features
- Intelligent process scoring
- Interactive TUI selection
- Robot mode for automation
- Resource usage analysis
Tech Stack
Synergies
Token-optimized notation format for efficient LLM context packing. Compresses structured data into a dense format that maximizes information per token.
Why It's Useful
LLM context windows are precious. TRU compresses JSON, YAML, and other structured data into a compact notation that conveys the same information in fewer tokens, letting you fit more context into each request.
Key Features
- 40-70% token count reduction
- Multi-language support
- Token count statistics
- Reversible compression
Tech Stack
Synergies
Transparent HTTP/HTTPS proxy for debugging and inspecting network traffic. Routes requests through a local proxy for analysis.
Why It's Useful
When debugging API integrations or AI agent network calls, you need visibility into what's being sent and received. Rust Proxy provides transparent interception without modifying your code.
Key Features
- Transparent HTTP/HTTPS proxying
- Request/response logging
- Latency measurement
- Header inspection
Tech Stack
Synergies
Network observer for AI CLI tools that logs requests and responses without proxying. Passive monitoring of LLM API traffic.
Why It's Useful
Understanding what your AI agents are actually sending to APIs helps with debugging, cost tracking, and optimization. RANO passively observes network traffic without adding proxy overhead.
Key Features
- Transparent HTTP proxy interception
- Provider-aware log parsing
- Token and cost tracking
- Real-time traffic monitoring
Tech Stack
Synergies
Converts websites to clean Markdown for LLM consumption. Strips ads, navigation, and boilerplate to extract just the content.
Why It's Useful
AI agents need web content in a format they can understand. MDWB fetches pages and converts them to clean Markdown, perfect for feeding into LLM context windows.
Key Features
- Clean content extraction
- Code block preservation
- Link handling
- Pipe-friendly output
Tech Stack
Synergies
Fixes malformed ASCII art diagrams generated by AI. Corrects alignment, box characters, and connection lines.
Why It's Useful
AI models often generate ASCII diagrams with alignment issues, broken lines, or inconsistent characters. AADC automatically detects and fixes these problems.
Key Features
- Auto-repair box alignment
- Connector line fixing
- Before/after diff preview
- Clipboard integration
Tech Stack
Synergies
Tracks LLM provider usage across multiple coding agents. Monitors API calls, token consumption, and costs.
Why It's Useful
When running multiple AI agents simultaneously, costs can spiral. CAUT provides visibility into which agents are using how many tokens and at what cost.
Key Features
- Multi-provider usage aggregation
- Per-session token breakdown
- Cost estimation and trends
- Export to CSV/JSON
Tech Stack
Synergies
Cross-provider AI coding session resumption — convert and resume sessions across providers (casr)
casr resume cod <session-id>Why It's Useful
Resume coding sessions across AI providers
Key Features
- Cross-provider session conversion
- Canonical session model
- 14+ provider support
- Session diff and merge
Tech Stack
Fallback release infrastructure — local builds via act when GitHub Actions is throttled (dsr)
dsr release ntm 1.2.3Why It's Useful
Fallback release infra when CI is throttled
Key Features
- Reuses existing GitHub Actions YAML
- Local builds via nektos/act
- Multi-platform support
- Artifact signing with minisign
Tech Stack
Durable, local-first, explainable memory for coding agents (ee)
ee pack "fix the auth bug"Why It's Useful
Durable, explainable local memory for coding agents
Key Features
- Hybrid BM25 + local vector retrieval with explainable scores
- Typed durable memories with confidence decay
- CASS session import turns agent history into evidence
- Token-budgeted context packs with deterministic hashes
Tech Stack
Pure-Rust Markdown engine rendering self-contained HTML and tagged PDF (fmd)
fmd README.md --out README.htmlWhy It's Useful
One binary turns Markdown into polished HTML and PDF
Key Features
- Self-contained HTML with inlined CSS, fonts, and dark mode
- Tagged compact PDF with real typography from the same AST
- Deterministic renders: same input yields same bytes
- Clean-room syntax highlighting plus Mermaid and SVG fidelity
Tech Stack
Two-tier hybrid local search — lexical (BM25) + semantic retrieval with progressive delivery (fsfs)
fsfs search "query"Why It's Useful
Two-tier hybrid search with progressive delivery
Key Features
- BM25 lexical + semantic retrieval
- Progressive delivery (fast initial + quality refinement)
- Local ML model support
- JSON API for agent integration
Tech Stack
Post-compaction reminder hook for Claude Code that forces an AGENTS.md re-read
printf '{"session_id":"demo","source":"compact"}\n' | claude-post-compact-reminderWhy It's Useful
Stop Claude from forgetting project rules after compaction
Key Features
- Auto-detects compaction events
- Injects AGENTS.md re-read reminder
- Zero overhead when not compacting
- Configurable reminder text
Tech Stack
Native single-binary Rust port of the Pi coding agent (pi)
pi "refactor this function"Why It's Useful
Native single-binary coding agent with local model support
Key Features
- Streaming responses with inline extended thinking
- Full built-in toolset plus Markdown-defined Rust subagents
- Multi-provider support including zero-config local models
- Capability-gated extensions with two-stage exec mediation
Tech Stack
Recover crashed coding-agent sessions after a hard power cut (pfr)
pfr --dry-runWhy It's Useful
Bring a whole agent fleet back after a blackout
Key Features
- Pre-boot mtime crash-cluster detection with scored confidence
- Frozen recovery plans so discovery and reopening are repeatable
- Model-matched resume commands for Codex and Claude Code
- Post-open verification against ps with a JSON report
Tech Stack
Cross-platform disk-pressure defense for AI coding workloads (sbh)
sbh statusWhy It's Useful
Predictive disk-pressure defense for AI workloads
Key Features
- Predictive disk space monitoring
- Safe cleanup policies
- Ballast file release
- Explainable policy decisions
Tech Stack
Chat Shared Conversation to File - convert AI share links to Markdown/HTML
Why It's Useful
Convert AI chat share links to Markdown and HTML
Key Features
- Multi-provider support (ChatGPT, Claude, Gemini, Grok)
- Dual Markdown + HTML output
- Code block preservation
- Batch URL processing
Tech Stack
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.