ruflo

Coordinates multiple specialized Claude agents (architect, coder, reviewer, tester, security-architect) working in parallel or sequentially through a centralized orchestration layer. Uses YAML-based agent configuration with role-specific prompts and capabilities, routing tasks via hooks system and hive-mind coordination. Agents share context through AgentDB v3 memory controllers, enabling distributed decision-making with unified state management across the swarm.

Exposes Ruflo's orchestration capabilities as a Model Context Protocol server with 10+ tool categories (agent-tools, memory-tools, neural-tools, hooks-tools, task-tools, terminal-tools, etc.) that Claude can invoke directly. Implements schema-based function calling with native bindings to Anthropic's Claude Code API, enabling Claude to spawn agents, manage memory, execute tasks, and monitor swarms without leaving the conversation context.

Provides environment management capabilities for deploying Ruflo across different environments (development, staging, production) with environment-specific configurations. Includes RVFA (Ruflo Virtual Field Appliance) for containerized deployment with pre-configured settings, dependencies, and integrations. Supports environment variables, secrets management, and configuration inheritance. Enables one-command deployment of complete Ruflo stacks with all dependencies (MCP server, daemon, memory backend, embeddings service).

Provides RuVocal Chat UI as a conversational interface for interacting with Ruflo agents and orchestration capabilities. Enables users to describe tasks in natural language and have the system automatically decompose them into agent workflows, select appropriate agents, and execute tasks. Chat interface maintains conversation history, displays agent execution progress, and allows users to interrupt or modify running workflows. Integrates with MCP server to expose all Ruflo capabilities as conversational commands.

Implements infinite context capability through ADR-051 (Architecture Decision Record) that enables agents to work with arbitrarily large codebases and context without hitting Claude's context window limits. Uses a combination of semantic chunking, progressive context loading, and intelligent context selection to maintain only relevant context in the active window. Agents can reference external context through memory and RAG without loading everything into the model's context.

Implements a guidance control plane that enforces organizational policies and governance rules across all agent executions. Policies can specify constraints (e.g., 'agents cannot delete production databases'), approval workflows (e.g., 'security changes require human review'), and audit requirements. Control plane intercepts agent execution at hooks and validates against active policies before allowing execution. Supports policy versioning, rollback, and audit trails for compliance.

Implements a multi-backend memory system using AgentDB v3 controllers that persist agent context, conversation history, and learned patterns across sessions. Supports pluggable backends (file-based, database, vector stores) with context persistence layer that automatically serializes/deserializes agent state. Integrates RuVector for semantic embeddings and SONA pattern learning to enable agents to recall relevant past interactions and adapt behavior based on historical success patterns.

Implements a hook system that intercepts agent execution at defined lifecycle points (pre-execution, post-execution, error handling, context updates) and routes tasks to appropriate agents based on configurable rules and learned patterns. Hooks can trigger neural analysis, update memory, modify task parameters, or redirect to different agents. The routing engine uses intelligence signals from past executions to optimize agent selection, reducing unnecessary context transfers and improving task completion rates.

Implements SONA (Self-Organizing Neural Architecture) for analyzing agent execution patterns, identifying successful strategies, and recommending optimizations. Processes execution logs through neural analysis to extract patterns (e.g., 'code-review followed by security-architect yields 95% defect catch rate'), stores patterns in memory, and uses them to inform future routing decisions and agent prompting. Integrates with RuVector for semantic pattern matching across different task types.

Integrates Retrieval-Augmented Generation (RAG) capabilities using RuVector embeddings to augment agent context with semantically relevant information from knowledge bases, documentation, and past executions. When agents execute tasks, the system automatically retrieves relevant context based on semantic similarity, reducing hallucination and improving task accuracy. Supports multiple knowledge sources (codebase, documentation, memory) with configurable retrieval strategies and ranking.

Provides a comprehensive TypeScript-based CLI (v3/@claude-flow/cli) with commands for initializing projects, configuring agents, managing memory, running neural analysis, and controlling daemon services. Supports YAML-based agent configuration (agents/architect.yaml, agents/coder.yaml, etc.) with role-specific prompts, capabilities, and constraints. CLI commands include agent lifecycle management (create, update, delete), memory operations (store, retrieve, search), and advanced features (neural analysis, security scanning, performance optimization).

Implements a background worker daemon (worker-daemon.ts) that runs long-lived background tasks (memory synchronization, neural analysis, pattern learning, metrics collection) without blocking the main CLI or MCP server. Uses a worker pool pattern to parallelize tasks and collect real-time metrics (execution time, success rate, memory usage) via statusline and performance monitoring. Daemon can be managed via CLI commands (start, stop, status) and integrates with system monitoring tools.

Provides a plugin system architecture that enables extending agent capabilities through custom plugins without modifying core agent code. Plugins can register new tools, hooks, memory backends, and neural analysis strategies. Includes official plugins (Claude Code Plugin) that integrate with external systems. Plugin system uses a registry pattern with dependency management and lifecycle hooks (install, enable, disable, unload). Plugins are loaded dynamically at runtime and can be managed via CLI commands.

Implements security scanning (security-tools CLI command) and input validation across all agent inputs and outputs using ContinueGate safety framework. Validates agent prompts, task parameters, and execution results against security policies before processing. Includes built-in checks for prompt injection, code injection, and policy violations. Security scanning can be run on-demand or integrated into agent execution hooks. Supports custom security policies via configuration.