DOCSEARCHbyAlgolia
Submit Docs

Agentic-Flow

repository·main·Indexed 20 days ago

https://github.com/ruvnet/agentic-flow

A production-ready AI agent orchestration framework (v2.0.2-alpha) featuring 66 self-learning agents and 213 MCP tools. It supports autonomous multi-agent swarms, SONA for adaptive learning, AgentDB for optimized memory, and SPARC workflows (Specification, Architecture, Reasoning, Code, and Refinement). The platform includes a FastMCP implementation with stdio and HTTP+SSE transports, a Federation Hub for multi-agent memory synchronization, and a CLI for agent execution using cloud providers or local ONNX models.

Tokens
911.5K
Snippets
2.7K
Records
3.6K
Agent score
66%

What's inside agentic-flow

  1. Overview of Agentic-Flow v2.0

    main
    Agentic-Flow v2.0 is a next-generation AI agent orchestration platform designed for high-performance, distributed, and self-learning agent workflows. It integrates AgentDB v2 for high-speed vector-graph hybrid storage, uses the QUIC protocol for low-latency distributed synchronization, and features 'Agent Booster' for ultra-fast local code editing. The system is built with a 'distributed-first' architecture, incorporating Byzantine fault tolerance and SIMD optimization for neural inference.

  2. Overview of Nova Medicina

    main

    Nova Medicina is an AI-powered medical triage assistant designed with anti-hallucination verification and healthcare provider integration.

    Note on Stability: As of the latest review, the project is considered ALPHA QUALITY and is NOT PRODUCTION READY. It features strong documentation and architectural design but has critical implementation gaps in source code and dependency management.

  3. Overview of Agentic-Flow Core Features

    main

    Agentic-Flow provides several specialized modules designed for high-performance agentic workflows:

    • AgentDB: A high-performance vector database featuring HNSW indexing, WASM acceleration, and 9 reinforcement learning algorithms, offering up to 150x faster search.
    • ReasoningBank: A self-learning AI system that utilizes pattern learning, experience replay, and meta-learning, integrated with AgentDB for continuous improvement.
    • QUIC Transport: A communication layer based on WebTransport that provides sub-millisecond latency, multiplexing, 0-RTT resumption, and built-in encryption.
    • Federation: A system for distributed agent coordination across multiple nodes, supporting ephemeral agents, fault tolerance, and auto peer discovery.
    • Agent Booster: A WASM-powered tool for ultra-fast code editing (up to 352x faster than cloud APIs) at $0 cost.
    • Multi-Model Router: An intelligent selection layer that optimizes for cost, quality, and privacy by automatically selecting models based on task requirements.

  4. Overview of Agent Booster NPM Ecosystem

    main
    The Agent Booster NPM ecosystem provides tools for prompt optimization and analysis, consisting of a main SDK for programmatic integration and a CLI for command-line operations. The system is designed with automatic runtime detection, prioritizing native performance and falling back to WASM when necessary. It is built for cross-platform compatibility and supports batch processing of prompts.

  5. Overview of the Agentic-Jujutsu Benchmark & Analysis Plan

    main

    The agentic-jujutsu benchmarking plan is designed to compare the performance and quality of jujutsu against traditional Git and Git worktrees. The implementation follows the SPARC methodology to achieve deep performance comparisons, code quality/security analysis, and self-learning pattern recognition using AgentDB integration.

    Key components of the benchmark include:

    • Performance Metrics: Execution time, memory usage, disk I/O, and CPU utilization.
    • Scalability Testing: Testing across varying repository sizes (1MB to 10GB), file counts (10 to 100k), and history depths (10 to 10k commits).
    • Analysis Framework: Evaluating cyclomatic complexity, maintainability, security (SAST/DAST), and speed optimization via hot path identification.
    • Reproducibility: Using Docker-based isolated environments for automated orchestration.

  6. Overview of Agent Booster

    main

    Agent Booster is an ultra-fast code application engine designed to be significantly faster and more cost-effective than traditional LLM-based methods (like Morph LLM). It achieves up to 200x faster latency and 100% cost savings by using local inference instead of API calls.

    Key Capabilities

    • Vector-Based Semantic Merging: Applies code changes without requiring an LLM.
    • Hybrid Fallback Strategy: Combines the speed of Agent Booster with LLM fallbacks to balance accuracy and performance.
    • Universal Deployment: Supports Native (Node.js), WASM (Browser), and MCP server (Claude/Cursor/VS Code) implementations.
    • Zero Runtime Cost: Operates 100% locally after the initial model download.
    • Deterministic Results: Ensures consistent output for the same input.

  7. Overview of Agentic-Flow v2 MCP Tools, CLI & SDK Improvements

    main

    Agentic-Flow v2.0 introduces significant enhancements to the Model Context Protocol (MCP) tools, the Command Line Interface (CLI), and the Software Development Kits (SDKs).

    Key Capabilities:

    • Enhanced MCP Tools: Features AgentDB-optimized memory operations (providing up to 150x performance), smart routing via semantic matching, neural pattern training, and built-in health monitoring.
    • Improved CLI: Includes interactive REPL modes, benchmarking suites, and 'Doctor' commands for system diagnostics.
    • Comprehensive SDKs: Provides full API coverage through TypeScript and Python SDKs, as well as a REST API client.
    • Diagnostics & Benchmarking: Supports health checks, performance profiling, auto-remediation, and regression detection through a dedicated benchmarking suite.

  8. Overview of SONA and AgentDB Training

    main

    The training documentation for Agentic-Flow covers the development and optimization of SONA (Self-Organizing Neural Architecture) and AgentDB. It provides guidance on implementing reasoning patterns, neural network training, and reinforcement learning within the ecosystem.

    Key technical topics include:

    • ReasoningBank pattern learning: Training agents to utilize structured reasoning patterns.
    • Reinforcement Learning: Support for 9 algorithms including Q-Learning, SARSA, Actor-Critic, and Decision Transformer implementations.
    • Memory-persistent AI systems: Architectures for long-term state and knowledge retention.
    • Self-aware feedback loops (SAFLA): Implementing feedback mechanisms for autonomous system improvement.

  9. Overview of QUIC Protocol Optimization for Agentic-Flow v3.0.0

    main

    Agentic-Flow v3.0.0 is integrating the QUIC (Quick UDP Internet Connections) protocol to optimize distributed AI agent orchestration. QUIC provides several key advantages over traditional TCP/HTTP/2 for multi-agent communication:

    • 0-RTT connection establishment: Reduces agent spawn latency by 50-70%.
    • Stream-level multiplexing: Eliminates head-of-line blocking, allowing concurrent agent operations to run independently.
    • Connection migration: Enables seamless agent handoffs during network changes.
    • Built-in encryption: Uses integrated TLS 1.3 for mandatory security with reduced overhead.
    • Adaptive congestion control: Supports pluggable algorithms like BBR, Cubic, and Reno to optimize throughput in various network conditions.

    Performance Expectations:

    • Latency: 2.8-4.4x improvement in multi-agent communication latency.
    • Recommended Implementation: Use the quinn (pure Rust) library for safety and WASM compatibility.

  10. Overview of RuVector Ecosystem Integration for Agentic-Flow

    main

    The RuVector ecosystem integration is designed to transform agentic-flow from a prototype into an enterprise-grade, self-learning AI orchestration system. This integration focuses on high-performance agent routing, multi-step reasoning, and real-time pattern detection.

    Key performance improvements expected from this integration include:

    • Agent routing latency: Reduced from 500ms to <10ms.
    • Routing accuracy: Increased from 70% to 90%.
    • System uptime: Increased from 95% to 99.9%.
    • Task planning quality: Significant improvement via multi-step reasoning.
    • Pattern detection: Real-time detection using Neuromorphic AI.

  11. Overview of Jujutsu Benchmark Suite objectives

    main

    The Jujutsu Benchmark Suite is designed to provide a deep performance comparison between Jujutsu and Git version control systems.

    Core Focus Areas:

    • VCS Operations: Performance of commit, branch, merge, and rebase.
    • Worktree Operations: Comparing Git worktrees against Jujutsu working copies.
    • Scalability: Testing repository performance from 1MB up to 10GB.
    • Self-Learning: Integrating with the AgentDB pattern recognition system.

    Benchmark Categories:

    1. VCS
    2. Worktree
    3. Scalability

  12. Overview of QUIC Phase 1 implementation

    main

    The QUIC Phase 1 implementation provides a high-performance transport layer for agentic-flow using a Rust-based QUIC protocol foundation. It includes TypeScript wrappers and WASM bindings for cross-platform compatibility.

    Core Components

    • QuicClient: Features connection pooling and automatic reuse for 4x memory efficiency.
    • QuicServer: Supports stream multiplexing and concurrent handling (100+ concurrent streams).
    • WASM Bindings: Enables cross-platform usage.
    • TypeScript Wrapper: Provides a type-safe API for web/Node.js environments.

    Performance Benefits

    Compared to TCP/HTTP/2, the QUIC implementation offers:

    • Connection Latency: 10-20ms (vs 100-150ms)
    • Agent Spawning: ~220ms for 10 agents (vs 3,700ms)
    • Throughput: ~8.9K msg/s (vs 3.4K msg/s)
    • Memory Usage: 1.6MB (vs 3.2MB)