@ruvnet

reasoningbank-with-agentdb enables adaptive learning for agents via vector-backed pattern storage, trajectory tracking, verdict judgment, and memory distillation with claimed 150x-500x performance gains over legacy implementations.

agentdb-advanced-features covers quic synchronization, multi-database sharding, custom distance metrics, hybrid vector-metadata search, and production patterns like connection pooling and error handling for distributed ai systems.

agentdb-performance-optimization covers quantization, hnsw indexing, caching, and batch operations to reduce memory 4-32x and accelerate vector search to sub-millisecond latency. provides configuration recipes for speed, accuracy, and memory-constrained deployments.

ruvnet-browser automates web interactions via element refs and ai-optimized snapshots, reducing context overhead. targets claude-flow agents with mcp tool bindings and multi-session support for parallel work.

agent-refinement covers iterative code improvement via test-driven development, refactoring, and performance tuning within the sparc methodology framework. provides concrete examples of tdd workflows and error handling patterns but lacks clear invocation contract and trigger specificity.

ruvnet-v3-ddd-architecture defines modular domain decomposition for claude-flow v3, splitting a 1440-line god object into bounded contexts with clean layering and event-driven communication patterns. lacks concrete execution steps and failure recovery guidance.

agent-tester provides comprehensive testing patterns across unit, integration, e2e, performance, and security domains. includes concrete code examples and coverage metrics, but lacks clear invocation intent and actionable decision workflows.

stream-chain orchestrates sequential multi-agent workflows where each step receives prior output as context. supports custom prompt chains and four predefined pipelines (analysis, refactor, test, optimize) with configurable timeouts and verbosity.

agent-architecture provides a reference system design template covering microservices, data modeling, kubernetes deployment, and security patterns. useful as a starting point but lacks executable procedures and clear failure recovery paths.

agentdb-memory-patterns covers persistent memory management for ai agents with session storage, pattern learning, and hierarchical organization. includes cli tooling, learning plugins, and reasoning modules for context synthesis.

skill-builder scaffolds claude code skills with yaml frontmatter and markdown structure. covers directory setup and basic skill anatomy but lacks depth on validation and failure scenarios.

pair-programming offers ai-assisted collaborative development with driver/navigator role switching, real-time code review, quality scoring, and testing workflows. lacks procedural specificity and concrete trigger examples.

agent-planner decomposes complex tasks into phases with dependency mapping and resource allocation, outputting structured plans with risk mitigation and success criteria.

agent-arch-system-design covers system architecture and design patterns with trigger patterns for microservices and scalability work. lacks concrete procedural steps and edge case handling for actual decision-making workflows.

agent-orchestrator-task coordinates complex objective decomposition, execution planning, and result synthesis across multiple agents using parallel and sequential strategies with memory-backed progress tracking.

agent-production-validator scans codebases for mock implementations and validates against real infrastructure (databases, apis, smtp). provides code examples but lacks clear invocation patterns and systematic decision logic.

agentdb-learning-plugins wraps 9 reinforcement learning algorithms (decision transformer, q-learning, sarsa, actor-critic, and others) behind a cli and api for training autonomous agents on collected experiences. covers offline rl, value-based learning, and policy gradients with wasm-accelerated inference.

reasoningbank-intelligence provides adaptive learning for agents via pattern recognition, strategy optimization, and continuous improvement. integrates with agentdb for persistent experience storage and meta-cognitive decision-making.

researcher is a code analysis and pattern recognition agent that gathers information across codebases, maps dependencies, and synthesizes findings into structured reports for downstream agents.

sparc-methodology provides a five-phase workflow (specification, pseudocode, architecture, refinement, completion) for structured complex implementation planning, with cli commands and agent coordination but limited procedural detail.

agent-data-ml-model covers end-to-end ml workflows including preprocessing, model selection, training, and evaluation. requires human approval for production deployment and delegates to specialized data agents.

flow-nexus-neural covers neural network training and deployment across single nodes and distributed E2B sandbox clusters, with support for multiple architectures, template marketplace integration, and federated learning. actual capability depth and production readiness remain unclear.

agent-analyze-code-quality evaluates codebases for quality issues, smells, and technical debt across multiple languages. it scans allowed directories, identifies complexity and anti-patterns, and suggests refactoring opportunities with severity ratings.

agent-performance-benchmarker measures throughput, latency, and resource utilization across consensus protocols with adaptive load generation. provides phase-level latency breakdown and comparative analysis but lacks concrete invocation guidance.

