ruvnet/ruflo
135 skills87k installs8M starsGitHub
Install
npx skills add https://github.com/ruvnet/rufloSkills in this repo
1Workflow AutomationWorkflow Automation packages ruflo’s claude-flow workflow commands into an agent skill for processes that span more than one step. Solo builders use it to create named flows from templates, run them against an environment, inspect status, and export YAML for reuse—mapping each step to an agent role with optional dependencies. It fits CI, deploy, test, release, and review automation when you already rely on Claude Code-style agent orchestration. The skill is intentionally narrow: it tells you when not to bother (single-step jobs) and surfaces the five first-class templates plus the example YAML shape so your agent can scaffold orchestration consistently. Intermediate complexity reflects needing familiarity with CLI workflows and multi-agent task graphs rather than writing one function.817installs2Agent WorkflowAgent Workflow is an agent skill that casts the assistant as a Flow Nexus Workflow Agent for designing and running event-driven automations. It focuses on declaring workflows with named steps, mapped actions, and assigned specialist agents such as tester, builder, and deployer, then binding triggers like repository pushes or manual approvals. The embedded toolkit shows MCP calls for creating pipelines, executing them with parallel processing, and leaning on message queues for coordination when multiple agents must hand off work. Solo builders adopting agent-first DevOps can use it to sketch CI/CD style flows without rewriting orchestration prose each time, and to plan error recovery and monitoring hooks before production load. Because triggers and recovery apply whenever you automate releases or operational playbooks, the skill is journey-wide even though Prism shelves it under Build integrations as the first touchpoint.810installs3Agent Arch System DesignAgent-arch-system-design is a Ruflo system-architect skill for solo builders who need a disciplined architecture pass before implementation agents take over. It listens for architecture, scalability, and microservices language and focuses outputs on decision records, diagrams, and structured design notes under allowed doc paths. Human approval is expected for major calls because the skill is explicitly non-autonomous on irreversible technical bets. Tooling constraints keep the agent from editing production code or shelling out, which reduces the risk of accidental refactors during a planning chat. Use it when you are scoping a new SaaS or API, comparing patterns, or documenting ADRs; then hand off to implementation skills or agents once the architecture folder reflects agreed constraints.779installs4Security Auditsecurity-audit from ruvnet/ruflo is an agent skill that packages comprehensive application security scanning and vulnerability detection for solo builders shipping SaaS or API backends. It directs the agent to run claude-flow security commands for input validation, path traversal, SQL injection, cross-site scripting, hardcoded secrets, and CVE dependency analysis, with optional npm audit fix remediation between scans. The README positions it for high-risk implementation moments: authentication and authorization logic, payment flows, personal data handling, new API endpoints, file uploads, and database access patterns. Two bash entry scripts split a full multi-check scan from a CVE-focused remediate-and-rescan loop. Complexity is intermediate because it assumes a Node/npm toolchain and comfort interpreting security CLI output. It complements code review skills by emphasizing exploit classes and dependency risk rather than style. Builders should treat results as gates before merge or deploy, not as a one-time checkbox.772installs5Agent SwarmAgent Swarm is a Flow Nexus-oriented agent skill for solo builders who need cloud multi-agent orchestration rather than a single chat thread. The persona acts as a swarm orchestrator: initialize topologies such as hierarchical or mesh, spawn specialized agents with declared capabilities like web search and analysis, and route complex work through coordinated tasks. Documented MCP patterns include swarm_init with maxAgents and strategy, agent_spawn with type and capabilities, and task orchestration hooks for parallel specialization. It targets builders already investing in agentic products who want balanced or adaptive allocation strategies and explicit lifecycle control from bootstrap to teardown. Expect JavaScript-oriented MCP examples and dependence on the Flow Nexus platform—not local-only Claude subagents without cloud infra.752installs6Agent Spec Mobile React Nativeagent-spec-mobile-react-native is a Ruflo agent specification that turns your coding agent into a mobile-focused implementer for React Native and Expo. It declares triggers on react native, expo, native modules, and typical app entry files, plus constraints that keep edits inside src, screens, navigation, and platform folders while blocking dependency trees and build outputs. Solo builders use it when a single generalist agent drifts on mobile concerns—navigation stacks, platform folders, or native bridges— and you want repeatable behavior with explicit tool limits. It is multi-phase in practice: most work sits in build, but validate prototypes and operate iteration on crash-prone native code also match the triggers. Pair it with auth or API skills separately; this spec is about shipping mobile UI and structure, not tenant setup.728installs7Github Code ReviewGitHub Code Review is an agent skill for solo and indie builders who ship through GitHub pull requests and want more than a single-pass LLM skim. It documents how to pull PR JSON and diffs with the GitHub CLI, initialize a ruv-swarm review swarm, and fan work across specialized reviewers for security, performance, coding style, architecture, and accessibility. The quick-start path covers lightweight status comments; the complete workflow bundles file stats, title/body context, and comprehensive depth so agents produce coordinated findings instead of one vague summary. Treat it as an orchestration playbook layered on gh and swarm tooling—not a replacement for human judgment on product risk or organizational policy. Best when you already use PRs and want repeatable, categorized feedback before merge.695installs8Agent ArchitectureAgent Architecture is a specialized SPARC phase skill that acts as the system architect between pseudocode and coding. It instructs the agent to define components and boundaries, design interfaces and contracts, select stacks, plan scale and resilience, and sketch deployment topology—often with layered diagrams from clients through gateways to services. Hooks mark the architecture phase start and completion in memory so later SPARC phases can retrieve arch_complete artifacts. It assumes pseudocode work already finished and searches memory for pseudo_complete before designing. Solo builders using multi-agent SPARC flows invoke it when a feature or product needs an explicit structural blueprint agents and humans can implement against, not when tweaking a single file.690installs9Github Workflow AutomationGitHub Workflow Automation is an agent skill for solo and indie builders who want GitHub Actions that adapt to the repo instead of copy-pasted templates. It layers ruv-swarm tooling on top of the GitHub CLI so your agent can propose pipelines from codebase signals, tighten slow or redundant jobs, and interpret failed runs with remediation hints. The skill targets high-priority progressive disclosure: start from a generated workflow, then iterate with optimize and analyze-failure flows. It fits teams shipping SaaS, APIs, or CLIs where one person owns both code and release engineering. Expect coordination concepts tied to claude-flow swarm modes—not a minimal single-file skill—so budget time to satisfy requires (gh, git, node, claude-flow). Use when you are past local dev and need repeatable CI/CD, security-aware automation, and repository workflow hygiene without hiring a dedicated platform engineer.687installs10Agent Trading PredictorAgent Trading Predictor is an agent skill that defines a financial trading persona and the MCP tool surface to invoke through Claude Code or similar hosts. Indie builders experimenting with agentic trading stacks use it when scaffolding bots or research agents that call ruflo’s sublinear-time-solver MCP server for prediction and validation workflows described in the skill. The readme positions predictive execution, latency arbitrage, order-book microstructure analysis, and continuous risk assessment as core behaviors—always paired with explicit MCP tool names so the agent knows what to request. It is a packaging layer for prompts and capabilities, not a regulated trading product; you still own compliance, keys, and broker integration. Treat outputs as research scaffolding until you validate models, legal constraints, and real market connectivity yourself.684installs11Agent Coordinationagent-coordination teaches solo builders how to use the ruflo/claude-flow stack to turn one coding session into a managed multi-agent operation. Instead of improvising sub-agents in chat, you pick a typed role—coder, reviewer, tester, security-auditor, pr-manager, or one of several swarm coordinators—and drive it through documented npx commands for spawn, discovery, health, metrics, graceful stop, and pre-warmed pools. The skill catalogs capability families so you can match agents to phases: specification and architecture agents during planning, code-review swarms before ship, release-manager during launch prep. It is integration-first documentation rather than a standalone methodology, so you still own task decomposition and result merging. Best results assume Node/npx available and comfort delegating parallel work; skip it when a single generalist agent can finish the job without pool overhead.682installs12Agent Analyze Code Qualityagent-analyze-code-quality packages a Claude Code–oriented code-analyzer agent for solo and indie builders who need structured quality passes without letting the agent mutate the repo. Invoke it when you want a second opinion on maintainability, smells, and refactor opportunities after a feature branch stabilizes or before you open a pull request. The skill constrains the agent to read-only tooling across common source trees, caps file operations, and encourages web-backed best-practice checks while keeping execution and delegation off the table. It fits SaaS, API, and CLI codebases where TypeScript, JavaScript, Python, or Java dominate. Pair it with your normal ship-phase review workflow rather than ad-hoc “scan my repo” prompts so findings stay consistent and scoped to real application directories.681installs13Agent Paymentsagent-payments is a Flow Nexus payments specialist skill that agents invoke as $agent-payments to manage rUv credits, billing, subscriptions, and tier upgrades inside the Flow Nexus ecosystem. Solo and indie builders shipping agent products on Flow Nexus use it when they need secure payment links, balance tracking, auto-refill when credits drop, and upgrade paths without hand-rolling Stripe-style flows in chat. The SKILL.md documents a concrete JavaScript-oriented MCP toolkit: check_balance, ruv_balance, ruv_history, create_payment_link, configure_auto_refill, user_upgrade, and user_stats. It fits the Build phase when you are integrating financial operations into an agent stack, and it pairs naturally with other ruflo/Flow Nexus skills that consume credits. Complexity is intermediate because you must understand user_id scoping, tier names, and threshold tuning. Review Flow Nexus security and audit posture on the Prism detail page before trusting production billing.681installs14EmbeddingsThe embeddings skill documents how solo builders wire ruflo/claude-flow vector embeddings into agent workflows. You initialize a sqlite-backed cache, embed single strings or JSON document batches, and query with semantic search tuned by top-k. HNSW indexing, optional hyperbolic geometry for hierarchies, and normalization or chunking knobs support knowledge bases and pattern libraries rather than keyword grep. Memory commands let agents persist keyed facts with embeddings and recall related entries later. Skip it when exact string matches suffice. The skill targets builders shipping agentic CLIs or internal copilots who need durable semantic retrieval without standing up a separate vector database on day one.680installs15Agent Planneragent-planner is a coordinator-style agent skill from the Ruflo stack that turns large, ambiguous requests into actionable execution plans. Solo and indie builders use it when a single chat thread is not enough to see dependencies, sequencing, and where specialized agents or tools should plug in. The workflow walks through scope analysis, atomic task breakdown, prerequisite mapping, rough time estimates, and blocker identification so you can hand a structured plan to coding, review, or ops skills instead of improvising step by step. It fits early in a build cycle when specs exist only as ideas, but it also helps when rescoping mid-project or replanning after failed attempts. Expect narrative plans and stored memory checkpoints rather than generated repos or PRs; pair it with implementation and review skills once the plan is stable.679installs16Agent Workflow AutomationAgent Workflow Automation is a DevOps-oriented agent skill that treats GitHub Actions as the control plane for intelligent, self-adjusting CI/CD. Solo and indie builders who already use Claude Code (or similar agents) can invoke it when they need new workflows, updates to existing pipelines, or visibility into runs and bottlenecks without bouncing between docs, copy-paste snippets, and tribal CI knowledge. The skill composes GitHub MCP capabilities with claude-flow swarm tooling so tasks like orchestration, performance reporting, and automation setup happen in one guided session. Hooks prime the agent to analyze repository layout, stash templates in swarm memory, then deploy workflows and surface metrics afterward. It suits small teams shipping from a single repo who want agent-assisted pipeline design rather than a static template library. It is not a hosted CI product itself—you still own secrets, branch protections, and review of generated YAML before merge.671installs17Agent Agentic PaymentsAgent Agentic Payments is an agent skill for solo builders shipping autonomous commerce: AI agents that need real spend authority without handing over a raw card. It centers on Active Mandates—time-bounded, amount-capped authorizations with merchant rules—for intents, carts, or subscriptions. You create and sign mandates, verify Ed25519 signatures, and escalate large purchases to multi-agent Byzantine consensus before capture. The skill maps to MCP workflows for mandate lifecycle, revocation, limit enforcement, and swarm coordination. Use it when your agent product must authorize purchases programmatically while keeping humans in control of caps and merchants. It assumes you are past prototype and integrating payment rails into an agent or marketplace backend, not when you are only validating pricing on a landing page.664installs18Agent Performance OptimizerAgent Performance Optimizer is a specialized agent skill that acts as a performance consultant for solo builders running APIs, SaaS backends, or distributed jobs. It walks through utilization analysis, profiling, and scalability assessment, then proposes concrete strategies—resource allocation, load balancing, cache tuning, and algorithm improvements—rather than generic “make it faster” advice. Invoke it when latency spikes, cloud bills climb, or you are unsure whether the limit is code, infra, or traffic shape. The packaged persona emphasizes sublinear methods and efficiency maximization, which suits iterative tuning before launch and ongoing production refinement. It is advisory: you still need real traces, benchmarks, and environment access to validate recommendations.663installs19Agent Orchestrator TaskAgent Orchestrator Task is a Ruflo orchestration skill that positions a Task Orchestrator agent as the hub for breaking large goals into executable units, scheduling them, and merging outcomes. Solo builders running multi-agent Claude or Cursor workflows invoke it when one chat thread cannot hold the whole problem—features that span backend, tests, and docs, or ops tasks that need ordered checkpoints. The skill documents decomposition, dependency management, parallel versus sequential versus adaptive execution, progress tracking, and priority handling, plus lightweight hooks that stamp orchestration start and completion in memory. It is procedural orchestration knowledge, not a hosted scheduler service. Use it when you want explicit plans and monitored subtasks instead of ad-hoc parallel tool calls. Downstream workers still need domain skills; this layer decides what runs when and how results roll up.662installs20Agent Repo Architectagent-repo-architect is an agent skill that drives repository structure optimization and multi-repository management for builders running ruv-swarm and Claude-Flow style orchestration. Solo founders who outgrow a flat repo—or need coordinated splits across services—invoke it to analyze layout, apply changes with validated edits, and emit architecture recommendations after tasks complete. The skill wires Bash, read/write/edit, todos, tasks, WebFetch, GitHub MCP, and claude-flow MCP tools with explicit hooks so structure work stays synchronized with swarm agents. Use it when spinning up new GitHub repos, forking patterns, pushing scaffold files, or aligning folder conventions before more agents join the project. It assumes comfort with npx ruv-swarm hooks and MCP-enabled agents. Placement is Build agent-tooling, but the same playbook helps during Operate when repos drift and during Ship review when structure blocks safe releases.662installs21Agent ResearcherAgent Researcher is an analyst-style agent skill from the Ruflo stack for thorough software investigation before you build or refactor. Solo and indie builders invoke it when a task needs more than a quick file peek: understanding how a codebase implements a feature, where documentation is thin, which dependencies matter, and what patterns repeat. The skill defines a repeatable methodology—broad search, complete context reads, cross-location checks, then synthesis into clear recommendations. It fits early journey research when comparing approaches or scoping a product, and it stays useful during Build and Operate when you need structured code archaeology or incident context. It is procedural knowledge packaged as an invokable researcher, not a hosted MCP server, and pairs naturally with planning or implementation skills once findings are documented.662installs22Agent Safla NeuralAgent SAFLA Neural is an advanced agent skill for builders who want agents that retain context, learn from feedback, and coordinate memory across sessions—not one-shot chat completions. It encodes expertise in Self-Aware Feedback Loop Algorithms: designing multi-tier memory, compression strategies, distributed neural training clusters, divergent thinking modes, and safety guardrails around self-modifying behavior. Solo founders experimenting with autonomous coding agents or internal copilots use it when plain prompt chains are insufficient and they need an explicit architecture for persistence and improvement loops. The skill is specialized agent infrastructure knowledge; it assumes comfort with distributed systems concepts and agent safety thinking. Expect architectural guidance and implementation patterns rather than a single integration checklist. Pair it with research or planning skills when you are still choosing whether persistent neural memory belongs in your product at all.661installs23Agent TesterAgent Tester is a Ruflo validator skill you invoke with $agent-tester when you want an agent to behave like a QA specialist instead of improvising a single happy-path test. It structures work around the test pyramid, maintainable test code, boundary conditions, performance checks, and security-focused validation. Hooks attempt to detect common JavaScript test runners and surface JSON summary counts after runs. Solo builders use it to turn vague “add tests” requests into layered coverage plans and executable suites aligned with ship readiness. It does not replace human review of flaky CI or production monitoring, but it standardizes how your coding agent thinks about quality before release.661installs24Memory ManagementMemory Management is a multi-phase agent skill for solo builders running ruflo / claude-flow style orchestration who need durable, searchable memory instead of repeating the same discoveries every session. It centers on AgentDB with HNSW vector search so agents can store successful patterns, find similar prior work, and consolidate memory through documented shell scripts and npx CLI commands. Use when tasks compound across builds, operations, and iteration—when you want semantic recall of how you solved authentication, deploy quirks, or integration edge cases. Skip when work is truly throwaway or you already have an authoritative external knowledge base. The skill expects comfort with CLI hooks and local backup directories, not a passive chat-only workflow.658installs25Agent Code AnalyzerAgent Code Analyzer is a ruflo code-analyzer specialist skill invoked as $agent-code-analyzer for deep review passes across structure, performance, security, and technical debt. It treats naming, error handling, documentation, architectural patterns, and dependency risk as first-class signals rather than a shallow lint diff. Pre- and post-task hooks integrate with claude-flow@alpha to bracket analysis with performance-oriented post-task reporting. Solo builders shipping without a human reviewer can use it after feature work or before merge to surface bottlenecks, vulnerabilities, and refactor opportunities with explicit specialization in quality assessment. It complements manual testing by focusing on systemic issues—complexity, smells, and debt—that fast iteration often skips.656installs26Agent Data Ml ModelAgent-data-ml-model packages the ruflo ml-developer persona as a Prism agent skill for solo builders who need structured help building machine learning workflows without handing deployment keys to the agent blindly. It activates when you are creating models, training classifiers, or wiring prediction code across notebooks and Python modules, with file-pattern hooks for ipynb, train scripts, and serialized weights. The skill emphasizes local data work—WebSearch is restricted—and gives the agent Read, Write, Edit, MultiEdit, Bash, and notebook tools within data and experiments directories while blocking credentials and git internals. For indie teams shipping predictive features or internal analytics, it compresses repetitive scaffolding—preprocessing, experiment folders, evaluation—into a repeatable agent session capped at sensible file-operation and runtime limits, so you stay in the build loop until you consciously approve anything production-facing.656installs27Agent Performance MonitorAgent Performance Monitor is an agent skill from the ruflo ecosystem that models a dedicated performance optimization agent: it collects real-time metrics across system health, per-agent behavior, swarm coordination, task execution, resources, and network traffic, then supports bottleneck analysis, SLA monitoring, and anomaly detection. Solo and indie builders shipping multi-agent or orchestration-heavy products can invoke it when they need a structured approach to observability beyond a single log line—especially when several workers share tasks and coordination latency matters. The bundled reference implementation sketches a MetricsCollector with maps for collectors, aggregators, streams, and alert thresholds, which you can adapt to your stack. Use it during hardening before launch, after ship when users hit edge cases, and in Operate when you tune cost and latency. It complements generic APM by naming agent-specific dimensions; it does not replace hosted Grafana or CloudWatch unless you wire exports yourself.656installs28Github AutomationGitHub Automation is an agent skill for solo builders who ship on GitHub and want repeatable repository operations from Claude Code or similar agents. It wraps everyday GitHub CLI flows alongside claude-flow commands for automated review, issue tracking, workflow templates, and release cuts. You reach for it when you are opening or shepherding pull requests, triaging issues, standing up GitHub Actions CI, or coordinating a release—not for local-only edits or hosts outside GitHub. The skill maps clear agent personas to PR management, review swarms, and release automation so one person can run a small-team shipping rhythm. It pairs naturally with conventional commits and branch protection habits already common on indie SaaS and API projects.656installs29Agent Docs Api OpenapiAgent Docs API OpenAPI is an autonomous documentation skill for solo builders who need credible HTTP API reference without hand-rolling every path and schema. It specializes in OpenAPI 3.0 and Swagger workflows: drafting specs, extending existing openapi.yaml or swagger.yaml files, and keeping endpoint descriptions, request bodies, and response models consistent with what you are building. Invoke it when you add routes, change payloads, or need a shareable contract for frontend clients, partner integrations, or later ship-phase security review. The agent is constrained to documentation paths and common spec formats (YAML, JSON, Markdown) so it stays focused on specs rather than running your server. That makes it a practical companion during build when the API surface is still moving but you want agents and humans to share one source of truth before you harden tests and publish docs in launch.655installs30Agentic JujutsuAgentic Jujutsu is an npm-distributed, jujutsu-style version control layer tuned for AI coding agents that work on the same codebase at once. It exposes a JjWrapper JavaScript API for everyday VC operations—status, logging, new commits, and branch creation—while adding agent-specific flows such as trajectories, ReasoningBank learning, and suggestion objects with confidence scores. Solo and indie builders who orchestrate Claude Code, Cursor, or Codex in parallel install it when Git’s lock contention and manual merge resolution slow autonomous edits. The README positions lock-free performance, high automatic conflict resolution, pattern recognition, and quantum-resistant security as differentiators from treating agents as single-threaded git users. Use it during active development when multiple agents branch and commit simultaneously, and again when you review or reconcile agent-produced history before release. It complements ordinary Git hosting rather than replacing human PR review discipline.654installs31Agent Ops Cicd Githubagent-ops-cicd-github is a Claude Code–style agent skill that acts as a specialized GitHub Actions engineer for solo and indie builders shipping from a repo. It activates when you mention GitHub Actions, CI/CD, pipelines, workflows, or deployment, or when it sees workflow YAML under .github or action manifests. The skill writes and refines workflow files, related scripts, and container definitions while staying inside allowed paths and avoiding secrets directories. It is built for moderate-complexity automation where you want repeatable test-and-deploy gates rather than one-off shell hacks. For a one-person team, that means turning “ship on green” into versioned YAML the agent can maintain alongside application code. Review generated jobs for secret usage and third-party actions before merging to default branch.654installs32Agent CoderAgent Coder is a phase-specific agent skill from the Ruflo family that acts as an implementation specialist for solo builders using multi-agent workflows. When you invoke it with a TASK, it adopts a senior software engineer stance: clear naming, single-responsibility modules, intuitive APIs, robust error handling, and performance-aware changes that stay readable. Hooks surface discipline—if your task mentions tests, the pre-hook nudges test-first work; after implementation, a light lint pass runs when a Node project is detected. It is meant for turning approved requirements into production-quality code inside an orchestrated agent stack, not for open-ended product discovery. Pair it with planning or review agents upstream and downstream. Intermediate complexity assumes you already have a repo, stack, and concrete task description; deliverables are implemented code and validated style checks rather than product specs.653installs33Agent Tdd London Swarmagent-tdd-london-swarm packages the London School of TDD for agent swarms orchestrated in the ruflo ecosystem. Solo builders shipping Node or full-stack SaaS often fail when one agent writes happy-path code while another adds tests that fight the architecture; this skill pushes mockist discipline so boundaries and collaborations are agreed before internals harden. It drives outside-in examples from user-visible behavior to collaborators, using doubles to document contracts between modules and services. Pre- and post-hooks coordinate with peer test agents and optionally run the project's npm test script, which ties agent narrative work to executable proof. Use it when you want swarm-scale coverage without collapsing into integrated tests for every layer. It pairs best with repos that already have a test runner wired. Advanced teams treating tests as design tools—not a Ship-afterthought—get the most value.653installs34Github Project Managementgithub-project-management is an intermediate agent skill for running GitHub as your system of record while an AI swarm helps coordinate work. It expects GitHub CLI authenticated, repository access, and optional ruv-swarm or claude-flow MCP so issues, boards, and hooks stay in sync. Solo builders use it when a growing backlog needs labels, boards, and sprint rhythm without hiring a PM. The skill walks through creating issues with structured bodies, initializing swarm pre-task hooks, and wiring project boards for visibility. It pairs naturally with PR and release skills in the same repo family. You still own priorities and merging; the skill accelerates repetitive GitHub operations and keeps agent tasks tied to trackable issues.653installs35Agent Dev Backend ApiAgent Dev Backend API is a phase-specific agent skill from the Ruflo stack for backend API implementation with pattern-aware, autonomous editing. It activates on REST, GraphQL, route, and controller work under conventional Node-style layouts, keeping changes inside api, routes, controllers, models, middleware, and tests while avoiding node_modules and dist. Solo builders use it to add endpoints, flesh out resolvers, and iterate on server code without hand-holding every file touch—similar to spawning a backend-focused sub-agent with explicit tool and path guardrails. Pair it with planning or review skills when a spec exists and you want structured implementation rather than ad-hoc chat patches. Invoke with the documented $agent-dev-backend-api entry when your task language matches create endpoint or implement API patterns.652installs36Agent Consensus CoordinatorAgent Consensus Coordinator is an advanced agent skill aimed at builders architecting multi-agent or distributed systems where independent nodes must reach agreement despite failures or adversarial behavior. It encodes expertise in Byzantine fault tolerance, voting mechanisms, agreement protocols, and coordination optimizations described as sublinear solvers for large-scale deployments. Solo builders rarely need this on day one, but it becomes relevant when your product is itself an agent mesh, a coordinated swarm, or blockchain-adjacent infrastructure and you want the coding agent to reason with protocol vocabulary instead of generic CRUD patterns. The skill emphasizes synchronization across swarms, distributed resource allocation, load balancing, and conflict resolution when decisions diverge. Treat it as specialized procedural knowledge for the build phase rather than interview prep or landing-page work. Confidence is moderate where upstream SKILL.md is thin on concrete install steps beyond the ruflo invoke alias.651installs37Agent Neural NetworkAgent Neural Network is an agent skill that acts as a Flow Nexus neural-network specialist for solo builders shipping ML features inside agent workflows. It focuses on designing layer stacks, launching distributed training jobs, tuning epochs and optimizers, and moving models through validation and inference using documented MCP calls rather than ad-hoc notebooks. The SKILL.md frames the agent as responsible for architecture choice, resource allocation, benchmarking, and lifecycle management on cloud sandboxes—useful when you need production-minded training without standing up your own GPU fleet. Invoke it during build when your product needs custom models, retraining pipelines, or scalable inference behind an API or agent tool. It complements generic coding skills by encoding Flow Nexus-specific orchestration patterns so your agent does not improvise unsafe or incomplete ML ops steps.651installs38Agent Swarm Memory ManagerAgent Swarm Memory Manager is an agent skill for solo and indie builders running coordinated multi-agent workflows through Claude-flow-style MCP memory. It defines how a dedicated memory-manager agent initializes status keys, maintains a shared memory index for fast retrieval, and keeps collective state synchronized across the hive. The playbook treats memory as infrastructure: you continuously write and sync state, namespace coordination data, and optimize reads through layered caching rather than ad-hoc context stuffing. Use it when several agents must share decisions, component maps, and history without drift or duplicate work. It matters because swarm setups fail quietly when each agent keeps a private transcript—this skill encodes the keeper role, indexing shape, and sync discipline so retrieval stays predictable as agent count grows.651installs39Neural TrainingNeural Training is a Ruflo/claude-flow skill for solo builders pushing agent systems into learned routing and pattern memory using SONA, Mixture of Experts, HNSW retrieval, LoRA distillation, and EWC++ consolidation. It documents when to trigger—training new patterns, optimizing agent routing, knowledge transfer, and recognition tasks—and maps each stage to bash commands such as neural train, status, patterns, predict, and optimize. The skill assumes you are already investing in claude-flow rather than running a single static prompt, and it tells you to skip it for simple one-off operations with no learning loop. For Prism, it belongs on Build agent-tooling as an advanced integration for people treating agents as trainable systems, with operational follow-up only after patterns are deployed into live workflows.650installs40Agent Issue Trackeragent-issue-tracker is a Claude Flow–aware GitHub issue skill for intelligent issue management: it wires swarm initialization, agent spawning, task orchestration, and memory usage together with Bash, TodoWrite, and read/write so backlog work stays visible across agents and repos. Solo and indie builders wearing the PM hat use it when GitHub Issues are the system of record but manual triage does not scale with agent-assisted development. The skill expects `gh` to be authenticated, sets up a coordination environment on start, and finishes by persisting issue state into swarm memory. It suits active build sprints, launch checklists expressed as issues, and ongoing operate cycles where cross-repository synchronization matters. Intermediate complexity reflects MCP plus CLI dependencies and swarm concepts; confidence is moderate because the bundled frontmatter mixes naming variants (agent-issue-tracker vs issue-tracker) that operators should verify in their fork.649installs41Agent Memory CoordinatorAgent Memory Coordinator is an Ruflo coordination skill that treats memory as a first-class subsystem for AI-coding agents. Solo and indie builders use it when multiple sessions, sub-agents, or pipelines need the same facts without bloating every prompt. It covers storing structured data under keys, pattern-based search, namespace isolation, compression, and sync so one agent can hand off context to another. The skill assumes high-priority coordination hooks and is aimed at builders shipping agent products or heavy Codex/Claude Code workflows—not casual single-chat tasks. Pair it with orchestration and tool skills once you outgrow ad-hoc markdown notes in the repo.649installs42Agent Code Review SwarmAgent-code-review-swarm packages the code-review-swarm workflow for solo builders and small teams who want PR reviews that behave like a staffed review board instead of a single lint pass. The skill initializes a swarm with MCP Claude Flow tools (swarm_init, agent_spawn, task_orchestrate), pulls live pull request metadata and diffs through GitHub CLI, and routes specialized agents across security, performance, style, and architecture concerns. Hooks require authenticated gh before work begins and signal when results are posted and quality gates are scored. It fits Ship when you are merging often, cannot afford a full-time reviewer, and still need merge discipline. Expect shell orchestration, file reads and writes, and optional todos—not a drop-in for non-GitHub hosts without adaptation. Pair it with your existing CI; it amplifies judgment on diffs rather than replacing unit tests.648installs43Agent Goal Planneragent-goal-planner is a Ruflo agent skill that implements Goal-Oriented Action Planning (GOAP) for software-building agents. Instead of flat todo lists, it treats objectives as states, actions as operators with preconditions and effects, and uses search—described as A*—to discover efficient, sometimes creative sequences through large decision spaces. Solo builders invoke it when a single prompt cannot reliably order dependent steps across tools, APIs, and code changes. The skill emphasizes adaptive replanning after partial failure, cost-aware paths, and blending LLM judgment with deterministic steps. That makes it useful whenever you need structured multi-step autonomy without hard-coding every branch: scoping features, implementing integrations, debugging regressions, or recovering mid-ship. It is methodology for agent control, not a hosted planner SaaS. Expect intermediate familiarity with how your agent exposes tools and state, because quality depends on accurate precondition and effect definitions you supply or refine during runs.648installs44Sparc MethodologySPARC Methodology is an agent skill that enforces Specification, Pseudocode, Architecture, Refinement, and Completion as separate written phases before and during complex implementation. It targets solo and indie builders using Claude Code, Cursor, or similar agents when a feature is too large to safely freestyle in chat—integrations, redesigns, or fuzzy requirements. The bundled init script scaffolds a per-feature folder under docs/sparc with five markdown files, and the review script verifies which phases exist so you do not merge half-planned work. Skip it for routine maintenance where the change is already bounded. Used well, SPARC turns agent sessions into auditable planning deliverables that reduce rework and make handoffs between research, build, and ship reviews predictable.648installs45Agent Automation Smart AgentSmart Agent Coordinator is an agent skill for solo and indie builders running multi-agent setups who need tasks decomposed and routed to the right specialist agents automatically. It analyzes requirements in plain language, scores complexity, infers required skills, estimates resources, and detects dependencies before choosing spawn patterns. Capabilities include intelligent spawning, capability matching, resource optimization, pattern learning, auto-scaling, and workload prediction, with optional hooks that snapshot swarm status and store coordination outcomes for later runs. Use it when a single general-purpose agent is underpowered for mixed workstreams—frontend, backend, review, and ops tasks in one backlog—and you want coordination logic instead of manual agent assignment. It complements build-phase agent stacks and bleeds into operate when you scale concurrent agent work in production iteration loops.647installs46Agent Topology Optimizeragent-topology-optimizer is an agent skill for solo builders running ruflo-style swarms who need performance-oriented network shapes instead of a fixed chat fan-out. It documents the Topology Optimizer agent: a specialization in dynamic topology reconfiguration and communication-pattern optimization across hierarchical, mesh, ring, star, hybrid, and adaptive modes. When you profile a workload—bursty parallel research, sequential review chains, or hub-and-spoke tool routing—the skill guides intelligent selection by analyzing the incumbent topology, generating candidates, and applying constraints before reconfiguration. The embedded JavaScript-oriented class sketch shows how analyzer, predictor, and optimizer subsystems cooperate, which helps indie teams reason about latency and fan-in before they scale agent count. Install it during build when your multi-agent demo works but message paths feel redundant or brittle. It is advanced material aimed at people already shipping agent orchestration, not first-time prompt writers.647installs47Swarm AdvancedSwarm Advanced is an agent skill for mastering Claude Flow swarm orchestration when one coding agent is not enough—you need researchers, implementers, and testers working in parallel with explicit topology choice. Solo builders running ambitious agent pipelines install it to learn how mesh setups suit open-ended analysis, hierarchical setups suit staged development, and star setups centralize coordination. The skill bridges MCP tool calls and CLI workflows so you can initialize capacity limits, spawn typed agents, and fan out tasks with a stated strategy such as parallel execution. It sits in advanced territory: you should already have Node/npm and comfort wiring MCP into Claude Code. Use it when delivery depends on coordinated multi-agent runs, not for everyday single-file edits.647installs48Agent AgentSublinear Goal Planner (invoked as agent-agent) is a Goal-Oriented Action Planning specialist for solo builders and small teams who run Claude Code, Cursor, or similar agents on open-ended work. Instead of improvising the next command in chat, you state a high-level objective and the skill models goals, actions, preconditions, and branches as a graph, then proposes an ordered plan you can execute step by step. It emphasizes sublinear optimization, temporal advantage hints, and replanning when reality diverges from the first pass—useful when shipping features touches frontend, APIs, CI, and ops in one thread. Treat it as methodology layered on top of narrower skills (brainstorming, writing-plans, debugging): invoke when the problem is multi-step and constraints interact, not for a single-file tweak with an already-approved spec.646installs49Agent ReviewerAgent Reviewer is a Ruflo validator skill that positions the coding agent as a senior reviewer for quality, security, and maintainability. Solo builders shipping without a human second pair can invoke it on PRs, feature branches, or pre-release snapshots to walk a repeatable checklist: does the code meet requirements and handle edge cases, are there security and performance issues, do standards and docs hold up. Pre- and post-hooks frame the task and persist a review checklist in memory so follow-up turns stay consistent. It complements automated CI but does not replace secret scanning, dependency audits, or production monitoring—use it in Ship for merge readiness and in Build when refactoring critical paths. Outputs are qualitative findings with severity-style framing (for example missing validation called out explicitly) rather than guaranteed compliance certification.646installs50Agent Specificationagent-specification implements the SPARC Specification phase for solo builders who need auditable requirements before agents or humans write code. The skill guides functional requirement capture with IDs, priorities, and acceptance criteria, plus constraint analysis, scope definition, stakeholder alignment, edge cases, and success metrics in structured YAML-friendly form. Hooks mark the active SPARC phase and store completion timestamps so multi-step SPARC runs stay ordered. Use it when you have a rough product idea or client brief and need a specification artifact that downstream design, architecture, and implementation agents can execute without reinterpretation. It sits primarily in Validate scope but hands off naturally into Build planning and Ship acceptance testing because criteria are written to be testable from day one.646installs51Agent Code Goal Planneragent-code-goal-planner is a code-centric Goal-Oriented Action Planning (GOAP) agent skill that helps solo and indie builders translate ambitious software objectives into intelligent, milestone-based plans with clear success criteria. Integrated with SPARC methodology, it is built for situations where implementation risk is high—new authentication flows, API surface changes, performance remediation, or multi-file refactors—rather than single-line edits. You invoke it when you know what you want to achieve but need a structured path: provider setup, token handling, security checks, profiling targets, indexing, and caching phases can each become measurable milestones. The skill fits builders using Claude Code, Cursor, or Codex who want planning discipline without outsourcing architecture to ad-hoc chat. It complements validate-time scoping and ship-time hardening by producing plans your agent can follow incrementally, reducing rework and making “done” objective instead of subjective.645installs52Agent Pr ManagerAgent PR Manager is an agent skill for comprehensive GitHub pull request operations when you want reviews, tests, and merges orchestrated rather than done manually in the browser. It wires Bash, git, GitHub CLI, and multiple mcp__claude-flow__ tools for swarm init, agent spawn, task orchestration, memory, and dedicated GitHub PR and code-review actions. Documented hooks enforce authentication and surface dirty working trees, open PRs, and test runs before work starts, then report PR status, checks, and recent commits afterward. Solo builders shipping through GitHub who already run npm tests and gh can treat this as a structured ship-phase ritual: coordinate reviewers as agents, track progress, and aim for safer merges. It assumes a development environment with GitHub CLI logged in and is intermediate in complexity because swarm and MCP setup sit on top of basic PR hygiene.645installs53Agent Resource AllocatorAgent Resource Allocator is a Ruflo optimization agent skill that teaches adaptive resource allocation, predictive scaling, and intelligent capacity planning for agent swarms. Solo builders running multi-agent workflows or small distributed backends can invoke it when usage spikes are unpredictable and fixed provisioning wastes money or causes throttling. The skill embeds a structured allocator model—separate sub-allocators per resource type, a predictor for future needs, and hooks to analyze current usage before committing allocations. It fits Operate when you tune production infra, and Build when you design agent-tooling that must scale with workload profiles. It is not a turnkey cloud console integration; you still wire policies to your host (Kubernetes, VMs, serverless limits). Use it alongside monitoring skills once metrics exist, and treat recommendations as plans to validate against real quotas and billing.645installs54Flow Nexus SwarmFlow Nexus Swarm is an agent skill for cloud-based orchestration of AI agent teams on the Flow Nexus platform. Solo and indie builders use it when they need scalable, event-driven automation—initializing swarms, chaining workflow steps, and monitoring runs—without building a custom coordinator from scratch. The skill documents swarm initialization, workflow automation, agent orchestration patterns, templates, and advanced features such as intelligent agent matching and auto-scaling infrastructure. It explicitly depends on the flow-nexus MCP server and a registered Flow Nexus account, so tagging and expectations should treat it as a platform integration, not a local-only script. It matters for builders shipping multi-agent products who want repeatable topologies and queue-backed execution rather than one-off chat sessions.645installs55Github Multi RepoGitHub Multi-Repository is an agent skill for organization-scale repo work when a solo builder or tiny team juggles frontend, backend, and shared packages. It combines swarm intelligence with GitHub-centric automation: initializing coordination across named repos, keeping dependencies aligned, optimizing repo structure from templates, and running integration-oriented workflows that span repositories. The documented stack expects ruv-swarm and gh-cli, and quick-start flows use npx claude-flow skill run with explicit repo lists and topology options such as hierarchical layouts. It fits indie studios that outgrow one monorepo but do not want a full platform team—when every release depends on consistent versions and coordinated PRs across repos. Expect advanced setup: multiple remotes, CLI auth, and orchestration concepts rather than a single merge button.645installs56Stream ChainStream-Chain is a Claude Flow agent skill for executing multi-step agent workflows where streamed JSON output from one prompt becomes the input context for the next. Solo builders use it when a single chat turn is too shallow—for example running “analyze codebase → identify improvements → generate action plan” as one chained invocation instead of manually copying outputs. Custom `run` mode accepts two or more prompts with full control over sequencing; `pipeline` mode runs predefined workflows like analysis for faster starts. The skill targets operators already on claude-flow who want pipeline semantics without building custom orchestration scripts. It pairs naturally with other ruflo workflow skills when you need repeatable agent chains during build and ship reviews. Intermediate complexity: you must understand prompt ordering and how prior-step context affects downstream behavior.645installs57Agent Collective Intelligence CoordinatorAgent Collective Intelligence Coordinator is a specialized Claude Flow skill that plays the hive-mind coordinator: it orchestrates distributed agents through memory synchronization, consensus protocols, and coherent collective decision-making. The procedure emphasizes writing swarm and shared collective state to MCP memory immediately and often—initializing hive topology, cognitive load, active agents, and ongoing sync of consensus level and decision queues. Solo builders experimenting with multi-agent swarms use it when a single coordinator agent must keep disparate workers aligned on shared knowledge rather than diverging in parallel chats. It assumes comfort with claude-flow MCP memory patterns and swarm namespaces. Complexity is advanced because mis-synced memory corrupts collective behavior. Use when standing up or operating a coordinated agent mesh during build-heavy agent work, not for simple one-off coding tasks.644installs58Agent Load BalancerLoad Balancing Coordinator is an agent skill for indie builders running more than one autonomous worker—parallel reviewers, scrapers, or codegen agents—who need fair throughput without hand-tuning thread counts. It documents a performance-optimization agent centered on dynamic task distribution, local queues per agent, and work-stealing when neighbors have spare capacity. The included patterns show how a requesting agent picks victim queues, attempts bounded steals, and degrades gracefully to a shared global priority queue. That matters when burst traffic or uneven task sizes leave some agents starved while others backlog. Use it while hardening orchestration you already host—Node schedulers, custom swarms, or ruflo-style multi-agent graphs—rather than as a managed cloud load balancer SKU. Expect to adapt queue priorities and steal thresholds to your latency SLOs.644installs59Agent Performance Analyzeragent-performance-analyzer is a Ruflo-oriented analysis skill that helps solo builders find why agent-heavy pipelines feel slow or expensive. It frames work around recognizable bottleneck types—long-running tasks, CPU/memory/I/O limits, chatty coordination between agents, forced serial steps, and oversized payloads—then applies monitoring and pattern recognition across repeated runs. Hooks announce analysis start, stash baseline timing in memory, and mark completion with optimization guidance. Use it when you already have agents executing workflows and need a structured pass over metrics rather than guessing which step to parallelize or cache. It pairs naturally with ship-phase performance tuning and build-phase agent-tooling design reviews. Intermediate complexity: you need runnable workflows and some observability hooks to benefit. It is analysis and planning, not automatic code rewriting.644installs60Agent Sona Learning OptimizerSONA Learning Optimizer is an agent skill for builders who want agents that improve from execution rather than staying fixed. It packages Self-Optimizing Neural Architecture ideas with LoRA fine-tuning for efficient updates, EWC++ continual learning to preserve prior knowledge, and a pattern library that recalls a small set of similar past decisions to steer new work. LLM routing selects models with quality and cost in mind, and the skill emphasizes measurable throughput and latency characteristics from ruvector-sona style benchmarks. Use it when you are running repeatable agent workflows—support triage, codegen pipelines, or research loops—and want compounding quality without rewriting prompts every week. It fits solo and indie teams shipping multi-step agents in Claude Code, Cursor, or custom runners where you can log outcomes and feed them back into training or routing policies.644installs61Github Release ManagementGitHub Release Management is a Ruflo / Claude Flow skill for comprehensive release orchestration: draft or published GitHub releases, generated notes, artifact builds, and multi-platform deploy targets such as npm, Docker, and GitHub-hosted assets. Solo builders shipping npm CLIs or Node services use the quick gh path when they only need a tagged release, then graduate to claude-flow swarm commands when validation, artifact builds, and coordinated rollout matter. The skill declares relations to PR management, issue tracking, workflow automation, and multi-repo coordination—useful when one person wears release manager and engineer hats. Dependencies include git, npm or yarn, GitHub CLI, and claude-flow; optional pieces add MCP GitHub and ruv-swarm. Expect hierarchical swarm topology for full pipelines rather than a single chat message replacement for CI.644installs62Hive Mind AdvancedHive Mind Advanced is an agent skill for sophisticated multi-agent coordination in Claude Flow. It teaches a queen-led architecture where strategic queens set objectives and specialized workers execute research, coding, analysis, testing, architecture, review, optimization, and documentation. Collective memory and consensus mechanisms keep swarms aligned when objectives split across parallel agents. Solo and indie builders shipping with Claude Code, Cursor, or Codex install it when a single conversational agent cannot safely own planning, implementation, and verification at once. Use it during build for parallel feature work, during ship when you want reviewer and tester workers in the loop, and during operate when you iterate on production fixes with optimizer and analyst roles. The skill is procedural knowledge for coordination design—not a hosted MCP server—so you still own prompts, tools, and guardrails in your repo.644installs63Agent Project Board Syncagent-project-board-sync exposes the ruflo project-board-sync coordination skill for builders who run multi-agent swarms but still want GitHub Projects as the source of truth for what is in flight. It wires swarm initialization, agent spawning, orchestration, memory, and GitHub-specific analyze/PR/issue/metrics helpers into a flow that keeps board columns aligned with agent tasks. Pre-flight checks fail fast when gh is not authenticated or projects are inaccessible, which protects solo operators from silent drift between chat todos and the board. It fits indie teams of one wearing PM and engineering hats: you get issue lists and project snippets after runs without manually dragging cards. Intermediate complexity reflects GitHub Projects permissions, org vs user owners, and dependence on Claude-Flow MCP availability alongside Bash and filesystem edits.643installs64Agent PseudocodeAgent-pseudocode is a SPARC methodology skill that acts as the Pseudocode phase specialist: it reads completed specification context from memory, designs algorithmic solutions, selects data structures, analyzes complexity, picks patterns, and emits clear pseudocode blocks ready for implementation agents. Solo builders use it when an agentic workflow already follows SPARC and they need a disciplined bridge between written requirements and TypeScript, Rust, or other code—without skipping logic design. The skill encodes standards (ALGORITHM naming, validation branches, database access steps in example flows) and integrates with ruflo-style memory hooks so downstream coding phases can retrieve pseudo_complete timestamps. It is planning and architecture work, not a linter or deploy tool; invoke after spec_complete material exists and before hands-on implementation skills run.643installs65Agent Swarm Pragent-swarm-pr is a development agent skill that treats a GitHub pull request as the control plane for a multi-agent swarm. It analyzes the diff, assesses impact and complexity, spawns an appropriate agent topology via claude-flow, and runs orchestrated review and validation work while persisting context in swarm memory. GitHub MCP tools cover the full PR lifecycle—fetching diffs, commenting, updating status, and merging when the swarm consensus allows—so solo and indie builders can keep their normal PR habit while replacing ad-hoc single-thread review with coordinated agents. Pre- and post-hooks bookend each run with metadata capture and completion metrics. It fits builders already on Claude Code-style tooling with MCP access who want automated, repeatable PR review without standing up a separate review bot repo.643installs66Agent Github Modesagent-github-modes packages the ruflo github-modes skill for solo and indie builders who want GitHub operations driven from Claude Code, Cursor, or similar agents instead of juggling separate tabs and scripts. It documents multiple integration modes—starting with gh-coordinator for hierarchical coordination—covering PR lifecycle, issues, releases, repo structure, and CI/CD handoffs. Invocation assumes GitHub CLI authentication and an active git working tree, then leans on Bash plus read/write tooling and Claude-Flow orchestration primitives to keep parallel agent work aligned with repository state. It suits agent-heavy product repos where you already use gh and want repeatable pre/post hooks and swarm-backed task batches, not one-off chat instructions. Complexity is intermediate because you must maintain tokens, understand branch policies, and trust agents with shell and API access.642installs67Agent SandboxAgent Sandbox is an agent skill for deploying and operating E2B isolated environments through Flow Nexus MCP tools. It targets solo builders who want agents to write, install dependencies, and test code in disposable VMs instead of on a laptop. The skill documents how to create named sandboxes with templates and environment variables, execute JavaScript or other supported languages with captured stdout, move files in and out, and troubleshoot failures when packages or timeouts misbehave. Resource monitoring and lifecycle termination are included so sandboxes do not leak cost or credentials. Use it while building agent workflows that need safe code execution, reproducing bugs in a clean image, or validating snippets before merge. It pairs naturally with multi-step agent stacks where coding and verification must stay separated from the host repo.642installs68Agent Test Long Runneragent-test-long-runner wraps the ruflo test-long-runner custom agent skill so solo builders can validate or invoke agents that are explicitly allowed—and expected—to work for extended periods on hard problems. Unlike quick codegen skills, it instructs the model to favor depth over speed, maintain progress communication, and deliver long-form artifacts such as architecture write-ups, comprehensive guides, and multi-source research summaries. It is aimed at agent authors and operators testing Claude-Flow or similar stacks before relying on them for production planning workflows. You might use it during build to stress-test orchestration timeouts and memory behavior, or during ship when you need an exhaustive review narrative rather than a lint pass. Intermediate complexity reflects session cost, context limits, and the need to supervise long autonomous runs.642installs69Agent V3 Memory Specialistagent-v3-memory-specialist is a ruflo V3 specialist skill for converging multiple in-repo memory implementations into a single AgentDB surface with HNSW-backed retrieval. Solo builders and small teams shipping agentic-flow or Claude Flow swarms install it when legacy MemoryManager, DistributedMemorySystem, SwarmMemory, and hybrid SQLite or Markdown backends make search slow or inconsistent. Pre-execution hooks enumerate systems to merge and verify agentic-flow@alpha; post-execution hooks persist patterns for later agents. The work sits in build-phase agent-tooling but pays off again in operate when session recall and cross-agent coordination matter. Expect alpha tooling, shell checks, and architecture-driven migration rather than a one-click toggle. Best when you already run the ruflo stack and need measurable search gains without breaking existing memory consumers.642installs70Flow Nexus NeuralFlow Nexus Neural is an agent skill that teaches your assistant to train and manage neural networks inside distributed E2B sandbox environments using the Flow Nexus MCP server. Solo builders shipping agent-first products use it when model work should happen in isolated cloud sandboxes rather than on a laptop GPU. The skill documents prerequisite CLI steps—adding the MCP server, register, and login—and walks through configurations for architectures from feedforward through transformer, plus tiered resource presets from nano to large. It is aimed at Claude Code and other MCP-capable agents that can invoke mcp__flow-nexus__ tools for training jobs and marketplace templates. Expect intermediate complexity: you need auth, network access, and comfort with JSON training configs. It does not replace full MLOps on your own cloud; it integrates a specific vendor path for fast agent-driven experiments and deployments.642installs71Performance AnalysisPerformance Analysis is an agent skill for Claude Flow swarms that bundles bottleneck detection, real-time and historical profiling, report generation, and optimization recommendations. Solo builders and small teams running agent orchestration can invoke CLI commands to analyze a specific swarm or the current session, export HTML reports with metrics, and optionally apply fixes when thresholds are exceeded. It fits builders who already use Claude Flow and need a structured way to turn swarm telemetry into actionable changes instead of ad-hoc log grepping. Use it when latency, memory, or network contention shows up under load, after workflow changes, or before scaling concurrent agents. The skill emphasizes operational clarity: name the slow layer, document it in a report, then follow suggested optimizations.642installs72Agent Raft Manageragent-raft-manager is a Ruflo coordinator skill that encodes operational knowledge for the Raft consensus protocol: randomized leader elections, append-only log replication to followers, safe membership churn, and resynchronization after splits. Solo builders running multi-node agent gateways, custom control planes, or indie SaaS backends that cannot afford split-brain writes can invoke it when tasks mention elections, replication lag, or quorum drift. The SKILL frontmatter lists explicit capabilities and shell-oriented hooks that nudge pre-flight health checks before elections and post-flight consistency validation—useful when your coding agent would otherwise hand-wave distributed correctness. This is advanced material: you already run clustered processes, understand terms, and need procedural guardrails rather than a tutorial on CAP tradeoffs. It complements infrastructure-as-code and observability stacks; it does not replace managed Kubernetes etcd or cloud databases. Expect to pair with your actual Raft library implementation and metrics, using the skill to structure agent-driven incident or bootstrap workflows.641installs73Agent Release SwarmAgent Release Swarm is a coordination skill from the ruflo ecosystem that treats a software release as a swarm problem rather than a single linear script. Solo builders who already run Claude-style agents with Bash, GitHub MCP, and claude-flow can invoke it to fan out changelog drafting, validation edits, PR creation, and deployment handoff across specialized agents while hooks keep swarm state synchronized. Pre-task initialization, post-edit validation, post-task finalization, and notification broadcast are all scripted through ruv-swarm CLI modes so you get repeatable release ceremonies without manually re-prompting each step. The skill assumes you are comfortable granting broad tool access—shell, git remotes, file writes, and GitHub APIs—because release automation touches production paths. It complements generic CI YAML: here the agent orchestrates judgment calls and parallel task graphs. Expect intermediate-to-advanced setup for MCP servers and swarm configuration before the first green release train.641installs74Agent Adaptive Coordinatoragent-adaptive-coordinator wraps the ruflo adaptive-coordinator: a critical-priority swarm coordinator that reconfigures agent topology based on workload, trains coordination models on historical swarm data, and routes tasks intelligently. Solo builders running multi-step agent pipelines invoke it when fixed hierarchies bottleneck—too few agents on validation, too many on trivial edits—or when they need continuous performance baselines stored in adaptive memory namespaces. Pre-hooks initialize up to fifteen agents with an adaptive strategy, analyze patterns via neural MCP tools, and start monitoring; post-hooks emit detailed performance reports and persist learning for the next run. It is journey-wide in spirit because orchestration touches validate prototypes, build integrations, ship checks, and operate iterations whenever parallel agents are in play, even though the catalog shelf is build/agent-tooling for discoverability.640installs75Pair ProgrammingPair Programming is an agent skill for professional AI-assisted pair sessions modeled on driver and navigator roles, with switch, TDD, review, mentor, and debug modes. Solo and indie builders use it when they want one agent to implement while another lens reviews security, performance, and best practices in near real time, with truth-score verification and optional rollback when quality gates fail. It integrates test generation, coverage tracking, and continuous testing so shipping code is not separated from validation. Session persistence keeps long refactor or learning sessions recoverable. It sits in the build phase as agent tooling but naturally extends into ship when review and TDD modes gate merges. Compared to freeform chat coding, it enforces explicit collaboration modes and measurable quality bars—useful when you are shipping alone but still want a second pair of eyes on every change.640installs76Agent Gossip CoordinatorAgent Gossip Coordinator is an agent skill from the Ruflo stack that walks you through gossip-based consensus for eventually consistent distributed systems. Solo builders shipping multi-agent backends or horizontally scaled services use it when they need information to propagate without a single leader—epidemic push/pull spread, peer management, and vector-clock synchronization with explicit conflict handling. The skill frames five responsibilities: dissemination, peer management, state synchronization, convergence monitoring, and scalability control including fanout optimization. Shell hooks echo task start, peer topology setup for dissemination tasks, and post-cycle convergence checks so your coding agent treats coordination as an operational ritual, not a one-off comment. It pairs naturally with swarm worker and coordinator skills when you are splitting execution across nodes but still want a simple, battle-tested consistency story instead of bolting on a heavy consensus library before you have traffic.639installs77Agent Matrix OptimizerAgent Matrix Optimizer is a specialized agent skill for matrix analysis and optimization using sublinear algorithms. Solo builders shipping scientific, ML, or high-dimensional backend features install it when they need trustworthy answers about whether a matrix is suitable for sublinear solvers before committing to expensive solves. The skill focuses on property detection—diagonal dominance, symmetry, and structure—condition assessment via condition numbers and spectral gaps, and concrete optimization recommendations plus performance prediction. Invocation is through the matrix-optimizer agent and MCP tools on the sublinear-time-solver server, including analyzeMatrix and solve for diagonally dominant systems. It fits builders who already have matrices or linear systems in code and want agent-guided analysis instead of guessing solver settings. Intermediate complexity assumes comfort with linear algebra vocabulary; the skill does not replace a full numerical library but orchestrates analysis and solver calls through documented MCP tools.639installs78Agent Production ValidatorAgent Production Validator is a production validation specialist agent skill from the ruflo stack. Solo builders use it when a feature branch looks done but might still hide mocks, fakes, or incomplete integrations that would fail in real deployment. The skill enforces implementation verification: grep-based scans for mock and stub patterns, emphasis on end-to-end testing against live systems, and optional npm production and E2E test runs after validation. Hooks bookend each task with visible CLI feedback so agents and humans see whether the codebase still contains TODO/FIXME placeholders. It complements unit tests by simulating real-world conditions and deployment readiness. Intermediate complexity fits anyone who already runs npm test scripts and can wire real service credentials for E2E. The skill is a checker-style workflow, not a code generator—outcomes are pass/fail style readiness signals and executed test commands rather than new product features.639installs79Agent Security ManagerConsensus Security Manager is an agent skill aimed at solo and indie builders shipping agentic or distributed systems where multiple nodes or agents must agree without trusting every participant. It packages procedural knowledge for deploying threshold cryptography, zero-knowledge proof flows where applicable, and operational guardrails when tasks mention consensus or coordination. The skill is not a single API wrapper; it orchestrates security manager behavior through documented responsibilities—key management, encrypted channels, and real-time countermeasures when attack patterns appear. Builders in the Build phase can invoke it while designing protocol handlers, then rely on the same skill during Ship to enforce audits after sensitive operations. The embedded JavaScript threshold signature scaffolding signals intermediate-to-advanced expectations: you should already have a consensus or multi-agent architecture in mind. Use it when generic appsec checklists are insufficient and you need agent-guided threat modeling tied to Byzantine fault assumptions.639installs80Agent Sync Coordinatoragent-sync-coordinator is a ruflo coordination skill that treats multi-repository drift as a swarm problem. Indie maintainers juggling monorepo-adjacent packages invoke it when versions, lockfiles, or cross-package APIs must move together without manual PR churn. It leans on GitHub MCP for pushes and pull requests and claude-flow for agent spawn, orchestration, and memory-backed sync state. Pre-hooks analyze compatibility; post-hooks validate success and document metrics. The skill fits ship-phase launch prep for coordinated releases but also helps in build when integration branches need alignment. Expect elevated permissions—git writes, network, and orchestration tools—and a workflow mindset rather than a single-file edit. Pair with claims or review skills if agents need scoped write access across repos.639installs81Agent V3 Security Architectagent-v3-security-architect is a V3 architect-role agent skill (v3-security-architect 3.0.0-alpha) focused on end-to-end security overhaul rather than one-off lint fixes. Solo and indie builders invoke it when a codebase needs threat modeling plus an ordered remediation plan for named issues: weak dependency posture, password hashing, embedded secrets, command injection, and path traversal. Hooks frame the work as foundation-phase security with critical priority, echo concrete CVE/HIGH labels before execution, and optionally persist outcomes as reusable patterns afterward. It pairs naturally with npm audit and shell-based verification in a real repo, and expects you to treat scoring and pattern adoption as deliverables, not ad-hoc chat advice. Use it when security debt blocks shipping or when you are hardening an agentic-flow style project after audit findings.639installs82Agent Worker SpecialistAgent Worker Specialist is a Ruflo hive-mind skill that turns your coding agent into a disciplined executor: accept tasks, run them precisely, and continuously publish state into shared memory so coordinators can route work safely. The protocol is explicit—on task start you store swarm worker status with assignment text, ETA, and dependencies; on each meaningful step you update progress with percentage, completed steps, blockers, and touched files. That pattern suits solo builders running Claude Flow or similar MCP-backed swarms who otherwise lose visibility when multiple workers write code in parallel. The skill emphasizes constant coordination over silent heroics, which shrinks merge conflicts and duplicate effort in small teams that cannot afford a dedicated orchestration engineer. Use it alongside gossip or coordinator skills when you have both dissemination of intent and ground-truth execution reporting.639installs83Claimsclaims is a ruflo skill for claims-based authorization across Claude Flow agents. Solo builders who spawn sub-agents for coding, memory, or network tasks use it to enforce least privilege instead of handing every agent full shell and filesystem access. Commands cover checking, granting, and revoking claims with path and memory namespace scopes, plus bundled security levels from read-only minimal through admin. The skill aligns with ship-phase security reviews and stays relevant in operate when you audit live agents. It is intentionally skipped for trusted single-agent local sessions with no isolation requirements, matching the SKILL.md guidance. Integrate before sync-coordinator or memory specialists when those workflows need bounded write or spawn rights.639installs84Agent Coordinator Swarm InitAgent-coordinator-swarm-init helps solo builders and small teams boot a coordinated agent swarm instead of ad-hoc parallel chats that lose state. The skill wraps a coordination-type agent focused on topology selection, resource allocation, and communication setup, with mandatory reads and writes to shared memory via claude-flow CLI hooks before and after initialization. It fits when you are about to run multi-step agent workflows—reviews, refactors, or research splits—and need a named topology, agent count, and persistent coordination namespace. Prism catalogs it under Build agent-tooling because that is where you first wire multi-agent infrastructure, but the same init ritual can precede Ship reviews or Operate incident swarms once your repo already exists. Complexity is intermediate because it assumes comfort with npx, memory namespaces, and distributed coordination concepts rather than single-shot coding prompts.638installs85Agent Mesh CoordinatorAgent Mesh Coordinator is a Ruflo coordinator-type skill that boots a mesh-style multi-agent network for tasks requiring distributed decision making and resilience. On invoke, pre-hooks initialize a Claude Flow swarm in mesh mode, broadcast network init messages to all peers, seed consensus with a gossip protocol proposal, and persist network state to memory; post-hooks emit a JSON performance report, store final swarm metrics, and shut the network down cleanly. Solo builders experimenting with agent meshes use it when a single linear agent is insufficient and they want MCP-driven peer coordination, load balancing, and consensus building without hand-wiring every message path. It assumes Flow/MCP tooling is available and treats coordination as a first-class build-time concern for complex agent systems.638installs86Agent Sparc CoordinatorAgent SPARC Coordinator is a journey-wide agent skill that orchestrates the SPARC methodology—Specification, Pseudocode, Architecture, Refinement, and Completion—for systematic software delivery. Solo builders use it whenever a feature or product needs structured phase discipline instead of jumping straight into code. It coordinates requirements and user stories, algorithmic planning, system design, iterative refinement, and completion criteria while tracking progress and enforcing quality gates. The canonical shelf is validate/scope because specification work precedes implementation, but the same coordinator applies during build when restructuring a module and during ship when formalizing completion checks. Intermediate complexity: expect to invest time in artifacts per phase. Works best with agents that support memory or session hooks described in the skill package.638installs87Agent Swarm Issueagent-swarm-issue (swarm-issue) is a coordination skill for builders who already work in GitHub Issues and want those tickets to drive parallel agents instead of one monolithic chat thread. It pulls issue title and body via gh or MCP, initializes a swarm topology, spawns agents, orchestrates subtasks, and mirrors status into issue comments and follow-up tasks. Pre- and post-hooks document expected memory and reporting behavior so runs stay traceable for a single maintainer wearing PM and engineer hats. It assumes MCP GitHub and claude-flow are available and is best treated as workflow glue between your issue backlog and executable agent work.638installs88Agent User ToolsAgent-user-tools packages the Flow Nexus user-tools agent persona for solo builders who embed platform administration inside coding agents. Instead of bespoke admin scripts, the skill documents JavaScript-oriented MCP invocations for profiles, storage paths, content types, and subscription setup. It targets operators who need consistent UX for account configuration, file organization, and communication hooks while staying inside an agent session. The gray-coded flow-nexus-user-tools definition emphasizes facilitation with Queen Seraphina when tasks exceed routine utilities. Install it when your product sits on Flow Nexus and agents must perform storage uploads, profile patches, or health checks as part of build or operate workflows—not when you only need local CLI tooling without a hosted Nexus tenant.638installs89Agent V3 Queen CoordinatorAgent-v3-queen-coordinator is a v3 Queen orchestrator skill for ruflo-style agentic-flow stacks. Solo builders and small teams invoke it when they need a single critical coordinator agent to run pre- and post-execution hooks, validate GitHub and intelligence subsystem readiness, and align a large concurrent swarm against architecture decision records. The skill encodes metadata for orchestrator role, agent id, and phase-all coverage so agents treat coordination as a first-class ritual rather than ad-hoc prompting. It pairs shell-visible diagnostics with npx agentic-flow memory store patterns after runs. Use when delivery depends on cross-agent issue tracking, mesh topology, and measurable v3 performance targets—not when you only need a one-off script or a single coding assistant without swarm semantics.638installs90Flow Nexus PlatformFlow Nexus Platform is a comprehensive agent skill for managing the Flow Nexus cloud platform through structured MCP invocations. It documents authentication and user lifecycle, sandbox execution, app store style deployment, payments and credit management, coding challenges and achievements, storage with real-time features, and system utilities in one reference workflow. Solo builders shipping agent-backed apps use it to avoid scattering partial docs across repos when they need to register accounts, verify auth, spin sandboxes, deploy apps, or reason about credits and challenges in the same session. The skill is integration-heavy: success depends on calling the correct `mcp__flow-nexus__*` operations with valid credentials and treating platform state as part of your product's operational backbone rather than a one-off script.638installs91Agent App StoreAgent App Store is a Flow Nexus specialist skill that treats the application marketplace as an operable surface for solo builders shipping agent-native products. It wires MCP calls for searching published apps, publishing new services with semver and metadata, and deploying starter templates such as express-api-starter with controlled configuration. The agent’s remit spans curation, versioning, distribution, and light ecosystem governance—helpful when you are moving from a private repo to something others can install or fork. Primary shelf is Launch distribution, but the same workflows support Build when you deploy templates and Operate when you track analytics and compliance. Expect integration-style depth: you should already be on Flow Nexus and comfortable delegating marketplace actions to an agent rather than clicking through a UI alone.637installs92Agent Crdt SynchronizerAgent CRDT Synchronizer is an agent skill that implements Conflict-free Replicated Data Types for eventually consistent distributed state. Solo builders shipping multi-node agents, collaborative tools, or offline-first apps use it when replicas must converge without a single writer or manual conflict resolution. The skill covers state-based and operation-based CRDTs, delta sync, standard data structures, and causal ordering so merges stay deterministic. It fits the build phase when backend and agent-tooling integrations need shared mutable state across processes. Intermediate complexity: you should understand replication basics and your agent runtime’s hook model. Pair it with orchestration and persistence skills rather than treating it as a one-off script.637installs93Agent Github Pr ManagerAgent-github-pr-manager packages a development-type agent for indie builders who ship through GitHub and want PR work off their plate without dropping rigor. It uses the gh CLI for authentication checks, branch context, PR creation, review assignment, merge management, and CI/CD coordination, and can spawn additional review agents for heavier workflows. The skill fits the Ship phase when a feature branch is ready for eyes and merge, and remains useful during Build when you open stacked PRs for agent-generated changes. Solo developers benefit when they need consistent PR descriptions, linked issues, and tracked review state instead of manual gh commands scattered in chat. Treat it as a workflow skill that assumes a real git remote and GitHub hosting; it complements local testing and security skills rather than replacing them.637installs94Agent Hierarchical CoordinatorAgent Hierarchical Coordinator is a critical-priority coordinator skill in the Ruflo family that runs queen-led hierarchical swarms with specialized worker delegation. Indie builders shipping agentic products invoke it when a TASK requires orchestrating multiple sub-agents under one supervisor rather than flat parallel chat threads. Pre-hooks initialize hierarchical topology through Claude Flow MCP, persist initializing status to a coordination memory namespace, and attach swarm monitoring; post-hooks emit performance reports and record completion counts. Capabilities include swarm coordination, task decomposition, supervision, delegation, performance monitoring, and conflict resolution—aimed at builders who already use MCP-backed agent flows. It is not a substitute for product specs or security review; it assumes you want structured multi-agent execution with shared coordination state. Use when complexity crosses a single agent and you need delegated work with observable swarm status.637installs95Agent Performance BenchmarkerAgent Performance Benchmarker is an analyst-style agent skill from the Ruflo stack that implements comprehensive performance benchmarking for distributed consensus protocols. Solo and indie builders who run multi-agent or distributed coordination backends can invoke it when a task mentions benchmarking or when they need evidence-backed comparisons before choosing or tuning a protocol. The skill wires pre- and post-hooks to start metric collection, finish analysis, and compile a report with recommendations rather than leaving numbers scattered in chat. Core responsibilities span protocol benchmarking, resource monitoring, comparative analysis across Byzantine, Raft, and Gossip approaches, adaptive parameter tuning signals, and readable reporting. It fits builders shipping agent infrastructure or APIs where latency and throughput matter, not someone sketching a landing page. Pair it with monitoring and deploy skills after benchmarks inform production limits.637installs96Agent RefinementAgent-refinement is a SPARC methodology skill for the Refinement phase: your coding agent iteratively improves quality through test-driven development, refactoring, performance work, stronger error handling, and clearer docs. It is aimed at solo and indie builders who already have implementation in place and need a structured pass before merge or release, especially when using ruflo-style agent hooks and memory stores. Invoke it when tests are missing, flaky, or when you want optimization without skipping behavioral specs. The readme embeds concrete TDD patterns (red phase test blocks) and lifecycle hooks that run npm test on entry and exit. It pairs naturally with earlier SPARC design/implementation agents and sits between raw feature work and release coordination—not a substitute for security review or deployment automation.637installs97Agent Release ManagerAgent-release-manager automates release coordination and deployment for solo builders and small teams managing multiple packages. It wires Bash, file edits, todos, and GitHub operations into a ruv-swarm hook pipeline that initializes release work, validates changes against release rules, updates status when tasks finish, and sends stakeholder notifications. The skill expects MCP access to GitHub and claude-flow for swarm orchestration, making it suited to indie maintainers who want agent-driven version management instead of ad-hoc manual tagging. Use it when you are ready to ship after tests and review, need consistent documentation updates with each release, or run monorepo-style releases that benefit from orchestrated sub-agents. It is not a substitute for full CI/CD platform configuration but complements agent workflows that already use ruflo hooks.637installs98Hive MindHive-Mind is a ruflo/claude-flow agent skill for Byzantine fault-tolerant consensus and distributed coordination when multiple agents must make collective decisions without a single point of failure. Solo builders shipping agent-heavy products install it when tasks fan out across workers, you need leader-based consistency (Raft) or stricter tolerance in untrusted settings (Byzantine), or you want hybrid hierarchical-mesh topologies instead of ad-hoc prompt chaining. The SKILL.md catalogs topology and consensus tables, when to trigger versus skip, and concrete shell commands to initialize the hive and spawn a queen. It assumes you are past pure ideation—you are wiring runtime coordination—not replacing implementation planning, code review, or observability stacks. Pair it with your agent orchestration layer; expect shell and network access for CLI-driven setup rather than in-chat-only instructions.637installs99Skill BuilderSkill Builder is a ruflo meta skill that walks solo builders through creating discoverable Claude Code Skills: correct YAML frontmatter, progressive disclosure in SKILL.md, and a complete on-disk layout Claude can autoload across Claude.ai, Claude Code, SDK, and API. You reach for it whenever a repeated workflow deserves packaging—debug rituals, deploy checklists, domain generators—not when you only need a one-off answer. Prerequisites are Claude Code 2.0+ or Claude.ai with Skills support plus comfort with Markdown and YAML. The quick start shows mkdir, heredoc SKILL.md creation, and verification via restart or refresh. Because skills are procedural knowledge, investing here pays off in Validate scoping helpers, Build integrations, Ship review gates, and Operate runbooks without rewriting prompts. Treat descriptions as the discovery hook: concrete triggers beat vague titles. Wrong nesting paths are called out explicitly since they are the most common solo-builder footgun.637installs100Agent ChallengesAgent Challenges is a Flow Nexus specialist skill that turns your coding agent into a challenges curator and grader inside the ruflo ecosystem. Solo and indie builders use it when they want structured practice, peer-style competition, and measurable progress without leaving the agent session. The skill documents MCP calls for listing challenges, validating submissions, and wiring achievement and credit flows—aligned with invoke via $agent-challenges. It fits builders who already use Flow Nexus and want agents to present difficulty tiers, give feedback on solutions, and keep leaderboards honest. You get repeatable patterns for gamified learning rather than one-off puzzle prompts in chat.636installs101Agent Implementer Sparc CoderAgent Implementer SPARC Coder is an agent skill that embodies the SPARC “coder” specialist: it transforms specifications and designs into working, tested software. Solo and indie builders use it when an agent should implement features—not brainstorm or plan—while honoring test-driven development from red through green to refactor. Pre-execution hooks signal TDD readiness and whether test folders exist; post-hooks attempt npm test or pytest when the repo supports them. Capabilities span generation, tests, refactors, optimization, docs, and parallel execution. It pairs naturally with upstream SPARC planning or spec skills and downstream review or ship-phase verification. Best when you already have a clear spec or task list and want disciplined implementation rather than ad-hoc coding in chat.636installs102Agent V3 Performance EngineerAgent V3 Performance Engineer is a Ruflo V3 specialist skill focused on validation and delivery of aggressive performance goals: Flash Attention speedups, AgentDB search gains, memory cuts, fast cold start, and sub-millisecond learning adaptation. Solo builders shipping agentic or Node-based products invoke it when optimization is a first-class milestone—not an afterthought. Hooks announce targets, verify npm/node tooling, and on completion attempt to persist performance patterns through agentic-flow memory commands. It sits between Build (when you instrument hot paths) and Operate (when you re-benchmark production regressions). The readme emphasizes benchmarking suites and domain-specific multipliers rather than generic “make it faster” advice. Use when you already have a baseline and need structured optimization aligned to stated V3 KPIs.636installs103Agent Migration PlanAgent Migration Plan is a ruflo planning skill that helps solo builders convert a folder of Claude slash commands into a structured multi-agent system. It activates as migration-planner with hooks that echo progress and tally .md commands awaiting migration, then follows a comprehensive plan format: agent YAML (role, name, responsibilities, capabilities), mapping from each command, and rollout sequencing. Indie operators use it when command sprawl becomes hard to maintain and they want consistent agent definitions instead of ad-hoc markdown commands. The skill is planning-first—outputs are mapping strategy and agent specs ready for implementation—not automatic code execution. Pair it with implementation skills once the plan is approved.635installs104Agent Scout Exploreragent-scout-explorer defines a Scout Explorer persona for ruflo/claude-flow swarms: the agent that explores unknown areas, classifies what it finds, and pushes intelligence back into shared memory so other agents can act without re-walking the same ground. The skill encodes a reconnaissance protocol—signal exploration start with structured status payloads, then stream discoveries with category, location, importance, and scout identity timestamps. It expects coordination through MCP memory calls rather than silent local notes, aligning with multi-agent setups where explorers feed planners, implementers, and reviewers. Solo builders adopting swarm workflows use it when onboarding to an unfamiliar repo, auditing dependency surfaces, or hunting opportunities and threats before scope lock. It pairs naturally with downstream build and ship agents once discoveries are centralized in the coordination namespace.635installs105Worker BenchmarksWorker Benchmarks is an invocable agent skill for the agentic-flow worker stack. It runs repeatable performance suites so a solo builder can validate trigger detection, worker registry operations, performance-based agent selection, model cache behavior, and concurrent worker execution before trusting automation in production. Each benchmark type ships iteration counts and p95 targets in the skill doc, which makes results easy to cite in ship checklists or post-deploy reviews. Use it when you are tuning worker triggers, comparing registry changes, or chasing regressions after dependency upgrades. Output is structured metrics and optimization-oriented analysis rather than a single pass/fail gate, so you pair it with your own thresholds and fix loops in Build or Operate.635installs106Worker Integrationworker-integration teaches solo builders using agentic-flow how background workers pick specialized agents, fall back when primaries are busy, and expose performance stats. The skill centers on npx agentic-flow workers commands to inspect recommendations for triggers like ultralearn and optimize, read metrics, and review integration statistics. A mapping table ties each trigger to primary agents (researcher, coder, security-analyst, tester, documenter, performance-analyzer) and multi-step pipeline phases so dispatch is predictable instead of ad hoc. Capabilities include agent selection, performance tracking, memory coordination, and self-learning loops—useful when you run recurring audits, benchmark runs, or documentation indexing without hand-picking an agent every time. Install it when you are operationalizing ruflo workers, not when you only need a one-off chat task.635installs107Agent Quorum ManagerAgent Quorum Manager is a coordinator skill from the Ruflo stack for builders running multiple agents or nodes that must agree under changing network conditions. It encodes dynamic quorum adjustment: recalculating quorum thresholds from live topology health, managing membership churn, monitoring latency and partitions, applying weighted votes by node capability, and balancing availability versus consistency. Solo builders rarely need raw Raft wiring day one, but this skill pays off when you orchestrate agent swarms, edge replicas, or custom consensus layers and want the agent to reason about fault tolerance instead of hard-coding static majority rules. Invoke it during backend design and again in operate when partitions or scale events force quorum changes. It is advanced distributed-systems material—pair with your existing coordinator agents rather than treating it as a drop-in CRUD generator.634installs108Agent V3 Integration ArchitectAgent V3 Integration Architect is an agent skill for solo and small teams deep-integrating Ruflo’s claude-flow lineage with agentic-flow@alpha instead of maintaining parallel implementations. It encodes ADR-001: retire on the order of ten thousand duplicate lines by mapping overlapping subsystems—swarm coordination, agent lifecycle, task execution, and session management—to the alpha platform’s hooks and memory patterns. Pre-execution hooks sanity-check agentic-flow availability, echo overlap statistics, and count existing hook integrations; post-execution hooks persist integration patterns into agentic-flow memory. Use it in Build when you are refactoring agent orchestration code, and again when Operate iteration exposes drift between duplicate coordinators. The skill is explicitly architect-grade: it prioritizes extension boundaries and hook contracts over one-off feature patches, so your agent stack stays one spine with specialized extensions rather than two competing trees.634installs109Agent Benchmark SuiteAgent-benchmark-suite is an Ruflo agent skill that packages a ComprehensiveBenchmarkSuite for solo builders running multi-agent or swarm-style systems. It sits on the Ship testing shelf but applies wherever you need evidence—not vibes—that latency, throughput, and coordination still hold after changes. The embedded JavaScript-oriented framework enumerates core benchmarks plus swarm-specific cases (load balancing, topology, fault tolerance) and wires reporting, comparison, and analysis helpers for regression detection. Indie teams shipping agent orchestration can invoke it with $agent-benchmark-suite when they want agents to follow a consistent validation ritual instead of one-off timing scripts. It complements build-time agent tooling by turning performance validation into a repeatable suite, and it feeds Operate monitoring instincts when baselines drift. Expect intermediate-to-advanced familiarity with benchmarking concepts and your runtime’s measurement hooks.633installs110Agent Byzantine CoordinatorAgent Byzantine Coordinator is a specialized Ruflo coordinator skill that drives practical Byzantine fault-tolerant consensus when multiple agents or nodes might act maliciously. The SKILL.md frames it as a high-priority coordinator with pre-hooks that sanity-check network integrity before consensus work and post-hooks that validate signatures and message ordering. Core responsibilities span PBFT protocol management, pattern-based detection of Byzantine behavior, cryptographic authentication of consensus traffic, view-change handling when leaders fail, and mitigations for known attack shapes. Solo builders reach for it when designing agent meshes that must agree on state or tasks despite unreliable or adversarial participants—not for everyday single-agent coding. Implementation notes in the readme point at three-phase PBFT execution rather than naive majority voting. Expect advanced distributed-systems concepts; the skill assumes you are composing agents in a coordinated runtime, not polishing a marketing site.633installs111Agent Multi Repo SwarmAgent Multi-Repo Swarm wraps ruflo’s multi-repo-swarm coordination skill for organization-wide agent automation. It targets solo founders wearing a platform hat and small teams that must keep several GitHub repositories in sync—spawning agents, orchestrating tasks, and reading swarm status through Claude Flow MCP instead of babysitting each repo manually. Pre-flight bash hooks fail fast when GitHub CLI is not authenticated or repo access is missing, which matters before you delegate destructive git operations. The skill is advanced: you need comfort with gh, git porcelain, and MCP tool names like mcp__claude-flow__github_pr_manage. On Prism it sits under Operate infrastructure as the primary shelf, with secondary placement in Build integrations and Ship review because PR lists and cross-repo PR management bleed into those phases. It is a workflow integration, not a marketplace MCP listing by itself.633installs112Agent Pagerank AnalyzerAgent-pagerank-analyzer is an agent skill that turns your coding assistant into a graph-analysis specialist focused on PageRank, influence propagation, and network optimization using sublinear approaches. Solo builders and small teams use it when designing multi-agent communication layouts, ranking nodes in recommendation or trust graphs, or studying resilience and routing on distributed topologies—not for casual CRUD work. The README frames applications across social network analysis, web graph analysis, recommendation systems, and swarm coordination. It fits the Build phase as agent-tooling because you typically invoke it while modeling systems, prototyping ranking features, or tuning how agents share load. Complexity is intermediate to advanced: you should already have a graph-shaped problem (adjacency, edges, metrics) before asking for computations or topology advice.633installs113Agentdb Vector SearchAgentDB Vector Search teaches agents how to implement semantic retrieval with AgentDB’s vector database rather than bolting on a generic SQL or keyword layer. The skill walks through initialization with realistic embedding dimensions, preset sizing for vector counts, and CLI-driven query patterns so a solo builder can prototype RAG locally and scale toward production indexes. It assumes Node.js 18+, AgentDB v1.0.7 or newer, and an embedding provider such as OpenAI. You would reach for it when a side project needs “find the most relevant chunk” behavior, when you are comparing HNSW-backed stores for an agent memory service, or when documentation search must understand paraphrases instead of exact keywords. It is engineering-focused documentation packaged as procedural knowledge—not a hosted search product. After setup, you still own ingestion pipelines, access control, and refresh strategies for your corpus.632installs114Agent Queen CoordinatorAgent Queen Coordinator is a Claude Flow–oriented agent skill that puts a sovereign orchestrator at the top of a hierarchical hive: strategic command, resource allocation, and coherence across decentralized workers. Solo builders running multi-agent experiments invoke it when they need explicit dominance hierarchy, royal directives assignable to all subjects, and durable coordination state in MCP memory—not ad-hoc chat delegation. The skill mandates writing queen status and shared directives before swarm work proceeds, aligning with ruflo-style swarm topologies. It fits builders who already use claude-flow memory namespaces and want a named coordinator persona with critical priority rather than a single flat agent loop. Expect MCP network usage and structured JSON payloads; it is not a UI or design tool.631installs115Hooks AutomationHooks Automation is a journey-wide Claude Code skill that wires intelligent pre- and post-operation hooks into your daily agent workflow. Before work starts, hooks can validate inputs, prepare environments, and route tasks to swarm agents; after work finishes, they format code, capture metrics, and feed neural pattern training so repeat successes compound. Session management keeps context across long builds, while memory coordination syncs knowledge between agents. Git hooks add automated quality checks on commit without you manually policing every change. The skill expects Claude Flow CLI and an MCP-capable setup, making it best for indie builders who treat Claude Code as their primary IDE and want less manual orchestration. It is not a single-phase marketing or deploy tool—it is procedural glue usable whenever you run multi-step agent sessions from idea exploration through production fixes.631installs116Agent AuthenticationAgent Authentication is a Flow Nexus–focused agent skill that walks solo builders through registration, login, session validation, profile updates, and password recovery using documented MCP tool patterns. It targets indie developers shipping SaaS or agent products that delegate identity to Flow Nexus instead of rolling custom auth stacks. Use it when you are wiring onboarding, fixing login regressions, or extending account settings in Claude Code, Cursor, or similar agents. The skill reads like a specialist playbook: concrete JavaScript-style MCP invocations, state checks, and support-oriented troubleshooting. It matters because botched auth blocks launches and creates security debt; having procedural steps in-repo keeps agents from improvising insecure shortcuts. Review the Security Audits panel on this catalog page before trusting credentials handling in production.629installs117Agent Base Template GeneratorAgent Base Template Generator is a ruflo skill that produces starter artifacts when you know what you are building but do not want to negotiate folder structure, types, and boilerplate from scratch. Solo builders use it for new React components—with sensible TypeScript and styling hooks—or for REST endpoints that already include error handling, validation placeholders, and documentation-shaped comments. The agent is oriented toward repeatable base templates you extend, not finished features. It fits early Build work and Validate prototyping when you need a credible scaffold to test an idea quickly. Because outputs are meant to be edited, it pairs well with your linters and design system choices afterward. Invoke when the task is explicitly “give me a proper starting file or module,” whether frontend or backend.628installs118Reasoningbank IntelligenceReasoningBank Intelligence implements adaptive learning for AI agents so solo builders can move beyond one-shot prompts toward systems that remember what worked. The skill documents how to wire ReasoningBank with optional AgentDB persistence, record experiences with structured outcomes and metrics, learn recurring patterns, and recommend strategies for new tasks based on prior context. It fits when you are building self-learning agents, tuning workflows from historical runs, or exploring meta-cognitive loops—not when you only need a static prompt library. Prerequisites in the SKILL.md anchor the stack on agentic-flow and AgentDB with Node 18+. After adoption, agents can suggest approaches (for example a code_review strategy for high-complexity TypeScript) informed by stored experiences rather than guesswork each session.628installs119V3 Cli ModernizationV3 CLI Modernization is an agent skill for solo builders maintaining or extending claude-flow v3 who need a maintainable CLI instead of hundred-kilobyte monoliths. It walks through analyzing current CLI structure, then implementing modular commands, smarter interactive UX, and hooks that participate in the full command lifecycle, with optional workflow automation. The SKILL.md frames concrete pain: oversized index and enterprise modules, weak interactivity, and shallow hooks. You use it when you are actively modernizing the v3 CLI surface—not when you only need one-off shell commands on a server. Outcomes are a decomposed command architecture, clearer operator experience, and hooks-ready automation paths aligned with Task-based parallel work. Best paired with an existing claude-flow or agentic-flow repo and a willingness to split large TypeScript CLI entrypoints into testable units.628installs120V3 Core ImplementationV3 Core Implementation is an agent skill for builders extending or forking claude-flow v3—the modular TypeScript agent orchestration stack. It walks through setting up a domain-driven directory layout under src/core, implementing bounded contexts such as task and session management, and wiring the microkernel with plugin loading and a domain registry. Solo developers shipping custom agent runtimes or internal devtools use it when they have moved past prototype and need production-shaped code: explicit entities, repositories, services, and event boundaries instead of a single god module. The skill assumes familiarity with TypeScript project structure and pairs naturally with agent-tooling work in Claude Code or similar environments. Quick-start bash snippets delegate work to a core-implementer agent persona, making it a workflow blueprint rather than a one-shot snippet generator. It is advanced relative to app CRUD skills because it encodes architectural decisions that affect every later feature.628installs121Agentdb Memory PatternsAgentDB Memory Patterns is the foundation skill for giving AI agents durable memory using AgentDB’s vector store and optional ReasoningBank hooks. It suits solo builders shipping chat products, coding assistants, or multi-step agents that must remember users, prior tool results, and learned interaction patterns across sessions. You initialize a database via CLI (including presets and in-memory mode for tests), expose MCP to Claude Code, and can scaffold plugins through the create-plugin flow. The skill emphasizes session versus long-term tiers, context management, and pattern learning rather than a single dump-all transcript approach. Node.js 18+ and AgentDB 1.0.7+ are required; understanding basic agent architectures helps. Use ReasoningBank with AgentDB when you need verdict-driven adaptive learning on top of these baseline patterns.627installs122Reasoningbank With AgentdbReasoningBank with AgentDB teaches you to implement adaptive agent learning on AgentDB’s vector backend instead of ad-hoc JSON memory. It targets builders shipping self-learning agents, decision optimizers, or experience-replay style workflows who need fast retrieval and a path off older ReasoningBank stores. The skill walks through initializing a dimensioned database, optional MCP exposure to Claude Code, migration with validation, and API usage for trajectories and judgments. Prerequisites include Node.js 18+, AgentDB 1.0.7+, and comfort with agent loops; RL theory is optional. Performance figures in the doc (150x–12,500x vs traditional setups) are marketing anchors you should validate in your workload. Pair it with broader AgentDB memory patterns when you need session chat memory plus learning-specific verdict and distillation pipelines.627installs123V3 Ddd ArchitectureV3 DDD Architecture is an agent skill for solo builders and small teams evolving claude-flow v3 from monolithic orchestration into Domain-Driven Design. It walks through analyzing the current god-object orchestrator, carving bounded contexts for tasks, sessions, health, lifecycle, and events, then defining clean interfaces and context maps. Quick-start flows spawn parallel architect tasks for analysis, decomposition, mapping, and interface design—useful when your agent runtime is growing past a single file and tests are brittle. The skill is methodology-heavy rather than a one-shot code generator: you still implement moves under core$domains/ with explicit separation of concerns. Reach for it during backend refactors of multi-agent systems, before adding major features, or when onboarding contributors who need a readable module map instead of a 1,400-line coordinator.627installs124Agentdb Advanced FeaturesAgentDB Advanced Features is an agent skill for solo and indie builders who ship multi-agent or retrieval-heavy products and need more than a single local vector store. It documents QUIC-based synchronization between AgentDB nodes, hybrid search that blends embeddings with structured filters, configurable distance metrics, and patterns for managing several databases as one logical system. The material assumes you already run AgentDB through agentic-flow and targets Node 18+ environments where agents must share memory and search results across processes or machines without drowning in bespoke networking code. Use it when you are designing distributed coordination, tightening RAG pipelines with filtered vector queries, or hardening a prototype into something that behaves like production infrastructure. It complements basic AgentDB setup skills by focusing on performance-oriented sync and search rather than CRUD basics.626installs125Agentdb Performance OptimizationAgentDB Performance Optimization is an agent skill from the Ruflo/agentic-flow ecosystem that teaches how to squeeze latency and RAM out of AgentDB vector databases. Solo builders shipping memory-augmented agents hit walls when pattern search climbs to tens of milliseconds or inserts stall at scale; the skill documents quantization (including binary for aggressive footprint cuts), HNSW indexing, caching, and batch operations with concrete TypeScript adapter setup. Prerequisites assume Node.js 18+ and AgentDB v1.0.7+ via agentic-flow. You can run the published benchmark CLI to compare pattern search, batch insert, and large-query scenarios against the skill’s reference numbers without trusting hand-wavy claims blindly—then apply the recommended configuration to your .db path. It fits Build when you first wire retrieval, and Operate when production traffic exposes hot paths. Not a replacement for data modeling: you still need sane chunking and metadata filters.625installs126V3 Deep IntegrationV3 Deep Integration is an agent skill for builders shipping multi-agent flows who are stuck maintaining claude-flow beside agentic-flow@alpha. It walks you through treating claude-flow as a specialized extension, designing an adapter layer, and folding overlapping swarm, agent lifecycle, task execution, and session modules into one codebase. The SKILL.md frames parallel Task invocations for architecture, SONA modes, Flash Attention speedups, and AgentDB coordination so performance and feature parity come from integration rather than copy-paste. Solo and indie devs use it when duplicate lines exceed roughly ten thousand and they need a concrete deduplication map before agents go to production. It is advanced systems work: you should already run agentic-flow@alpha and understand swarm topology. Outcomes are a smaller surface area, shared primitives with the host framework, and integration tasks you can assign to an architect agent instead of hand-merging two trees.625installs127V3 Mcp OptimizationV3 MCP Optimization is an advanced agent skill for tuning claude-flow v3 Model Context Protocol servers when latency and scale hurt daily agent workflows. It walks solo builders and small teams through analyzing cold-start cost, per-request connection overhead, linear tool-registry lookups, and idle connection memory, then applying connection pooling, dynamic load balancing, transport reuse, and monitoring to approach documented targets such as sub-100ms tool paths and faster initialization. The quick-start pattern fans out parallel specialist tasks so diagnosis and implementation can proceed concurrently. Use it while hardening agent stacks you already ship, not as a first-day MCP tutorial. Expect shell-oriented changes in the ruflo/claude-flow codebase and coordination with your existing MCP tool surface.625installs128V3 Memory UnificationV3 Memory Unification is a specialist-oriented skill for Ruflo-style agent stacks that have outgrown parallel memory implementations. It walks solo builders and small teams through consolidating MemoryManager, distributed and swarm-specific stores, advanced managers, SQLite, Markdown, and hybrid layers into AgentDB with HNSW indexing. The documented performance envelope—150x to 12,500x faster search—frames why unification matters when agents retrieve context at scale. Implementation is framed around architecture design, AgentDB configuration, and migrating legacy data without breaking existing callers. This is not a drop-in chat memory tweak; it assumes you are actively building or refactoring an agent platform backend and can delegate tasks to a v3-memory-specialist persona. Expect ADR-driven decisions and migration planning as first-class deliverables.625installs129V3 Swarm CoordinationV3 Swarm Coordination is an agent skill for solo builders and small teams shipping a major claude-flow v3 rewrite without losing thread on security, memory, and integration work. It documents how to stand up a 15-agent hierarchical mesh: a queen coordinator fans out Task() calls to specialists such as security architect, CVE auditor, memory specialist, integration architect, and performance engineer. The playbook emphasizes critical-path security in phase one, then parallel core execution so AgentDB memory unification and agentic-flow integration can proceed while dependencies stay explicit. You use it when a single chat session cannot safely cover CVE remediation, TDD security frameworks, and 2.49x–7.47x performance targets at once. It turns an overwhelming multi-month program into repeatable agent assignments that match ADR constraints and timeline checkpoints, so your coding agent executes in parallel instead of serial guesswork.625installs130Agentdb Learning PluginsAgentDB Learning Plugins is an agent skill for builders who want agents that learn from outcomes instead of static prompts alone. It documents how to use AgentDB’s plugin system across nine reinforcement learning algorithms—from Decision Transformer and Q-Learning through SARSA and Actor-Critic—so you can scaffold, train, and deploy learning plugins inside agentic-flow stacks. Quick start centers on the AgentDB CLI: interactive create-plugin, template picks like decision-transformer or q-learning, dry-run previews, and list-templates for discovery. The skill assumes Node.js 18+ and AgentDB v1.0.7+ and notes WASM-accelerated inference for materially faster training iterations. Use it when implementing RL, optimizing agent policies from logged experience, or packaging repeatable learning modules for autonomous workflows your solo project can actually ship and iterate.624installs131Verification & Quality AssuranceVerification & Quality Assurance is an agent skill for teams using the Ruflo ecosystem who want verification spelled out as operable CI behavior, not vague “check your work” prompts. It centers on regression guards, witness manifests, and discoverability audits that actually run on push, alongside a broader quality model: truth scoring, automated security and best-practices checks, statistical trend tracking, and optional automatic rollback when scores fall below a high bar (0.95 by default). Solo builders shipping agent-heavy SaaS or APIs benefit when one missed tool call or silent regression would erode trust. Use it while hardening Ship workflows and when you need a repeatable verify command (`ruflo verify`) before promoting builds. Treat aspirational dashboard and live WebSocket monitoring as roadmap unless your install matches the shipped paths called out in the skill doc.624installs132V3 Performance OptimizationV3 Performance Optimization is an agent skill for solo builders running claude-flow v3 who need measurable proof that attention, vector search, and memory optimizations actually land. It structures work as parallel performance-engineer tasks: establish v2 baselines, then validate Flash Attention speedups, HNSW search gains, and memory footprint reductions against explicit matrices in the skill. The quick-start commands show how to fan out validation without guessing whether a change regressed throughput. Use it after you integrate v3 components but before you treat agent orchestration as production-ready. It matters because agent frameworks advertise dramatic multiples; without a shared benchmark ritual you cannot tell marketing claims from your laptop’s reality or catch regressions when you add tools and context.623installs133V3 Security OverhaulV3 Security Overhaul is an agent skill for solo builders and small teams hardening claude-flow v3 with an orchestrated security architecture pass. It coordinates specialized v3 agents to design threat boundaries, remediate documented critical CVEs, and embed secure-by-default patterns in TypeScript services. Quick-start task prompts cover dependency updates with npm audit, password hashing migration to bcrypt, and secure credential generation. The skill extends into Zod input validation and a London School security testing mindset so fixes are behavior-specified rather than bolted on. It assumes you are actively implementing or refactoring v3, not doing a one-line lint fix. Use it when shipping agent orchestration infrastructure where weak crypto or leaked defaults would be catastrophic. Pair with broader review skills after structural changes land.622installs134Swarm OrchestrationSwarm Orchestration is an agent skill that helps solo builders tackle work too large for a single chat thread by standing up a hierarchical multi-agent swarm through the Claude Flow CLI. It is meant when three or more files move together—new features spanning modules, API surface changes that need matching tests, security-sensitive edits, performance passes, or schema work—not for one-line fixes or configuration tweaks. The skill encodes default anti-drift settings: initialize with a hierarchical topology, cap concurrent agents, and prefer specialization so agents do not collide on the same concerns. Companion scripts start the swarm and watch status on an interval so you can see coordination health while execution proceeds. Treat it as orchestration glue on top of your repo and test harness; you still own review, merge discipline, and production rollout. Skip it when exploration is cheap or the change is narrowly scoped.525installs135Iot FirmwareIot-firmware is an agent skill that orchestrates firmware rollouts across device fleets using the Cognitum IoT plugin exposed through npx. Solo builders and small teams operating connected hardware can start a versioned deploy to a fleet ID, advance a rollout after canary health checks, roll back a bad release, or inspect rollout status and history without writing bespoke deployment glue each time. The workflow encodes staged promotion—pending, canary, rolling, complete, or rolled-back—so advancement stays gated on anomalies rather than blind percentage ramps. Allowed tools include Bash for npx invocations and Claude Flow memory helpers, which suits agent-driven ops sessions. Use it when firmware OTA is part of your production stack and you want repeatable, auditable commands from Claude Code or similar agents.1installs