Unheard-of Velocity
in Complex Software
Eight interconnected tools that enable multiple AI agents to work in parallel, review each other's work, and make incredible autonomous progress, all while you're away.
“The magic isn't in any single tool. It's in how they work together. Using three tools is 10x better than using one.”
6+
Parallel agents
8+
Projects simultaneously
2K+
GitHub stars
3+ hrs
Autonomous work
The Agentic Coding Flywheel
Eight tools that create unheard-of velocity
Explore the Flywheel
Click a tool to see its connections and features
A self-reinforcing system that enables multiple AI agents to work in parallel across 8+ projects, reviewing each other's work, creating and executing tasks, and making incredible autonomous progress while you're away.
How the Tools Work Together
These aren't hypothetical scenarios. These are actual daily workflows running across 8+ projects with multiple AI agents.
Daily Parallel Progress
Keep multiple projects moving forward simultaneously, even when you don't have mental bandwidth for all of them.
Come back 3+ hours later to find incredible autonomous progress across all projects
Agents Reviewing Agents
Have your agents review each other's work to catch bugs, errors, and issues before they become problems.
Multiple agents catching each other's errors before they ship
5,500 Lines to 347 Beads
Transform massive planning documents into executable, dependency-tracked task graphs that agents can work through systematically.
Project nearly complete the same day, agents pushing commits while you're in bed
Fresh Eyes Code Review
Have agents deeply investigate code with fresh perspectives, finding bugs that humans miss.
Systematic, methodical bug discovery and correction
The Prompts That Power the Workflow
Copy these prompts to your Stream Deck or command palette. Each takes under a second to execute with a single button press.
Deep Code Exploration
I want you to sort of randomly explore the code files in this project, choosing code files to deeply investigate and understand and trace their functionality and execution flows through the related code files which they import or which they are imported by. Once you understand the purpose of the code in the larger context of the workflows, I want you to do a super careful, methodical, and critical check with "fresh eyes" to find any obvious bugs, problems, errors, issues, silly mistakes, etc. and then systematically and meticulously and intelligently correct them.
When: When you want agents to find hidden bugs and understand the codebase deeply
Agent Peer Review
Ok can you now turn your attention to reviewing the code written by your fellow agents and checking for any issues, bugs, errors, problems, inefficiencies, security problems, reliability issues, etc. and carefully diagnose their underlying root causes using first-principle analysis and then fix or revise them if necessary? Don't restrict yourself to the latest commits, cast a wider net and go super deep!
When: After agents have been working independently, have them review each other
UX/UI Deep Scrutiny
I want you to super carefully scrutinize every aspect of the application workflow and implementation and look for things that just seem sub-optimal or even wrong/mistaken to you, things that could very obviously be improved from a user-friendliness and intuitiveness standpoint, places where our UI/UX could be improved and polished to be slicker, more visually appealing, and more premium feeling and just ultra high-quality, like Stripe-level apps.
When: When dissatisfied with UX but don't have energy to grapple with it directly
Comprehensive Beads Planning
OK so please take ALL of that and elaborate on it more and then create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid, with detailed comments so that the whole thing is totally self-contained and self-documenting (including relevant background, reasoning/justification, considerations, etc.-- anything we'd want our "future self" to know about the goals and intentions and thought process and how it serves the over-arching goals of the project.)
When: After generating improvement suggestions, turn them into actionable tasks
Plan Space Validation
Check over each bead super carefully-- are you sure it makes sense? Is it optimal? Could we change anything to make the system work better for users? If so, revise the beads. It's a lot easier and faster to operate in "plan space" before we start implementing these things!
When: Before executing a large batch of beads, validate the plan
Systematic Bead Execution
OK, so start systematically and methodically and meticulously and diligently executing those remaining beads tasks that you created in the optimal logical order! Don't forget to mark beads as you work on them.
When: After planning and validation, execute the work
Post-Implementation Review
Great, now I want you to carefully read over all of the new code you just wrote and other existing code you just modified with "fresh eyes" looking super carefully for any obvious bugs, errors, problems, issues, confusion, etc. Carefully fix anything you uncover.
When: After a batch of implementation work, review everything
Intelligent Commit Grouping
Now, based on your knowledge of the project, commit all changed files now in a series of logically connected groupings with super detailed commit messages for each and then push. Take your time to do it right. Don't edit the code at all. Don't commit obviously ephemeral files.
When: Final step after all work is done
Using Three Tools is 10x Better Than One
Each tool amplifies the others. The synergies compound over time.
The Core Loop
NTM spawns agents that register with Mail for coordination. They use BV to find tasks to work on. The result: autonomous agents that figure out what to do next without human intervention.
“Spawn 6 agents across 3 projects. Each finds work via BV, coordinates via Mail. You return 3 hours later to merged PRs.”
Collective Memory
CASS indexes all agent sessions for instant search. CM stores learnings as procedural memory. Together: agents that never repeat mistakes and always remember what worked.
“New agent asks 'how did we handle auth?' CASS finds the answer in 60ms. CM surfaces the playbook that worked.”
Safety Net
UBS catches bugs before they're committed. SLB prevents dangerous commands from running without approval. Together: aggressive automation with guardrails.
“Agent finds a bug, wants to `git reset --hard`. SLB requires a second agent to approve. UBS validates the fix before merge.”
Approval Workflow
SLB sends approval requests directly to agent inboxes via Mail. Recipients can review context and approve or reject. Fully auditable decision trail.
“Agent proposes database migration. SLB notifies reviewers via Mail. Second agent reviews diff, approves. Audit log preserved.”
Learned Patterns
BV tracks task patterns and completion history. CM stores what approaches worked. Together: each new task benefits from all past solutions.
“Similar bug appears in new project. CM surfaces the pattern. BV creates bead linking to successful prior fix.”
Account Orchestration
CAAM manages API keys for all your agent accounts. NTM spawns agents with the right credentials automatically. Seamless multi-account workflows.
“Rate limited on one Claude account? NTM spawns agents with fresh credentials from CAAM. No manual switching.”
All Eight Flywheel Tools
Each tool installs in under 30 seconds. Written in Go, Rust, TypeScript, and Python.
Named Tmux Manager
The agent cockpit
Transform tmux into a multi-agent command center. Spawn Claude, Codex, and Gemini agents in named panes. Broadcast prompts to specific agent types. Persistent sessions survive SSH disconnects.
- Spawn multiple agents: ntm spawn project --cc=3 --cod=2 --gmi=1
- Broadcast to agent types: ntm send project --cc 'prompt'
curl --proto '=https' --proto-redir '=https' -fsSL https://r...MCP Agent Mail
Gmail for your agents
A complete coordination system for multi-agent workflows. Agents register identities, send/receive messages, search conversations, and declare file reservations to prevent edit conflicts.
- Agent identities with auto-generated names
- GitHub-flavored Markdown messages with threading
curl --proto '=https' --proto-redir '=https' -fsSL "https://...Ultimate Bug Scanner
Polyglot static analysis
Wraps best-in-class static analyzers (ESLint, Ruff, Clippy, golangci-lint) with consistent JSON output. Sub-5-second feedback loops. Perfect as pre-commit hook or agent post-processor.
- 7 languages: JS/TS, Python, Go, Rust, C/C++, Java, Ruby
- 18 detection categories: security, async bugs, null safety
curl --proto '=https' --proto-redir '=https' -fsSL "https://...Beads Viewer
Task dependency graphs
Transforms task tracking with DAG-based analysis. Nine graph metrics, robot protocol for AI, time-travel diffing. Agents use BV to figure out what to work on next.
- 9 graph metrics: PageRank, Betweenness, HITS, Critical Path
- 6 TUI views: list, kanban, graph, insights, history, flow
curl --proto '=https' --proto-redir '=https' -fsSL "https://...Coding Agent Session Search
Instant search across all agents
Unified search for all AI coding sessions. Indexes Claude, Codex, Cursor, Gemini, ChatGPT, Cline, and more. Tantivy-powered <60ms prefix queries.
- 10 agent formats: Claude Code, Codex, Cursor, Gemini, ChatGPT
- Tantivy search with <60ms prefix queries
curl --proto '=https' --proto-redir '=https' -fsSL https://r...CASS Memory System
Persistent agent memory
Human-like memory for AI agents. Procedural playbooks, episodic session logs, semantic facts. Agents learn from experience and never repeat mistakes.
- ACE pipeline: Generator → Reflector → Validator → Curator
- Playbook bullets with decay (90-day half-life)
curl --proto '=https' --proto-redir '=https' -fsSL https://r...Coding Agent Account Manager
Instant auth switching
Manage multiple API keys for Claude, Codex, and Gemini. Sub-100ms account switching. Smart rotation with cooldown tracking. Encrypted credential bundles.
- Sub-100ms account switching
- Smart rotation: cooldown, health, recency, plan type
curl --proto '=https' --proto-redir '=https' -fsSL "https://...Simultaneous Launch Button
Two-person rule for agents
Safety friction for autonomous agents. Three-tier risk classification. Cryptographic command binding with SHA-256+HMAC. Dynamic quorum. Complete audit trails.
- 3-tier: CRITICAL (2+), DANGEROUS (1), CAUTION (auto-30s)
- SHA-256 command binding (raw + cwd + argv)
curl --proto '=https' --proto-redir '=https' -fsSL https://r...Built From Daily Experience
Unix Philosophy
Each tool does one thing well. They compose through JSON, MCP, and Git.
Agent-First
Every tool has --robot mode. Designed for AI agents to call programmatically.
Self-Reinforcing
The flywheel effect: each tool makes the others more powerful.
Battle-Tested
Born from daily use with 3+ AI agents on production codebases.
Ready to 10x Your Velocity?
The Agent Flywheel installer sets up all flywheel tools automatically. From zero to multi-agent workflows in 30 minutes.