Swarm intelligence & optimization

At 3:00 a.m., your delivery system has 18 vans, 240 stops, and a new road closure. It needs a route plan before the first driver leaves. There are far too many possible routes to try one by one. The cost function includes distance, traffic, driver hours, vehicle capacity, and late-delivery penalties. It is not smooth. It has sharp cliffs, missing data, and rules that say “this route is simply illegal.”

Calculus is not much help.

Population-based search gives you many candidate solutions to evaluate, often in parallel, while preserving several possibilities instead of betting everything on one early guess. But it does not eliminate coordination. Standard PSO synchronizes a shared global best, and standard ACO updates a shared pheromone table. Synchronization, communication, and contention can still bottleneck. If the objective has a faulty assumption or bad data, every swarm member can optimize the same wrong world.

The useful answer can still emerge from many small search processes exploring, remembering good discoveries, and influencing one another. No single process has to carry the entire search state. That does not guarantee the best answer.

That is swarm intelligence: useful global behavior emerging from many simple agents following local rules. In optimization, the agents are usually lightweight mathematical search processes called particles or ants, not LLMs. Two classic algorithms are particle swarm optimization, or PSO, and ant colony optimization, or ACO.

Both are gradient-free metaheuristics. They do not need the slope of the objective function. They guide trial solutions toward promising regions without promising an exact answer. Their value is a controlled compromise between exploring possibilities and exploiting what already looks good.

Particle swarm optimization

Imagine tuning one setting: the temperature at which a warehouse freezer should run. Let x be that temperature, and let the objective be energy cost plus spoiled-inventory risk:

f(x) = (x - 3)^2

At x=8, the score is 25; at x=4, it is 1. The closer the setting gets to 3, the lower the score.

A PSO particle stores:

• Its current position, the candidate solution it is testing.
• Its velocity, the direction and size of its next move.
• Its personal best, or pbest: the best position it has seen.
• The swarm’s global best, or gbest: the best position found by any particle.

Each particle is pulled by three influences:

1. Inertia preserves some previous motion and encourages exploration.
2. Cognitive pull points toward its pbest, preserving private discoveries.
3. Social pull points toward gbest, spreading useful discoveries.

A common update is:

v_i(t+1) = w v_i(t) + c1 r1 (pbest_i - x_i(t)) + c2 r2 (gbest - x_i(t))

Then:

x_i(t+1) = x_i(t) + v_i(t+1)

Here, w controls inertia, c1 and c2 control the two pulls, and r1 and r2 are random values between zero and one. The random factors keep every particle from moving identically.

The code removes randomness and uses fixed coefficients so the arithmetic is easy to follow. It is a teaching version, not a complete production implementation.

import numpy as np

def objective(x):
    return (x - 3.0) ** 2

positions = np.array([-8.0, 0.0, 6.0, 10.0, 14.0])
velocities = np.zeros(5)
personal_best = positions.copy()

best_index = np.argmin([objective(x) for x in personal_best])
global_best = personal_best[best_index]

for step in range(1, 4):
    for i in range(len(positions)):
        velocities[i] = (
            0.5 * velocities[i]
            + 0.8 * (personal_best[i] - positions[i])
            + 0.8 * (global_best - positions[i])
        )
        positions[i] += velocities[i]

        if objective(positions[i]) < objective(personal_best[i]):
            personal_best[i] = positions[i]

    best_index = np.argmin([objective(x) for x in personal_best])
    global_best = personal_best[best_index]
    print(
        f"step {step}: "
        f"global best x={global_best:.2f}  "
        f"f={objective(global_best):.4f}"
    )

step 1: global best x=2.80  f=0.0400
step 2: global best x=2.80  f=0.0400
step 3: global best x=2.98  f=0.0006

The first useful discovery is x=2.80, found by the particle that started at 14. Its first move overshoots toward the true optimum. Its new score, 0.04, beats its old score of 121, so it records 2.80 as its pbest. The other particles then feel a social pull toward it.

Not every particle improves on every step. A particle can pass through a worse position while retaining its earlier pbest. On step three, another particle reaches 2.976, whose score is approximately 0.0006, improving gbest.

The population is not reasoning about freezers. It repeatedly evaluates a candidate, remembers the best candidate seen, and moves toward useful memories.

What PSO is really searching

A position can have many dimensions. For a delivery operation, one particle might represent:

[number of vans, depot departure time, loading slack, battery reserve]

The objective converts that vector into one score, such as operating cost plus late-delivery and battery penalties. Continuous variables work naturally. Integers need rounding or specialized updates. A route represented as a sequence of stop IDs is not naturally a PSO position; a discrete encoding may perform poorly.

High inertia encourages exploration; strong social pull speeds convergence but can spread an early mistake. Random coefficients, velocity limits, bounds, constraint handling, and an evaluation budget all matter.

Noise can make a lucky low score look like a real discovery. PSO may store it as pbest or gbest and pull other particles toward it. Resample promising candidates on independent simulator-noise draws and compare estimated means with uncertainty rather than trusting one observation.

Ant colony optimization

PSO fits numeric positions. A route that visits locations in sequence is a graph problem. A TSP has one closed tour; the delivery problem is a vehicle-routing problem, or VRP, with multiple routes, assignments, capacity, driver hours, time windows, depot returns, and road closures.