ruvnet-agent-analyze-code-quality provides code review triggers and metadata structures but lacks actionable procedures. the skill defines what to detect (code smells, complexity) without specifying how the agent executes analysis or handles partial failures.

claims provides a role-based access control framework for agent operations, mapping seven permission types (read, write, execute, spawn, memory, network, admin) to scoped resources via CLI commands. lacks procedural depth and failure handling.

agent-tdd-london-swarm documents london school mockist tdd patterns with code examples, but lacks actionable procedure for actual swarm invocation and omits failure handling.

workflow-automation provides command-line tooling for orchestrating multi-step processes with named agents and dependency graphs, but lacks concrete guidance on error handling, timeout behavior, or recovery patterns.

agent-github-pr-manager coordinates pull request workflows including creation, review assignment, merge strategy selection, and ci-cd integration via gh cli, with multi-agent review coordination for complex scenarios.

v3-security-overhaul coordinates threat modeling, cve remediation, and security testing via delegated agents. lacks concrete step-by-step execution paths and operational clarity.

security-audit lists cli commands for scanning vulnerabilities, cve detection, and input validation, but lacks procedural depth on execution sequencing, failure handling, or interpreted outcomes.

agent-hierarchical-coordinator delegates work across specialized agent types (researcher, coder, analyst, tester) using a queen-led swarm model. execution relies on mcp__claude-flow__ tool calls that may not exist in all environments, limiting practical portability.

agent-reviewer outlines a code review process with checklists for functionality, security, performance, and maintainability, but lacks concrete trigger conditions, clear decision-points, and explicit failure recovery paths.

swarm-init coordinates multi-agent initialization with topology selection (hierarchical, mesh, star, ring) and enforces memory-based inter-agent communication via the coordination namespace. lacks concrete procedural steps and executable decision logic.

release-manager automates multi-package version coordination and deployment via ruv-swarm orchestration. covers branch creation, validation, and pr automation but lacks specificity on when/how to invoke and what actually fails.

flow-nexus-platform provides broad coverage of a proprietary platform's core functions, but lacks actionable depth in procedures and fails to specify authentication flows, sandbox commands, or deployment mechanics.

agent-base-template-generator produces starter templates for react components, api endpoints, and project structures. lacks explicit procedure steps, decision logic, and failure handling. vague on what templates are actually generated.

v3-cli-modernization outlines cli refactoring with interactive prompts and modular decomposition, but lacks concrete procedures, error handling specifics, and testable criteria.

ruvnet-agent-production-validator provides test patterns and shell commands for scanning mock implementations and validating real database/api integrations. lacks actionable decision logic, trigger specificity, and explicit failure recovery strategies.

gossip-coordinator outlines distributed consensus via epidemic protocols but lacks concrete invocation patterns, step-by-step procedures, and failure recovery specifics needed for operational deployment.

swarm-advanced covers initialization and basic mesh topology setup for multi-agent workflows, but the skill is incomplete, lacking actionable procedures, failure handling, and concrete use-case examples.

agent-raft-manager coordinates raft consensus operations including leader election, log replication, and membership changes for distributed systems. implementation details are architectural rather than procedurally actionable.

agent-quorum-manager coordinates dynamic quorum adjustment for distributed consensus. it calculates optimal quorum via multiple strategies (network, performance, fault tolerance) and applies changes with validation. code-heavy but lacks operational clarity on invocation.

ruvnet-agent-planner provides task decomposition, dependency mapping, and resource allocation for multi-step orchestration. outputs yaml-structured plans with phases, critical paths, and risk mitigation. lacks concrete trigger conditions and failure recovery specifics.

ruvnet-agent-code-analyzer describes a code quality inspection agent with broad surface-level capability claims but no concrete input contracts, decision logic, or failure handling.

sparc-coordinator describes a five-phase methodology framework (specification, pseudocode, architecture, refinement, completion) with quality gates and agent coordination patterns. lacks concrete invocation details and actionable step sequences.

ruvnet-agent-researcher outlines a code analysis and pattern recognition workflow with memory coordination, but lacks concrete decision logic, failure handling, and specificity around invocation and success criteria.

agent-code-analyzer performs static code quality assessment including complexity, security, and performance analysis, but lacks concrete invocation patterns and explicit error handling paths.

