From geepers-mcp
Powerful agent combinations that work synergistically when run together.
npx claudepluginhub lukeslp/geepers-mcp --plugin geepers-mcpPowerful agent combinations that work synergistically when run together. --- ``` PARALLEL: scout + planner THEN: conductor (if direction unclear) OR direct to focused agent ``` - **scout** (5 min): Scans project health, identifies issues - **planner** (5 min): Prioritizes tasks, identifies dependencies - Result: Clear picture of current state + roadmap for session - **Sequential**: 15 min (scou...
Master coordinator for complex multi-step tasks: analyzes projects, designs architecture, delegates to specialist subagents via Task, manages parallel execution and GitHub PRs. Invoke proactively for 2+ modules or open-ended 'build/refactor/architecture' requests.
Orchestrates 5-phase agent workflow: sequential Plan, parallel Test/Implementation/Packaging, sequential Cleanup. Delegate for structured project development with agent hierarchy.
Multi-agent orchestrator that coordinates complex tasks across sub-agents in parallel: full feature implementation, large-scale refactors, multi-agent spanning tasks, complex debugging. Synthesizes results with progress tracking.
Share bugs, ideas, or general feedback.
Powerful agent combinations that work synergistically when run together.
PARALLEL: scout + planner
THEN: conductor (if direction unclear) OR direct to focused agent
# Start parallel agents
scout --project=wordblocks
planner --project=wordblocks
# While running, you'll see both:
# - Scout findings (issues, quick wins)
# - Planner recommendations (prioritized tasks)
# Then route based on findings
builder --queue=wordblocks-queue.md # If implementation phase
# OR
orchestrator_quality --findings=scout-report.md # If cleanup needed
1. planner → Create prioritized task queue
2. builder → Implement each item atomically
3. integrator → Verify cross-system integrity
4. critic → Assess architectural impact
5. repo → Clean git history
# Phase 1: Planning
planner --project=corpus --task="Add lemmatization"
# Output: corpus-queue.md with 5 prioritized tasks
# Phase 2: Building
builder --project=corpus --queue=corpus-queue.md
# Implements: DB migration → API endpoint → UI component → tests
# Phase 3: Integration testing
integrator --project=corpus --files="api.py,ui.tsx,schema.py"
# Checks: API works with updated schema, UI calls endpoint correctly
# Phase 4: Architecture review
critic --project=corpus --focus="lemmatization-feature"
# Assesses: Did we add complexity? Is it maintainable?
# Phase 5: Git cleanup
repo --project=corpus --cleanup=true
PARALLEL: scout + critic + testing + security
THEN: orchestrator_quality (synthesize findings)
# Start all audits in parallel
scout --project=wordblocks &
critic --project=wordblocks &
testing --project=wordblocks &
security --project=wordblocks &
# Wait for all to complete, then synthesize
wait
orchestrator_quality \
--scout=reports/scout-wordblocks.md \
--critic=reports/critic-wordblocks.md \
--testing=reports/testing-wordblocks.md \
--security=reports/security-wordblocks.md
PARALLEL: canary + diag + perf
THEN: services (if action needed)
# Morning health check
canary &
diag &
perf &
wait
# If canary found issues, drill deeper
if [ $CANARY_STATUS = "WARN" ]; then
services --action=diagnose --issue=$CANARY_FINDING
fi
1. scout → Identify refactoring opportunities
2. PARALLEL: critic + snippets
3. planner → Prioritize refactoring tasks
4. scalpel → Implement carefully
5. integrator → Verify no regressions
# Phase 1: Identification
scout --project=diachronica --focus="refactoring"
# Finds: 12 opportunities (duplication, long functions, etc)
# Phase 2: Impact assessment (parallel)
critic --project=diachronica &
snippets --project=diachronica --extract=patterns &
wait
# Phase 3: Planning
planner --project=diachronica \
--source=scout-report.md,critic-report.md
# Phase 4-5: Implementation with verification
for task in $(cat diachronica-queue.md | grep "^## ")
do
scalpel --task=$task
integrator --verify-no-regressions
done
PARALLEL: scout + snippets
THEN: docs
# Collect insights
scout --project=diachronica --generate-insights &
snippets --project=diachronica --extract=patterns &
wait
# Generate documentation
docs --project=diachronica \
--insights=scout-report.md \
--patterns=snippets-report.md \
--output=ARCHITECTURE.md
1. diag → Root cause analysis
2. scalpel → Surgical fix
3. testing → Add regression test
4. repo → Document fix
# Diagnose the issue
diag --service=wordblocks --since="2 hours ago"
# Output: "Memory leak in WebSocket handler, lines 234-245"
# Fix with precision
scalpel --file=src/websocket.ts --lines=234-245
# Prevent recurrence
testing --add-regression-test \
--file=test/websocket.test.ts \
--scenario="memory-leak-on-disconnect"
# Document findings
repo --commit-message="fix: Prevent WebSocket memory leak on client disconnect
Root cause: Connection cleanup wasn't removing event listeners.
See diag report from $(date).
Fixes: #2847"
| Goal | Workflow | Time | Complexity |
|---|---|---|---|
| Start session focused | #1 (Startup) | 10 min | Low |
| Build feature right | #2 (Implementation) | 4 hours | High |
| Comprehensive audit | #3 (Quality Sprint) | 45 min | Medium |
| Monitor health | #4 (Health Check) | 8 min | Low |
| Clean up code | #5 (Refactoring) | 5 hours | High |
| Create docs | #6 (Documentation) | 25 min | Low |
| Fix production issue | #7 (Bug Investigation) | 45 min | Medium |
Ensure parallel agents write to different files:
# Good: Different output files
scout --output=reports/scout-{project}.md
planner --output=reports/planner-{project}.md
# Bad: Same output file (conflict)
scout --output=report.md
planner --output=report.md
Respect task dependencies:
# Good: Scout runs first, then Planner sees results
scout && planner
# Bad: Planner runs before Scout findings exist
planner & scout
Use status to track workflow progress:
scout &
planner &
PIDS=$!
status --watch --pids=$PIDS
Run Workflow #4 on schedule:
# In crontab
0 */4 * * * /path/to/workflow-health-check.sh
Use heavier workflows for higher-stakes work:
# Quick fix: Skip Workflow #2, use quickwin
# Major feature: Use full Workflow #2 (Planner → Builder → Integrator)
# Production issue: Use full Workflow #7 (Diag → Fix → Test → Docs)
Solution: Use explicit sequencing
# Bad: No guarantee of order
geepers_agent1 &
geepers_agent2 &
geepers_agent3 &
# Good: Explicit sequence
geepers_agent1 && geepers_agent2 && geepers_agent3
Solution: Design non-overlapping scopes
# Scout analyzes code quality
# Planner creates task queue (different output)
# They don't conflict because different outputs
Solution: Profile and optimize
time scout --project=X
time planner --project=X
# If one is slow, consider parallelizing differently
Last Updated: 2026-01-05 Part of Agent Optimization Analysis