ACO can address this VRP, but an implementation needs a multi-route encoding—such as route separators or a construction process that builds one van route at a time—and feasibility-aware construction or repair. A MILP or CP-SAT solver may be better when constraints are central and the instance is manageable.

ACO assigns each graph edge a pheromone value, recording how strongly previous ants reinforced it, and a heuristic value, often 1 / distance. An ant constructs a route one edge at a time, sampling among available choices. A common weight for edge j is:

tau_ij^alpha * eta_ij^beta

alpha controls trust in pheromone; beta controls trust in the heuristic.

Suppose an ant at depot A can choose B, two kilometers away, or C, five kilometers away. Both edges have pheromone 1, with alpha=1 and beta=2.

• A to B: 1^1 * (1 / 2)^2 = 0.25
• A to C: 1^1 * (1 / 5)^2 = 0.04

The total weight is 0.29, so B is chosen with probability 0.25 / 0.29, or about 86.2%. It is favored, not forced; the shortest next edge may not belong to the shortest complete route.

After ants build routes, pheromone first evaporates:

tau_ij = (1 - rho) * tau_ij

If rho=0.2 and pheromone is 0.5, evaporation leaves 0.4. Evaporation prevents old choices from remaining permanently attractive.

Ants then deposit pheromone, often in proportion to route quality:

deposit = Q / route_length

With Q=100, a route of length 20 deposits 5, while one of length 50 deposits 2. For a constrained VRP, quality should reflect the complete feasible plan, not distance alone. A shorter route that overloads a van is not a useful discovery.

This indirect coordination is stigmergy: agents influence one another by changing a shared environment. In software, that environment is usually a pheromone table in memory or a database.

Choosing the method

Choose based on the candidate representation and evaluation cost:

“Gradient-free” does not mean free. If one evaluation simulates 240 deliveries for an hour, 1,000 candidates are expensive. Parallel evaluation reduces wall-clock time, not compute cost. Standard PSO and ACO also retain shared-state costs: gbest must be synchronized, and pheromone updates must be aggregated.

Use PSO for vectors whose numeric changes have meaningful interpretations. Use ACO for solutions assembled from linked discrete decisions. If an exact solver handles the constraints, test it first; a metaheuristic should not replace a proof merely because it is convenient.

A production pattern

Start with the representation. Define what every coordinate, edge, or decision means. If a particle contains [3.7 vans], choose rounding, an integer-specific operator, or another method.

Make the objective observable. Return the total score and components such as fuel cost, lateness, and capacity violations. The optimizer needs one number; operators need the components when a result looks absurd.

Make constraints explicit:

• Repair changes an invalid candidate into a valid one.
• Penalty adds cost for violations.
• Feasible construction prevents impossible partial choices.
• Separate checks reject candidates before expensive simulation.

Penalties can be too small, allowing illegal plans, or too large, hiding the useful objective. Repair can silently produce a candidate far from the one the optimizer intended.

Run multiple optimizer seeds and compare with a simple baseline. For noisy simulators, independently rescore the best candidates and report means plus variance or confidence intervals. Record seeds, parameters, evaluation count, best score over time, final candidate, and violations.

Stop on a time or evaluation budget, or after a fixed period without improvement. In live planning, a theoretically better route that misses dispatch is not better. Finally, validate with a separate checker: if the score forgot vehicle capacity, the swarm will optimize an imaginary world.

Failure modes you can see first

PSO collapses too early

If particles become nearly identical after a few iterations while the score is mediocre, social pressure has probably erased exploration. Reduce social influence, increase diversity, use random coefficients, or restart part of the swarm. If every seed finds the same bad score, inspect the objective and bounds before tuning.

PSO oscillates or leaves its bounds

Wildly alternating scores, NaN values, or repeated boundary hits indicate excessive velocity or unstable coefficients. Use velocity limits and explicit boundary handling; reflecting a velocity is safer than merely clipping a position. Normalize variables with incompatible units.

ACO locks onto one bad route

If pheromone concentrates on one route immediately, early positive feedback has become runaway exploitation. Increase exploration or evaporation, cap pheromone values, and deposit only from the best few routes. Preserve a separate best-so-far archive so evaporation cannot erase the best result.

The optimizer returns an impossible answer

A plan with duplicate stops, overloaded vehicles, negative reserves, or missed time windows means constraints were not enforced. Test the checker with deliberately invalid candidates, make feasibility a first-class output, and reject infeasible results in safety-sensitive systems.

In one breath

Swarm intelligence uses local rules, memory, and shared signals to search collectively. PSO moves numeric candidates using inertia, personal best, and global best. ACO builds graph paths using heuristic choice, pheromone reinforcement, evaporation, and stigmergy.

Choose by representation: numeric vectors suggest PSO; linked discrete routes suggest ACO; smooth objectives suggest gradients; small exact spaces suggest solvers. Neither swarm guarantees an optimum or removes coordination costs. Compare with a baseline, repeat across seeds, account for noise, enforce constraints, and validate the final answer independently.

Quick check

Next

Swarm optimization is collective behavior aimed at searching, rather than agents learning from one another as in multi-agent reinforcement learning. It is one example of the emergence explored through generative agents. For agents that communicate, delegate, and coordinate tasks, see multi-agent orchestration.