hooks-automation describes an automated coordination layer for claude code operations via pre/post hooks and mcp integration, but lacks specifics on actual implementation, trigger conditions, failure handling, and measurable outcomes.

memory-management wraps an agentdb vector search backend with hnsw indexing for pattern retrieval and semantic lookup across distributed agents, but lacks procedural detail and failure handling.

agent-code-review-swarm deploys specialized ai agents for code review via swarm orchestration. lacks procedural detail, concrete trigger definition, and failure handling guidance.

swarm-orchestration coordinates multi-agent task decomposition across codebases using hierarchical topology, but lacks procedural detail and failure handling.

agent-swarm-pr coordinates multi-agent code review and pr lifecycle management via github integration, but lacks actionable structure and concrete failure handling.

byzantine-coordinator describes consensus protocol orchestration with malicious actor detection, but lacks actionable procedures and concrete invocation patterns needed for actual deployment.

hive-mind-advanced describes a queen-led multi-agent coordination pattern with byzantine consensus and shared memory, but lacks procedural detail, concrete examples, and failure mode analysis.

agent-benchmark-suite provides performance benchmarking and regression detection capabilities, though lacks concrete procedures, trigger specifications, and failure handling details.

github-project-management claims to coordinate issue tracking and project board automation via swarm orchestration, but the provided content is a stub with one code example and no actionable procedure, decision logic, or failure handling.

agent-v3-integration-architect outlines a migration strategy to consolidate claude-flow into agentic-flow@alpha, targeting 10,000+ lines of code reduction through adapter layers and phased integration. the document is aspirational rather than immediately executable.

github-automation covers pr creation, issue management, code review, and release workflows via cli commands and agent types, but lacks actionable procedures and failure handling.

agent-load-balancer provides abstract load-balancing algorithms and data structures (work-stealing, weighted fair queuing, circuit breaker) without a runnable procedure, invocation contract, or actual integration points that work.

release-swarm declares intent to orchestrate multi-platform software releases via ai swarms but provides no actionable procedure, decision logic, or outcome definition beyond a tool list.

agent-authentication is a flow nexus platform handler for login, registration, session management, and account operations. lacks concrete procedures, decision logic, and failure mode guidance.

agent-ops-cicd-github is a GitHub Actions workflow agent with minimal documented procedure. trigger phrases exist but no actionable steps, decision points, output contracts, or failure handling are specified.

worker-benchmarks wraps a command-line performance testing suite for agentic-flow workers, covering trigger detection, registry, agent selection, and concurrency. missing intent clarity, input validation details, success criteria, and failure handling.

agent-performance-optimizer claims capability in bottleneck identification and resource analysis, but lacks concrete procedures, decision logic, input/output contracts, or failure recovery patterns.

agent-consensus-coordinator claims expertise in byzantine fault tolerance and distributed consensus but provides no concrete workflow, decision logic, or actionable procedure. reads as aspirational capability listing rather than invocable skill.

agent-neural-network claims expertise in distributed ml orchestration and model lifecycle management but provides no actionable procedures, trigger phrases, or concrete decision logic. reads as a role description rather than an executable skill.

backend-dev is a declarative agent config that claims self-learning via nonexistent agentic-flow apis. trigger coverage is broad but vague. procedure is pseudocode theater with no actionable steps. edge cases absent. marketing language dominates substance.

agent-resource-allocator presents pseudocode for adaptive resource allocation, predictive scaling, and circuit breaker patterns. lacks invocation examples, concrete trigger phrases, failure mode documentation, and executable procedures.

agent-github-modes claims comprehensive github integration across workflows, prs, and releases but provides no actionable procedure, decision logic, or output contract. the skill is mostly capability list.

sparc-coder claims tdd-driven code generation with test implementation and refactoring, but the skill.md is incomplete, lacking executable procedure and clear decision logic.

swarm-memory-manager claims to coordinate distributed memory across agents with caching and synchronization, but the skill lacks actionable procedures, real trigger conditions, and concrete failure handling. mostly aspirational pseudo-code without executable steps.

agent-performance-monitor is a pseudocode-heavy design document that outlines performance monitoring capabilities (metrics collection, bottleneck detection, sla monitoring, anomaly detection) but lacks actionable invocation procedures, concrete trigger phrases, failure handling, and implementation clarity.

neural-training provides pattern optimization via SONA, MoE, and EWC++ with HNSW retrieval. covers model training, routing, and catastrophic forgetting prevention through command-line interface.

