Swarm Intelligence

What is Swarm Intelligence?

Swarm intelligence is how many simple agents, following simple rules, produce complex collective behavior. No single ant builds a colony; no single bee finds the best flowers. But together, through local interactions and shared signals, they solve problems that no individual could.

Communication Patterns

Pattern	How It Works	Pros	Cons
Message Passing	Agents send direct messages to each other	Precise, targeted communication	Must know who to talk to
Shared State	Agents read/write to a shared memory	Simple, decoupled agents	Concurrency issues, bottleneck
Blackboard	Shared workspace; agents react to changes	Flexible, event-driven	Complex coordination logic
Stigmergy	Agents modify environment; others react	Fully decoupled, scalable	Indirect, slower convergence

Message Bus Architecture

Network Topologies

The topology defines how agents connect and communicate. Different topologies suit different problem structures:

Topology	Structure	Communication	Best For
Mesh	Every agent connects to every other	O(n²) connections	Small groups needing full collaboration
Star	All agents connect through a central hub	Hub routes all messages	Centralized coordination, orchestrator pattern
Hierarchical	Tree structure — managers and workers	Top-down delegation, bottom-up reporting	Large organizations, clear task decomposition
Ring	Each agent connects to two neighbors	Messages pass around the ring	Sequential processing, consensus algorithms

Blackboard Architecture

The blackboard pattern uses a shared workspace where agents post findings and react to changes. A controller decides which agent to activate based on the current state of the blackboard.

// Blackboard architecture for agent communication
interface BlackboardEntry {
  agent: string;
  type: 'hypothesis' | 'evidence' | 'conclusion';
  content: string;
  confidence: number;
  timestamp: number;
}

class Blackboard {
  private entries: BlackboardEntry[] = [];
  private subscribers: Map<string, (entry: BlackboardEntry) => void> = new Map();

  // Agents post findings to the shared workspace
  post(entry: BlackboardEntry): void {
    this.entries.push(entry);
    console.log(`[${entry.agent}] posted ${entry.type}: "${entry.content}" (conf: ${entry.confidence})`);

    // Notify all subscribers
    for (const [name, handler] of this.subscribers) {
      if (name !== entry.agent) handler(entry);
    }
  }

  // Agents subscribe to react to new entries
  subscribe(agentName: string, handler: (entry: BlackboardEntry) => void): void {
    this.subscribers.set(agentName, handler);
  }

  // Query the blackboard for relevant information
  query(type?: string, minConfidence?: number): BlackboardEntry[] {
    return this.entries.filter(e =>
      (!type || e.type === type) &&
      (!minConfidence || e.confidence >= minConfidence)
    );
  }
}

// Usage: research swarm
const board = new Blackboard();

board.subscribe('analyst', (entry) => {
  if (entry.type === 'evidence' && entry.confidence > 0.7) {
    // Analyst reacts to high-confidence evidence
    board.post({
      agent: 'analyst',
      type: 'hypothesis',
      content: `Based on "${entry.content}", I hypothesize...`,
      confidence: 0.6,
      timestamp: Date.now(),
    });
  }
});

Nature-Inspired AI Swarms

Many AI swarm algorithms are directly inspired by nature:

• Ant Colony Optimization (ACO): Digital pheromone trails for path finding and routing problems
• Particle Swarm Optimization (PSO): Agents explore solution space, sharing best-found positions
• Bee Algorithm: Scout bees explore, recruit others to promising areas — used for load balancing
• Firefly Algorithm: Agents attracted to brighter (better) solutions — used for optimization

Modern AI Swarms

Key Takeaways

1. Swarm intelligence produces complex behavior from simple agents following simple rules
2. Communication patterns: message passing, shared state, blackboard, stigmergy
3. Network topology (mesh, star, hierarchical) affects coordination efficiency
4. The blackboard pattern is a flexible shared workspace for multi-agent collaboration
5. Nature-inspired algorithms (ACO, PSO) solve optimization via collective exploration