ruvltra

<div align="center">

RuvLTRA

The First Purpose-Built Model for Claude Code Agent Orchestration

100% Routing Accuracy | Sub-Millisecond Inference | Self-Learning

Quick Start | Features | Models | Benchmarks | Integration

</div>

---

What is RuvLTRA?

RuvLTRA (Ruvector Ultra) is a specialized model family designed specifically for Claude Code and AI agent orchestration. Unlike general-purpose LLMs, RuvLTRA is optimized for one thing: intelligently routing tasks to the right agent with perfect accuracy.

The Problem It Solves

When you have 60+ specialized agents (coders, testers, reviewers, architects, security experts), how do you know which one to use? Traditional approaches:

• Keyword matching: Fast but brittle (misses context)
• LLM classification: Accurate but slow and expensive
• Embedding similarity: Good but not perfect

RuvLTRA combines all three with a hybrid routing strategy that achieves 100% accuracy while maintaining sub-millisecond latency.

---

Why RuvLTRA?

---

Features

Core Capabilities

Unique Innovations

Claude Code Native

RuvLTRA was built by Claude Code, for Claude Code:

User: "Add authentication to the API"
          ↓
    [RuvLTRA Routing]
          ↓
    Keyword match: "authentication" → security-related
    Embedding match: similar to auth patterns
    Confidence: 0.98
          ↓
    Route to: backend-dev + security-architect

---

Models

Architecture

Based on Qwen2.5 with custom optimizations:

---

Quick Start

Python

from huggingface_hub import hf_hub_download

# Download the model
model_path = hf_hub_download(
    repo_id="ruv/ruvltra",
    filename="ruvltra-claude-code-0.5b-q4_k_m.gguf"
)

# Use with llama-cpp-python
from llama_cpp import Llama
llm = Llama(model_path=model_path, n_ctx=2048)

# Route a task
response = llm.create_embedding("implement user authentication with JWT")
# → Use embedding for similarity matching against agent descriptions

Rust

use ruvllm::prelude::*;

// Auto-download from HuggingFace
let model = RuvLtraModel::from_pretrained("ruv/ruvltra")?;

// Route a task
let routing = model.route("fix the memory leak in the cache module")?;
println!("Agent: {}", routing.agent);        // "coder"
println!("Confidence: {}", routing.score);   // 0.97
println!("Tier: {}", routing.tier);          // 2 (Haiku-level)

TypeScript/JavaScript

import { RuvLLM, RlmController } from '@ruvector/ruvllm';

// Initialize with auto-download
const llm = new RuvLLM({ model: 'ruv/ruvltra' });

// Simple routing
const route = await llm.route('optimize database queries');
console.log(route.agent);      // 'performance-optimizer'
console.log(route.confidence); // 0.94

// Advanced: Recursive Language Model
const rlm = new RlmController({ maxDepth: 5 });
const answer = await rlm.query('What are causes AND solutions for slow API?');
// Decomposes into sub-queries, synthesizes comprehensive answer

CLI

# Install
npm install -g @ruvector/ruvllm

# Route a task
ruvllm route "add unit tests for the auth module"
# → Agent: tester | Confidence: 0.96 | Tier: 2

# Interactive mode
ruvllm chat --model ruv/ruvltra

---

Claude Code Integration

RuvLTRA powers the intelligent 3-tier routing system in Claude Flow:

┌─────────────────────────────────────────────────────────┐
│                    User Request                         │
└─────────────────────┬───────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────────┐
│                 RuvLTRA Routing                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │
│  │  Keywords   │→ │  Embeddings │→ │  Confidence │     │
│  │   Match?    │  │  Similarity │  │    Score    │     │
│  └─────────────┘  └─────────────┘  └─────────────┘     │
└─────────────────────┬───────────────────────────────────┘
                      ↓
        ┌─────────────┼─────────────┐
        ↓             ↓             ↓
┌───────────┐  ┌───────────┐  ┌───────────┐
│  Tier 1   │  │  Tier 2   │  │  Tier 3   │
│  Booster  │  │   Haiku   │  │   Opus    │
│   <1ms    │  │  ~500ms   │  │   2-5s    │
│    $0     │  │  $0.0002  │  │  $0.015   │
└───────────┘  └───────────┘  └───────────┘

Supported Agents (60+)

---

Benchmarks

Routing Accuracy

Performance (M4 Pro)

Optimization Gains (v2.5)

---

Training

Dataset

