# V3 Deep Integration

> Integración profunda con agentic-flow@alpha implementando el ADR-001. Elimina más de 10.000 líneas duplicadas construyendo claude-flow como una extensión especializada.

Fuente: https://skillsagentes.com/skills/ruvnet/ruflo/v3-deep-integration
Markdown: https://skillsagentes.com/skills/ruvnet/ruflo/v3-deep-integration.md

Repositorio: https://github.com/ruvnet/ruflo
Autor: ruvnet
Licencia: MIT
Actualizado: hace 6 meses
Coste de contexto: 45 tok instalada, 1.8k tok al activarse, 1.8k tok con todos los archivos del bundle
Bundle: 1 archivo, 7 KB
Permisos que pide: ninguno declarado

## Instalación

Un skill son archivos markdown: los mismos archivos valen para cualquier agente y lo único que cambia es el directorio de destino, es decir la bandera `--agent`. Añade `-g` para instalarlo en todos los proyectos de la máquina.

```bash
# Claude Code
npx -y skills add ruvnet/ruflo --skill v3-integration-deep --agent claude-code
# Cursor
npx -y skills add ruvnet/ruflo --skill v3-integration-deep --agent cursor
# Codex
npx -y skills add ruvnet/ruflo --skill v3-integration-deep --agent codex
# Gemini CLI
npx -y skills add ruvnet/ruflo --skill v3-integration-deep --agent gemini
# Windsurf
npx -y skills add ruvnet/ruflo --skill v3-integration-deep --agent windsurf
# Cline
npx -y skills add ruvnet/ruflo --skill v3-integration-deep --agent cline
```

## Qué hace

- Integra claude-flow v3 como extensión especializada de agentic-flow@alpha en lugar de una implementación paralela.
- Elimina más de 10.000 líneas duplicadas migrando SwarmCoordinator, AgentManager, TaskScheduler y SessionManager.
- Integra los 5 modos de aprendizaje SONA, Flash Attention y la coordinación cross-agent de AgentDB.
- Define una capa de compatibilidad hacia atrás para una migración gradual.

## Cuándo usarla

- Vas a eliminar duplicación de código integrando claude-flow con agentic-flow@alpha.
- Necesitas integrar SONA, Flash Attention o AgentDB en claude-flow v3.
- Vas a migrar gradualmente sistemas legacy manteniendo compatibilidad hacia atrás.

## Qué la activa

- "Diseña la capa adaptadora para agentic-flow@alpha"
- "Integra los 5 modos de aprendizaje SONA en claude-flow"
- "Migra el SwarmCoordinator para usar el sistema de swarm de agentic-flow"

## Archivos

- SKILL.md — 7 KB

## SKILL.md

Reproducido tal cual desde ruvnet/ruflo bajo MIT. Esta sección es el documento original y está en inglés.

# V3 Deep Integration

## What This Skill Does

Transforms claude-flow from parallel implementation to specialized extension of agentic-flow@alpha, eliminating massive code duplication while achieving performance improvements and feature parity.

## Quick Start

```bash
# Initialize deep integration
Task("Integration architecture", "Design agentic-flow@alpha adapter layer", "v3-integration-architect")

# Feature integration (parallel)
Task("SONA integration", "Integrate 5 SONA learning modes", "v3-integration-architect")
Task("Flash Attention", "Implement 2.49x-7.47x speedup", "v3-integration-architect")
Task("AgentDB coordination", "Setup 150x-12,500x search", "v3-integration-architect")
```

## Code Deduplication Strategy

### Current Overlap → Integration
```
┌─────────────────────────────────────────┐
│  claude-flow          agentic-flow      │
├─────────────────────────────────────────┤
│ SwarmCoordinator  →   Swarm System      │ 80% overlap (eliminate)
│ AgentManager      →   Agent Lifecycle   │ 70% overlap (eliminate)
│ TaskScheduler     →   Task Execution    │ 60% overlap (eliminate)
│ SessionManager    →   Session Mgmt      │ 50% overlap (eliminate)
└─────────────────────────────────────────┘

TARGET: <5,000 lines (vs 15,000+ currently)
```

