Coordinate multiple AI agents with agentic-flow to run tasks in parallel or through ordered stages. Configure shared memory, team structure, workload distribution, retries, and task reassignment, then monitor how the group performs.
Orchestrate multi-agent swarms with agentic-flow for parallel task execution, dynamic topology, and intelligent coordination. Use when scaling beyond single agents, implementing complex workflows, or building distributed AI systems.
Review the instructions the agent will receive before you install.
Orchestrates multi-agent swarms using agentic-flow's advanced coordination system. Supports mesh, hierarchical, and adaptive topologies with automatic task distribution, load balancing, and fault tolerance.
# Initialize swarm
npx agentic-flow hooks swarm-init --topology mesh --max-agents 5
# Spawn agents
npx agentic-flow hooks agent-spawn --type coder
npx agentic-flow hooks agent-spawn --type tester
npx agentic-flow hooks agent-spawn --type reviewer
# Orchestrate task
npx agentic-flow hooks task-orchestrate \
--task "Build REST API with tests" \
--mode parallel
// Equal peers, distributed decision-making
await swarm.init({
topology: 'mesh',
agents: ['coder', 'tester', 'reviewer'],
communication: 'broadcast'
});
// Centralized coordination, specialized workers
await swarm.init({
topology: 'hierarchical',
queen: 'architect',
workers: ['backend-dev', 'frontend-dev', 'db-designer']
});
// Automatically switches topology based on task
await swarm.init({
topology: 'adaptive',
optimization: 'task-complexity'
});
// Execute tasks concurrently
const results = await swarm.execute({
tasks: [
{ agent: 'coder', task: 'Implement API endpoints' },
{ agent: 'frontend', task: 'Build UI components' },
{ agent: 'tester', task: 'Write test suite' }
],
mode: 'parallel',
timeout: 300000 // 5 minutes
});
// Sequential pipeline with dependencies
await swarm.pipeline([
{ stage: 'design', agent: 'architect' },
{ stage: 'implement', agent: 'coder', after: 'design' },
{ stage: 'test', agent: 'tester', after: 'implement' },
{ stage: 'review', agent: 'reviewer', after: 'test' }
]);
// Let swarm decide execution strategy
await swarm.autoOrchestrate({
goal: 'Build production-ready API',
constraints: {
maxTime: 3600,
maxAgents: 8,
quality: 'high'
}
});
// Share state across swarm
await swarm.memory.store('api-schema', {
endpoints: [...],
models: [...]
});
// Agents read shared memory
const schema = await swarm.memory.retrieve('api-schema');
// Automatic work distribution
await swarm.enableLoadBalancing({
strategy: 'dynamic',
metrics: ['cpu', 'memory', 'task-queue']
});
// Handle agent failures
await swarm.setResiliency({
retry: { maxAttempts: 3, backoff: 'exponential' },
fallback: 'reassign-task'
});
// Track swarm metrics
const metrics = await swarm.getMetrics();
// { throughput, latency, success_rate, agent_utilization }
# Pre-task coordination
npx agentic-flow hooks pre-task --description "Build API"
# Post-task synchronization
npx agentic-flow hooks post-task --task-id "task-123"
# Session restore
npx agentic-flow hooks session-restore --session-id "swarm-001"
Solution: Verify memory access and enable hooks
Solution: Check topology (use adaptive) and enable load balancing
No reviews yet. Tell others what you thought.
No login needed. Share how it worked for you, ask a question, or note where it did not run.
No comments yet. Be the first to write one.
Build advanced AgentDB workflows with database synchronization, multiple databases, and search that combines meaning with attribute filters. Covers similarity measures, diverse search results, and operational patterns for distributed AI applications.
Create AgentDB learning plugins that use recorded experience to improve agent decisions. Choose a learning method, store states, actions, and rewards, train models, and evaluate suggested actions through CLI and API workflows.
Build AI agents that retain conversation history, user preferences, and useful interaction patterns with AgentDB. The skill covers persistent storage, meaning memories survive between sessions, plus retrieval, context management, and ReasoningBank integration.
Tune AgentDB memory use and search speed through quantization, which stores vectors more compactly, search indexes, caching, and batch operations. Includes configuration examples and benchmarks to help balance accuracy, speed, and storage as datasets grow.
Build document search with AgentDB that finds related content by meaning. Store documents as numerical representations, combine similarity search with metadata filters, and retrieve relevant passages for systems that generate answers using source material.
Automate browser tasks with agent-browser, using snapshots that label page elements for the agent. Handle login flows, fill and submit forms, extract page information, and capture screenshots through a repeatable navigation and interaction workflow.