Agent skill for v3-integration-architect - invoke with $agent-v3-integration-architect
npxskills add ruvnet/claude-flow--skill agent-v3-integration-architectLoading…
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 || true
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.
┌─────────────────────────────────────────┐
│ 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)
// 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);
}
}
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);
}
}
// 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']
});
}
}
// 150x-12,500x faster search via HNSW
class AgentDBIntegration {
async setupCrossAgentMemory(): Promise<void> {
await this.agentdb.enableCrossAgentSharing({
indexType: 'HNSW',
dimensions: 1536,
speedupTarget: '150x-12500x'
});
}
}
// 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);
}
}
// 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
});
}
}
}
// 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)
}
}
// 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);
}
}
}
// 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
}
}
// 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'
};
// 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'
};
// Target: <0.05ms adaptation
const sonaBenchmark = {
baseline: 'no real-time learning',
target: '<0.05ms adaptation time',
modes: ['real-time', 'balanced', 'research', 'edge', 'batch']
};
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();
}
}
| 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 |
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Run Codex CLI, Claude Code, OpenCode, or Pi Coding Agent via background process for programmatic control.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Run Codex CLI, Claude Code, OpenCode, or Pi Coding Agent via background process for programmatic control.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.