Method

1. Base Model: Qwen2.5-0.5B-Instruct
2. Fine-tuning: LoRA (r=8, alpha=16)
3. Loss: Triplet loss with margin 0.5
4. Epochs: 30 (early stopping on validation)
5. Learning Rate: 1e-4 with cosine decay

Self-Learning (SONA)

RuvLTRA uses SONA (Self-Optimizing Neural Architecture) for continuous improvement:

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│   RETRIEVE   │ →   │    JUDGE     │ →   │   DISTILL    │
│ Pattern from │     │ Success or   │     │ Extract key  │
│    HNSW      │     │   failure?   │     │  learnings   │
└──────────────┘     └──────────────┘     └──────────────┘
                                                  ↓
                     ┌──────────────┐     ┌──────────────┐
                     │   INSTANT    │ ←   │ CONSOLIDATE  │
                     │   LEARNING   │     │   (EWC++)    │
                     └──────────────┘     └──────────────┘

---

Novel Capabilities

1. Recursive Language Model (RLM)

Unlike traditional RAG, RuvLTRA supports recursive query decomposition:

Query: "What are the causes AND solutions for slow API responses?"
                              ↓
                    [Decomposition]
                    /            \
    "Causes of slow API?"    "Solutions for slow API?"
           ↓                        ↓
    [Sub-answers]            [Sub-answers]
           \                        /
                    [Synthesis]
                         ↓
            Coherent combined answer

2. Memory-Augmented Routing

Every successful routing is stored in HNSW-indexed memory:

// First time: Full inference
route("implement OAuth2") → security-architect (97% confidence)

// Later: Memory hit in <25μs
route("add OAuth2 flow") → security-architect (99% confidence, cached pattern)

3. Confidence-Aware Escalation

Low confidence triggers automatic escalation:

Confidence > 0.9  → Use recommended agent
Confidence 0.7-0.9 → Use with human confirmation
Confidence < 0.7  → Escalate to higher tier

4. Multi-Agent Composition

RuvLTRA can recommend agent teams for complex tasks:

const routing = await llm.routeComplex('build full-stack app with auth');
// Returns: [
//   { agent: 'system-architect', role: 'design' },
//   { agent: 'backend-dev', role: 'api' },
//   { agent: 'coder', role: 'frontend' },
//   { agent: 'security-architect', role: 'auth' },
//   { agent: 'tester', role: 'qa' }
// ]

---

Comparison

---

Links

---

Citation

@software{ruvltra2025,
  author = {ruvnet},
  title = {RuvLTRA: Purpose-Built Agent Routing Model for Claude Code},
  year = {2025},
  version = {2.5.0},
  publisher = {HuggingFace},
  url = {https://huggingface.co/ruv/ruvltra},
  note = {100\% routing accuracy with hybrid keyword-embedding strategy}
}

---

License

Apache-2.0 / MIT dual license.

---

<div align="center">

Built for Claude Code. Optimized for agents. Designed for speed.

Get Started | View on GitHub

</div>

---

⚡ TurboQuant KV-Cache Compression

RuvLTRA models are fully compatible with TurboQuant — 2-4 bit KV-cache quantization that reduces inference memory by 6-8x with <0.5% quality loss.

Usage with RuvLLM

cargo add ruvllm    # Rust
npm install @ruvector/ruvllm   # Node.js

use ruvllm::quantize::turbo_quant::{TurboQuantCompressor, TurboQuantConfig, TurboQuantBits};

let config = TurboQuantConfig {
    bits: TurboQuantBits::Bit3_5, // 10.7x compression
    use_qjl: true,
    ..Default::default()
};
let compressor = TurboQuantCompressor::new(config)?;
let compressed = compressor.compress_batch(&kv_vectors)?;
let scores = compressor.inner_product_batch_optimized(&query, &compressed)?;

v2.1.0 Ecosystem

• Hybrid Search — Sparse + dense vectors with RRF fusion (20-49% better retrieval)
• Graph RAG — Knowledge graph + community detection for multi-hop queries
• DiskANN — Billion-scale SSD-backed ANN with <10ms latency
• FlashAttention-3 — IO-aware tiled attention, O(N) memory
• MLA — Multi-Head Latent Attention (~93% KV-cache compression)
• Mamba SSM — Linear-time selective state space models
• Speculative Decoding — 2-3x generation speedup

RuVector GitHub | ruvllm crate | @ruvector/ruvllm npm