## agentic-flow@alpha Feature Integration

### SONA Learning Modes
```typescript
class SONAIntegration {
  async initializeMode(mode: SONAMode): Promise<void> {
    switch(mode) {
      case 'real-time':   // ~0.05ms adaptation
      case 'balanced':    // general purpose
      case 'research':    // deep exploration
      case 'edge':        // resource-constrained
      case 'batch':       // high-throughput
    }
    await this.agenticFlow.sona.setMode(mode);
  }
}
```

### Flash Attention Integration
```typescript
class FlashAttentionIntegration {
  async optimizeAttention(): Promise<AttentionResult> {
    return this.agenticFlow.attention.flashAttention({
      speedupTarget: '2.49x-7.47x',
      memoryReduction: '50-75%',
      mechanisms: ['multi-head', 'linear', 'local', 'global']
    });
  }
}
```

### AgentDB Coordination
```typescript
class AgentDBIntegration {
  async setupCrossAgentMemory(): Promise<void> {
    await this.agentdb.enableCrossAgentSharing({
      indexType: 'HNSW',
      speedupTarget: '150x-12500x',
      dimensions: 1536
    });
  }
}
```

### MCP Tools Integration
```typescript
class MCPToolsIntegration {
  async integrateBuiltinTools(): Promise<void> {
    // Leverage 213 pre-built tools
    const tools = await this.agenticFlow.mcp.getAvailableTools();
    await this.registerClaudeFlowSpecificTools(tools);

    // Use 19 hook types
    const hookTypes = await this.agenticFlow.hooks.getTypes();
    await this.configureClaudeFlowHooks(hookTypes);
  }
}
```

## Migration Implementation

### Phase 1: Adapter Layer
```typescript
import { Agent as AgenticFlowAgent } from 'agentic-flow@alpha';

export class ClaudeFlowAgent extends AgenticFlowAgent {
  async handleClaudeFlowTask(task: ClaudeTask): Promise<TaskResult> {
    return this.executeWithSONA(task);
  }

  // Backward compatibility
  async legacyCompatibilityLayer(oldAPI: any): Promise<any> {
    return this.adaptToNewAPI(oldAPI);
  }
}
```

### Phase 2: System Migration
```typescript
class SystemMigration {
  async migrateSwarmCoordination(): Promise<void> {
    // Replace SwarmCoordinator (800+ lines) with agentic-flow Swarm
    const swarmConfig = await this.extractSwarmConfig();
    await this.agenticFlow.swarm.initialize(swarmConfig);
  }

  async migrateAgentManagement(): Promise<void> {
    // Replace AgentManager (1,736+ lines) with agentic-flow lifecycle
    const agents = await this.extractActiveAgents();
    for (const agent of agents) {
      await this.agenticFlow.agent.create(agent);
    }
  }

  async migrateTaskExecution(): Promise<void> {
    // Replace TaskScheduler with agentic-flow task graph
    const tasks = await this.extractTasks();
    await this.agenticFlow.task.executeGraph(this.buildTaskGraph(tasks));
  }
}
```

### Phase 3: Cleanup
```typescript
class CodeCleanup {
  async removeDeprecatedCode(): Promise<void> {
    // Remove massive duplicate implementations
    await this.removeFile('src$core/SwarmCoordinator.ts');    // 800+ lines
    await this.removeFile('src.agents/AgentManager.ts');      // 1,736+ lines
    await this.removeFile('src$task/TaskScheduler.ts');       // 500+ lines

    // Total reduction: 10,000+ → <5,000 lines
  }
}
```

## RL Algorithm Integration

```typescript
class RLIntegration {
  algorithms = [
    'PPO', 'DQN', 'A2C', 'MCTS', 'Q-Learning',
    'SARSA', 'Actor-Critic', 'Decision-Transformer'
  ];

  async optimizeAgentBehavior(): Promise<void> {
    for (const algorithm of this.algorithms) {
      await this.agenticFlow.rl.train(algorithm, {
        episodes: 1000,
        rewardFunction: this.claudeFlowRewardFunction
      });
    }
  }
}
```

