
Worker Integration
- 996 installs
- 67k repo stars
- Updated August 4, 2026
- ruvnet/ruflo
worker-integration is a version 1.0.0 agentic-flow skill that routes background worker tasks to specialized agents with performance tracking and self-learning for developers building coordinated agent dispatch pipelines.
About
worker-integration is a version 1.0.0 invocable ruvnet/ruflo skill for Worker-Agent integration in agentic-flow. It provides intelligent task dispatch from background workers to specialized agents, with performance_tracking, memory_coordination, agent_selection, and self_learning capabilities. Developers use npx agentic-flow workers agents for trigger-specific recommendations such as ultralearn or optimize, npx agentic-flow workers metrics for performance data, and npx agentic-flow workers stats --integration for coordination stats. Reach for worker-integration when worker triggers need automated agent routing instead of hard-coded handler maps.
- Intelligent agent selection based on trigger type
- Performance tracking and metrics dashboard
- Memory coordination across worker-agent handoffs
- Self-learning capabilities that improve dispatch over time
- 8 predefined trigger-to-agent mappings with fallback logic
Worker Integration by the numbers
- 996 all-time installs (skills.sh)
- +3 installs in the week ending Aug 5, 2026 (Skillselion tracking)
- Ranked #1,093 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
- Security screen: LOW risk (skills.sh audit)
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/ruvnet/ruflo --skill worker-integrationAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 996 |
|---|---|
| repo stars | ★ 67k |
| Security audit | 3 / 3 scanners passed |
| Last updated | August 4, 2026 |
| Repository | ruvnet/ruflo ↗ |
How do you route worker tasks to specialized agents?
Automatically route tasks from background workers to the best specialized agents while tracking performance and enabling self-learning.
Who is it for?
Developers building agentic-flow pipelines who need intelligent worker-to-agent dispatch with tracked performance.
Skip if: Static cron scripts without agent selection or projects outside the agentic-flow worker system.
When should I use this skill?
A developer needs worker-agent routing, agent recommendations per trigger, or integration metrics for agentic-flow background workers.
What you get
Worker-agent routing maps, performance metrics, integration stats, and self-learning dispatch recommendations.
- Worker-agent routing configuration
- Performance and integration metrics output
By the numbers
- Version 1.0.0 invocable skill with 4 capabilities: agent_selection, performance_tracking, memory_coordination, self_lear
- Documents 3 CLI command families: workers agents, workers metrics, and workers stats --integration
Files
Worker-Agent Integration Skill
Intelligent coordination between background workers and specialized agents.
Quick Start
# View agent recommendations for a trigger
npx agentic-flow workers agents ultralearn
npx agentic-flow workers agents optimize
# View performance metrics
npx agentic-flow workers metrics
# View integration stats
npx agentic-flow workers stats --integrationAgent Mappings
Workers automatically dispatch to optimal agents based on trigger type:
| Trigger | Primary Agents | Fallback | Pipeline Phases |
|---|---|---|---|
ultralearn | researcher, coder | planner | discovery → patterns → vectorization → summary |
optimize | performance-analyzer, coder | researcher | static-analysis → performance → patterns |
audit | security-analyst, tester | reviewer | security → secrets → vulnerability-scan |
benchmark | performance-analyzer | coder, tester | performance → metrics → report |
testgaps | tester | coder | discovery → coverage → gaps |
document | documenter, researcher | coder | api-discovery → patterns → indexing |
deepdive | researcher, security-analyst | coder | call-graph → deps → trace |
refactor | coder, reviewer | researcher | complexity → smells → patterns |
Performance-Based Selection
The system learns from execution history to improve agent selection:
// Agent selection considers:
// 1. Quality score (0-1)
// 2. Success rate
// 3. Average latency
// 4. Execution count
const { agent, confidence, reasoning } = selectBestAgent('optimize');
// agent: "performance-analyzer"
// confidence: 0.87
// reasoning: "Selected based on 45 executions with 94.2% success"Memory Key Patterns
Workers store results using consistent patterns:
{trigger}/{topic}/{phase}
Examples:
- ultralearn$auth-module$analysis
- optimize$database$performance
- audit$payment$vulnerabilities
- benchmark$api$metricsBenchmark Thresholds
Agents are monitored against performance thresholds:
{
"researcher": {
"p95_latency": "<500ms",
"memory_mb": "<256MB"
},
"coder": {
"p95_latency": "<300ms",
"quality_score": ">0.85"
},
"security-analyst": {
"scan_coverage": ">95%",
"p95_latency": "<1000ms"
}
}Feedback Loop
Workers provide feedback for continuous improvement:
import { workerAgentIntegration } from 'agentic-flow$workers$worker-agent-integration';
// Record execution feedback
workerAgentIntegration.recordFeedback(
'optimize', // trigger
'coder', // agent
true, // success
245, // latency ms
0.92 // quality score
);
// Check compliance
const { compliant, violations } = workerAgentIntegration.checkBenchmarkCompliance('coder');Integration Statistics
$ npx agentic-flow workers stats --integration
Worker-Agent Integration Stats
══════════════════════════════
Total Agents: 6
Tracked Agents: 4
Total Feedback: 156
Avg Quality Score: 0.89
Model Cache Stats
─────────────────
Hits: 1,234
Misses: 45
Hit Rate: 96.5%Configuration
Enable integration features in .claude$settings.json:
{
"workers": {
"enabled": true,
"parallel": true,
"memoryDepositEnabled": true,
"agentMappings": {
"ultralearn": ["researcher", "coder"],
"optimize": ["performance-analyzer", "coder"]
}
}
}Related skills
How it compares
Use worker-integration when agentic-flow workers need dynamic agent routing and tracked metrics rather than static handler assignment.
FAQ
How does worker-integration pick agents?
worker-integration uses agentic-flow agent_selection to map worker triggers to specialized agents; developers inspect recommendations with npx agentic-flow workers agents followed by a trigger name such as ultralearn or optimize.
What metrics does worker-integration expose?
worker-integration exposes performance_tracking through npx agentic-flow workers metrics and integration coordination stats via npx agentic-flow workers stats --integration, supporting memory_coordination and self_learning over time.
Is Worker Integration safe to install?
skills.sh reports 3 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.