SKILL.md
name: v3-integration-architect
version: "3.0.0-alpha"
updated: "2026-01-04"
description: V3 Integration Architect for deep agentic-flow@alpha integration. Implements ADR-001 to eliminate 10,000+ duplicate lines and build claude-flow as specialized extension rather than parallel implementation.
color: green
metadata:
v3_role: "architect"
agent_id: 10
priority: "high"
domain: "integration"
phase: "integration"
hooks:
pre_execution: |
echo "🔗 V3 Integration Architect starting agentic-flow@alpha deep integration..."
# Check agentic-flow status
npx agentic-flow@alpha --version 2>$dev$null | head -1 || echo "⚠️ agentic-flow@alpha not available"echo "🎯 ADR-001: Eliminate 10,000+ duplicate lines"
echo "📊 Current duplicate functionality:"
echo " • SwarmCoordinator vs Swarm System (80% overlap)"
echo " • AgentManager vs Agent Lifecycle (70% overlap)"
echo " • TaskScheduler vs Task Execution (60% overlap)"
echo " • SessionManager vs Session Mgmt (50% overlap)"
# Check integration points
ls -la services$agentic-flow-hooks/ 2>$dev$null | wc -l | xargs echo "🔧 Current hook integrations:"post_execution: |
echo "🔗 agentic-flow@alpha integration milestone complete"
# Store integration patterns
npx agentic-flow@alpha memory store-pattern \
--session-id "v3-integration-$(date +%s)" \
--task "Integration: $TASK" \
--agent "v3-integration-architect" \
--code-reduction "10000+" 2>$dev$null || trueV3 Integration Architect
🔗 agentic-flow@alpha Deep Integration & Code Deduplication Specialist
Core Mission: ADR-001 Implementation
Transform claude-flow from parallel implementation to specialized extension of agentic-flow, eliminating 10,000+ lines of duplicate code while achieving 100% feature parity and performance improvements.
Integration Strategy
Current Duplication Analysis
┌─────────────────────────────────────────┐
│ FUNCTIONALITY OVERLAP │
├─────────────────────────────────────────┤
│ claude-flow agentic-flow │
├─────────────────────────────────────────┤
│ SwarmCoordinator → Swarm System │ 80% overlap
│ AgentManager → Agent Lifecycle │ 70% overlap
│ TaskScheduler → Task Execution │ 60% overlap
│ SessionManager → Session Mgmt │ 50% overlap
└─────────────────────────────────────────┘
TARGET: <5,000 lines orchestration (vs 15,000+ currently)Integration Architecture
// Phase 1: Adapter Layer Creation
import { Agent as AgenticFlowAgent } from 'agentic-flow@alpha';
export class ClaudeFlowAgent extends AgenticFlowAgent {
// Add claude-flow specific capabilities
async handleClaudeFlowTask(task: ClaudeTask): Promise<TaskResult> {
return this.executeWithSONA(task);
}
// Maintain backward compatibility
async legacyCompatibilityLayer(oldAPI: any): Promise<any> {
return this.adaptToNewAPI(oldAPI);
}
}agentic-flow@alpha Feature Integration
SONA Learning Modes
interface SONAIntegration {
modes: {
realTime: '~0.05ms adaptation',
balanced: 'general purpose learning',
research: 'deep exploration mode',
edge: 'resource-constrained environments',
batch: 'high-throughput processing'
};
}
// Integration implementation
class ClaudeFlowSONAAdapter {
async initializeSONAMode(mode: SONAMode): Promise<void> {
await this.agenticFlow.sona.setMode(mode);
await this.configureAdaptationRate(mode);
}
}Flash Attention Integration
// Target: 2.49x-7.47x speedup
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
// 150x-12,500x faster search via HNSW
class AgentDBIntegration {
async setupCrossAgentMemory(): Promise<void> {
await this.agentdb.enableCrossAgentSharing({
indexType: 'HNSW',
dimensions: 1536,
speedupTarget: '150x-12500x'
});
}
}MCP Tools Integration
// Leverage 213 pre-built tools + 19 hook types
class MCPToolsIntegration {
async integrateBuiltinTools(): Promise<void> {
const tools = await this.agenticFlow.mcp.getAvailableTools();
// 213 tools available
await this.registerClaudeFlowSpecificTools(tools);
}
async setupHookTypes(): Promise<void> {
const hookTypes = await this.agenticFlow.hooks.getTypes();
// 19 hook types: pre$post execution, error handling, etc.
await this.configureClaudeFlowHooks(hookTypes);
}
}RL Algorithm Integration
// Multiple RL algorithms for optimization
class RLIntegration {
algorithms = [
'PPO', 'DQN', 'A2C', 'MCTS', 'Q-Learning',
'SARSA', 'Actor-Critic', 'Decision-Transformer',
'Curiosity-Driven'
];
async optimizeAgentBehavior(): Promise<void> {
for (const algorithm of this.algorithms) {
await this.agenticFlow.rl.train(algorithm, {
episodes: 1000,
learningRate: 0.001,
rewardFunction: this.claudeFlowRewardFunction
});
}
}
}Migration Implementation Plan
Phase 1: Foundation Adapter (Week 7)
// Create compatibility layer
class AgenticFlowAdapter {
constructor(private agenticFlow: AgenticFlowCore) {}
// Migrate SwarmCoordinator → Swarm System
async migrateSwarmCoordination(): Promise<void> {
const swarmConfig = await this.extractSwarmConfig();
await this.agenticFlow.swarm.initialize(swarmConfig);
// Deprecate old SwarmCoordinator (800+ lines)
}
// Migrate AgentManager → Agent Lifecycle
async migrateAgentManagement(): Promise<void> {
const agents = await this.extractActiveAgents();
for (const agent of agents) {
await this.agenticFlow.agent.create(agent);
}
// Deprecate old AgentManager (1,736 lines)
}
}Phase 2: Core Migration (Week 8-9)
// Migrate task execution
class TaskExecutionMigration {
async migrateToTaskGraph(): Promise<void> {
const tasks = await this.extractTasks();
const taskGraph = this.buildTaskGraph(tasks);
await this.agenticFlow.task.executeGraph(taskGraph);
}
}
// Migrate session management
class SessionMigration {
async migrateSessionHandling(): Promise<void> {
const sessions = await this.extractActiveSessions();
for (const session of sessions) {
await this.agenticFlow.session.create(session);
}
}
}Phase 3: Optimization (Week 10)
// Remove compatibility layer
class CompatibilityCleanup {
async removeDeprecatedCode(): Promise<void> {
// Remove old 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 code reduction: 10,000+ lines → <5,000 lines
}
}Performance Integration Targets
Flash Attention Optimization
// Target: 2.49x-7.47x speedup
const attentionBenchmark = {
baseline: 'current attention mechanism',
target: '2.49x-7.47x improvement',
memoryReduction: '50-75%',
implementation: 'agentic-flow@alpha Flash Attention'
};AgentDB Search Performance
// Target: 150x-12,500x improvement
const searchBenchmark = {
baseline: 'linear search in current memory systems',
target: '150x-12,500x via HNSW indexing',
implementation: 'agentic-flow@alpha AgentDB'
};SONA Learning Performance
// Target: <0.05ms adaptation
const sonaBenchmark = {
baseline: 'no real-time learning',
target: '<0.05ms adaptation time',
modes: ['real-time', 'balanced', 'research', 'edge', 'batch']
};Backward Compatibility Strategy
Gradual Migration Approach
class BackwardCompatibility {
// Phase 1: Dual operation (old + new)
async enableDualOperation(): Promise<void> {
this.oldSystem.continue();
this.newSystem.initialize();
this.syncState(this.oldSystem, this.newSystem);
}
// Phase 2: Gradual switchover
async migrateGradually(): Promise<void> {
const features = this.getAllFeatures();
for (const feature of features) {
await this.migrateFeature(feature);
await this.validateFeatureParity(feature);
}
}
// Phase 3: Complete migration
async completeTransition(): Promise<void> {
await this.validateFullParity();
await this.deprecateOldSystem();
}
}Success Metrics & Validation
Code Reduction Targets
- Total Lines: <5,000 orchestration (vs 15,000+)
- SwarmCoordinator: Eliminated (800+ lines)
- AgentManager: Eliminated (1,736+ lines)
- TaskScheduler: Eliminated (500+ lines)
- Duplicate Logic: <5% remaining
Performance Targets
- Flash Attention: 2.49x-7.47x speedup validated
- Search Performance: 150x-12,500x improvement
- Memory Usage: 50-75% reduction
- SONA Adaptation: <0.05ms response time
Feature Parity
- 100% Feature Compatibility: All v2 features available
- API Compatibility: Backward compatible interfaces
- Performance: No regression, ideally improvement
- Documentation: Migration guide complete
Coordination Points
Memory Specialist (Agent #7)
- AgentDB integration coordination
- Cross-agent memory sharing setup
- Performance benchmarking collaboration
Swarm Specialist (Agent #8)
- Swarm system migration from claude-flow to agentic-flow
- Topology coordination and optimization
- Agent communication protocol alignment
Performance Engineer (Agent #14)
- Performance target validation
- Benchmark implementation for improvements
- Regression testing for migration phases
Risk Mitigation
Risk
Likelihood
Impact
Mitigation
agentic-flow breaking changes
Medium
High
Pin version, maintain adapter
Performance regression
Low
Medium
Continuous benchmarking
Feature limitations
Medium
Medium
Contribute upstream features
Migration complexity
High
Medium
Phased approach, compatibility layer