agent-coordination provides command syntax and agent type taxonomy for spawning multi-agent systems, but lacks executable procedures, failure modes, and concrete coordination logic.

agent-crdt-synchronizer declares support for conflict-free replicated data types and eventual consistency but provides no actionable procedure, decision logic, or output contract to invoke or validate synchronization behavior.

worker-specialist describes a task execution agent that reports progress via memory coordination, but lacks actionable procedures, concrete trigger phrases, and realistic failure handling. the spec reads as aspirational architecture rather than implementable skill.

agent-coder is a metadata stub claiming code generation and refactoring capabilities but provides no actionable procedure, decision logic, or output contract. the pre-hook is a shell snippet with no binding to actual skill execution.

agent-swarm describes aspirational multi-agent orchestration capabilities without actionable procedures, concrete inputs, outputs, or decision logic. deployment and coordination mechanics remain unspecified.

agent-v3-memory-specialist claims to unify memory systems via agentdb and hnsw indexing, referencing adrs 006 and 009, but provides no actionable steps, decision logic, or failure handling.

ruvnet-agent-repo-architect claims multi-repo management and structure optimization but lacks concrete intent definition, actionable decision logic, and failure handling. the skill reads as capability wish-list rather than executable procedure.

agent-v3-performance-engineer claims aggressive performance targets across flash attention, search, and memory optimization but lacks actionable procedures, trigger clarity, and failure handling. benchmark code examples are pseudocode without implementation.

ruvnet-github-project-management presents swarm-coordinated issue and board automation for github projects, but relies heavily on nonexistent cli tools and lacks concrete failure handling or tested workflows.

marketing copy masquerading as a skill definition. no actionable procedure, no clear intent structure, no trigger phrases, no input/output contract, no worked example.

sync-coordinator claims to manage multi-repository version alignment and dependency synchronization using swarm orchestration, but provides mostly pseudocode examples with unvalidated tool calls and no concrete failure modes or recovery verification.

agent-memory-coordinator describes a distributed memory system for cross-session persistence and inter-agent knowledge sharing, but lacks concrete invocation mechanics, actionable procedures, and error handling specifics.

agent-swarm-issue describes github issue-based multi-agent coordination with task decomposition and progress tracking. content is heavily bash-script focused and lacks actionable intent definition or clear decision logic.

multi-repo-swarm describes cross-repository orchestration via gh cli and a fictional ruv-swarm npm package, with bash examples for dependency updates and pr creation across repos. concrete procedures exist but rely on undocumented tooling.

agent-goal-planner promises GOAP-based replanning but provides no actual procedure, decision logic, or invocation contract. reads as concept documentation rather than implementable skill.

v3-deep-integration promises architectural refactoring of claude-flow via agentic-flow@alpha but lacks operational definition, concrete procedures, and failure handling for this complex cross-vendor integration.

agent-workflow describes event-driven workflow automation with agent coordination and message queue processing, but lacks concrete procedural steps, specific trigger examples, or actionable implementation guidance.

safla-neural claims to build self-aware feedback agents with persistent memory and autonomous learning. no concrete invocation examples, implementation steps, or operational constraints provided.

agent-sandbox provides high-level responsibilities for e2b sandbox management but lacks concrete procedures, decision logic, input schemas, and failure handling needed for reliable skill invocation.

agent-security-manager declares broad security intentions (cryptographic verification, attack detection, key management) but provides no actionable procedures, decision logic, or concrete output contracts. metadata-heavy, execution-empty.

metadata and shell scaffolding masquerading as agent skill definition. lacks actual orchestration intent, step procedures, decision trees, or output contract. incomplete artifact.

ruvnet-github-code-review promises multi-agent code review coordination across security, performance, and architecture domains but lacks concrete procedural steps, actionable decision logic, error handling, and proof that the referenced ruv-swarm CLI tools actually exist or work as documented.

agent-topology-optimizer appears to be code scaffolding rather than a callable skill; no clear invocation contract, intent, input schema, or outcome signal defined. the document reads as architectural pseudocode for topology systems without actionable procedures.

ruvnet-agent-trading-predictor claims to exploit temporal advantages and light-speed latency arbitrage for high-frequency trading, but lacks actionable procedures, realistic risk controls, and grounding in actual market mechanics.

ruvnet-agent-test-long-runner is a generic long-task executor with no concrete intent, no measurable inputs, and no decision logic. it reads as motivational advice rather than an actionable skill definition.

