ruflo

Coordinates specialized AI agents (architect, coder, reviewer, tester, security-architect) working in parallel or sequential patterns through a centralized orchestration layer. Uses YAML-based agent configuration with role-specific prompts, hook-based routing logic, and a Hive Mind coordination system that manages task distribution, dependency resolution, and inter-agent communication. Agents can operate in autonomous mode (self-directed execution) or collaborative mode (Claude Code integration for human-in-the-loop oversight).

Exposes Ruflo's agent orchestration, memory, and task execution capabilities as Model Context Protocol (MCP) tools that Claude and other MCP-compatible clients can invoke. Implements a schema-based function registry (agent-tools, memory-tools, task-tools, hooks-tools, neural-tools, performance-tools, system-tools, terminal-tools, daa-tools, hive-mind-tools) with native bindings for OpenAI and Anthropic function-calling APIs. The MCP server runs as a persistent daemon and handles tool invocation, parameter validation, and result serialization.

Provides a control plane for managing agent behavior alignment and governance policies. Allows operators to define constraints on agent actions (e.g., 'agents cannot delete production databases', 'code changes require review'), which are enforced at runtime. The guidance system uses a declarative policy language to specify allowed/disallowed actions. Policies can be scoped to specific agents, tasks, or users. Violations are logged and can trigger alerts or block execution. The control plane integrates with the hook system to enforce policies at decision points.

Implements infinite context support through ADR-051 (Architecture Decision Record 051) which uses a hierarchical context compression strategy. Long conversations are automatically summarized and compressed into context summaries that preserve key decisions and information. Summaries are stored in memory and retrieved when relevant, allowing agents to maintain context across arbitrarily long conversations. The system uses semantic similarity to determine which summaries to retrieve, avoiding context window overflow. Compression is configurable and can be tuned for different use cases.

Provides a containerized deployment appliance (RVFA) that packages Ruflo with all dependencies (Node.js, databases, embeddings service) into a single deployable unit. The appliance includes pre-configured settings, security hardening, and monitoring. Supports deployment to cloud platforms (AWS, GCP, Azure) and on-premises infrastructure. Includes automated scaling based on agent load and health monitoring with automatic recovery.

Provides a web-based chat interface (RuVocal) for interacting with Ruflo agents through natural language. Users can chat with individual agents or the swarm, and the UI displays agent reasoning, decisions, and execution progress. The interface supports file uploads for code/documentation context, displays generated artifacts (code, reports), and provides controls for agent behavior (pause, resume, adjust parameters). Real-time updates show agent activity and task progress.

Maintains agent state, conversation history, learned patterns, and task context across sessions using AgentDB v3 controllers with pluggable backends (SQLite, PostgreSQL, Redis, custom). Implements context persistence through a memory bridge that automatically serializes/deserializes agent state, embeddings, and decision history. RuVector integration enables semantic memory queries (find similar past decisions, retrieve relevant context). SONA pattern learning system identifies recurring decision patterns and optimizes future agent behavior based on historical outcomes.

Routes tasks to appropriate agents using a declarative hook system that evaluates task characteristics against agent capabilities. Hooks are lifecycle events (pre-task, post-task, on-error, on-completion) with conditional logic that determines which agent should handle a task. The routing engine uses task metadata (type, complexity, domain), current agent load, and learned performance history to make routing decisions. Hooks can be chained to create complex workflows (e.g., architect → coder → reviewer → tester).

Integrates Ruflo agents with Claude Code (Anthropic's code execution environment) to enable agents to write, test, and execute code directly. Provides a skill library of pre-built code patterns and utilities that agents can reference. Agents can use Claude Code to prototype solutions, run tests, and validate architectural decisions before committing to production. The integration includes bidirectional communication: Claude Code can invoke Ruflo agents for specialized tasks, and Ruflo agents can trigger Claude Code execution for code generation/testing.

Augments agent context with relevant information from knowledge bases using semantic search powered by RuVector embeddings. When agents encounter tasks, the RAG system automatically retrieves similar past decisions, relevant documentation, and related code patterns. Embeddings are computed for all stored context (agent memories, code snippets, decision records) and indexed for fast semantic retrieval. The system supports multiple embedding backends and can be configured for different retrieval strategies (top-k, similarity threshold, diversity sampling).

Continuously monitors agent performance, system health, and task execution metrics through background worker processes. Collects metrics including agent response times, task success rates, memory usage, embedding latency, and hook execution times. Exposes metrics through a statusline interface (shell-based dashboard) and programmatic APIs. Background workers run as daemon processes and aggregate metrics at configurable intervals. Performance data is stored in AgentDB and can be queried for trend analysis and optimization.

Manages long-running background services (worker daemons, MCP server, embeddings service, memory backend) as coordinated processes. Provides lifecycle management (start, stop, restart, status) for all background services through CLI commands and programmatic APIs. Daemon processes are monitored for health and automatically restarted on failure. The system maintains a single source of truth for daemon state and coordinates startup/shutdown sequences to ensure dependencies are satisfied.

Provides a plugin system that allows developers to extend agent capabilities with custom tools, skills, and integrations. Plugins are TypeScript modules that register new tools with the MCP server, add skills to the skill library, or extend agent behavior through hooks. The plugin system includes a plugin registry, lifecycle hooks (on-load, on-unload), and dependency management. Official plugins include Claude Code integration, HuggingFace model access, and specialized domain tools.

Implements security scanning for agent-generated code and user inputs through a configurable validation pipeline. ContinueGate is a safety gate that inspects code before execution, checking for common vulnerabilities (SQL injection, command injection, unsafe file operations). Input validation applies schema-based validation to all MCP tool invocations and agent parameters. Security scanning includes dependency vulnerability checks and code pattern analysis. Results are logged for audit trails and can trigger alerts or block execution based on severity.