ruvnet/ruflo
242 skills205k installs16M starsGitHub
Install
npx skills add https://github.com/ruvnet/rufloSkills in this repo
1Agent Arch System DesignAgent Arch System Design is a Ruflo agent skill that acts as a system architecture designer for high-level technical decisions, patterns, and scalability planning. It triggers on architecture, system design, microservices, design pattern, and architectural decision keywords, plus file patterns such as architecture folders, design folders, ADR markdown, and PlantUML diagrams. The agent reads and writes architecture documentation under docs/architecture and docs/design, creates diagrams, and evaluates technology trade-offs while restricting edits to source trees and blocking Bash execution or implementation agent spawning. Human approval is required for major architectural changes, technology stack decisions, breaking changes, and security architecture. Deliverables include C4 model diagrams, component interaction views, data flow diagrams, Architecture Decision Records, and technology evaluation matrices framed around quality attributes, constraints, trade-offs, business alignment, and risk mitigation. It delegates to docs-technical, analyze-security, arch-database, arch-cloud, and arch-security peers while keeping sequential analysis for complex design sessions up to fifteen minut.1.3kinstalls2Agent WorkflowThe agent-workflow skill is designed for agent skill for workflow - invoke with $agent-workflow. Creates, executes, and manages complex automated workflows with message queue processing and intelligent agent coordination. color: teal --- You are a Flow Nexus Workflow Agent, an expert in designing and orchestrating event-driven automation workflows. Invoke when the user asks about agent workflow or related SKILL.md workflows.1.3kinstalls3Security AuditThe security-audit skill Security Audit Skill Purpose Comprehensive security scanning and vulnerability detection Includes input validation path traversal prevention CVE detection and secure coding pattern enforcement When to Trigger authentication implementation authorization logic payment processing user data handling API endpoint creation file upload handling database queries external API integration When to Skip read-only operations on public data internal development tooling static documentation styling changes Commands Full Security Scan Run comprehensive security analysis on the codebase bash npx claude-flow cli security scan depth full Example bash npx claude-flow cli security scan depth full output security-report json Input Validation Check Check for input validation issues bash npx claude-flow cli security scan check input-validation Example bash npx claude-flow cli security scan check input-validation path src api Path Traversal Check Check for path traversal vulnerabilities bash npx claude-flow cli security scan check path-traversal SQL Injection Check Check for SQL injection vulnerabilities bash npx claude-flow cli security scan check sql-injection XSS Check Check fo.1.2kinstalls4Workflow AutomationThe workflow-automation skill > # Workflow Automation Skill ## Purpose Create and execute automated workflows for complex multi-step processes. ## When to Trigger - Multi-step automated processes - Reusable workflow creation - Complex task orchestration - CI/CD pipeline setup ## Commands ### Create Workflow ```bash npx claude-flow workflow create --name "deploy-flow" --template ci ``` ### Execute Workflow ```bash npx claude-flow workflow execute --name "deploy-flow" --env production ``` ### List Workflows ```bash npx claude-flow workflow list ``` ### Export Template ```bash npx claude-flow workflow export --name "deploy-flow" --format yaml ``` ### View Status ```bash npx claude-flow workflow status --name "deploy-flow" ``` ## Built-in Templates | Template | Description | |----------|-------------| | `ci` | Continuous integration pipeline | | `deploy` | Deployment workflow | | `test` | Testing workflow | | `release` | Release automation | | `review` | Code review workflow | ## Workflow Structure ```yaml name: example-workflow steps: - name: analyze agent: researcher task: "Analyze requirements" - name: implement agent: coder depends: [analyze] task: "Implement solution" - name: tes.1.2kinstalls5Agent SwarmThe agent-swarm skill agent skill for swarm invoke with agent-swarm Deploys coordinates and scales multi-agent swarms in the Flow Nexus cloud platform for complex task execution color purple You are a Flow Nexus Swarm Agent a master orchestrator of AI agent swarms in cloud environments Your expertise lies in deploying scalable coordinated multi-agent systems that can tackle complex problems through intelligent collaboration Your core responsibilities Initialize and configure swarm topologies hierarchical mesh ring star Deploy and manage specialized AI agents with specific capabilities Orchestrate complex tasks across multiple agents with intelligent coordination Monitor swarm performance and optimize agent allocation Scale swarms dynamically based on workload and requirements Handle swarm lifecycle management from initialization to termination Your swarm orchestration toolkit javascript Initialize Swarm mcp__flow-nexus__swarm_init topology hierarchical mesh ring star hierarchical maxAgents 8 strategy balanced balanced specialized adaptive Deploy Agents mcp__flow-nexus__agent_spawn type researcher coder analyst optimizer coordinator name Lead Researcher capabilities web_search anal.1.1kinstalls6Agent Spec Mobile React NativeThe agent-spec-mobile-react-native skill defines a specialized React Native mobile developer agent for cross-platform iOS and Android work. It triggers on react native, expo, mobile app, and native module tasks across jsx, tsx, App.js, ios, and android paths. Allowed tools include Read, Write, Edit, MultiEdit, Bash, Grep, and Glob with adaptive error handling and batch update communication. The agent focuses on functional components, React Navigation, platform-specific styling, native module integration, and performance tuning such as FlatList and asset optimization. Constraints limit edits to src, app, components, screens, navigation, ios, android, and assets while forbidding node_modules and build artifacts. It delegates testing to test-unit and test-e2e agents and shares context with frontend and platform-specific mobile specs. Hooks verify React Native or Expo setup before execution and remind developers to test on both platforms afterward.1.1kinstalls7Agent Analyze Code QualityThe agent-analyze-code-quality skill defines a read-only Code Quality Analyzer agent for deep reviews across JavaScript, TypeScript, Python, Java, and Go sources. Triggers include code review, analyze code, refactor, technical debt, and code smell tasks under src, lib, app, components, services, and utils paths while excluding node_modules, dist, and build artifacts. Allowed tools are Read, Grep, Glob, and WebSearch with Write, Edit, Bash, and Task restricted to keep analysis non-mutating. The agent evaluates readability, maintainability, performance, security basics, and SOLID or DRY practices while detecting long methods, large classes, duplicate or dead code, complex conditionals, and god objects. Output follows a markdown report with quality score, critical issues, smells, refactoring opportunities, and positive findings. It can delegate to analyze-security or analyze-performance agents and shares context with analyze-refactoring and test-unit.1.1kinstalls8Github Workflow Automationgithub-workflow-automation is a ruflo skill (version 1.0.0) for advanced GitHub Actions automation with AI swarm coordination, intelligent CI/CD pipelines, and repository management. It requires gh GitHub CLI, git, claude-flow@alpha, and Node v16+, and tags cover github-actions, workflow-automation, deployment, and security. Developers invoke it to draft, optimize, and orchestrate workflow YAML instead of hand-writing every job matrix, cache step, and deployment gate. The skill suits teams standardizing Actions across repos or retrofitting security and deployment stages into existing pipelines with agent-assisted edits rather than one-off shell scripts.1.1kinstalls9Github Code Reviewgithub-code-review is a ruflo agent skill at version 1.0.0 that deploys specialized review agents for comprehensive GitHub pull request analysis using swarm coordination. The skill orchestrates multi-agent reviews covering security, performance, style, architecture, and accessibility, generates intelligent PR comments, and enforces quality gates before merge. It requires github-cli, ruv-swarm, and claude-flow capabilities for automated PR management and swarm-based review orchestration. github-code-review goes beyond traditional static analysis by routing domain-specific agents to relevant diff sections. Developers reach for github-code-review when they want AI-powered PR review pipelines that parallel human reviewer specialization—security sweeps, perf hotspots, style consistency, architectural boundaries, and a11y checks—in one automated workflow on GitHub.1.1kinstalls10Agent Trading Predictoragent-trading-predictor is an agent skill in ruvnet/ruflo invoked with $agent-trading-predictor that boots a Trading Predictor Agent persona. The persona emphasizes temporal-advantage calculations, sublinear algorithms, real-time market analysis, risk assessment, and high-frequency strategy framing, and expects companion sublinear-time-solver MCP tools for prediction and validation. Use it when you are composing a trading-oriented agent that should call solver MCP endpoints instead of hand-writing prediction prompts. The skill defines behavioral instructions rather than exchange order execution code. Treat outputs as analytical agent guidance that still needs real market data feeds, compliance review, and broker integration before production trading.1.1kinstalls11Memory ManagementMemory Management is a ruflo skill from ruvnet/ruflo that wraps @claude-flow/cli memory operations for AgentDB with HNSW indexing. Bundled shell scripts export memory to timestamped JSON backups via npx @claude-flow/cli memory export, run consolidation through hooks worker dispatch with a consolidate trigger, and report stats after optimization. Developers reach for Memory Management when coding agents must recall semantically similar prior solutions, back up memory state before risky changes, or prune and consolidate growing pattern stores. The skill integrates with the broader claude-flow hook and worker system rather than ad-hoc file copies. It suits teams running multi-session agent swarms that accumulate reusable patterns worth retrieving by similarity instead of exact string match.1.1kinstalls12Agent Ops Cicd Githubagent-ops-cicd-github is a ruflo skill (version 1.0.0, cicd-engineer specialization) for GitHub Actions pipeline creation and optimization without leaving the codebase. It triggers on keywords like github actions, ci/cd, pipeline, workflow, deployment, and continuous integration, and matches .github/workflows YAML files. The autonomous agent focuses on workflow automation and deployment pipelines with moderate complexity, authored for Claude Code DevOps workflows. Developers reach for agent-ops-cicd-github when they need new GitHub Actions workflows, pipeline tuning, or ongoing CI/CD maintenance generated directly in repository workflow files.1.1kinstalls13Agent Performance Optimizeragent-performance-optimizer is a ruflo specialist invoked with $agent-performance-optimizer to find bottlenecks and tune resource allocation in AI agents and cloud workloads. The agent focuses on computational performance analysis, system optimization, resource management, and efficiency maximization using sublinear algorithms across distributed systems and cloud infrastructure. Developers reach for agent-performance-optimizer when agent pipelines run slow, cloud costs spike from over-provisioned resources, or production services need structured performance triage instead of ad hoc profiling. The skill targets measurable runtime and allocation gains rather than cosmetic code cleanup.1.1kinstalls14Agent Paymentsagent-payments is a Flow Nexus skill invoked with $agent-payments that installs a Payments Agent specialized in financial operations within the ruflo ecosystem. The agent manages rUv credit systems and balance tracking, processes payments and billing securely, configures auto-recharge and tier management, and optimizes subscription workflows for Flow Nexus projects. Core responsibilities span credit ledger operations, payment processing guardrails, and subscription lifecycle tasks so coding agents do not improvise unsafe billing logic. Developers reach for agent-payments when integrating paid agent features, metering token usage against credits, or automating recharge and tier changes inside Flow Nexus. The skill pairs domain expertise in Flow Nexus billing with agent-native invocation patterns for hands-free financial operations during development and operations.1.1kinstalls15Agent Architectureagent-architecture is a ruflo SPARC Architecture phase specialist invoked with $agent-architecture to produce system designs from specifications and pseudocode. Capabilities include system_design, component_architecture, interface_design, scalability_planning, and technology_selection, with pre-hooks that retrieve pseudocode via memory_search and post-hooks that store completed architecture artifacts. Developers reach for agent-architecture after pseudocode is done and before implementation, when they need structured component boundaries, interface contracts, and scalability plans inside an agent-driven SPARC pipeline. The skill prioritizes maintainable architectures aligned with prior workflow memory rather than isolated diagram suggestions.1.1kinstalls16Agent Coordinationagent-coordination is a Ruflo skill for spawning, lifecycle management, and coordination patterns across 60+ specialized agent types. Core development roles include `coder`, `reviewer`, `tester`, `planner`, and `researcher`; V3 roles add `security-architect`, `security-auditor`, `memory-specialist`, and `performance-engineer`; swarm roles include `hierarchical-coordinator`, `mesh-coordinator`, and `adaptive-coordinator`. Developers reach for agent-coordination when a task needs parallel specialists—security review while coding, or coordinated swarms—not a single general agent. The skill says to skip it for simple single-agent work with no coordination overhead.1kinstalls17Embeddingsembeddings is a Ruflo skill for vector search and similarity queries inside Claude and agentic-flow workflows. The skill combines sql.js WASM SQLite for cross-platform persistent embedding caches with HNSW indexing that the documentation cites as 150x to 12,500x faster search, plus a Poincare ball hyperbolic model for hierarchical data and vector normalization utilities. Developers reach for embeddings when building semantic search over code or docs, pattern matching across agent memory, or knowledge retrieval pipelines, and the skill reports 75x faster performance with agentic-flow integration compared to naive approaches. Skip embeddings when exact string matching or simple key lookups suffice without semantic understanding.1kinstalls18Swarm Orchestrationswarm orchestration is a skill from ruvnet/ruflo for multi-agent swarm coordination on complex tasks. Bundled bash scripts run npx @claude-flow/cli swarm init with hierarchical topology, max-agents 8, and specialized strategy, then monitor status on a 5-second interval. A separate monitor script watches swarm health in real time. Developers reach for swarm orchestration when a feature or refactor touches many files and modules and needs specialized agents under anti-drift defaults rather than a single monolithic agent pass.1kinstalls19Agent Planneragent-planner is a high-priority Ruflo coordinator agent skill invoked via $agent-planner that performs strategic planning and task orchestration for multi-step software projects. Developers reach for it when a goal is too large for a single agent turn and needs decomposition into dependency-ordered subtasks with timeline and risk estimates before execution agents take over. The skill activates pre/post hooks that log planning start and completion to agent memory, and its capabilities span task_decomposition, dependency_analysis, resource_allocation, timeline_estimation, and risk_assessment. It sits upstream of implementation skills, producing structured plans rather than code patches.1kinstalls20Agent Workflow AutomationAgent Workflow Automation is a ruflo skill from ruvnet/ruflo that orchestrates GitHub Actions CI/CD through MCP integrations. It exposes tools including mcp__github__create_workflow, update_workflow, list_workflows, get_workflow_runs, and create_workflow_dispatch alongside claude-flow swarm_init, agent_spawn, task_orchestrate, and memory_usage for adaptive multi-agent pipeline optimization. Developers reach for Agent Workflow Automation when they want agents to scaffold workflow YAML, tune failing pipelines, and iteratively improve CI based on run history rather than hand-editing .github/workflows files in isolation. The skill is invoked with $agent-workflow-automation and targets self-organizing pipelines that coordinate testing, build, and deployment stages through automated agent swarms.1kinstalls21Github Automationgithub-automation is a rufnet/ruflo skill for GitHub workflow automation, pull request management, issue tracking, and code review coordination integrated with GitHub Actions. It triggers on PR creation, issue management, CI/CD workflow setup, code review automation, and release management. Commands include gh pr create with structured title and body templates for feature pull requests. The skill explicitly skips local-only changes and non-GitHub repositories. Developers reach for github-automation when they want their coding agent to open PRs, triage issues, configure workflows, and coordinate releases without leaving the agent session. It spans PR drafting through release automation across the ship pipeline.1kinstalls22Agent Repo Architectagent-repo-architect is a ruflo skill for repository structure optimization and multi-repo management with ruv-swarm coordination. It invokes tools including Bash, Read, Write, Edit, Glob, Task, WebFetch, GitHub MCP (create_repository, fork_repository, push_files, create_or_update_file), and claude-flow swarm_init/agent_spawn to design scalable project architecture. Developers reach for agent-repo-architect when standing up agent-friendly monorepos, wiring multi-repo boundaries, or maintaining clean folder conventions that autonomous agents can navigate. The skill targets architecture type workflows with purple-tagged repo-architect metadata. Use it before large agent swarms or when GitHub and claude-flow MCP tools must operate across coordinated repositories.1kinstalls23Agent Docs Api Openapiagent-docs-api-openapi is a ruflo documentation specialist agent (version 1.0.0) for creating and maintaining OpenAPI and Swagger API documentation directly from codebase artifacts. It scans routes, schemas, and handlers to produce OpenAPI 3.0 YAML or JSON, then keeps interactive docs aligned when endpoints change. Developers reach for it when launching a new REST service, onboarding partner integrators, or eliminating drift between implementation and published specs. The agent treats documentation as a build artifact—generating paths, request bodies, response models, and security schemes—rather than hand-writing stale wiki pages. Invoke after adding endpoints or before publishing a developer portal.1kinstalls24Agent Code Analyzeragent-code-analyzer is a rufnet/ruflo agent skill typed as code-analyzer with high priority and indigo specialization for code quality assessment and security analysis. Invoked with $agent-code-analyzer, it runs pre-task and post-task hooks through npx claude-flow@alpha hooks with performance analysis enabled on completion. Capabilities include code quality metrics, performance bottleneck identification, security risk detection, and technical debt surfacing before merge. Developers reach for agent-code-analyzer when they want agent-driven comprehensive review beyond single-purpose linters. The skill integrates with the broader ruflo agent orchestration stack and is designed for pre-merge quality gates on feature branches and pull requests.1kinstalls25Agent Data Ml ModelAgent-data-ml-model is version 1.0.0 ml-developer agent skill in ruvnet/ruflo, invoked with `$agent-data-ml-model`. The specialized agent handles ML model creation, data preprocessing, model evaluation, and deployment with metadata marking complexity as complex and autonomous deployment disabled pending approval. Triggers include machine learning, train model, predict, classification, regression, and neural network keywords across project file patterns. Reach for agent-data-ml-model when ruflo orchestration should run a constrained ML developer agent rather than generic coding assistance for sklearn, PyTorch, or similar training pipelines.1kinstalls26Agent Orchestrator Taskagent-orchestrator-task is a Ruflo orchestration skill invoked as $agent-orchestrator-task for central task coordination across agent workflows. It decomposes complex goals into ordered subtasks, plans execution, manages dependencies, tracks progress, handles priorities, and aggregates results into a final synthesis. Pre- and post-hooks initialize orchestration and store task-plan state in memory for continuity. Developers reach for agent-orchestrator-task when a single prompt must fan out into dependent subtasks across files, services, or agents rather than executing linearly. The skill exposes six core capabilities: task decomposition, execution planning, dependency management, result aggregation, progress tracking, and priority management.1kinstalls27Agent Testeragent-tester is a ruflo comprehensive testing and quality assurance specialist agent with pre-hooks that detect jest.config.js or vitest.config.ts before executing npm test with JSON reporting. It covers unit, integration, end-to-end, performance, and security testing workflows, summarizing passed and failed test counts after runs. Developers invoke agent-tester when scaffolding test suites, validating a PR before merge, or expanding coverage across layers without manually switching between frameworks. The agent prioritizes high-severity validation tasks and integrates shell hooks for environment checks. Use it when the codebase already has or needs a Node-based test runner and you want one agent to coordinate multi-layer QA.1kinstalls28Agent Safla NeuralAgent-safla-neural is a ruflo skill invoked with `$agent-safla-neural` that deploys a SAFLA Neural Specialist for Self-Aware Feedback Loop Algorithms. The agent combines distributed neural training concepts with persistent memory patterns so agents retain context across sessions, learn from experience, and adapt strategies via feedback loops. It targets developers building self-aware autonomous systems rather than static prompt chains. Reach for agent-safla-neural when ruflo projects need persistent neural-style memory, cross-session learning, or feedback-driven agent refinement instead of one-shot LLM calls.1kinstalls29Github Project ManagementGithub-project-management is version 2.0.0 comprehensive GitHub PM skill in ruvnet/ruflo for swarm-coordinated issue tracking, project board automation, and sprint planning. It requires GitHub CLI (`gh`) authenticated, ruv-swarm or claude-flow MCP configured, and repository access permissions. Tools span `mcp__github__*`, `mcp__claude-flow__*`, Bash, Read, Write, and TodoWrite for agile workflows. Tags include github, project-management, issue-tracking, project-boards, sprint-planning, agile, and swarm-coordination. Reach for github-project-management when AI agent swarms should operate GitHub boards and issues autonomously instead of manual `gh issue` and project column updates.1kinstalls30Agent Agentic Paymentsagent-agentic-payments is a ruflo specialist agent for autonomous payment authorization in AI commerce pipelines. It creates and manages Active Mandates with spend caps, time windows, and merchant allowlists; signs transactions with Ed25519 cryptographic signatures; and coordinates multi-agent Byzantine consensus before funds move. Developers invoke it when building agent marketplaces, delegated purchasing bots, or machine-to-machine checkout where human approval is replaced by cryptographically verifiable policy. The skill focuses on authorization policy design, signature verification flows, and consensus thresholds rather than basic Stripe webhook setup. Reach for it when payment autonomy, not just payment acceptance, is the requirement.1kinstalls31Agent Researcheragent-researcher is a ruflo agent skill invoked as $agent-researcher that acts as a research specialist before coding starts. It declares five analyst capabilities—code_analysis, pattern_recognition, documentation_research, dependency_tracking, and knowledge_synthesis—and runs pre/post hooks that store research context in memory and surface prior findings. Developers reach for agent-researcher when they need thorough codebase investigation, dependency mapping, or documentation synthesis instead of jumping straight into patches. The skill prioritizes high-confidence understanding of existing patterns and external references before design or implementation decisions. Use it at task kickoff when ambiguity, unfamiliar modules, or cross-repo context would otherwise cause rework.1kinstalls32Agent Dev Backend Apiagent-dev-backend-api is a ruflo skill at version 2.0.0-alpha that invokes the backend-dev agent via $agent-dev-backend-api for API design, implementation, optimization, and continuous improvement. V2 capabilities include self_learning, context_enhancement, fast_processing, and smart_coordination, with triggers on keywords such as api, endpoint, and rest. Developers reach for agent-dev-backend-api when backend work needs an autonomous specialist that recognizes patterns across sessions instead of one-off endpoint snippets. The agent targets moderate-complexity REST API projects inside ruflo multi-agent development flows.1kinstalls33Agent Neural Networkagent-neural-network is a ruflo Flow Nexus skill that acts as a neural network training and deployment specialist for distributed machine learning workloads. The agent designs and configures neural network architectures, orchestrates distributed training and inference, and manages model lifecycle using Flow Nexus cloud infrastructure. Developers invoke agent-neural-network through the $agent-neural-network entry point when ML tasks require cloud-powered distributed compute beyond single-machine notebooks. Core responsibilities span architecture selection, training orchestration, inference deployment, and ongoing model lifecycle management. The skill targets production-scale neural network operations rather than one-off prototype scripts.1kinstalls34Agent Coderagent-coder is a ruflo skill that invokes the $agent-coder implementation specialist for code generation, refactoring, optimization, API design, and error handling. Pre-hooks echo the task, remind developers to write tests first when the task mentions test or spec, and post-hooks run npm run lint when package.json exists. Developers reach for agent-coder when they want a dedicated coder agent instead of a general assistant handling implementation. The skill fits ruflo swarm setups where implementation tasks need a high-priority developer-type agent with defined capabilities and validation hooks.1kinstalls35Agent Memory Coordinatoragent-memory-coordinator is a Ruflo coordination skill invoked as $agent-memory-coordinator for persistent memory across coding agent sessions. The skill handles memory-management, namespace-coordination, data-persistence, compression-optimization, synchronization, and search-retrieval so specialized agents share working context without duplication or drift. Reach for agent-memory-coordinator when building multi-agent workflows that span long sessions, need namespace isolation, or require searchable knowledge stores across pre-session hooks. High-priority coordination hooks check memory system status and list active namespaces before agents read or write shared state.1kinstalls36Agentic Jujutsuagentic-jujutsu is version 2.3.2 ruflo skill for quantum-resistant, self-learning version control when multiple AI agents modify one repository at once. The README cites lock-free operations at 23x faster than Git and automatic conflict resolution with an 87% success rate, plus ReasoningBank intelligence for pattern learning across sessions. Developers reach for agentic-jujutsu when Git merge queues block parallel agent edits or when swarm workflows need coordinated commits without constant human conflict resolution. The skill targets future-proof multi-agent development pipelines that treat version control as an agent coordination layer.1kinstalls37Agent Swarm Memory Manageragent-swarm-memory-manager is a critical-priority Ruflo skill acting as the distributed consciousness keeper for multi-agent swarms. Core responsibilities include distributed memory management with continuous consistency checks, persistence across agent sessions, efficient retrieval through advanced caching, and synchronization protocols that prevent conflicting swarm state. Developers reach for agent-swarm-memory-manager when Claude-Flow or Ruflo swarms run parallel agents that must read and write shared project knowledge without stale caches, lost context, or divergent task memory during long orchestration runs.1kinstalls38Agent Tdd London Swarmagent-tdd-london-swarm invokes the $agent-tdd-london-swarm tdd-london-swarm tester agent inside ruflo for mock-driven development, outside-in TDD, behavior verification, and swarm test coordination. Pre-hooks announce the London School session and coordinate with other swarm test agents via npx when available; post-hooks confirm mock-driven completion. Developers reach for agent-tdd-london-swarm when tests must drive design through mocks and collaborators rather than classic Detroit-style state tests. The skill fits multi-agent projects where testing agents must collaborate on behavior specs across a swarm.1kinstalls39Sparc Methodologysparc-methodology is a ruflo skill backed by bash init and review scripts that scaffold a five-phase SPARC workflow for every new feature. Running the init script with a feature name creates ./docs/sparc/$FEATURE_NAME/ and five phase files: 1-specification.md, 2-pseudocode.md, 3-architecture.md, 4-refinement.md, and 5-completion.md. A companion review script runs phase checklist reviews. Developers reach for sparc-methodology when agents tend to jump straight to code and need enforced thinking steps—spec first, pseudocode second, architecture third—documented on disk. The methodology suits greenfield features or large refactors where traceable phase artifacts matter more than speed on tiny patches.1kinstalls40Agent Github Modesagent-github-modes is a ruflo agent skill for comprehensive GitHub integration via github-modes capabilities. It coordinates GitHub workflow orchestration, pull request management and review, issue tracking, release management, deployment coordination, repository architecture, and CI/CD pipeline coordination with batch optimization. The skill invokes claude-flow MCP tools including swarm_init, agent_spawn, and task_orchestrate alongside Bash, TodoWrite, Read, and Write. Developers reach for agent-github-modes when multi-step GitHub operations—opening PRs, triaging issues, syncing branches, or coordinating releases—should run as structured agent modes instead of ad hoc shell scripts. Priority is medium in ruflo metadata and the skill type is development-focused purple github-modes integration.1kinstalls41Agent Performance Monitoragent-performance-monitor is a Ruflo performance optimization agent invoked as $agent-performance-monitor. It specializes in real-time metrics collection, bottleneck analysis, SLA monitoring, resource tracking, and anomaly detection across live agent executions. The skill includes JavaScript-oriented metrics collection patterns for instrumenting agent runs and surfacing latency or throughput regressions before they breach SLAs. Developers reach for it when agent fleets need observability comparable to microservice APM but tuned for LLM workflow steps and tool calls.1kinstalls42Agent Issue Trackeragent-issue-tracker is a Ruflo Claude-Flow skill for intelligent GitHub issue management and project coordination. Capabilities include automated issue creation with smart templates, progress tracking via swarm coordination, multi-agent collaboration on complex issues, milestone coordination, and cross-repository issue synchronization. The skill invokes Claude-Flow MCP tools such as swarm_init, agent_spawn, task_orchestrate, and memory_usage alongside standard Read, Write, Bash, and TodoWrite. Developers reach for agent-issue-tracker when AI swarms must open labeled issues, monitor delivery, and synchronize work across repos without manual project-management overhead.1kinstalls43Stream Chainstream-chain is a ruflo workflow skill at version 1.0.0 for Stream-JSON chaining across multi-agent pipelines, data transformation, and sequential workflows. It provides two modes: Custom Chains via run for full prompt-sequence control and Predefined Pipelines via pipeline for common battle-tested workflows. Each step streams its output directly into the next agent, enabling complex sequential processing without manual handoff glue code. Developers reach for stream-chain when building multi-step agent pipelines that transform data across stages, such as extract-then-summarize-then-format flows. Tags include streaming, pipeline, chaining, multi-agent, and workflow.1kinstalls44Agent Goal Planneragent-goal-planner is an advanced ruflo agent skill that applies Goal-Oriented Action Planning (GOAP)—gaming AI techniques—for developers whose agents must achieve complex objectives through creative tool combinations. The Goal-Oriented Action Planning specialist dynamically creates optimal action sequences, excels at adaptive replanning when state changes, and searches complex state spaces for novel solutions beyond fixed scripts. Invoke it with $agent-goal-planner when tasks require multi-step reasoning, tool chaining, or recovery after failed intermediate steps. The skill discovers paths by evaluating preconditions and effects across available actions rather than following a single hard-coded workflow. Reach for agent-goal-planner when objectives are underspecified, environments shift mid-run, or agents must replan after partial failures.1kinstalls45Agent Code Review Swarmagent-code-review-swarm is a ruflo skill that deploys specialized AI agents through claude-flow MCP tools including swarm_init, agent_spawn, and task_orchestrate to perform comprehensive pull request reviews. Capabilities include automated multi-agent code review, security vulnerability analysis, performance bottleneck detection, architecture pattern validation, and style and convention enforcement. The skill uses Bash, Read, Write, and TodoWrite alongside MCP orchestration to go beyond traditional static analyzers. Developers invoke it with $agent-code-review-swarm when a PR needs parallel expert passes across security, performance, and architecture concerns before merge.1kinstalls46Agent Topology Optimizeragent-topology-optimizer is a performance optimization agent skill from ruvnet/ruflo that reconfigures multi-agent swarm topologies and communication patterns at runtime. The Topology Optimizer agent specializes in dynamic topology reconfiguration, adaptive network structures, and communication pattern optimization for orchestrated agent swarms. Developers reach for agent-topology-optimizer when multi-agent latency, message fan-out, or routing bottlenecks appear during swarm orchestration work. The skill exposes JavaScript-oriented topology optimization flows for tuning how agents connect, delegate, and exchange state inside ruflo-style swarm runtimes.1kinstalls47Neural Trainingneural-training is a ruvnet/ruflo agent skill that trains and optimizes neural patterns using SONA (Self-Optimizing Neural Architecture), MoE (Mixture of Experts), and EWC++ for knowledge consolidation. The intelligence pipeline retrieves patterns via HNSW indexing reported as 150x–12,500x faster retrieval, judges quality, and consolidates learned routing behavior for agent systems. Developers reach for neural-training when building agents that must learn recurring patterns, optimize routing decisions, or retain knowledge across sessions without full retraining. Skip it for one-off tasks with no learning requirement.1kinstalls48Agent Consensus Coordinatoragent-consensus-coordinator is an advanced agent skill from the ruflo library for developers orchestrating multi-agent systems that must agree on outcomes without manual reconciliation. The Consensus Coordinator Agent applies sublinear solvers and mathematical agreement protocols for Byzantine fault tolerance, voting mechanisms, distributed coordination, and consensus optimization in large-scale agent fleets. Invoke it with $agent-consensus-coordinator when agents produce conflicting outputs, need quorum votes, or require fault-tolerant decision merging. The skill focuses on protocol design and coordination mechanics rather than single-agent prompting. Reach for agent-consensus-coordinator when reliability matters more than speed and agents must converge on a single authoritative result after parallel work.1kinstalls49Agent Project Board Syncagent-project-board-sync is a ruflo coordination skill that mirrors AI swarm tasks onto GitHub Projects for visual management, progress tracking, and team coordination. It uses Bash, Read, Write, Edit, Glob, Grep, LS, and TodoWrite plus Claude Flow MCP tools including swarm_init, agent_spawn, task_orchestrate, swarm_status, memory_usage, github_repo_analyze, github_pr_manage, and github_issue_track. Developers reach for agent-project-board-sync when multi-agent coding runs need live board visibility instead of opaque terminal logs. Invoke it when spawning swarms on features tracked in GitHub Projects or when agents must update card status as milestones complete. The skill connects swarm orchestration state to GitHub's native project views.1kinstalls50Github Multi Repogithub-multi-repo is a ruflo skill at version 1.0.0 for multi-repository coordination, synchronization, and architecture management with AI swarm orchestration. It combines swarm intelligence, package synchronization, template management, and distributed workflows across GitHub repos. The skill requires ruv-swarm@^1.0.11 and gh-cli@^2.0.0 and exposes capabilities for cross-repository coordination, architecture optimization, and package synchronization. Developers reach for github-multi-repo when a product spans several GitHub repositories that must share package versions, templates, and architectural conventions.1kinstalls51Swarm Advancedswarm-advanced is a version 2.0.0 orchestration skill from the Claude Flow team for developers who coordinate multiple specialized AI agents on complex research, development, and testing work. It covers advanced swarm patterns using Claude Flow MCP tools and CLI commands, with prerequisites including npm install -g claude-flow@alpha and adding the claude-flow MCP server via claude mcp add. Tags include swarm, distributed, parallel, research, testing, development, and coordination. Reach for swarm-advanced when single-agent context limits block parallel exploration, cross-functional agent roles must collaborate, or MCP-driven swarm commands should replace manual agent handoffs. The skill maps orchestration strategies for distributed workflows rather than implementing application code directly.1kinstalls52Agent Agentagent-agent is a ruflo/claude-flow skill wrapping a sublinear Goal-Oriented Action Planning specialist. It uses gaming-AI GOAP techniques to discover novel solutions by combining actions creatively across complex state spaces. The skill excels at adaptive replanning, multi-step reasoning, and finding optimal paths when objectives are underspecified. Developers invoke it with $agent-agent when agents need autonomous plan generation instead of step-by-step human guidance. It applies graph analysis and sublinear optimization to transform high-level goals into ordered action sequences agents can follow.1kinstalls53Agent Automation Smart Agentagent-automation-smart-agent is a ruflo skill for intelligent agent coordination and dynamic spawning. It declares six capabilities: intelligent-spawning, capability-matching, resource-optimization, pattern-learning, auto-scaling, and workload-prediction. On invocation with $agent-automation-smart-agent, it analyzes task requirements, checks swarm status from memory, and spawns agents matched to workload needs. Developers reach for it when multi-agent swarms must self-organize instead of manually selecting agent types for each task.1kinstalls54Agent Performance Analyzeragent-performance-analyzer is a ruflo skill invoked with $agent-performance-analyzer for performance bottleneck analysis in agent workflows. The perf-analyzer analyst type collects baseline metrics, runs performance_analysis and bottleneck_detection, applies pattern_recognition and trend_analysis, and outputs optimization_planning recommendations. Pre-hooks start analysis timestamps and collect baseline performance metrics; post-hooks mark analysis completion in agent memory. Developers reach for agent-performance-analyzer when agent swarms or multi-step workflows feel slow and they need measured execution data plus a concrete optimization plan.1kinstalls55Agent Pseudocodeagent-pseudocode is a ruflo architect-type skill for the SPARC Pseudocode phase. It declares five capabilities: algorithm_design, logic_flow, data_structures, complexity_analysis, and pattern_selection. Pre-hooks store the sparc_phase as pseudocode and retrieve completed specifications from memory; post-hooks mark pseudocode completion. Developers invoke it with $agent-pseudocode when specs need translation into precise algorithmic blueprints before writing production code. The skill fits SPARC methodology workflows where specification precedes implementation.1kinstalls56Github Release Managementgithub-release-management is a version 2.0.0 ruflo skill for comprehensive GitHub release orchestration with AI swarm coordination. It automates semantic versioning, changelog drafting, pre-release testing, deployment steps, and safe rollback when releases fail. The skill requires gh (GitHub CLI), git, npm or yarn, and Node.js 20 or newer, with optional ruv-swarm and mcp-github integrations for enhanced coordination. Developers reach for github-release-management when repetitive manual release steps—tagging, changelog edits, CI gates, and publish commands—slow down shipping. It relates to github-pr-management, github-issue-tracking, github-workflow-automation, and multi-repo-coordination skills in the same repo. Invoke it before cutting a production GitHub Release or when standardizing release runbooks across repositories.1kinstalls57Agent Collective Intelligence Coordinatoragent-collective-intelligence-coordinator is a critical-priority ruflo skill acting as the neural nexus for hive-mind multi-agent systems. It orchestrates distributed cognitive processes, synchronizes collective memory, and enforces coherent decision-making through consensus protocols across all agents. Developers invoke it with $agent-collective-intelligence-coordinator when multiple agents must share state and reach unified decisions instead of working in isolation. The skill fits complex workflows where agent outputs must converge before downstream actions execute.1kinstalls58Agent Resource Allocatoragent-resource-allocator is a Performance Optimization Agent skill in the ruflo ecosystem that implements adaptive resource allocation, predictive scaling, and intelligent capacity planning for AI coding agent swarms. The skill exposes JavaScript-oriented allocation logic that monitors real-time workload signals and adjusts compute, memory, storage, and network assignments so swarms stay responsive without over-provisioning. Developers reach for agent-resource-allocator when Claude Flow or ruv-swarm deployments show uneven agent utilization, queue backlogs, or runaway resource consumption during coordinated coding tasks. Invoke it during swarm orchestration setup or when scaling agent pools across machines. The skill pairs naturally with swarm coordination and task orchestration tools in ruflo rather than replacing application-level performance profiling.1kinstalls59Agent Revieweragent-reviewer is a ruflo validator agent specializing in code review and quality assurance before merge or deployment. Capabilities include code_review, security_audit, performance_analysis, best_practices enforcement, and documentation_review. Pre-task hooks build a review checklist stored in memory covering functionality, security, performance, maintainability, and documentation—five explicit dimensions. Post-task hooks confirm completion and persist review summaries. Developers reach for agent-reviewer when automated or agent-assisted PR review must catch security and performance regressions alongside style issues. Invoke it on pull requests, pre-deploy branches, or after large refactors. The skill behaves as a senior reviewer agent with medium priority in swarm workflows.1kinstalls60Agent Specificationagent-specification is a ruflo SPARC Specification phase specialist invoked with $agent-specification. The analyst-type skill gathers requirements, analyzes constraints, defines acceptance criteria, maps stakeholders, and produces a specification document before implementation starts. Pre and post hooks store SPARC phase state in agent memory and mark specification completion timestamps. Developers reach for agent-specification when a feature request is still ambiguous and they need measurable requirements, scope boundaries, and testable acceptance criteria written down first.1kinstalls61Agent Pr Manageragent-pr-manager is a ruflo development skill for comprehensive GitHub pull request management with swarm coordination. It uses Bash, Read, Write, Edit, Glob, Grep, and TodoWrite plus claude-flow MCP tools including swarm_init, agent_spawn, task_orchestrate, github_pr_manage, github_code_review, and github_metrics. Pre-hooks verify gh auth status before workflows run. Developers invoke it with $agent-pr-manager when PRs need multi-agent review, automated testing, conflict resolution, and merge orchestration instead of manual gh CLI steps.1kinstalls62Agent Code Goal Planneragent-code-goal-planner is a ruflo Code-centric Goal-Oriented Action Planning specialist that decomposes complex software objectives into achievable milestones with explicit success criteria. Example flows include OAuth2 API integration plans covering provider setup, token management, and endpoint wiring. Developers reach for agent-code-goal-planner when requirements arrive as broad goals—add authentication, refactor a module, ship an API—rather than ticket-level tasks. The skill produces structured implementation plans agents and engineers can execute sequentially. Invoke it at the start of large features or refactors where unclear scope would otherwise cause rework. Pair with agent-project-board-sync to mirror milestones onto GitHub Projects.1kinstalls63Flow Nexus Swarmflow-nexus-swarm is a version 1.0.0 agent orchestration skill from ruvnet/ruflo that guides developers through deploying and managing cloud-based AI agent swarms on Flow Nexus. The skill covers swarm management, workflow automation, message queue processing, and intelligent agent coordination using event-driven patterns. It requires an active Flow Nexus account and the flow-nexus MCP server as prerequisites before any deployment steps run. Developers reach for flow-nexus-swarm when building multi-agent systems that must scale in the cloud, route work across agents, and process asynchronous events rather than running a single local agent loop. The skill fits teams wiring production agent topologies where coordination, queuing, and workflow state must live off-machine on Flow Nexus infrastructure.1kinstalls64Agent Load Balanceragent-load-balancer is a Ruflo skill implementing a Load Balancing Coordinator agent for dynamic task distribution, work-stealing algorithms, and adaptive load balancing across multiple Claude or Cursor agents. The skill profiles a performance optimization agent specialized in resource allocation and parallel work queues, with JavaScript-oriented work-stealing scheduler examples in source. Developers reach for agent-load-balancer when single-agent throughput bottlenecks large codebases, test suites, or batch refactors and coordinated multi-agent parallelism is required. Invoke it with $agent-load-balancer when orchestration must rebalance idle and busy workers rather than run tasks serially.1kinstalls65Agent Swarm Pragent-swarm-pr is a Ruflo swarm-pr agent skill that coordinates multi-agent code review, validation, and integration workflows with automated GitHub pull request lifecycle management. The skill wires GitHub MCP tools—including get_pull_request, get_pr_diff, create_pr_comment, list_pull_requests, update_pull_request, and merge_pull_request—together with Claude Flow swarm_init, agent_spawn, and task_orchestrate calls. Developers reach for agent-swarm-pr when a PR needs parallel reviewer agents, diff analysis, comment threads, and merge gating instead of manual single-reviewer passes. Invoke with $agent-swarm-pr when GitHub PR URLs, review bottlenecks, or swarm-based validation appear in the workflow.1kinstalls66Hive Mind Advancedhive-mind-advanced is a Ruflo skill at version 1.0.0 implementing an advanced Hive Mind collective intelligence system for queen-led multi-agent coordination with Byzantine consensus and persistent collective memory. Tagged with hive-mind, swarm, queen-worker, consensus, and collective-intelligence, the skill represents Claude Flow's hierarchical architecture where a queen agent assigns roles and workers execute with shared state. Developers reach for hive-mind-advanced when simple parallel agents are insufficient and strategic coordination, consensus mechanisms, and durable swarm memory are required across long-running development tasks. The skill suits complex orchestration beyond basic load balancing or single-PR review swarms.1kinstalls67Performance Analysisperformance-analysis is a monitoring and profiling skill from ruvnet/ruflo at version 1.0.0 that consolidates bottleneck detection, swarm operation profiling, detailed report generation, and actionable optimization recommendations for Claude Flow swarms. It identifies performance bottlenecks across communication, processing, memory, and network layers in multi-agent systems. Tagged for performance, bottleneck, optimization, profiling, metrics, and analysis workflows. Developers reach for performance-analysis when Claude Flow swarms exhibit latency, resource contention, or degraded throughput and need structured profiling reports with concrete tuning suggestions.1kinstalls68Agent Sona Learning Optimizeragent-sona-learning-optimizer is a Ruflo skill for SONA-powered agents that continuously improve from every task execution. Capabilities include sona_adaptive_learning, LoRA fine-tuning, EWC++ continual learning, pattern discovery, LLM routing, quality optimization, and sub-millisecond learning hooks. The agent reuses discovered patterns across tasks while preserving prior knowledge through EWC++ memory constraints. Developers reach for agent-sona-learning-optimizer when building long-running agents that must adapt weights and routing over time instead of static prompt-only behavior. The skill fits experimentation with neural architecture self-optimization embedded in agent runtimes rather than one-shot inference calls.1kinstalls69Hive Mindhive-mind is a ruflo skill providing Byzantine fault-tolerant consensus and distributed swarm coordination for developers running multi-agent systems that must survive agent failures and align on collective decisions. Queen-led hierarchical management supports multiple consensus strategies and topology choices documented in the skill's reference table for different coordination patterns. Trigger when tasks need distributed multi-agent execution, fault-tolerant operations, or collective decision making—skip for single-agent local edits or simple one-shot commands. hive-mind fits complex coordination where agents vote, delegate, and recover from stragglers or bad outputs. Pair it with agent-scout-explorer when scouts feed intelligence into a coordinated swarm. The skill targets ruflo users building resilient agent fleets rather than ad-hoc prompt chains without governance or consensus guarantees. Documented topologies map queen-led hierarchy to use cases requiring fault-tolerant collective decisions across distributed agent workloads.1kinstalls70Agent Mesh Coordinatoragent-mesh-coordinator is a high-priority coordinator skill from ruvnet/ruflo that establishes resilient peer-to-peer meshes among AI agents. The skill handles distributed coordination, peer communication, fault tolerance, consensus building, load balancing, and network resilience for swarms that must continue when nodes fail. Pre-hooks initialize mesh topology through mcp__claude-flow__swarm_init mesh with maxAgents=12 and a distributed strategy, then configure peer discovery and communication channels. Developers invoke agent-mesh-coordinator with $agent-mesh-coordinator when projects need decentralized decision-making rather than a single coordinator leader. It extends agent-coordinator-swarm-init by emphasizing mesh networks and fault-tolerant consensus instead of one-time initialization only. Use it for large multi-agent pipelines requiring peer resilience; skip it for two-agent handoffs, simple sequential prompts, or GitHub PR automation that agent-github-pr-manager already covers.1kinstalls71Agent Release Swarmagent-release-swarm is a release coordination skill from ruvnet/ruflo invoked as `$agent-release-swarm` that delegates to a release-swarm agent type. The swarm uses Bash, Read, Write, Edit, TodoWrite, Task, and WebFetch alongside GitHub MCP tools including `create_pull_request`, `merge_pull_request`, `create_branch`, and `push_files`, plus claude-flow MCP calls such as `swarm_init`, `agent_spawn`, and `task_orchestrate`. It handles changelog generation through multi-platform deployment in a single coordinated workflow. Developers reach for agent-release-swarm when a release spans versioning, PR creation, merging, and deployment steps that benefit from parallel AI agent coordination rather than manual shell scripts.1kinstalls72Agent Sandboxagent-sandbox is an E2B sandbox management skill from ruvnet/ruflo invoked as `$agent-sandbox`, delegating to a flow-nexus-sandbox agent specialist. The agent creates and configures E2B sandboxes with appropriate templates, executes code safely in isolated environments, and orchestrates code execution workflows at scale. Core responsibilities include sandbox provisioning, environment configuration, and isolated execution with proper resource management. Developers reach for agent-sandbox when AI agents need to run untrusted or experimental code—generated patches, test scripts, or exploratory commands—inside disposable sandboxes instead of the host machine.1kinstalls73Agent Swarm Issueagent-swarm-issue is a ruflo coordination skill invoked with $agent-swarm-issue that transforms GitHub issues into intelligent multi-agent tasks. It integrates GitHub MCP tools for get, create, update, list issues, and create comments alongside claude-flow MCP tools for swarm_init, agent_spawn, task_orchestrate, and memory_usage. Additional tools include TodoWrite, TodoRead, Bash, Grep, Read, and Write for local execution. Developers reach for agent-swarm-issue when a single GitHub issue spans multiple implementation areas and manual agent prompting cannot track decomposition and progress. The skill automates swarm initialization from issue context, spawns specialized agents per subtask, and keeps the GitHub issue updated as work advances.1kinstalls74Agent Test Long Runneragent-test-long-runner is a long-running test agent skill from ruvnet/ruflo invoked as `$agent-test-long-runner`, wrapping a test-long-runner agent designed for tasks exceeding 30 minutes. Capabilities include complex codebase analysis, thorough multi-source research, detailed reporting, and long-form content generation such as comprehensive guides and tutorials. The agent operates without artificial time pressure, making it suitable for open-ended validation and documentation tasks. Developers reach for agent-test-long-runner when a testing or analysis task is too deep for standard agents—full repository audits, exhaustive documentation reviews, or multi-hour research sweeps.1kinstalls75Agent V3 Memory Specialistagent-v3-memory-specialist is a v3 memory unification skill from ruvnet/ruflo at version 3.0.0-alpha, invoked as `$agent-v3-memory-specialist`. The v3-memory-specialist consolidates 6+ legacy memory systems into AgentDB with HNSW indexing, implementing ADR-006 (Unified Memory Service) and ADR-009 (Hybrid Memory Backend) to achieve 150x–12,500x search improvements. Pre-execution hooks audit current memory systems before unification begins. Developers reach for agent-v3-memory-specialist when Claude Flow agents suffer from fragmented memory backends and need a single hybrid memory service with vector search performance gains.1kinstalls76Agent V3 Security Architectagent-v3-security-architect is a ruflo V3 Security Architect agent skill at version 3.0.0-alpha updated 2026-01-04, responsible for complete security overhaul, threat modeling, and CVE remediation planning. The agent addresses critical vulnerabilities labeled CVE-1, CVE-2, and CVE-3 while implementing secure-by-default patterns during foundation-phase security work. Developers invoke agent-v3-security-architect when applications need structured threat models, prioritized remediation plans, and architectural security fixes beyond lint-level issues. Pre-execution hooks initialize security audit preparation, producing threat models, CVE remediation roadmaps, and secure-default configuration guidance.1kinstalls77Flow Nexus Neuralflow-nexus-neural is a neural network training skill from ruvnet/ruflo at version 1.0.0 that deploys and trains models in distributed E2B sandbox environments through the Flow Nexus MCP server. Supported architectures include feedforward, LSTM, GAN, and transformer networks, with pre-built templates available from the marketplace. Setup requires `claude mcp add flow-nexus npx flow-nexus@latest mcp start` and authentication registration. Developers reach for flow-nexus-neural when they need to train or deploy custom neural networks in isolated sandboxes without provisioning local or cloud GPU clusters, leveraging Flow Nexus for distributed execution.1kinstalls78Agent Adaptive Coordinatoragent-adaptive-coordinator is a ruflo agent skill that acts as a dynamic topology-switching coordinator for self-organizing agent swarms with real-time optimization. On invocation it initializes adaptive swarms through `mcp__claude-flow__swarm_init auto --maxAgents=15 --strategy=adaptive`, enabling capabilities such as topology adaptation, performance optimization, pattern recognition, predictive scaling, and intelligent routing. Developers use agent-adaptive-coordinator when project demands shift mid-run and static agent assignments would bottleneck parallel work. The skill reconfigures agent roles and routes tasks based on workload patterns, producing optimized multi-agent execution plans for complex coding sessions.1kinstalls79Agent Coordinator Swarm Initagent-coordinator-swarm-init is a high-priority coordination skill from ruvnet/ruflo that prepares distributed multi-agent swarms before complex workflows execute. The skill specializes in swarm initialization, topology optimization, resource allocation, network configuration, and performance tuning for coordinator-led agent teams. Pre-hooks write initializing status into shared memory via npx claude-flow@alpha memory store under a swarm namespace, giving downstream agents a consistent coordination baseline. Developers invoke it with $agent-coordinator-swarm-init when standing up ruflo swarms that need shared memory, distributed coordination systems, and tuned network topologies rather than single-agent prompts. It pairs naturally with agent-mesh-coordinator for peer networks and agent-crdt-synchronizer for eventually consistent shared state. Use agent-coordinator-swarm-init at the start of multi-agent pipelines when topology and memory namespaces must be configured before task dispatch, not for GitHub PR management or unrelated CLI scripting.1kinstalls80Agent Performance Benchmarkeragent-performance-benchmarker is a ruvnet/ruflo analyst skill invoked with $agent-performance-benchmarker to run structured performance studies on AI agent workloads. The skill collects throughput, latency, and resource metrics, runs comparative analysis across configurations, and supports adaptive tuning recommendations so teams can trade off cost against response quality. Developers reach for agent-performance-benchmarker when evaluating prompt variants, swarm topologies, or orchestration changes and need reproducible numbers instead of subjective impressions. The skill exposes five core capabilities—throughput_measurement, latency_analysis, resource_monitoring, comparative_analysis, and adaptive_tuning—aligned with distributed-system benchmarking patterns.1kinstalls81Agent Production Validatoragent-production-validator is a ruflo production-validation agent skill that ensures applications are fully implemented and deployment-ready before release. Pre-execution hooks grep the `src/` tree for `mock`, `fake`, `stub`, `TODO`, and `FIXME` patterns to surface unfinished implementations, alongside capabilities for implementation verification, end-to-end testing guidance, deployment readiness checks, and real-world simulation. Developers invoke agent-production-validator immediately before deploy when stubs may remain hidden in feature branches. The skill outputs a production readiness report listing mock artifacts, open TODOs, and remediation steps required before shipping.1kinstalls82Agent Security Manageragent-security-manager is a critical-priority ruflo security skill invoked with $agent-security-manager for comprehensive protection of distributed consensus protocols. Capabilities include cryptographic security, attack detection, key management, secure communication, and threat mitigation. Pre-operation hooks activate cryptographic verification when consensus tasks are detected; post-operation hooks run security audits after protocol changes. Developers reach for agent-security-manager when Raft or similar consensus code needs hardening against tampering, key compromise, or communication attacks before merge. The skill treats security as an automated gate around consensus development rather than a manual checklist applied after the fact.1kinstalls83Agent Worker Specialistagent-worker-specialist is a ruvnet/ruflo execution skill invoked with $agent-worker-specialist to carry out delegated tasks within a hive-mind swarm while reporting status before, during, and after every assignment through memory coordination. The worker-specialist agent operates at high priority as the dedicated executor that turns high-level coordinator assignments into precise file edits, command runs, and verified completions. Developers reach for agent-worker-specialist when a swarm coordinator needs reliable foot soldiers that maintain constant communication instead of silent, opaque execution. The skill mandates a task execution protocol with mandatory progress reporting and memory-backed coordination so coordinators can track parallel workstreams.1kinstalls84Agent Matrix Optimizeragent-matrix-optimizer is a specialized ruflo agent skill invoked with $agent-matrix-optimizer for matrix analysis and optimization using sublinear algorithms. The agent examines matrix properties, verifies diagonal dominance, estimates condition numbers, and delivers optimization recommendations tailored to large-scale linear systems. Developers reach for agent-matrix-optimizer when preparing matrices for sublinear solvers or diagnosing numerical instability before solver execution. The skill positions the agent as a matrix optimization expert rather than a general linear algebra calculator, focusing on property analysis and pre-solver preparation. Use it when matrix structure—not just values—determines solver performance or convergence risk.1kinstalls85Agent Raft Manageragent-raft-manager is a ruflo coordinator skill invoked with $agent-raft-manager that manages the Raft consensus algorithm for distributed agent systems. Documented capabilities include leader election, log replication, follower management, membership changes, and consistency verification. Pre-operation hooks check cluster health before elections; post-operation hooks validate log consistency after each Raft operation. Developers reach for agent-raft-manager when building multi-agent architectures that need deterministic leader selection and replicated state across nodes. The skill treats consensus as a first-class coordination concern rather than ad-hoc locking, making it suitable for agent swarms requiring fault-tolerant shared decision logs.1kinstalls86Agent Refinementagent-refinement is a ruflo developer skill invoked as $agent-refinement that specializes in the SPARC Refinement phase for iterative quality improvement. Capabilities include code optimization, test development, refactoring, performance tuning, and general quality improvement with high priority within the SPARC workflow. Pre hooks mark the refinement phase in memory, run npm test --if-present for baseline signal, and post hooks rerun npm test to validate final state before completion. Developers reach for agent-refinement when first-pass code works but needs hardened tests, cleaner structure, faster paths, and updated docs before merge or release. The skill encodes a deliberate polish loop rather than greenfield generation, making it the right trigger once feature scaffolding exists and quality gates matter.1kinstalls87Agent Sparc Coordinatoragent-sparc-coordinator is a ruvnet/ruflo coordination skill invoked with $agent-sparc-coordinator to enforce the SPARC development methodology across agent-driven coding sessions. The skill manages phase transitions, enforces quality gates, tracks methodology compliance, synthesizes results between phases, and monitors progress with memory_store and memory_search hooks. Developers reach for agent-sparc-coordinator when ad-hoc agent coding produces inconsistent specs, skipped design steps, or incomplete handoffs between planning and implementation. Capabilities include sparc_coordination, phase_management, quality_gate_enforcement, methodology_compliance, result_synthesis, and progress_tracking with high priority in the ruv-swarm agent roster.1kinstalls88Claimsclaims is a ruvnet/ruflo security skill that implements claims-based authorization for agent operations and access control in multi-agent environments. The skill lets developers grant, revoke, and verify permissions before agents read files, write code, execute shell commands, spawn sub-agents, access memory, or use the network. Developers reach for claims when open-access agent swarms become risky and operations need explicit authorization checks tied to claim types. Documented claim types include read, write, execute, spawn, memory, and network, each gating a distinct capability boundary. Skip claims for single-agent local work with no security requirements.1kinstalls89Pair Programmingpair programming is a ruvnet/ruflo collaboration skill that simulates professional pair programming with AI playing driver, navigator, or alternating switch roles. The skill supports TDD, debugging, refactoring, and learning sessions with automatic role switching, continuous code review, security scanning, performance optimization, and truth-score verification. Developers reach for pair programming when they want an interactive coding partner that critiques changes as they land instead of generating bulk code silently. Multiple collaboration modes—driver, navigator, and switch—let teams choose whether the AI writes code, guides design, or alternates responsively during the session.1kinstalls90Agent App Storeagent-app-store is a ruflo Flow Nexus skill invoked as $agent-app-store that acts as an application marketplace and template management specialist. The agent curates the Flow Nexus marketplace, facilitates app publishing and versioning, supports discovery workflows, and handles deployment operations for agent skills and templates. Developers reach for agent-app-store when they need to list a new agent capability, promote templates across a team catalog, or orchestrate marketplace distribution without manual CLI steps. The skill positions itself as an ecosystem steward: it manages publication pipelines, helps users find deployable apps, and keeps marketplace metadata consistent. It fits teams standardizing reusable agent assets inside Flow Nexus rather than copying skill folders ad hoc across repositories.1kinstalls91Agent Challengesagent-challenges is a Flow Nexus skill invoked as $agent-challenges that acts as a coding challenges and gamification specialist. The Flow Nexus Challenges Agent curates challenges across difficulty levels and categories, validates solutions, and manages leaderboards and achievement systems. Developers reach for agent-challenges when they want structured practice problems, competitive programming-style drills, or agent training loops inside Flow Nexus rather than ad-hoc kata files. The skill pairs naturally with flow-nexus-platform for authentication, sandboxes, and broader platform operations.1kinstalls92Agent Crdt Synchronizeragent-crdt-synchronizer is a high-priority synchronizer skill from ruvnet/ruflo that brings conflict-free replicated data types to multi-agent workflows. The skill supports state-based CRDTs, operation-based CRDTs, delta synchronization, conflict resolution, and causal consistency so distributed agent instances converge without centralized locking. Pre-hooks prepare delta state computation when synchronization tasks run, and post-hooks finalize CRDT sync status for downstream coordinators. Developers invoke agent-crdt-synchronizer with $agent-crdt-synchronizer when collaborative agent pipelines share mutable state across nodes or intermittent networks. It complements agent-coordinator-swarm-init for swarm bootstrapping and agent-mesh-coordinator for peer consensus under fault tolerance. Use this skill when eventual consistency and CRDT merge semantics matter; skip it for simple file-based locks, Git merge workflows, or single-writer agent sessions that do not span instances.1kinstalls93Agent Github Pr Manageragent-github-pr-manager is a high-priority development skill from ruvnet/ruflo for complete GitHub pull request lifecycle automation. The skill covers PR creation, review coordination, merge management, conflict resolution, status tracking, and CI/CD integration inside agent-driven workflows. Pre-hooks verify GitHub CLI authentication with gh auth status and inspect current branch state before PR operations proceed. Developers invoke agent-github-pr-manager with $agent-github-pr-manager when agents should open PRs, chase reviews, resolve merge conflicts, and manage merges instead of manual gh commands. It fits ship-stage code review and integration gates for teams already standardized on GitHub CLI rather than web-only workflows. Pair it with repository CI pipelines so status-tracking hooks reflect check results. Skip it for non-GitHub hosts, projects without gh CLI authentication, or teams that forbid agent-driven merges without human approval policies.1kinstalls94Agent Hierarchical Coordinatoragent-hierarchical-coordinator is a ruflo hierarchical coordinator skill invoked as $agent-hierarchical-coordinator with critical priority for queen-led swarm orchestration. Capabilities include swarm coordination, task decomposition, agent supervision, work delegation, performance monitoring, and conflict resolution among specialized workers. Pre hooks initialize hierarchical swarm topology via mcp__claude-flow__swarm_init with adaptive strategy and maxAgents=10, then mandate coordination plan initialization before work starts. Developers reach for agent-hierarchical-coordinator when a single agent cannot cover a large feature and a queen must split work across focused sub-agents with oversight. The pattern mirrors engineering team leads breaking epics into tickets, assigning owners, and monitoring progress—implemented as an agent swarm rather than manual project management.1kinstalls95Agent Release Manageragent-release-manager is a ruvnet/ruflo development skill invoked with $agent-release-manager to orchestrate end-to-end software releases using ruv-swarm and GitHub MCP tools. The skill handles semantic version bumps, changelog drafting, branch and PR creation, PR merges, issue tracking, and coordinated deployment steps across multiple packages. Developers reach for agent-release-manager when a release spans several repositories or services and manual tagging, PR hygiene, and deployment sequencing become error-prone. Integrated tools include Bash, Read, Write, Edit, TodoWrite, Task, WebFetch, GitHub MCP actions, and claude-flow swarm_init, agent_spawn, and task orchestration hooks.1kinstalls96Agent Scout Exploreragent-scout-explorer is a ruflo scout-explorer agent skill acting as the reconnaissance specialist for hive-mind swarms that must map unknown codebases, documentation, dependencies, or market contexts before other agents act. The scout follows a mandatory reconnaissance protocol: explore targets, identify opportunities and threats, and report every discovery immediately to shared memory so downstream agents avoid duplicate work. Priority is high and the role is framed as the hive's sensors—continuous intelligence gathering rather than one-shot search. Invoke agent-scout-explorer when onboarding to a foreign repository, auditing dependencies, or scouting competitive or technical landscapes for a multi-agent workflow. The skill assumes ruflo memory coordination is available and pairs naturally with hive-mind orchestration for distributed decision making after exploration completes. Scout Explorer agents operate as the eyes of the hive mind, continuously updating memory coordination so builder and fixer agents inherit structured intelligence instead of repeating discovery passes.1kinstalls97Agent Sync Coordinatoragent-sync-coordinator is a ruvnet/ruflo coordination skill invoked with $agent-sync-coordinator to align versions, dependencies, and cross-package integration across multiple GitHub repositories. The skill uses GitHub MCP tools for push_files, create_or_update_file, get_file_contents, create_pull_request, search_repositories, and list_repositories alongside claude-flow swarm_init, agent_spawn, and task_orchestrate for intelligent multi-agent execution. Developers reach for agent-sync-coordinator when package versions drift, shared dependencies fall out of sync, or documentation references stale APIs across repos. The sync-coordinator agent type focuses on version alignment, dependency synchronization, and cross-package integration with swarm orchestration.1kinstalls98Agent V3 Queen Coordinatoragent-v3-queen-coordinator is a ruflo skill at version 3.0.0-alpha invoked as $agent-v3-queen-coordinator for large-scale swarm orchestration. Metadata defines a critical-priority orchestrator role with concurrency_limit 1, agent_id 1, and phase all, targeting 15-agent concurrent coordination across a 14-week v3 delivery plan. The coordinator implements ADR-001 through ADR-010 and uses hierarchical mesh topology for GitHub issue management and cross-agent synchronization. Pre_execution hooks announce 15-agent swarm startup and verify intelligence status before work proceeds. Developers reach for agent-v3-queen-coordinator when hierarchical coordinators capped at ten agents are insufficient and GitHub-tracked multi-agent delivery needs a queen mesh orchestrator with documented architecture decisions.1kinstalls99Agent Gossip Coordinatoragent-gossip-coordinator is a ruflo Flow Nexus coordinator skill invoked as $agent-gossip-coordinator for gossip-based multi-agent consensus. Capabilities include epidemic dissemination, peer selection, state synchronization, conflict resolution, and scalability optimization for eventually consistent agent swarms. Pre-execution hooks initialize peer network topology when dissemination tasks run, and post hooks finalize gossip protocol cycles after broadcasts complete. Developers reach for agent-gossip-coordinator when centralized orchestration bottlenecks and agents must propagate updates peer-to-peer across larger swarms. The skill suits experiments in decentralized agent collaboration—shared memory convergence, distributed task awareness, or resilient state fan-out—where strict immediate consistency is less important than horizontal scale.999installs100Agent User Toolsagent-user-tools is a ruflo Flow Nexus skill invoked as $agent-user-tools that specializes in user management and system utilities for agent-driven applications. The agent handles user profiles, preferences, and account configuration; manages file storage, organization, and access control; supports real-time subscriptions; and performs platform administration tasks. Developers reach for agent-user-tools when building SaaS or agent platforms on Flow Nexus that need authenticated user context, stored artifacts, live updates, and operational admin actions without bespoke backend glue. The skill consolidates utility operations that otherwise scatter across separate APIs, letting coding agents configure accounts, move files, and maintain platform health through one coordinated specialist.999installs101Flow Nexus Platformflow-nexus-platform is a version 1.0.0 Flow Nexus skill tagged with authentication, sandboxes, deployment, payments, gamification, and cloud. It covers authentication and user management, sandbox management, app store deployment, payments and credits, and coding challenges in one platform guide. Developers reach for flow-nexus-platform when their coding agent must authenticate users, run code in sandboxes, publish apps, manage credits, or orchestrate challenge workflows on Flow Nexus. The skill complements agent-challenges for deeper gamification while handling the full platform surface area.998installs102Skill Builderskill builder is a ruflo Skill Builder agent skill that guides creation of custom Claude Code Skills with valid YAML frontmatter, progressive disclosure architecture, and full file-and-folder layout. The skill targets Claude Code 2.0+ and explains how skills are discovered across Claude.ai, Claude Code, SDK, and API surfaces. Developers reach for skill builder when they need repeatable workflow packaging—turning tribal prompt knowledge into autonomously discoverable skills with templates and spec-compliant structure. It covers prerequisites, directory organization, and progressive disclosure so agents load only the context needed per task. Use it whenever a team outgrows one-off instructions and wants maintainable, shareable skill packages rather than unstructured markdown notes.998installs103Agent Implementer Sparc Coderagent-implementer-sparc-coder is a Ruflo agent skill that implements the SPARC coder role for specification-to-code delivery with test-driven development. The skill runs a Red → Green → Refactor loop, scaffolds missing test directories, and supports code generation, test implementation, refactoring, optimization, documentation, and parallel execution. Pre-execution hooks verify whether tests/, test/, or __tests__/ exist and prepare the TDD workflow before code generation begins. Developers reach for agent-implementer-sparc-coder when they have a written spec or feature brief and want an agent to produce working, tested implementation rather than untested stubs. The skill declares high priority and six core capabilities spanning generation through documentation in the ruflo agent roster.997installs104Agent Migration Planagent-migration-plan is a ruvnet/ruflo planning skill that analyzes an existing .claude/commands directory and produces a comprehensive migration plan for converting command files into an agent-based system. Capabilities include migration planning, system transformation, agent mapping, compatibility analysis, and rollout coordination. The skill activates when a commands folder exists and maps each command to corresponding agent definitions. Developers reach for agent-migration-plan when upgrading Claude Code command workflows to the newer agent invocation model without losing command coverage or rollout order.997installs105Agent Multi Repo Swarmagent-multi-repo-swarm is a ruvnet/ruflo coordination skill for cross-repository swarm orchestration and organization-wide agent collaboration. It uses Bash, Read, Write, Edit, Glob, Grep, LS, and TodoWrite alongside claude-flow MCP tools including swarm_init, agent_spawn, task_orchestrate, swarm_status, memory_usage, github_repo_analyze, github_pr_manage, and github_sync_coord. Developers reach for agent-multi-repo-swarm when automation must span several GitHub repos simultaneously—analyzing repos, managing PRs, and syncing coordinated changes. Invoke with $agent-multi-repo-swarm when cross-repo agent swarms replace single-repository agent loops.997installs106Agent Pagerank Analyzeragent-pagerank-analyzer is a Ruflo expert agent skill specialized in graph analysis and PageRank calculations with sublinear algorithms. The agent analyzes influence propagation, optimizes communication topologies, and computes large-scale graph metrics for agent swarms, social networks, web graphs, recommendation engines, and distributed system layouts. Developers reach for agent-pagerank-analyzer when routing, ranking, or coordination patterns depend on centrality and network structure rather than simple round-robin dispatch. The skill targets network optimization, influence analysis, swarm topology design, and recommendation-system graph modeling as stated in its agent definition.997installs107Agent Quorum Manageragent-quorum-manager is a Ruflo coordinator agent skill that implements dynamic quorum adjustment and intelligent membership management across distributed agent networks. The skill provides dynamic_quorum_calculation, membership_management, network_monitoring, weighted_voting, and fault_tolerance_optimization as declared capabilities. Pre-execution hooks analyze network topology and node health when quorum tasks are detected, and post hooks validate completed quorum adjustments. Developers reach for agent-quorum-manager when agent collectives must reach consensus despite membership churn, uneven node health, or partial failures. The skill is marked high priority in the ruflo roster for coordination-heavy agent workflows.997installs108Agent V3 Integration Architectagent-v3-integration-architect is a Ruflo V3 architect agent skill at version 3.0.0-alpha updated 2026-01-04 for deep agentic-flow@alpha integration. The skill implements ADR-001 to eliminate 10,000+ duplicate lines and positions claude-flow as a specialized extension rather than a parallel implementation. Developers reach for agent-v3-integration-architect when multiple agentic codebases overlap and need a unified integration boundary instead of forked maintenance. The agent carries architect role metadata with agent_id 10, high priority, and integration-phase hooks that start agentic-flow deep integration on execution.997installs109Agent V3 Performance Engineeragent-v3-performance-engineer is a Ruflo V3 specialist agent skill at version 3.0.0-alpha updated 2026-01-04 responsible for aggressive performance targets across AI agents and inference pipelines. The skill targets 2.49x–7.47x Flash Attention speedup and 150x–12,500x search improvements alongside a comprehensive benchmarking suite. Pre-execution hooks announce optimization missions and performance targets before work begins. Developers reach for agent-v3-performance-engineer when agent orchestration or inference paths miss latency budgets and need structured profiling rather than ad hoc tweaks. The agent carries specialist role metadata with agent_id 14, high priority, and performance-domain classification.997installs110Worker Integrationworker-integration is a version 1.0.0 invocable ruvnet/ruflo skill for Worker-Agent integration in agentic-flow. It provides intelligent task dispatch from background workers to specialized agents, with performance_tracking, memory_coordination, agent_selection, and self_learning capabilities. Developers use npx agentic-flow workers agents for trigger-specific recommendations such as ultralearn or optimize, npx agentic-flow workers metrics for performance data, and npx agentic-flow workers stats --integration for coordination stats. Reach for worker-integration when worker triggers need automated agent routing instead of hard-coded handler maps.996installs111Worker Benchmarksworker-benchmarks is a version 1.0.0 invocable skill from ruvnet/ruflo for the agentic-flow worker system. It runs npx agentic-flow workers benchmark for a full suite or targets four benchmark types: trigger-detection, registry, agent-selection, and concurrent. Capabilities include performance_testing, metrics_collection, and optimization_recommendations so engineers can profile worker bottlenecks before scaling task dispatch. Developers reach for worker-benchmarks when agentic-flow workers need quantified baselines instead of guessing registry or selection latency under load.995installs112Agent Benchmark Suiteagent-benchmark-suite is a rufnet/ruflo Benchmark Suite agent skill for comprehensive performance benchmarking, regression detection, and performance validation on AI agents and multi-agent swarms. It automates standardized tests covering latency, throughput, and coordination so teams can compare runs and catch regressions before release. Developers invoke it with $agent-benchmark-suite when agent workflows need quantified performance baselines instead of ad-hoc manual timing. The skill positions itself as a Performance Optimization Agent specializing in automated benchmarking frameworks for agentic systems.994installs113Agent Byzantine Coordinatoragent-byzantine-coordinator is a ruvnet/ruflo coordinator agent skill that runs Byzantine fault-tolerant consensus protocols across multiple AI agents when some participants may behave maliciously or return inconsistent outputs. The skill exposes capabilities including PBFT consensus, malicious-actor detection, message authentication, view management, and attack mitigation so multi-agent pipelines can agree on results despite faulty nodes. Developers reach for agent-byzantine-coordinator when orchestrating agent swarms, delegated coding tasks, or verification chains where a single rogue agent could poison downstream decisions without cryptographic-style checks. Pre- and post-hooks verify network integrity before consensus rounds and log coordinator completion status. The coordinator type is marked high priority within the ruflo skill graph. Use agent-byzantine-coordinator when reliability requirements exceed simple majority voting or sequential agent handoffs in distributed agent workflows.994installs114Agent Authenticationagent-authentication (flow-nexus-auth) from ruvnet/ruflo is a Flow Nexus authentication and user management specialist skill invoked with $agent-authentication. The agent handles user registration and login through Flow Nexus MCP tools, manages sessions, and performs account operations including profile updates within the Flow Nexus cloud platform. Core responsibilities cover seamless user onboarding, secure authentication flows, and comprehensive account management for agent-built cloud apps. Developers reach for agent-authentication when their AI coding agent needs to wire login, registration, session, and profile workflows into a Flow Nexus application without hand-writing auth integration boilerplate.993installs115Agent Queen Coordinatoragent-queen-coordinator is a Ruflo hive-mind skill embodying the Queen Coordinator persona at the apex of a hierarchical agent swarm. The coordinator makes strategic decisions, allocates resources across specialized worker agents, and enforces coherence through a hybrid centralized-decentralized control model flagged as critical priority. Developers invoke it when building multi-agent systems that need a single sovereign orchestrator rather than flat peer-to-peer agent chains. The skill defines core responsibilities for strategic planning, resource routing, and swarm state consistency. Use agent-queen-coordinator when agent count grows beyond simple handoffs and requires top-down task decomposition with bottom-up result aggregation.993installs116Agentdb Vector Searchagentdb vector search is a Ruflo skill that implements semantic vector search with AgentDB v1.0.7+, advertising 150x–12,500x faster operations than traditional solutions and sub-millisecond HNSW search under 100µs. It requires Node.js 18+ and an OpenAI API key or custom embedding model to index documents, run similarity matching, and power context-aware queries in RAG systems and intelligent knowledge bases. Developers reach for it when wiring retrieval into coding agents or chat backends where brute-force cosine scans choke on growing document corpora. The skill covers HNSW indexing and quantization configuration through agentic-flow or standalone AgentDB installs.991installs117Hooks Automationhooks automation is a Ruflo agent skill that installs an intelligent hook system for Claude Code sessions. It provides pre and post task hooks, session management, Git integration, memory coordination, and neural pattern training connected to MCP tools so operations are validated and formatted automatically. The skill targets developers running sustained agentic coding who want every edit, commit, and task transition coordinated without manual oversight. hooks automation spans multiple workflow phases because hooks fire across tasks, sessions, and Git events rather than a single build step. Use it when Claude Code needs persistent automation across a repository instead of one-off formatting or lint commands.991installs118V3 Ddd Architecturev3 ddd architecture is a Claude Code skill from ruvnet/ruflo for implementing Domain-Driven Design in claude-flow v3 agent projects. The skill decomposes god objects into bounded contexts, applies clean architecture separation, and uses a microkernel pattern for modular, testable agent code. It supports parallel domain modeling tasks and architecture analysis via claude-flow Task invocations. Developers reach for v3 ddd architecture when agent repositories become hard to test, boundaries blur between domains, or a refactor toward maintainable module boundaries is required mid-build.989installs119Agent Base Template Generatoragent-base-template-generator is a Claude Code skill from ruvnet/ruflo invoked as $agent-base-template-generator for creating foundational boilerplate. It generates well-structured base templates for new projects, React components, API endpoints, and features following best practices that developers can customize. Example triggers include starting a user profile component or scaffolding a new service module. Developers reach for agent-base-template-generator at the start of features when repetitive setup slows delivery and a consistent starter pattern is preferred over blank files.988installs120Reasoningbank IntelligenceReasoningBank Intelligence is a Claude Code skill from ruvnet/ruflo that implements ReasoningBank's adaptive learning system for AI agents. It enables pattern recognition, strategy optimization, and continuous improvement from task outcomes, supporting meta-cognitive agent behavior. The skill expects agentic-flow v1.5.11+, AgentDB v1.0.4+ for persistence, and Node.js 18+, with TypeScript import examples for ReasoningBank integration. Developers reach for ReasoningBank Intelligence when building self-learning agents, optimizing multi-step workflows, or adding experience-driven strategy selection to agentic-flow projects.987installs121V3 Cli ModernizationV3 CLI Modernization is a Claude Code skill from ruvnet/ruflo that upgrades claude-flow v3 CLI with interactive prompts, intelligent command decomposition, enhanced hooks integration, performance optimization, and workflow automation. It analyzes monolithic CLI structure, identifies optimization opportunities, and implements modular hook-driven patterns. Developers reach for V3 CLI Modernization when refactoring a Claude-powered CLI, adding interactive command flows, or deepening hooks-based automation in claude-flow v3 projects.987installs122Reasoningbank With Agentdbreasoningbank-with-agentdb is a Claude Code skill from ruvnet/ruflo that pairs ReasoningBank adaptive learning with AgentDB, a high-performance vector database for agent memory. It supports experience replay, memory distillation, and continuous decision improvement across agent sessions. The skill fits ruflo agent stacks where learning outcomes must persist in vector storage rather than ephemeral context. Developers reach for reasoningbank-with-agentdb when agents need durable experience banks, replay-based strategy refinement, and distilled long-term memory on top of ReasoningBank patterns.986installs123V3 Core ImplementationV3 Core Implementation is a Claude Code skill from ruvnet/ruflo that builds claude-flow v3 core TypeScript modules following Domain-Driven Design, clean architecture, dependency injection, and comprehensive test coverage. It sets up DDD domain structure, base classes, and parallel Task-driven domain implementations such as task domains. Developers reach for V3 Core Implementation when scaffolding the foundational backend of claude-flow v3 with modular domains, DI patterns, and production-ready TypeScript architecture instead of ad-hoc agent scripts.986installs124Agentdb Memory Patternsagentdb memory patterns provides memory management patterns for AI agents built on AgentDB persistent storage with ReasoningBank integration. The skill covers session memory, long-term storage, pattern learning, and context management so agents remember conversations and maintain state across sessions. The readme cites 150x–12,500x performance gains versus traditional solutions with 100% backward compatibility. Prerequisites include Node.js 18+ and AgentDB. Developers reach for this skill when building stateful agents, multi-turn chat systems, or intelligent assistants that must recall prior interactions and learned patterns.985installs125Agentdb Performance Optimizationagentdb performance optimization focuses on lowering memory consumption and speeding vector search and pattern retrieval in AgentDB-backed agent applications. The skill guides tuning strategies for embedding indexes, cache layers, and retrieval hot paths so multi-agent systems sustain lower RAM footprints and faster query latency under load. Developers reach for agentdb performance optimization when AgentDB memory growth or slow similarity search blocks production agent deployments. Catalog listing describes performance-oriented AgentDB workflows; confirm the local skill readme matches before applying version-specific tuning parameters.984installs126V3 Deep Integrationv3 deep integration guides merging the claude-flow project into agentic-flow@alpha as a specialized extension within the ruflo agent platform. The stated goal is eliminating more than 10,000 lines of duplicated code by unifying orchestration paths, shared modules, and extension boundaries between the two frameworks. Developers reach for v3 deep integration when maintaining parallel claude-flow and agentic-flow codebases becomes unsustainable and a single integrated agentic-flow alpha architecture is required. Catalog metadata describes this consolidation workflow; validate repository layout and alpha APIs locally before executing large-scale merges.984installs127V3 Memory UnificationV3 Memory Unification is a ruflo skill that merges disparate agent memory systems into one AgentDB backend with HNSW vector search, implementing ADR-006 (Unified Memory Service) and ADR-009 (Hybrid Memory Backend). The skill guides initialization, indexing configuration, and migration while preserving backward compatibility with existing memory APIs. Developers reach for V3 Memory Unification when agent recall latency or consistency across memory stores blocks production agent workflows. Documented benchmarks cite 150x–12,500x search performance improvements after unification. Quick-start flows invoke specialist tasks such as v3-memory-specialist for architecture design and AgentDB HNSW setup.984installs128Agentdb Advanced Featuresagentdb advanced features documents advanced AgentDB capabilities for distributed multi-agent architectures. The skill covers QUIC-based synchronization between agent nodes, hybrid vector search combining lexical and embedding retrieval, configurable custom distance metrics for similarity ranking, and multi-database coordination across agent memory stores. Developers reach for agentdb advanced features when scaling beyond single-node AgentDB deployments and needing networked agent state, flexible retrieval ranking, or federated storage patterns. Catalog metadata describes these integration surfaces; verify local SKILL.md content matches before relying on version-specific API details.983installs129Agentdb Learning Pluginsagentdb learning plugins is a ruflo skill focused on creating and training self-improving reinforcement learning plugins that extend autonomous agents through the AgentDB ecosystem. The skill guides plugin scaffolding, training loops, and integration so agents can refine behavior from feedback without manual prompt rewrites. Developers reach for agentdb learning plugins when building adaptive multi-step agents that must learn from outcomes stored in AgentDB. It pairs with other ruflo v3 memory and coordination skills for end-to-end agent platforms. Use it during build-phase agent-tooling when static tool registries no longer capture evolving task performance.983installs130V3 Mcp OptimizationV3 MCP Optimization is a ruflo skill that accelerates claude-flow v3 Model Context Protocol servers through transport-layer tuning, connection pooling, load balancing, tool registry optimization, and performance monitoring. The documented target is sub-100ms MCP tool response times for agent workflows blocked by slow round trips. Quick-start flows invoke mcp-specialist tasks to analyze bottlenecks and apply pooling and registry changes incrementally. Developers reach for V3 MCP Optimization after MCP integrations work functionally but lag under concurrent agent load. It complements swarm coordination and memory unification skills in large ruflo v3 deployments.983installs131V3 Swarm CoordinationV3 Swarm Coordination is a ruflo skill that launches and manages a 15-agent hierarchical mesh swarm for claude-flow v3, parallelizing work across security, core, and integration domains while respecting dependencies. The approach follows 10 architecture decision records across a documented 14-week timeline, with Phase 1 prioritizing the security domain. Quick-start commands initialize the swarm via v3-queen-coordinator tasks and route domain-specific work to specialized agents. Developers reach for V3 Swarm Coordination when a v3 migration exceeds single-agent capacity and requires governed parallel execution. It integrates with memory unification and MCP optimization skills for full-stack agent platform delivery.983installs132Verification & Quality AssuranceVerification & Quality Assurance is an agent skill that delivers comprehensive truth scoring, automated correctness checks, security validation, and an automatic rollback system for agent-generated code and outputs. It calculates live reliability metrics on a 0.0-1.0 scale, runs regression-guard jobs, maintains a witness manifest, and exports results for CI/CD pipelines. Builders receive statistical trend analysis, confidence intervals, real-time monitoring, and instant reversion of any change that falls below the 0.95 accuracy threshold. The concrete shipped components include six regression-guard jobs plus the witness manifest and tool-discoverability audit that execute on every push. This skill gives solo developers confidence that agent outputs meet production standards without manual review of every diff.982installs133V3 Performance OptimizationV3 Performance Optimization is a Claude-flow v3 agent skill that validates and tunes multi-agent runtime performance through Flash Attention, AgentDB HNSW indexing, and continuous benchmarking. The skill establishes v2 baselines, runs parallel validation tasks, and drives toward documented targets including 2.49x–7.47x Flash Attention speedups, 150x–12,500x search gains, and 50–75% memory reduction. Developers reach for V3 Performance Optimization when claude-flow v3 search, attention, or memory metrics miss SLA after feature work. It pairs specialized v3-performance-engineer agents with repeatable benchmark workflows rather than one-off manual profiling.981installs134V3 Security OverhaulV3 Security Overhaul is a claude-flow v3 agent skill that orchestrates comprehensive security remediation across threat modeling, CVE fixes, and secure-by-default development practices. The skill addresses critical vulnerabilities CVE-1, CVE-2, and CVE-3 through parallel specialized agents including v3-security-architect for threat models and security boundaries. Developers reach for V3 Security Overhaul when implementing claude-flow v3 and need systematic elimination of critical flaws before agents gain filesystem, network, or spawn permissions. It coordinates security architecture design with concrete CVE remediation rather than ad-hoc patch lists.981installs135Cron Schedulecron-schedule is a ruvnet/ruflo skill that registers durable background workers using CronCreate with standard five-field cron expressions and prompt payloads. Workers survive session restarts and can dispatch hooks such as mcp__claude-flow__hooks_worker-dispatch for security audits, performance optimization, memory consolidation, and codebase mapping. The skill documents recommended intervals including */15 for audits, */30 for optimize and map workers, and hourly consolidate jobs. Developers reach for cron-schedule when agent workflows must run on a timer without standing up separate cron daemons or cloud schedulers. CronList and CronDelete support listing and removing registered workers.814installs136Iot Firmwareiot-firmware is a Claude Code skill in ruvnet/ruflo that orchestrates firmware rollouts across IoT device fleets using canary deployment and anomaly-gated advancement. It exposes deploy, advance, rollback, status, and list commands executed via npx @claude-flow/plugin-iot-cognitum cognitum-iot firmware. Developers reach for iot-firmware when managing fleet-wide firmware updates from an agent session instead of manual CLI repetition. The skill integrates with claude-flow memory tools and supports argument hints for each rollout operation.808installs137Api Docsapi-docs is a ruflo agent skill that generates accurate API documentation directly from TypeScript and JavaScript source code. The workflow scans public functions, classes, and interfaces, parses existing JSDoc @param, @returns, @throws, and @example tags, fills gaps for undocumented public APIs, and emits OpenAPI 3.0 definitions for HTTP endpoints. It dispatches documentation work via MCP using claude-flow hooks_worker-dispatch with trigger document and scope api. Developers reach for api-docs when OpenAPI specs drift from implementation, when exported functions lack JSDoc, or when they need agent-driven doc generation from a source path argument without manually maintaining separate reference files.798installs138Deep Researchdeep-research is an agent research skill for developers who need thorough, multi-source investigation before choosing a feature, architecture, or product direction. The skill coordinates claude-flow MCP capabilities including memory_store, memory_search, agentdb hierarchical store/recall, pattern search/store, neural_predict, hooks intelligence pattern tools, and task_create/list orchestration. Developers invoke deep-research with a topic argument when they want evidence gathered across sources, prior session memory, and stored patterns, then synthesized into structured findings rather than a single web snippet. The workflow is designed for decision gates where shallow answers would create rework downstream.797installs139Session Persistsession-persist is a skill from ruvnet/ruflo that persists and restores agent sessions across conversations via claude-flow MCP tools including session_save, session_restore, session_list, session_info, session_delete, and session hooks. It supports CLI-style arguments `--save`, `--restore`, and `--list` for checkpointing long-running implementation work and resuming with full context later. Allowed tools span mcp__claude-flow__ session operations plus Bash for orchestration. Developers reach for session-persist when multi-hour refactors or investigations must pause without losing tool results, decisions, or partial edits, and when they want durable checkpoints during lengthy agent-driven builds.686installs140Goal Plangoal-plan is a rufnet/ruflo agent skill that turns vague ideas into Goal-Oriented Action Plans (GOAP) with precondition analysis, cost optimization, and adaptive replanning before and during implementation. The skill wires agents to claude-flow MCP tools for task_create, task_list, task_assign, task_complete, memory_store, memory_search, workflow_create, workflow_execute, and related hooks so plans persist across sessions. Developers supply a goal description; goal-plan breaks it into ordered steps with clear success criteria and adjusts when blockers appear. Reach for goal-plan when a multi-step feature, migration, or integration needs explicit sequencing instead of open-ended agent chat. Skip goal-plan for single-file edits or tasks with an obvious one-step fix. goal-plan spans planning through execution and replanning, making it multi-phase rather than a one-shot pre-build checklist.679installs141Pii Detectpii-detect is a PII and secrets detection skill from ruvnet/ruflo that scans text, code, and configuration before data enters commits, logs, storage, or LLM responses. It targets emails, phone numbers, SSNs, API keys, passwords, and related sensitive patterns through aidefence MCP tools including aidefence_has_pii, aidefence_scan, aidefence_analyze, and transfer_detect-pii, with Bash available for local inspection. Developers invoke pii-detect with an input-text argument hint when reviewing diffs, sanitizing logs, or validating agent output prior to push. The skill complements broader security review by catching accidental credential and identity leakage early in the development loop rather than after production exposure.674installs142Iot Fleetiot-fleet is a ruvnet/ruflo agent skill for creating and managing Cognitum Seed device fleets with firmware policies via the @claude-flow/plugin-iot-cognitum package. Subcommands include fleet create with --name, fleet list, fleet add FLEET_ID DEVICE_ID, fleet remove, and fleet delete, each invoked through npx -y -p @claude-flow/plugin-iot-cognitum@latest cognitum-iot. The skill integrates with claude-flow memory tools for persistent fleet context and allows Bash execution for fleet orchestration. Developers reach for iot-fleet when provisioning IoT fleets, attaching devices, enforcing firmware policies, or auditing fleet membership through an AI agent interface.673installs143Browser Scrapebrowser-scrape is a ruflo plugin skill deprecated since v0.2.0 and scheduled for removal in v0.3.0. It remains a thin backward-compatibility shim pointing developers to browser-extract, which adds RVF cognitive containers per session, mandatory AIDefence PII and prompt-injection gates, persistent browser-templates namespaces, and automatic browser-selectors updates for DOM drift recovery. The legacy skill accepts a URL argument and uses allowed tools Bash and Read. Developers should invoke browser-extract instead; browser-scrape only matters when older ruflo workflows or scripts still reference the v0.1 interface.672installs144Cognitive Patterncognitive-pattern is a Ruflo skill for codifying reasoning strategies, decision trees, and problem-solving approaches that Claude, Cursor, or Codex agents can reuse and refine. It calls MCP tools such as daa_cognitive_pattern, daa_workflow_create, daa_workflow_execute, and daa_knowledge_share to define patterns, wire workflows, and track learning status. Developers reach for cognitive-pattern when agent outputs are inconsistent and they want explicit, versionable reasoning scaffolds instead of ad-hoc prompts for complex multi-step decisions.667installs145Discover Pluginsdiscover-plugins is a Claude skill from ruvnet/ruflo that finds relevant MCP servers and agent skills using ruflo transfer MCP tools such as plugin-search, plugin-featured, store-search, store-trending, and guidance_recommend. It accepts an optional search-query argument and reads installed MCP status before recommending installs. Allowed tools include Bash and Read for inspecting the local environment alongside claude-flow guidance endpoints. Developers reach for discover-plugins when starting a new automation task, expanding an agent toolchain, or replacing a missing integration with a catalog-backed MCP server or skill.667installs146Init Projectinit-project is a Ruflo bootstrap skill that runs npx @claude-flow/cli@latest init to wire MCP tools, hooks, and agent configs into a fresh repository. It supports --wizard interactive setup or --preset standard|minimal|full for non-interactive defaults, creating CLAUDE.md, .claude/settings.json, and a .claude-flow/ directory with ruflo MCP server registration. Developers reach for init-project when starting a new repo and need agent-ready configuration instead of manually copying MCP and hook files from documentation.667installs147Browser Testbrowser-test is a UI test recipe skill from ruvnet/ruflo that chains browser-record for capture with browser-replay for verification through Claude Flow browser MCP tools. Each test run produces a replayable RVF artifact rather than a one-off ephemeral session, supporting arguments like a target URL, optional screenshots, and comparison against a prior session ID. The skill exposes click, fill, type, select, hover, wait, screenshot, and snapshot actions via mcp__claude-flow__browser_* tools. Developers reach for browser-test when they need reproducible agent-driven UI tests with recorded sessions they can replay and diff across builds.665installs148Ruflo Doctorruflo-doctor is a Ruflo health-check skill that executes npx @claude-flow/cli@latest doctor --fix to scan and repair a Claude-Flow/Ruflo stack. The doctor command validates Node.js 20+, npm 9+, git, config validity, daemon status, memory database, API keys, MCP servers, disk space, and TypeScript setup, then applies targeted fixes such as memory init --force, daemon start, and config reset. Developers reach for ruflo-doctor when agent workflows stall, MCP connections fail, daemons are down, or Ruflo config drift breaks local runs. The skill accepts an optional --fix flag via argument-hint and restricts tooling to Bash(npx *) for safe CLI invocation. Outputs are a pass/fail diagnostic report plus applied repair actions agents can rerun until the stack is green.664installs149Autopilot Loopautopilot-loop is a skill from ruvnet/ruflo that executes a single autonomous loop iteration in Claude Code. Each pass calls `mcp__claude-flow__autopilot_status`, stops with `autopilot_disable` when tasks finish or max iterations hit, fetches the next action from `autopilot_predict`, executes that work, then schedules another wake via native `/loop`. Allowed tools include autopilot_status, autopilot_predict, autopilot_log, autopilot_progress, autopilot_disable, ScheduleWakeup, and Agent. Developers reach for it when long tasks need self-correction without constant prompting. The skill composes Claude Code looping with ruflo autopilot telemetry.662installs150Test Gapstest-gaps is a ruvnet ruflo skill that finds coverage holes and suggests next tests after feature work. CLI commands include `npx @claude-flow/cli@latest hooks coverage-gaps --format table --limit 20`, `hooks coverage-route --task`, and `hooks coverage-suggest --path src/`. Optional flags `--path PATH` and `--limit N` scope analysis. Alternatively, dispatch the testgaps worker through `mcp__claude-flow__hooks_worker-dispatch`. Developers reach for test-gaps when asking what still needs tests, auditing untested modules, or closing coverage gaps before PR merge. Bash, Read, and Grep permissions support local codebase inspection alongside CLI output.662installs151Memory Searchmemory-search is a state-of-the-art semantic retrieval skill for the Ruflo agent memory system, exposing hybrid sparse+dense search, Graph RAG multi-hop traversal, MMR diversity reranking, and recency weighting through Claude Flow MCP tools like memory_search, memory_store, memory_retrieve, and agentdb_context-synthesize. Developers reach for memory-search when a coding agent must recall architecture choices, naming conventions, or debugging conclusions from earlier sessions instead of re-scanning the repository. Strategy selection is query-driven: dense for fast single-hop lookups, --hybrid for keyword-heavy questions, and --graph-rag for multi-hop reasoning across linked memory nodes. Namespace scoping keeps team or project memories isolated while unified search spans stored artifacts.661installs152Research Synthesizeresearch-synthesize is a ruflo agent skill that pulls findings from Claude Flow memory and AgentDB tools, then outputs structured reports with evidence grading, contradiction resolution, and recommendations. It supports `--format report`, `brief`, or `table` outputs and chains memory search, unified search, retrieve, store, context-synthesize, and pattern-search MCP calls. Developers reach for research-synthesize after deep-research or web gathering when raw notes must become a single actionable brief before scoping or building. The skill is intended for agent sessions with Read, Write, and Bash access in Claude Code or similar environments.661installs153Vector Searchvector-search is a RuFlo Claude Flow skill for vector search via embeddings_generate, embeddings_search, embeddings_compare, embeddings_init, embeddings_status, embeddings_hyperbolic, embeddings_neural, embeddings_rabitq_build, embeddings_rabitq_search, embeddings_rabitq_status, and ruvllm_hnsw_create MCP tools. Large-scale retrieval uses HNSW indexes; a WASM router handles up to 11 hot patterns through ruvllm_hnsw endpoints. RaBitQ 1-bit quantization provides 32× memory reduction for quantized searches invoked with --quantized. Developers pass a query and optional --limit N when agents need semantic pattern lookup, embedding comparison, or memory-efficient recall. The skill suits claude-flow pipelines combining RuVLLM HNSW with standard embeddings backends for hybrid retrieval strategies.660installs154Ddd Aggregateddd-aggregate is a ruvnet/ruflo skill for developers adding a new aggregate to an existing bounded context without hand-writing boilerplate. Pass arguments as `<context-name> <aggregate-name>` to generate an aggregate root package with entity, value objects, repository interface, domain events, and test stubs aligned to DDD conventions. The skill integrates Claude-Flow MCP memory and hook tools—memory_store, memory_search, agentdb_hierarchical-store, hooks_pre-task, hooks_post-task—plus Bash, Read, Write, Edit, Grep, and Glob for repo-aware scaffolding. Use ddd-aggregate when modeling a business concept that owns invariants and needs the entity-repository-events triplet. Skip it for anemic CRUD endpoints or UI-only features without domain rules to enforce.659installs155Dependency Checkdependency-check is a security skill in ruvnet/ruflo that audits third-party packages before merge or deploy using Claude Flow CLI and npm audit. It runs commands such as `npx @claude-flow/cli@latest security cve --list`, `security cve --severity critical`, `security scan --type deps --depth deep`, and `npm audit --json`, then maps findings to severity-driven actions like blocking critical issues. Developers reach for dependency-check after lockfile changes, `npm install`, release prep, or when investigating a published CVE advisory. The skill accepts an optional `--path` argument, stores results via `mcp__claude-flow__memory_store`, and is designed for agent workflows that must validate supply-chain risk without manual CLI scripting.659installs156Diff Analyzediff-analyze is a ruvnet ruflo skill that inspects git diffs before commits or pull requests using six claude-flow MCP analyze tools: analyze_diff, analyze_diff-risk, analyze_diff-classify, analyze_diff-reviewers, analyze_diff-stats, and analyze_file-risk. Developers invoke it when preparing large or cross-module PRs, assessing merge risk, or picking appropriate reviewers. Optional arguments include `--branch BRANCH` and `--pr PR#` for targeted analysis. The skill also permits Bash for local git context. Outputs include risk scores, change classifications, reviewer suggestions, and per-file risk breakdowns so teams catch high-impact diffs early instead of discovering issues in late review.659installs157Neural Trainneural-train is a ruvnet/ruflo skill that trains SONA plus MicroLoRA neural patterns from successful task completions, executing the DISTILL and CONSOLIDATE phases of a documented four-step pipeline. CLI flags include --pattern-type coordination|edit|task, --epochs N, and --microlora, routed through Claude-flow MCP tools such as neural_train, neural_status, neural_patterns, neural_predict, neural_optimize, neural_compress, and intelligence trajectory hooks. Developers invoke neural-train inside terminal or agent workflows when prior runs produced high-quality edits or coordination traces worth compressing into reusable patterns. The skill targets small learned behaviors for coding agents rather than full foundation-model fine-tuning. Reach for neural-train after collecting successful trajectories you want agents to replay with lower variance on similar tasks. Intelligence trajectory hooks cover pretrain, trajectory-start, trajectory-step, and trajectory-end events so multi-step agent runs feed the DISTILL phase with coordination, edit, or task pattern labels. neural_status and neural_patterns MCP calls report training progress before predict and optimize reuse consolidated weights.659installs158Security Scansecurity-scan is a ruvnet/ruflo security skill that orchestrates Claude Flow CLI scans across quick, standard, and deep depth levels before merges or production deploys. It runs `npx @claude-flow/cli@latest security scan --depth DEPTH --output json`, lists CVEs via `security cve --list`, and exports STRIDE threat models with `security threats --model stride --export md`. Developers invoke it when reviewing PRs for security regressions, auditing authentication and input-handling paths, or responding to a user request for a security check. The skill uses Bash, Read, Grep, `mcp__claude-flow__memory_store`, and `mcp__claude-flow__hooks_post-task` to persist findings and hook post-task workflows, making it suited for agent-driven release gates rather than one-off manual pentests.659installs159Daa Agentdaa-agent is a ruvnet/ruflo skill for creating Dynamic Agentic Architecture (DAA) agents that go beyond static configurations. It exposes create, adapt, and status flows through MCP tools including daa_agent_create, daa_agent_adapt, daa_learning_status, daa_performance_metrics, and daa_knowledge_share, plus Bash access. Developers use it when agents must adapt behavior from performance data, learn across interactions, and share knowledge with peer agents. The argument hint supports create, adapt, and status modes. Reach for daa-agent when building autonomous research, planning, coding, and iteration agents that improve over time rather than one-shot prompt chains.656installs160Monitor Streammonitor-stream is an observability skill in ruvnet/ruflo for real-time Claude Flow swarm monitoring. Instead of polling `swarm status` in a loop, it runs `npx @claude-flow/cli@latest swarm watch --stream` through the Monitor tool, emitting NDJSON lines for agent spawns, task completions, memory writes, and health checks where each stdout line triggers a notification. For one-shot snapshots it falls back to `mcp__claude-flow__swarm_status` or `mcp__claude-flow__swarm_health`. Developers reach for monitor-stream when debugging long-running agent workflows, watching swarm health during orchestration, or acting on live infrastructure and API event streams. ADR-091 documents the rationale for streaming over polling in agent operations.656installs161Horizon Trackhorizon-track is a RuFlo Claude Flow skill that tracks long-horizon objectives across multiple sessions with milestone checkpoints, progress persistence, and drift detection. It uses claude-flow memory_store, memory_search, memory_list, memory_retrieve, task_list, task_summary, progress_check, progress_summary, agentdb_hierarchical-store, agentdb_hierarchical-recall, hooks_intelligence_pattern-store, session_save, and session_restore to keep objectives alive between agent runs. Developers invoke horizon-track with an objective name when shipping work spans days or weeks and context must survive session boundaries. The skill detects when execution drifts from stated milestones and surfaces blockers through progress summaries. It suits complex feature implementation, refactors, or audits where PM-style continuity is as important as code output.655installs162Loop Workerloop-worker is a ruvnet/ruflo skill for developers who need persistent, stateful agent loops instead of single-turn commands. It integrates Claude Code native `/loop` scheduling with Ruflo MCP worker hooks: dispatch via `mcp__claude-flow__hooks_worker-dispatch`, monitor with hooks_worker-status, and chain iterations through ScheduleWakeup. Cache-aware delay uses `min(270, cache_ttl * 0.9)` seconds, defaulting to 270 seconds between worker runs to keep prompt cache warm. Invoke loop-worker with a worker name argument to run periodic background tasks until success criteria or a maximum iteration cap. Reach for it when operational automation must retry on an interval—sync jobs, queue drainers, or long-running fix loops—without manually re-prompting each cycle.655installs163Memory Bridgememory-bridge is a RuFlo Claude Flow skill that bridges Claude Code auto-memory into AgentDB with ONNX embeddings, deduplication, and unified cross-project search. Claude Code stores memories as markdown in ~/.claude/projects/*/memory/*.md; memory-bridge reads those files for the current project or all projects via --all-projects, generates 384-dim ONNX embeddings using all-MiniLM, deduplicates with --dedupe, and exposes results through memory_search_unified. MCP tools memory_import_claude and memory_bridge_status track import health. Developers reach for memory-bridge when agent context scattered across Claude Code memory files must become searchable alongside AgentDB patterns. Bash and Read access support filesystem traversal of project memory directories.655installs164Swarm Initswarm-init is a RuFlo Claude Flow skill that initializes a multi-agent swarm with anti-drift configuration for coordinated work requiring three or more agents. It calls mcp__claude-flow__swarm_init with topology options hierarchical, mesh, hierarchical-mesh, ring, star, or adaptive, maxAgents 8, and strategy specialized—or uses npx @claude-flow/cli. Skip swarm-init for single-file edits or quick questions. Allowed tools include swarm_status, Task, and SendMessage for inter-agent coordination. Developers reach for swarm-init when implementing features across modules, running cross-module refactors, or conducting security audits that benefit from specialized agent roles. The skill sets anti-drift guardrails before dispatching parallel agent work in Claude Code sessions.655installs165Trader Backtesttrader-backtest is a ruvnet/ruflo skill with 562 skills.sh installs that runs historical backtests through the neural-trader Rust/NAPI engine, reported as 8–19× faster than pure JavaScript alternatives. It retrieves strategy configs from claude-flow trading-strategies memory, executes npx neural-trader --backtest with --walk-forward over a ticker and date range, and captures return, Sharpe, Sortino, drawdown, win rate, and trade counts. Results deduplicate prior runs by paramsHash in trading-backtests memory, then Ed25519-sign into SignedBacktestArtifact bodies per ADR-126 Phase 4 for paper-to-live promotion gates. Unsigned artifacts log warnings and block promotion until a witness key from RUFLO_WITNESS_KEY_PATH or verification/witness-key.json is available. Sharpe above 1.5 triggers agentdb_pattern-store and neural_train calls. Developers reach for trader-backtest when validating quantitative strategies inside ruflo before promoting configs to live trading.655installs166Agentdb Queryagentdb-query is a Ruflo skill in ruvnet/ruflo that teaches coding agents to query AgentDB through the @claude-flow controller bridge using 15 agentdb_* MCP tools. The documented 7-step workflow runs health check, session start, hierarchical store and recall across working, episodic, and semantic tiers, ReasoningBank-routed pattern search, context synthesis, and causal-edge graph linking. Developers reach for agentdb-query when Claude Code or Cursor agents must persist decisions, trajectories, and learned patterns across sessions instead of flat memory_store keys. The skill covers namespace routing rules, three operational fallback modes, and CLI alternatives via npx @claude-flow/cli memory commands when the bridge is unavailable.654installs167Chat Formatchat-format is a ruflo agent skill that standardizes chat templates and provider-specific prompt formatting across Anthropic, OpenAI, Gemini, Ollama, and Cohere through Claude Flow MCP tools. It pairs `ruvllm_chat_format` with HNSW context tools (`ruvllm_hnsw_create`, `ruvllm_hnsw_add`, `ruvllm_hnsw_route`) so agents retrieve relevant context before inference. Developers reach for chat-format when swapping models, normalizing message schemas, or building RAG workflows that must stay consistent across providers. The skill accepts a prompt plus an optional `--provider` flag and is designed for agent sessions in Claude Code or Cursor where Bash and MCP calls are allowed.654installs168Cost Optimizecost-optimize is a RuFlo Claude Flow skill that analyzes recent token usage across agents and models, identifies waste, and recommends specific optimizations with estimated dollar savings. It connects to claude-flow memory and AgentDB pattern tools—memory_search, memory_list, memory_store, agentdb_pattern-search, agentdb_pattern-store, agentdb_semantic-route, and hooks_model-outcome—to inspect model selection efficiency and recurring spend patterns. Developers reach for cost-optimize when API bills exceed expectations or when proactively tuning agent stacks before scale. The skill targets model routing inefficiencies and redundant context rather than generic budgeting advice. It fits Claude Code agent workflows that already use claude-flow MCP hooks and want actionable, savings-backed recommendations instead of manual log review.654installs169Create Plugincreate-plugin is a ruvnet/ruflo skill that scaffolds new Claude Code plugins from scratch with the correct directory structure, plugin.json manifest, skills, commands, and agents. The workflow collects a plugin name argument-hint, checks conflicts via mcp__claude-flow__transfer_plugin-search and transfer_store-search MCP tools, then writes files using Bash, Read, Write, and Edit permissions. Developers reach for create-plugin when packaging reusable agent capabilities—custom skills, slash commands, subagents, and MCP hooks—for teams or marketplace distribution instead of one-off project prompts. The skill also calls transfer_plugin-info for metadata alignment. Agents follow numbered steps to validate naming, lay out plugin folders, and wire Claude-flow transfer endpoints so new plugins integrate cleanly with existing Claude Code extension conventions. Numbered steps prompt for plugin name and description, then lay out skills, slash commands, and subagent folders expected by Claude Code marketplace conventions. transfer_plugin-info aligns manifest metadata while Bash and Edit permissions write plugin.json and starter command files to disk in one guided pass.654installs170Doc Gendoc-gen is a RuFlo Claude Flow skill that generates and maintains documentation with drift detection, dispatching work through mcp__claude-flow__hooks_worker-dispatch with trigger document. Developers can schedule recurring maintenance via CronCreate—for example schedule 0 */2 * * * to run a document worker every two hours—so docs refresh as code evolves. The skill compares current code against existing documentation and flags inconsistencies rather than blindly overwriting files. It uses Bash for npx commands, Read and Write for file updates, and memory_store for context persistence. Reach for doc-gen when asked to write, update, or refresh docs, detect drift, or automate recurring documentation upkeep in Claude Code agent sessions.654installs171Safety Scansafety-scan is a ruflo security skill that inspects untrusted input—user submissions, API payloads, webhook bodies, and tool outputs—for prompt injection, jailbreak attempts, and unsafe content before agents pass data to models or execute commands. It calls Claude Flow AIDefence MCP tools including `aidefence_scan`, `aidefence_analyze`, `aidefence_is_safe`, `aidefence_learn`, and `aidefence_stats`. Developers reach for safety-scan at ingestion boundaries where external text could manipulate agent behavior. The skill accepts raw input text and returns safety verdicts suitable for blocking or quarantining hostile content in production agent workflows.654installs172Trader Signaltrader-signal is a ruflo skill from ruvnet that generates trading signals through neural-trader's anomaly detection engine with Z-score scoring and neural prediction. The workflow ensures neural-trader is installed via npm, then scans symbols with configurable strategy flags such as --strategy and --symbols for tickers like AAPL and MSFT. It integrates claude-flow MCP tools for memory_store, memory_retrieve, memory_search, neural_predict, and agentdb_pattern-search alongside Bash and Read permissions. Developers reach for trader-signal when building or operating agentic trading pipelines that need repeatable signal scans rather than manual chart review. Argument hints document strategy and symbol list parameters for scripted invocations.654installs173Workflow Runworkflow-run is a ruvnet/ruflo skill for running and managing workflows on two surfaces: claude-flow MCP persisted definitions and native .claude/workflows/*.js orchestrations via the Workflow tool. It calls workflow_execute, workflow_run, workflow_pause, workflow_resume, workflow_cancel, and workflow_status MCP tools, plus Read and Bash. Developers pass a workflow-id-or-name argument to trigger execution, monitor progress, and control lifecycle states. Use workflow-run when multi-step agent pipelines need pause/resume/cancel semantics instead of fire-and-forget single prompts. The skill unifies MCP workflow lifecycle management with Claude native JS workflow invocation in one entry point.654installs174Autopilot Predictautopilot-predict is a ruvnet/ruflo skill for developers who want coding agents to propose the next action instead of waiting for explicit instructions. It calls `mcp__claude-flow__autopilot_predict` for a recommended step, executes directly when confidence exceeds 0.7, otherwise checks `mcp__claude-flow__autopilot_progress` for incomplete tasks and picks the highest-priority item. After work completes, `mcp__claude-flow__autopilot_learn` records outcomes and `mcp__claude-flow__autopilot_history` supplies prior patterns. Reach for autopilot-predict mid-session when task queues are ambiguous, multi-step refactors need sequencing, or you want the agent to self-route based on Ruflo's learned workflow intelligence rather than static checklists alone.653installs175Git Workflowgit-workflow is a ruvnet/ruflo skill for developers managing complex Git operations with coding agents. Invoke it with `<branch|pr|merge|rebase> [options]` to analyze repositories, assess diffs, and coordinate pull requests through Claude-Flow MCP tools including analyze_diff, analyze_diff-risk, analyze_diff-stats, github_pr_manage, github_repo_analyze, and github_metrics, plus Bash for local Git commands. Use git-workflow for multi-branch releases, conflict resolution, and PR lifecycle coordination when simple commit-and-push flows are insufficient. The skill fits ship-phase review work where agents need structured diff risk signals and GitHub PR automation instead of ad hoc terminal Git commands alone.653installs176Wasm Gallerywasm-gallery is a ruflo skill for the Claude Flow WASM agent gallery. Developers list available agents, search by keyword, create gallery entries, build WASM agents, and export packages through MCP tools including `wasm_gallery_list`, `wasm_gallery_search`, `wasm_gallery_create`, `wasm_agent_create`, and `wasm_agent_export`. Reach for wasm-gallery when you need pre-built WASM agents for demos, documentation, or component libraries instead of writing every agent from scratch. The skill accepts an optional search query argument and supports Bash for local packaging steps in Claude Code or Cursor agent sessions.653installs177Intelligence Routeintelligence-route is a RuFlo Claude Flow skill that routes tasks via a 3-tier model selector and learned patterns, emitting a routing rationale through hooks_explain. It connects to hooks_route, hooks_model-route, hooks_model-stats, hooks_model-outcome, hooks_intelligence_pattern-search, hooks_intelligence_attention, hooks_intelligence_stats, neural_predict, and hooks_pre-task to pick the optimal agent and model tier for each job. Developers pass a task description and optional --why flag when model choice affects cost, latency, or reasoning depth. The skill learns from prior outcomes stored in intelligence patterns rather than applying static model maps. Use intelligence-route at the start of non-trivial agent work in Claude Code when routing decisions should be explicit and auditable.652installs178Llm Configllm-config is a RuFlo Claude Flow skill that configures RuVLLM for local inference and fine-tuning. It exposes ruvllm_generate_config, ruvllm_status, ruvllm_microlora_create, ruvllm_microlora_adapt, ruvllm_sona_create, and ruvllm_sona_adapt through claude-flow MCP, with CLI arguments --model MODEL and --adapter microlora or sona. Developers use llm-config when standing up local inference instead of cloud APIs, creating MicroLoRA adapters for task-specific fine-tuning, or enabling SONA for real-time adaptation. Bash access supports complementary setup commands. The skill targets teams embedding custom models in claude-flow agent pipelines where model config, adapter creation, and adaptation must happen inside the same toolchain as swarm and routing skills.652installs179Rvf Managervf-manage is a Claude Code skill for managing RVF (Ruflo Vector Format) files that store portable agent memory. The skill exposes six CLI operations—import, export, list, migrate, stats, and delete—and routes work through eight claude-flow MCP memory tools plus Bash for backup, cross-project transfer, and team knowledge sharing. Developers reach for rvf-manage when an agent session must persist context outside a single repo, when migrating between Claude projects, or when auditing stored memory footprint before cleanup. It pairs naturally with Ruflo agent workflows that already emit RVF artifacts and expect repeatable memory hygiene without manual file surgery.652installs180Validate Pluginvalidate-plugin is a ruflo skill that verifies Claude Code plugins follow the correct format after creation or modification. It accepts a plugin-path argument and performs three check classes: directory structure confirming .claude-plugin/plugin.json exists at the plugin root, plugin.json schema validation for required fields name, description, and version, and skills auto-discovery ensuring every skills/<name>/SKILL.md is a valid skill. Allowed tools include MCP claude-flow transfer_plugin-info plus Bash, Read, Glob, and Grep. Developers run validate-plugin before publishing to catch structural issues early. The skill prevents broken plugin manifests and invalid skill frontmatter from reaching registries or team installs.652installs181Trader Portfoliotrader-portfolio is a ruflo skill that runs neural-trader's mean-variance portfolio engine inside Claude agent workflows. It ensures neural-trader is installed via npm ls or npm install --ignore-scripts neural-trader, loads current holdings through mcp__claude-flow__memory_search, and applies optional --risk-target constraints when generating a rebalancing plan. Allowed tools include Bash, Read, and five claude-flow MCP operations: memory_store, memory_retrieve, memory_search, neural_predict, and agentdb_pattern-search for signal and pattern context. The workflow ties AI-driven predictions to concrete allocation adjustments rather than static spreadsheets. Developers reach for trader-portfolio when building agentic trading pipelines that must read persisted portfolio state, compute risk-bounded weights, and output actionable rebalance steps from terminal sessions integrated with ruflo memory and prediction MCP tools during ongoing market operations.651installs182Wasm Agentwasm-agent is a Claude Code skill that provisions sandboxed WebAssembly agents for safe, isolated execution without leaving the IDE. Four primary commands—create, list, prompt, and terminate—drive seven claude-flow wasm_agent MCP tools covering agent creation, prompting, tool invocation, file access, export, and teardown. Developers reach for wasm-agent when running untrusted code, experimenting with agent configurations, or building portable agents that run anywhere WASM is supported. The workflow keeps experimentation contained while still allowing prompt-driven iteration and artifact export from the sandbox.651installs183Adr Reviewadr-review is a ruflo skill that reviews code changes against accepted Architecture Decision Records to detect violations, drift, and non-compliance. It starts from a git diff such as `git diff main...HEAD --name-only`, then queries claude-flow AgentDB hierarchical and causal memory tools alongside Bash, Read, Grep, and Glob. Developers reach for adr-review before merging a PR, after significant refactors, or during periodic compliance audits to ensure implementation respects documented decisions. The optional `--branch BRANCH` argument scopes review to a specific branch comparison.650installs184Workflow Createworkflow-create is a ruflo skill for authoring workflows on the surface that fits the job. MCP workflow templates provide persisted definitions with pause-resume lifecycle for long-lived, human-gated, resumable pipelines. Native .claude/workflows/*.js scripts handle agent, parallel, and pipeline fan-out orchestration inside Claude Code. The skill accepts arguments like name, optional --native flag, and --steps N, using claude-flow MCP tools workflow_create, workflow_template, workflow_list, workflow_status, and workflow_delete plus Write, Read, Edit, and Bash. Developers reach for workflow-create when standard slash skills are insufficient and they need durable multi-step agent pipelines with explicit lifecycle control or JavaScript orchestration scripts.650installs185Ddd Contextddd-context is a scaffolding skill for Domain-Driven Design bounded contexts in the ruflo repo. It parses a kebab-case context name, validates naming, and creates the standard domain/application/infrastructure directory layout—or lists existing contexts when no name is passed. The skill integrates with Claude Flow memory and AgentDB hierarchical store tools to persist context metadata for later agent retrieval. Developers reach for ddd-context when bootstrapping a fresh module, carving a monolith into bounded contexts, or enforcing consistent folder conventions before writing domain logic. It focuses on structure creation, not business rule implementation.648installs186Iot Registeriot-register is a ruflo skill from ruvnet/ruflo with 556 skills.sh installs that registers Cognitum Seed devices through the @claude-flow/plugin-iot-cognitum package. It resolves an endpoint from user input or defaults to http://169.254.42.1/, the Cognitum Seed link-local USB Ethernet address. The workflow runs npx -y -p @claude-flow/plugin-iot-cognitum@latest cognitum-iot register ENDPOINT, optionally pairs with a token via cognitum-iot pair DEVICE_ID, then checks status with cognitum-iot status DEVICE_ID. Registration events persist through mcp__claude-flow__memory_store under the iot-devices namespace with keys like iot-register-DEVICEID. Allowed tools include Bash for npx commands, Read, and claude-flow memory_store. Developers reach for iot-register when onboarding Cognitum Seed hardware into ruflo agentic IoT pipelines.648installs187Market Patternmarket-pattern is a ruflo skill for candlestick and chart pattern detection over previously ingested OHLCV data. It accepts a symbol and optional period (for example 1D), searches memory for stored bars, classifies formations such as doji, hammer, engulfing, and head-shoulders, and persists matches through AgentDB pattern-store and pattern-search alongside Claude Flow memory tools. The skill also routes through ruvllm HNSW for pattern lookup workflows. Developers use market-pattern after market data ingestion completes and they need repeatable pattern classification rather than manual chart review. It does not ingest raw feeds by itself.647installs188Adr Createadr-create is a ruvnet/ruflo skill that creates a new Architecture Decision Record with the next sequential number, registers it in the AgentDB graph, and links it to related ADRs. Developers invoke it with an argument-hint title when adopting new technology, making API design choices, changing data models, or recording infrastructure decisions that future agents must recall. Allowed tools include mcp__claude-flow__agentdb_hierarchical-store, agentdb_hierarchical-query, agentdb_causal-edge, memory_store, memory_search, plus Bash, Read, Write, Edit, Grep, and Glob for file operations. The workflow produces numbered ADR markdown files while persisting causal edges between related decisions in AgentDB. Catalog metadata lists 440 installs. adr-create fits Claude-flow agent workflows where architecture rationale must survive session compaction and be queryable through hierarchical AgentDB recall instead of scattered wiki notes without graph links.646installs189Ddd Validateddd-validate is a ruflo skill that systematically validates domain boundaries across bounded contexts in a DDD codebase. It discovers contexts by scanning `src/*/domain/`, then checks cross-boundary import violations and aggregate invariant issues that erode isolation between contexts. Developers reach for ddd-validate when auditing a DDD codebase for leaks, before merging cross-cutting changes, or as a CI gate to catch boundary erosion early. It integrates claude-flow memory store, memory search, and pre/post-task hooks alongside Bash, Read, Grep, and Glob for repository scans.646installs190Trader Traintrader-train wraps the neural-trader npm package to train market prediction models from a Claude Code session. It verifies neural-trader is installed (installing via npm if missing), then runs npx neural-trader with a chosen model flag—lstm, transformer, or nbeats—plus a ticker symbol and confidence level such as 0.95. Training output is persisted through Claude Flow memory_store, memory_search, and the neural_train MCP tool for later inference workflows. Developers invoke trader-train when they need repeatable CLI-driven model training on ingested market data instead of hand-rolling PyTorch or TensorFlow scripts. The skill focuses on training orchestration, not live order execution.646installs191Observe Metricsobserve-metrics is an observability skill in ruvnet/ruflo that pulls metrics from the observability namespace via claude-flow MCP tools including memory_search, memory_store, and agentdb_pattern-search. It accepts an optional --period argument such as 1h and aggregates counters, gauges, and histograms while flagging anomalies. Developers use it for snapshots of task completion rates, error rates, active agent counts, memory usage, and token consumption when monitoring swarm performance during live operation.644installs192Observe Traceobserve-trace is a distributed tracing skill in ruvnet/ruflo that takes a task-id argument and collects spans via claude-flow MCP tools including agentdb_semantic-route and agentdb_context-synthesize. It builds a visual trace tree showing execution flow, per-span timing, bottlenecks, and how agents coordinated during a task. Developers reach for observe-trace when they need to understand which spans ran, how long each took, and where coordination failed during multi-agent execution.644installs193Adr Indexadr-index is a documentation automation skill from ruvnet/ruflo that runs scripts/import.mjs to build or rebuild an ADR index plus dependency graph in a single Bash call instead of hundreds of MCP round-trips. It persists every ADR under */docs/adr/ or */docs/adrs/ to the adr-patterns namespace and every relationship—supersedes, amends, related, depends-on—to adr-edges. The importer handles two formats found in the Ruflo monorepo: v3-style headings with Status lines and plugin-style YAML frontmatter with id and status fields. Developers reach for adr-index when ADR files multiply across packages and manual cross-referencing breaks down.642installs194Federation Statusfederation-status is a ruflo skill that shows federation health including peers, sessions, trust levels, and message metrics across cross-installation agent connectivity. It runs `npx -y -p @claude-flow/plugin-agent-federation@latest ruflo-federation status` for overall health and `ruflo-federation peers` to list peers with trust levels and scores, then summarizes active sessions, messages exchanged, PII redactions, and threat detection results. Developers reach for federation-status when asked 'is federation healthy?', 'show peers', or 'federation status' during operations on a federated Claude-flow agent network.642installs195Iot Anomaliesiot-anomalies is a ruvnet/ruflo skill that runs Z-score anomaly detection on a Cognitum Seed device's recent telemetry via npx -y -p @claude-flow/plugin-iot-cognitum@latest cognitum-iot anomalies DEVICE_ID. It reviews six anomaly types—spike, flatline, drift, oscillation, pattern-break, and cluster-outlier—and recommends quarantine when the anomaly score exceeds 0.9. Developers invoke it when a device reports odd metrics, before approving firmware canary advancement, or while triaging fleet-wide health alerts. Detected patterns can be stored through mcp__claude-flow__memory_store for learning across incidents. Allowed tools include Bash(npx *), memory_store, and Read. Catalog metadata lists 440 installs. iot-anomalies fits Claude-flow IoT operations where statistical telemetry screening must precede canary promotion or fleet incident response instead of manual threshold guessing.642installs196Sparc Implementsparc-implement is a ruvnet/ruflo skill covering SPARC Pseudocode and Architecture phases 2 and 3 after specification is complete. It guides agents to draft algorithm pseudocode, establish module boundaries and API contracts, then implement executable code using claude-flow memory, task, hooks intelligence, neural predict, and workflow tools plus Bash Read Write Edit. Developers use sparc-implement when a feature spec exists and they want methodical translation into architecture and code rather than ad-hoc generation. The skill fits multi-step agent workflows where trajectory steps and task completion tracking matter.642installs197Vector Embedvector-embed is a ruflo skill that generates and stores vector embeddings using the ruvector npm package at version 0.2.25. It embeds text or files with ONNX all-MiniLM-L6-v2 producing 384-dimensional vectors, normalizes them, and stores results in an HNSW index cited at 52,000+ inserts per second and roughly 0.045ms search latency. Developers reach for vector-embed to embed text, code, or documents for semantic search, similarity comparison, clustering, or claude-flow agent memory via memory_store and memory_search. The argument hint accepts `<text-or-file>` input for direct embedding runs.642installs198Federation Auditfederation-audit is a ruvnet/ruflo skill that queries structured federation audit logs with compliance mode filtering for HIPAA, SOC2, and GDPR plus severity filtering across critical, error, warn, and info levels. Agents parse --compliance, --since DATE, and --severity arguments, then run npx -y -p @claude-flow/plugin-agent-federation@latest ruflo-federation audit with the selected filters. The workflow summarizes total events, PII detections, threat blocks, and trust changes, highlighting critical findings for review. Allowed tools include Bash(npx *), mcp__claude-flow__memory_search, Read, and Grep. Developers reach for federation-audit when multi-agent federation deployments need compliance-scoped log review or incident triage on federated trust boundaries. Catalog metadata lists 440 installs. federation-audit fits Claude-flow security workflows where regulated environments require filtered audit trails instead of raw unscoped log dumps.641installs199Federation Initfederation-init is a ruflo skill that initializes agent federation on a node using @claude-flow/plugin-agent-federation via npx. It generates an ed25519 keypair, writes federation configuration, optionally applies a compliance mode (hipaa, soc2, gdpr, or none), and surfaces the node public key and endpoint for peer sharing. Allowed tools include Bash for npx, Read and Write for config, and claude-flow MCP memory and hooks. Developers reach for federation-init when standing up a federated agent node before connecting peers in a distributed Claude-flow deployment.641installs200Kg Extractkg-extract is a ruvnet/ruflo skill that extracts entities—classes, functions, modules, types, and concepts—and relations including imports, extends, implements, depends-on, and calls from source files or documentation, then stores them as a knowledge graph in AgentDB. Developers invoke it with a path argument-hint when building or updating codebase knowledge graphs for structure understanding, dependency tracing, or agent memory priming. Allowed tools include Read, Glob, Grep, Bash, mcp__claude-flow__agentdb_hierarchical-store, agentdb_causal-edge, agentdb_pattern-store, and embeddings_generate for semantic enrichment. The workflow supports understanding large repositories without rereading every file each agent turn. Catalog metadata lists 440 installs. kg-extract pairs with adr-create and agentdb-query in Claude-flow workflows where structured graphs power hierarchical recall and causal reasoning over code relationships.641installs201Trader Regimetrader-regime is a ruflo skill that runs neural-trader regime detection to classify current market conditions as bull, bear, ranging, or volatile, then suggests strategies suited to that regime. It accepts symbols such as SPY or comma-separated tickers like AAPL and MSFT, installs neural-trader via npm when missing, and integrates claude-flow MCP memory and neural_predict tools. Developers reach for trader-regime when evaluating market conditions, selecting a strategy for current volatility, or making backtests and signal runs regime-aware.641installs202Trader Risktrader-risk is a financial risk skill from ruvnet/ruflo that assesses portfolio and position exposure using the neural-trader CLI. It ensures neural-trader is installed, then runs commands such as npx neural-trader --risk assess --symbol TICKER and npx neural-trader --var --symbol TICKER --investment 10000 for single positions, plus portfolio-wide sweeps with optional --portfolio NAME flags. The skill surfaces VaR, CVaR, Sharpe ratio, position sizing guidance, and circuit breaker status, storing results via claude-flow memory tools. Developers reach for trader-risk before trade execution or when auditing automated trading agent exposure.641installs203Cost Reportcost-report is a skill in ruvnet/ruflo that builds a comprehensive cost report from claude-flow memory and agentdb retrieval tools, showing token usage, USD charges, and budget utilization for a chosen period such as today. It answers which agents and models consume the most budget and whether spend is on track. Developers reach for cost-report during Claude Code or Cursor agent sessions when finance or engineering leads need accountable LLM billing data instead of guessing from console logs. The skill accepts period arguments like `--period today` and integrates with Bash for report assembly.640installs204Iot Witness Verifyiot-witness-verify is a ruvnet/ruflo skill that verifies witness chain integrity for a Cognitum Seed device by running npx -y -p @claude-flow/plugin-iot-cognitum@latest cognitum-iot witness verify DEVICE_ID. It checks for epoch gaps and hash chain breaks, reporting an integrity score from 0.0 to 1.0. When gaps are found, agents store audit trail entries via mcp__claude-flow__memory_store under the iot-audit namespace with keys like iot-witness-gap-DEVICEID. Allowed tools include Bash(npx *), memory_store, and Read. Developers reach for iot-witness-verify when device provenance must be validated before trusting telemetry history or during compliance investigations on IoT audit trails. Catalog metadata lists 440 installs. iot-witness-verify complements iot-anomalies by proving chain-of-custody integrity rather than only statistical metric deviations.640installs205Migrate Createmigrate-create is a ruvnet/ruflo skill that generates a new numbered database migration with matching up and down SQL files for schema changes like new tables, columns, indexes, or constraints. It uses Glob to find the highest existing migration number, then writes the next sequential pair through Read, Write, and Bash with optional claude-flow memory helpers. Developers invoke migrate-create when starting a schema change instead of manually copying filenames or risking numbering collisions across branches. The skill expects a migration name argument and fits standard SQL migration directory conventions.640installs206Sparc Specsparc-spec is a ruvnet/ruflo skill that executes SPARC Specification phase 1 from a feature description argument. It gathers requirements, defines acceptance criteria, identifies constraints, and stores the resulting spec in claude-flow memory using task and hooks intelligence trajectory-start tools plus Bash Read Edit. Developers reach for sparc-spec at the start of a governed feature when success metrics and boundaries must be explicit before pseudocode or coding. The skill pairs with sparc-implement for phases 2 and 3 and fits agent teams using memory-backed planning instead of informal chat prompts.640installs207Kg Traversekg-traverse is an agent retrieval skill from ruvnet/ruflo that performs pathfinder graph traversal starting from a seed entity with an optional --depth limit. It expands outward through causal edges, scores paths by relevance, and prunes low-similarity branches using AgentDB MCP tools including hierarchical-recall, causal-edge, pattern-search, and context-synthesize. Developers reach for kg-traverse when they need to explore what depends on an entity, what it depends on, or discover indirect relationships across codebases, documentation, and project context. The skill reduces hallucination risk by grounding agent answers in graph-linked facts rather than isolated file snippets.639installs208Migrate Validatemigrate-validate is a ruvnet/ruflo skill that reviews all pending database migrations before apply time, checking foreign key references, missing rollback SQL, destructive changes without safeguards, and naming convention violations. It uses Read, Glob, Grep, and Bash alongside claude-flow memory and agentdb pattern tools to store findings. Reach for migrate-validate in CI or pre-deploy checks when a bad migration could break production schema or block rollbacks. The skill fits teams maintaining raw SQL migration folders who want automated consistency checks instead of manual DBA review on every pull request.639installs209Vector Clustervector-cluster is a ruvnet/ruflo skill that groups vectors in a namespace by semantic similarity using `npx ruvector@0.2.25 hooks graph-cluster` with spectral or Louvain community detection. Developers pass a namespace and optional `--k` parameter after embeddings are stored, revealing themes, outliers, and natural groupings across code or documents. Use vector-cluster when RAG or agent memory collections grow large enough that flat search misses structure. The skill integrates claude-flow memory search and store tools and expects ruvector 0.2.25 available via npm.639installs210Browser Loginbrowser-login is a Claude Code skill in ruflo that automates a one-time login against any target URL, then stores a reusable authenticated session for later agent runs. The flow uses claude-flow MCP browser tools—browser_open, browser_fill, browser_click, browser_snapshot, browser_eval, and related calls—to complete username, password, and optional MFA steps from argument hints like login-url and --mfa. Before persistence, cookies pass through mcp__claude-flow__aidefence_scan and aidefence_has_pii checks so sensitive data is sanitized, then the handle is saved in browser-cookies under a named vault entry. Developers reach for browser-login when building agents or scrapers that must call authenticated dashboards, admin panels, or SaaS APIs that lack OAuth machine credentials. Allowed tools include Bash, Read, and Write alongside the browser and AIDefence MCP integrations.637installs211Cost Compact Contextcost-compact-context is a Bash-driven Claude Code skill in ruvnet/ruflo that shells a Node one-liner to call getTokenOptimizer().getCompactContext() from @claude-flow/integration when no MCP tool wraps getTokenOptimizer (noted in ADR-0002). The bridge dynamically imports agentic-flow with graceful fallback: if the package is missing, tokensSaved is 0 and the skill exits cleanly. Developers pass a single query argument and receive compacted ReasoningBank context sized for cost-analysis questions while seeing bridge-reported token savings. Reach for cost-compact-context when tuning Claude-Flow or agentic-flow agent runs where verbose reasoning context inflates billable tokens. It complements token optimizers and ReasoningBank workflows rather than replacing full context dumps or MCP-based inspection tools.637installs212Sparc Refinesparc-refine is a ruflo skill implementing SPARC Refinement and Completion phases after initial implementation. The skill iteratively reviews code quality, expands test coverage, validates deliverables against the original specification, and generates documentation using Claude-flow MCP memory, task, hooks, and neural tools. Agents coordinate trajectory tracking and task completion states throughout the refinement loop. Developers reach for sparc-refine when an agent-built feature needs structured post-implementation review rather than ad-hoc fixes before release.637installs213Market Ingestmarket-ingest is a ruflo skill that ingests raw market price and volume data for a given symbol, normalizes it into OHLCV vectors, and stores the results with HNSW indexing for fast pattern search. The skill integrates Claude-flow MCP tools for memory storage, embedding generation, and HNSW index creation as the first step before pattern detection or comparison workflows. Developers pass a symbol and optional API source argument to populate searchable vector stores. Reach for market-ingest when building trading analytics agents that need structured OHLCV data indexed for similarity queries rather than raw API responses.636installs214Vector Hyperbolicvector-hyperbolic is a ruflo skill that generates high-dimensional embeddings and projects hierarchical data into the Poincare ball using ruvector@0.2.25. The skill targets structures like dependency trees, module hierarchies, org charts, taxonomies, and ontologies where hyperbolic space captures hierarchical distances in fewer dimensions than Euclidean embeddings. Agents run npx ruvector embed commands and store results via Claude-flow memory tools. Developers reach for vector-hyperbolic when similarity search or distance metrics must respect tree-like hierarchy rather than flat vector geometry.635installs215Browser Form Fillbrowser-form-fill is an agent skill in ruvnet/ruflo that opens a URL, applies a structured field-map.json to inputs, and optionally submits the form using claude-flow browser MCP primitives. The manifest lists 11 browser tools—including browser_fill, browser_select, browser_check, browser_click, and browser_snapshot—plus aidefence_has_pii for PII screening before submission. Developers pass argument hints like `<url> <field-map.json> [--template <name>] [--submit]` and can reuse known layouts from browser-templates instead of rediscovering selectors each run. The workflow suits agent-driven QA, onboarding smoke tests, and scripted data entry where the same form appears across environments. Reach for browser-form-fill when an agent must populate registration, checkout, or admin forms from JSON payloads while preserving optional template lookup and explicit submit control. It pairs Bash Read Write for map files with browser wait and snapshot steps to confirm field state before clicking submit.627installs216Browser Replaybrowser-replay is a Testing & QA skill in ruvnet/ruflo that replays recorded session trajectories against a target URL or a mutated variant. The skill uses browser-selectors embedding similarity to recover when DOM structure drifts between recording and replay, reducing brittle selector failures during regression runs. Developers reach for browser-replay when validating recorded user flows after UI refactors, testing against staging variants, or automating click, fill, type, and navigation sequences captured in a prior session. It integrates with claude-flow browser MCP tools including click, fill, screenshot, and wait operations, accepting session-id, url, mutate JSON, and tolerance parameters.627installs217Browser Recordbrowser-record from ruvnet/ruflo is the primitive browser skill on which other ruflo browser capabilities compose. It opens a named browser session, allocates an RVF cognitive container, and binds every action to a ruvector trajectory recording for later replay or analysis. Arguments accept a URL or task plus options such as --with-dom and --viewport WxH. Allowed tools include claude-flow MCP browser_open, browser_close, browser_session-list, browser_screenshot, browser_snapshot, browser_wait, plus aidefence PII scanning and Bash Read Write. Developers invoke browser-record when autonomous agents need persistent, named sessions with full action traces rather than one-off page fetches. Downstream skills assume this session-and-container binding exists before navigation, extraction, or multi-step UI workflows run.626installs218Dossier Collectdossier-collect is a skill in ruvnet/ruflo that constructs a graph-structured dossier on a seed entity using parallel fan-out and recursive expansion. It fans out across six source classes—web, memory, knowledge-graph, codebase, ADR index, and git intel—and accepts CLI flags such as --max-depth, --max-breadth, --sources, --budget-usd, and --exact to cap traversal and spend. The skill integrates claude-flow MCP tools for memory_store, memory_search, agentdb pattern search, embeddings_search, and hooks intelligence pattern retrieval. Reach for dossier-collect when onboarding to an unfamiliar codebase, investigating a person or organization, or assembling ADR and git context before architecture or implementation work. The output is a connected dossier graph rather than isolated search hits, making it suited to agent workflows that must reason across heterogeneous evidence.610installs219Browser Extractbrowser-extract is a ruflo/claude-flow skill that opens pages through MCP browser tools, runs stored browser-templates or ad-hoc DOM selectors, and returns structured text or values. Every extraction passes through AIDefence checks for PII detection and prompt-injection safety before content is handed to the model. Developers invoke it with a URL plus optional --template or --save-template flags when agents need repeatable page parsing without writing custom scraper scripts. Supported browser actions include snapshot, eval, click, scroll, screenshot, and wait, gated by aidefence_has_pii and aidefence_is_safe.607installs220Browser Screenshot Diffbrowser-screenshot-diff is a ruflo agent skill that pairs each step in session A to the same step-id in session B, then diffs captured screenshots and accessibility snapshots to find the first divergence and compute an aggregate similarity score. Invocation accepts session-id-a, session-id-b, an optional --threshold between 0 and 1, and --mode pixel, dom, or both for combined comparison. Allowed tools include mcp__claude-flow__browser_eval plus Bash, Read, and Write for report output. Developers reach for browser-screenshot-diff after recording a before-and-after browser session when validating UI refactors, replay correctness, or accessibility tree changes. The skill reports the first mismatched trajectory step and an overall similarity metric rather than replacing full end-to-end test suites.606installs221Cost Budget Checkcost-budget-check from ruvnet/ruflo reads accumulated cost-tracking spend plus budget configuration, computes utilization, and emits a measured four-tier alert ladder at 50% INFO, 75% WARNING, 90% CRITICAL, and 100% HARD_STOP. It loads cost-tracking:budget-config for the project limit, sums total_cost_usd across session-* records produced by cost-track, and supports --period today, week, month, or all. Allowed tools include Bash and claude-flow memory_retrieve, memory_list, and memory_store. Developers invoke it during lengthy autonomous runs where token spend must stay inside team limits without manual spreadsheet tracking. The skill closes the loop between cost-track session logging and enforceable budget awareness before overruns halt production agent workflows.602installs222Browser Auth Flowbrowser-auth-flow is a skill in ruvnet/ruflo's ruflo-browser plugin that probes a site's authentication flow and writes structured findings.md inside an RVF container. It opens a recorded browser session, drives login like browser-login, then runs configurable probes for missing CSRF tokens, cross-origin redirect leaks, weak session cookies, and OAuth state or nonce problems. Captured tokens and PII stay quarantined behind aidefence_scan gates and are never returned unredacted. Output includes per-probe severity ratings and a pass, warn, or fail verdict, with sessions indexed under tag auth-probe for regression baselines. Typical trajectories run 15–40 steps. Developers invoke it for pre-deployment auth audits, suspected token leaks, or establishing ongoing auth regression checks—not for exploitation or automated remediation.599installs223Cost Trackcost-track is a ruflo-cost-tracker plugin skill in ruvnet/ruflo that auto-captures per-session token usage from the active Claude Code session jsonl at ~/.claude/projects/<encoded-cwd>/<session>.jsonl. It tallies assistant-message usage fields per model—including prompt cache hits—computes USD cost using REFERENCE.md pricing tiers, and writes structured records to the cost-tracking AgentDB namespace via mcp__claude-flow__memory_store. The skill is the producer side for companion skills cost-report, cost-optimize, and cost-budget-check. Install with npx -y skills add ruvnet/ruflo --skill cost-track --agent claude-code and invoke via /cost-track after meaningful work chunks or at session end. Allowed tools include Bash and memory_store. Developers reach for cost-track when Claude Code sessions need measured token totals instead of guessing API bills.596installs224Cost Federationcost-federation is a ruflo skill that implements consumer-side wiring for ADR-097 Phase 3 federation_spend events in multi-agent federation setups. Each completed federation_send publishes an event carrying peerId, taskId, tokensUsed, usdSpent, and timestamp; cost-tracker aggregates those events into per-peer rolling windows at one hour, twenty-four hours, and seven days. A federation breaker then queries the aggregate to suspend peers exceeding configured spend thresholds before additional federation tasks dispatch. The skill uses Bash tooling and activates when upstream publishers land, even though Phase 3 is not yet merged upstream. Developers reach for cost-federation when operating ruflo multi-agent federation networks that need automated spend caps instead of manual invoice review. It complements cost-tracker as the declared federation_spend event consumer and encodes the suspension-threshold integration contract defined in ADR-097 for production multi-agent federation operations.595installs225Intelligence Transferintelligence-transfer is an AI & Agent Building skill in ruvnet/ruflo that shares learned patterns across projects and machines through IPFS via Pinata. The skill supports store, load, and from-project modes with optional IPFS CID and source project path arguments, leveraging claude-flow hooks_transfer, pattern-search, pattern-store, and neural_patterns MCP tools. Developers reach for intelligence-transfer when patterns learned in one codebase should accelerate another project or when teams want portable agent intelligence instead of siloed session memory. It addresses the gap where most learned optimizations stay trapped in a single repository after sessions end.595installs226Cost Booster Routecost-booster-route is a Claude Flow agent skill that wraps mcp__claude-flow__hooks_route to route batch development tasks through a 3-tier router and surface how many jobs qualify for Agent Booster Tier 1. Tier 1 bypasses execute as WASM transforms with no LLM call, structurally $0 cost, while higher tiers still use Sonnet or Opus when needed. The skill accepts a task description or --from-recent flag and can cross-check prior routing via memory_search and memory_list. Developers reach for cost-booster-route before running similar task batches or when cost-report shows Sonnet or Opus spend on simple, repeatable descriptions that should bypass the model.594installs227Cost Conversationcost-conversation is a Productivity & Planning skill in ruvnet/ruflo that aggregates LLM costs by conversation session instead of by agent or model. While cost-report and cost-optimize summarize spend by agent and model, this skill surfaces which individual sessions cost the most, including started-at timestamps, message counts, top model used, and total session cost. Developers reach for cost-conversation after multiple agent sessions to retrospect on expensive Opus runs, evaluate project session patterns, or scope budget before starting a long conversation. It runs via Bash against the ruflo cost-tracking store and is useful for sustainability reviews of agent-assisted development workflows.594installs228Cost Summarycost-summary is a stable single-call cost reporting interface for the ruvnet/ruflo Claude Flow plugin ecosystem. Instead of adding MCP tools to @claude-flow/cli (deferred per ADR-0002 as out-of-scope plugin work), the skill shells out a script that returns the same cost_report data through a stdout JSON contract or markdown table. Other plugins, scripts, and dashboards parse the output with --format json|markdown. Developers reach for cost-summary when they need a machine-readable spend snapshot during agent operations, budget checks, or federation rollups without building custom CLI patches.594installs229Cost Trendcost-trend is a Testing & QA skill in ruvnet/ruflo that analyzes persisted benchmark runs in docs/benchmarks/runs/*.json to surface performance drift over time. While the smoke gate passes when winRate is at or above 0.80, cost-trend catches slow regressions such as win rate creeping from 100% toward 85% that still pass binary gates. The skill reports first-to-last deltas plus a per-run series, flagging regressions in win rate, latency, escalation rate, and LLM-baseline cost. Developers reach for cost-trend before releases to verify benchmark curves remain healthy and to detect gradual degradation across the full run corpus.594installs230Vector Setupvector-setup is an AI & Agent Building skill in ruvnet/ruflo that bootstraps ruvector@0.2.25 and optional add-ons so every /vector subcommand works on first run. Out of the box, several vector commands fail with missing dependency errors for ruvector-onnx-embeddings-wasm, @ruvector/pi-brain, and SONA packages. The skill installs ONNX WASM embeddings, Brain commands, and SONA components, registers the MCP server, and verifies the install through a doctor check. Developers reach for vector-setup when setting up ruflo vector search on a new machine or after encountering confusing dep errors on /vector subcommands, using the optional --full flag for complete add-on installation.594installs231Adr Verifyadr-verify is a ruflo companion skill to adr-index that audits persisted ADR graphs via claude-flow memory tools and Bash, exiting with code 1 when cycles are detected. It flags dangling edges pointing at missing ADR IDs—often from sibling repos or deletions—supersede cycles such as ADR-A supersedes ADR-B while ADR-B supersedes ADR-A, and status mismatches when an ADR is marked superseded inconsistently. Developers run it after ADR imports to catch data corruption before agents or teams rely on the graph. Allowed tools include Bash plus mcp__claude-flow__memory_list and memory_retrieve.593installs232Cost Exportcost-export is a ruflo agent skill that pulls every session-* and budget-config-* record from the cost-tracking AgentDB namespace and emits Prometheus textfile or webhook JSON for external observability. Without export, cost data stays inside AgentDB; with it, the same telemetry feeds Grafana, Datadog, or custom dashboards. Run it after cost-track sessions or on a cron via /loop 5m to keep external metrics near real-time. Arguments accept --prometheus <path> for textfile collector output and --webhook <url> for JSON push. The skill uses Bash and fits teams operating AI agent fleets who need budget visibility outside the ruflo runtime.593installs233Cost Booster Editcost-booster-edit is an agent-booster execution skill from ruvnet/ruflo that applies simple, deterministic code transforms via the agent-booster WASM engine exposed through agentic-flow/agent-booster (npm agent-booster v0.2.x). Developers invoke it after cost-booster-route classifies a change as Tier 1 eligible, when bulk edits like var-to-const, add-types, remove-console, add-error-handling, async-await, or add-logging must run across many files without an LLM round-trip. Transforms complete in sub-millisecond time at $0 per call. Reach for cost-booster-edit when structural refactors are already classified and need fast, repeatable application across a codebase.591installs234Cost Benchmarkcost-benchmark is a ruflo verification skill that runs scripts/bench.mjs against the structural and adversarial cases in bench/booster-corpus.json, optionally comparing the local booster to Gemini, Sonnet, or Opus baselines via --llm or --anthropic flags. Results land as per-case and summary tables under docs/benchmarks/runs/, backing measurable claims in cost-booster-edit and cost-booster-route skills. Developers reach for cost-benchmark before publishing a release to confirm booster win rate has not regressed, after expanding the corpus, or when auditing claimed cost-reduction percentages. The skill allows Bash execution only and acts as the measurable gate between routing edits and public performance statements.590installs235Browserbrowser is a Claude Code skill from ruvnet/ruflo (version 1.0.0) for web browser automation using agent-browser with AI-optimized accessibility snapshots. Instead of dumping full DOM trees, the skill returns element refs (@e1, @e2) that reduce agent context by 93%. The workflow runs agent-browser open, snapshot -i for interactive elements, then click, fill, and screenshot commands before close. Developers and claude-flow agents invoke browser for scraping, navigation, form interaction, and visual verification. Triggers include /browser, browse, web automation, scrape, navigate, and screenshot.582installs236Witnesswitness is a ruflo skill from ruvnet/ruflo that ships every release with a signed manifest listing documented fixes, each tracked by sha256 hash and a distinctive marker substring in source files. Commands init, regen, verify, and history bootstrap verification.md.json, witness-fixes.json, and verification-history.jsonl using Node scripts under plugins/ruflo-core/scripts/witness/. Ed25519 signatures derive from the current git commit so anyone can re-derive the public key and verify without a committed private key. history.mjs queries temporal JSONL snapshots to pinpoint the commit that introduced a regression. Developers reach for witness when CI must gate publishes on fix-marker presence—ruflo's own v3-ci.yml runs witness-verify—or when copying the toolkit into any project for release regression tracking.567installs237Managed Agentmanaged-agent is a ruflo skill for Anthropic's cloud Managed Agent runtime behind the `ruflo-agent` CLI. It exposes create, prompt, status, events, list, and terminate operations through claude-flow MCP tools alongside wasm-agent creation and Bash. The skill documents when to choose the cloud harness versus the local wasm-agent runtime based on tool and deployment needs. Developers reach for managed-agent when provisioning, prompting, monitoring, or terminating cloud-hosted coding agents with filesystem and tool access rather than running agents only on local WASM infrastructure.519installs238Trader Cloud Backtesttrader-cloud-backtest in ruvnet/ruflo (313 installs) dispatches compute-heavy neural-trader workloads—multi-year walk-forward backtests, large Monte Carlo simulations, parameter sweeps, and LSTM/Transformer/N-BEATS model training—to Anthropic Managed Agent cloud containers instead of local machines. The 83-line skill recipe defines 7 steps: cost estimate, container provision with neural-trader initScript, cheap 1-path pre-flight smoke, full job via managed_agent_prompt, artifact retrieval to /tmp/equity.csv and /tmp/trades.csv, Ed25519 SignedBacktestArtifact verification before memory_store, and eager managed_agent_terminate. Nine scoped MCP tools cover managed_agent_create through terminate plus memory_store, memory_search, and agentdb_pattern-store when Sharpe exceeds 1.5. Developers reach for trader-cloud-backtest when local hardware cannot finish walk-forward validation or 1000-path Monte Carlo grids; quick sanity checks stay on the local trader-backtest skill. Prerequisites include ANTHROPIC_API_KEY and Managed Agents beta access per ADR-117 and ADR-115.519installs239Trader Portfolio Cgtrader-portfolio-cg is a Claude skill from ruvnet/ruflo that solves mean-variance optimization Σ·x=μ using Conjugate Gradient instead of the legacy Neumann series (ADR-123 Wedge 8, ADR-126 Phase 3). Benchmarks show Neumann at ~50 µs for n=256 versus CG delivering 40-60× speedups over the legacy npx neural-trader --portfolio optimize path. The skill accepts --portfolio-id and --tolerance 1e-6 arguments and integrates with ruflo-sublinear solve and claude-flow memory tools. Quant developers reach for trader-portfolio-cg when portfolio rebalance latency blocks production trading loops. It targets the Phase 3 conjugate-gradient migration away from Neumann-series solvers.442installs240Trader Explaintrader-explain is a signal-explanation skill from ruvnet/ruflo that attributes predictions from LSTM or Transformer models using a feature-contribution graph and single-entry forward-push PageRank (ADR-123). Invoke it with a signalId and optional --top-k (default 10) and --seed flags; allowed tools include Bash, Read, and MCP integrations for claude-flow memory and ruflo-sublinear PageRank entry. The skill returns a markdown table of top-K ranked features driving the prediction and persists results to trading-analysis as a SignedAttributionArtifact under ADR-126 Phase 6. Developers reach for it when regulatory or internal review requires regulator-grade feature attribution for any model signal, not just heuristic summaries.439installs241Sparc ImplementRun the SPARC Architecture and Implementation phases — design module boundaries, write pseudocode, implement code, and run tests0installs242Trader RiskAssess portfolio risk using npx neural-trader — VaR, CVaR, Sharpe, position sizing, circuit breaker status0installs