vague orchestration skill with incomplete implementation covering hive-mind decision-making; missing concrete trigger phrases, actionable procedures, and edge case handling.

agent-trading-predictor claims to exploit temporal advantages and sublinear algorithms for high-frequency trading, but provides no actionable procedure, input specification, or outcome metrics.

agent-user-tools is a vague generalist wrapper claiming user management and storage duties without specifying what it actually does, how it integrates, or what triggers its behavior.

Agent skill for goal-planner - invoke with $agent-goal-planner

Agent skill for data-ml-model - invoke with $agent-data-ml-model

Agent skill for orchestrator-task - invoke with $agent-orchestrator-task

>

Agent skill for architecture - invoke with $agent-architecture

Agent skill for arch-system-design - invoke with $agent-arch-system-design

Agent skill for automation-smart-agent - invoke with $agent-automation-smart-agent

Agent skill for mesh-coordinator - invoke with $agent-mesh-coordinator

Agent skill for pseudocode - invoke with $agent-pseudocode

Comprehensive GitHub release orchestration with AI swarm coordination for automated versioning, testing, deployment, and rollback management

Agent skill for specification - invoke with $agent-specification

Agent skill for scout-explorer - invoke with $agent-scout-explorer

Agent skill for workflow-automation - invoke with $agent-workflow-automation

Cloud-based AI swarm deployment and event-driven workflow automation with Flow Nexus platform

Agent skill for migration-plan - invoke with $agent-migration-plan

Agent skill for automation-smart-agent - invoke with $agent-automation-smart-agent

Comprehensive GitHub code review with AI-powered swarm coordination

Agent skill for sona-learning-optimizer - invoke with $agent-sona-learning-optimizer

Worker-Agent integration for intelligent task dispatch and performance tracking

Agent skill for spec-mobile-react-native - invoke with $agent-spec-mobile-react-native

>

Agent skill for performance-analyzer - invoke with $agent-performance-analyzer

Agent skill for adaptive-coordinator - invoke with $agent-adaptive-coordinator

Agent skill for v3-security-architect - invoke with $agent-v3-security-architect

Agent skill for docs-api-openapi - invoke with $agent-docs-api-openapi

Agent skill for pr-manager - invoke with $agent-pr-manager

Agent skill for repo-architect - invoke with $agent-repo-architect

>

Unify 6+ memory systems into AgentDB with HNSW indexing for 150x-12,500x search improvements. Implements ADR-006 (Unified Memory Service) and ADR-009 (Hybrid…

Quantum-resistant, self-learning version control for AI agents with ReasoningBank intelligence and multi-agent coordination

Agent skill for queen-coordinator - invoke with $agent-queen-coordinator

Advanced GitHub Actions workflow automation with AI swarm coordination, intelligent CI/CD pipelines, and comprehensive repository management

Implement semantic vector search with AgentDB for intelligent document retrieval, similarity matching, and context-aware querying. Use when building RAG…

Achieve aggressive v3 performance targets: 2.49x-7.47x Flash Attention speedup, 150x-12,500x search improvements, 50-75% memory reduction. Comprehensive…

15-agent hierarchical mesh coordination for v3 implementation. Orchestrates parallel execution across security, core, and integration domains following 10 ADRs…

MCP server optimization and transport layer enhancement for claude-flow v3. Implements connection pooling, load balancing, tool registry optimization, and…

Core module implementation for claude-flow v3. Implements DDD domains, clean architecture patterns, dependency injection, and modular TypeScript codebase with…

Domain-Driven Design architecture for claude-flow v3. Implements modular, bounded context architecture with clean separation of concerns and microkernel…

agent-pagerank-analyzer — an installable skill for AI agents, published by ruvnet/ruflo.

Agent skill for app-store - invoke with $agent-app-store

Agent skill for challenges - invoke with $agent-challenges

agent-test-long-runner — an installable skill for AI agents, published by ruvnet/ruflo.

Multi-repository coordination, synchronization, and architecture management with AI swarm orchestration

Agent skill for matrix-optimizer - invoke with $agent-matrix-optimizer

agent-project-board-sync — an installable skill for AI agents, published by ruvnet/ruflo.

Agent skill for code-goal-planner - invoke with $agent-code-goal-planner

Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms

Agent skill for issue-tracker - invoke with $agent-issue-tracker

Agent skill for agentic-payments - invoke with $agent-agentic-payments

Agent skill for payments - invoke with $agent-payments