## Performance Integration

### Flash Attention Targets
```typescript
const attentionBenchmark = {
  baseline: 'current attention mechanism',
  target: '2.49x-7.47x improvement',
  memoryReduction: '50-75%',
  implementation: 'agentic-flow@alpha Flash Attention'
};
```

### AgentDB Search Performance
```typescript
const searchBenchmark = {
  baseline: 'linear search in current systems',
  target: '150x-12,500x via HNSW indexing',
  implementation: 'agentic-flow@alpha AgentDB'
};
```

## Backward Compatibility

### Gradual Migration
```typescript
class BackwardCompatibility {
  // Phase 1: Dual operation
  async enableDualOperation(): Promise<void> {
    this.oldSystem.continue();
    this.newSystem.initialize();
    this.syncState(this.oldSystem, this.newSystem);
  }

  // Phase 2: Feature-by-feature migration
  async migrateGradually(): Promise<void> {
    const features = this.getAllFeatures();
    for (const feature of features) {
      await this.migrateFeature(feature);
      await this.validateFeatureParity(feature);
    }
  }

  // Phase 3: Complete transition
  async completeTransition(): Promise<void> {
    await this.validateFullParity();
    await this.deprecateOldSystem();
  }
}
```

## Success Metrics

- **Code Reduction**: <5,000 lines orchestration (vs 15,000+)
- **Performance**: 2.49x-7.47x Flash Attention speedup
- **Search**: 150x-12,500x AgentDB improvement
- **Memory**: 50-75% usage reduction
- **Feature Parity**: 100% v2 functionality maintained
- **SONA**: <0.05ms adaptation time
- **Integration**: All 213 MCP tools + 19 hook types available

## Related V3 Skills

- `v3-memory-unification` - Memory system integration
- `v3-performance-optimization` - Performance target validation
- `v3-swarm-coordination` - Swarm system migration
- `v3-security-overhaul` - Secure integration patterns

## Dónde encaja

- Categoría: [Herramientas para desarrolladores](https://skillsagentes.com/categorias/herramientas-desarrollo.md) — Skills que cambian cómo tu agente escribe, revisa y despliega código.
- Creador: [ruvnet](https://skillsagentes.com/creators/ruvnet.md) — 275 skills en el directorio
- [Todas las skills](https://skillsagentes.com/skills.md)
- [Ranking de instalaciones](https://skillsagentes.com/ranking.md)

## Otras skills del mismo repositorio

- [Harness Gepa](https://skillsagentes.com/skills/ruvnet/ruflo/harness-gepa.md): Inspecciona y audita genomas GEPA: carga y valida un genoma, renderiza el system prompt que compila, o clasifica los modos de fallo de una transcripción de ejecución.
- [Deepseek Reason](https://skillsagentes.com/skills/ruvnet/ruflo/deepseek-reason.md): Completion en modo razonamiento contra deepseek-reasoner (R1) de DeepSeek. Devuelve el chain-of-thought por separado de la respuesta final. Lee DEEPSEEK_API_KEY y degrada si falta o la API no responde.
- [Deepseek Chat](https://skillsagentes.com/skills/ruvnet/ruflo/deepseek-chat.md): Completion de un solo turno contra el modelo deepseek-chat de DeepSeek vía /v1/chat/completions. Lee DEEPSEEK_API_KEY y degrada con status:degraded si falta o la API no responde. Para tareas sin razonamiento.
- [Adr Index](https://skillsagentes.com/skills/ruvnet/ruflo/adr-index.md): Construye o reconstruye el índice de ADRs y su grafo de dependencias ejecutando scripts/import.mjs, en vez de cientos de llamadas MCP.
- [Agntcy Status](https://skillsagentes.com/skills/ruvnet/ruflo/agntcy-status.md): Muestra el estado de la integración AGNTCY/SLIM/CASA: si los paquetes están instalados, qué transporte está activo y si el enforcement de CASA está habilitado.

---

Skills Agentes · [Índice de páginas en markdown](https://skillsagentes.com/sitemap.md) · [Inicio](https://skillsagentes.com/index.md)