Agent-Based Modeling: Local Rules, Global Patterns

Terminology

What & Why

An agent-based model (ABM) is a simulation where you define individual agents, give them simple rules, drop them into an environment, and watch what happens. There is no equation governing the system as a whole. The macro-level behavior emerges from micro-level interactions.

This bottom-up approach captures phenomena that top-down equations miss:

• Ant colony optimization: Ants with no global knowledge find shortest paths through pheromone feedback loops.
• Predator-prey dynamics: Oscillating population cycles emerge from individual hunting and reproduction rules.
• Schelling's segregation: Mild individual preferences (e.g., "I want at least 30% of my neighbors to be like me") produce extreme neighborhood segregation.

ABMs are the tool of choice when the system is heterogeneous (agents differ), spatial (location matters), adaptive (agents learn or evolve), or when you care about transient dynamics rather than just equilibrium. They are used in epidemiology (disease spread), economics (market simulations), ecology (ecosystem modeling), and urban planning (pedestrian flow).

How It Works

The ABM Loop

Every ABM follows the same core loop:

1. Initialize agents with positions, states, and parameters.
2. For each time step: a. Each agent perceives its local environment. b. Each agent decides on an action based on its rules. c. Each agent executes its action (move, deposit, consume, reproduce, die). d. The environment updates (pheromone evaporation, resource regrowth).
3. Record macro-level metrics (population counts, spatial patterns, convergence).

Example 1: Ant Foraging

Ants search for food on a 2D grid. Each ant follows these rules:

• If not carrying food: move randomly, biased toward higher pheromone concentrations. If food is found, pick it up.
• If carrying food: move toward the nest, depositing pheromone on each cell visited.
• Pheromone evaporates at rate \rho per time step: \tau_{ij}(t+1) = (1 - \rho) \cdot \tau_{ij}(t).

The positive feedback loop (more pheromone attracts more ants, which deposit more pheromone) causes the colony to converge on the shortest path to food.

Example 2: Schelling's Segregation

Agents of two types (e.g., red and blue) occupy cells on a grid. Each agent has a happiness threshold h: the minimum fraction of same-type neighbors it requires. If an agent is unhappy (fewer than h fraction of neighbors are the same type), it moves to a random empty cell.

Even with h = 0.3 (agents are happy with 70% different neighbors), the system rapidly self-organizes into highly segregated clusters. This demonstrates how individual tolerance does not translate to collective integration.

Example 3: Predator-Prey (Wa-Tor)

The Wa-Tor simulation places fish and sharks on a toroidal grid:

• Fish move randomly and reproduce after a fixed number of turns.
• Sharks move toward adjacent fish (eating them for energy), lose energy each turn, and die when energy reaches zero.
• Sharks reproduce after accumulating enough energy.

The result: oscillating population cycles matching the Lotka-Volterra equations, but with spatial structure (waves of predators chasing waves of prey).

Complexity Analysis

For $n$ agents on a grid of size $N \times N$, simulated for $T$ time steps:

For ant colony optimization on a graph with $m$ edges and $n$ ants, the pheromone update per iteration costs:

where $\Delta\tau_{ij}^k = Q / L_k$ if ant $k$ used edge $(i,j)$, and $L_k$ is the total path length of ant $k$.

Implementation

ALGORITHM SchellingSegregation(gridSize, numAgents, threshold, maxSteps)
INPUT: gridSize: integer (N x N grid), numAgents: integer,
       threshold: float (happiness threshold), maxSteps: integer
OUTPUT: grid state after convergence or maxSteps

BEGIN
  grid <- CREATE N x N grid, all EMPTY
  agents <- EMPTY LIST
  emptyCells <- LIST of all (r, c) positions

  // Place agents randomly (half type A, half type B)
  FOR i FROM 0 TO numAgents - 1 DO
    pos <- REMOVE random element from emptyCells
    type <- IF i < numAgents / 2 THEN 'A' ELSE 'B'
    grid[pos] <- type
    APPEND {pos, type} TO agents
  END FOR

  FOR step FROM 1 TO maxSteps DO
    unhappy <- EMPTY LIST

    FOR EACH agent IN agents DO
      neighbors <- GetMooreNeighbors(grid, agent.pos)
      sameCount <- COUNT of neighbors with same type as agent
      totalCount <- COUNT of non-empty neighbors
      IF totalCount > 0 AND sameCount / totalCount < threshold THEN
        APPEND agent TO unhappy
      END IF
    END FOR

    IF LENGTH(unhappy) = 0 THEN
      BREAK  // all agents are happy
    END IF

    // Relocate unhappy agents
    FOR EACH agent IN unhappy DO
      IF LENGTH(emptyCells) > 0 THEN
        newPos <- REMOVE random element from emptyCells
        APPEND agent.pos TO emptyCells
        grid[agent.pos] <- EMPTY
        grid[newPos] <- agent.type
        agent.pos <- newPos
      END IF
    END FOR
  END FOR

  RETURN grid
END

ALGORITHM AntForaging(gridSize, nestPos, foodPos, numAnts, evapRate, maxSteps)
INPUT: gridSize: N x N, nestPos/foodPos: (r,c), numAnts: integer,
       evapRate: float, maxSteps: integer
OUTPUT: pheromone grid, food collected count

BEGIN
  pheromone <- CREATE N x N grid, all 0.0
  ants <- ARRAY of numAnts, each at nestPos, carrying = FALSE
  foodCollected <- 0

  FOR step FROM 1 TO maxSteps DO
    FOR EACH ant IN ants DO
      IF ant.carrying = FALSE THEN
        // Move toward higher pheromone with probability
        neighbors <- GetAdjacentCells(ant.pos)
        ant.pos <- ChooseWeightedByPheromone(neighbors, pheromone)
        IF ant.pos = foodPos THEN
          ant.carrying <- TRUE
        END IF
      ELSE
        // Move toward nest, deposit pheromone
        pheromone[ant.pos] <- pheromone[ant.pos] + 1.0
        ant.pos <- MoveToward(ant.pos, nestPos)
        IF ant.pos = nestPos THEN
          ant.carrying <- FALSE
          foodCollected <- foodCollected + 1
        END IF
      END IF
    END FOR

    // Evaporate pheromone
    FOR r FROM 0 TO gridSize - 1 DO
      FOR c FROM 0 TO gridSize - 1 DO
        pheromone[r][c] <- pheromone[r][c] * (1 - evapRate)
      END FOR
    END FOR
  END FOR

  RETURN pheromone, foodCollected
END

Real-World Applications

• Epidemiology: ABMs simulate disease spread (COVID-19 models) with heterogeneous agents, contact networks, and intervention strategies like vaccination and quarantine
• Traffic and transportation: Microsimulation models (SUMO, MATSim) use agent-based vehicles to predict congestion, evaluate road designs, and optimize traffic signals
• Economics and finance: Agent-based computational economics models market dynamics, bubbles, and crashes by simulating heterogeneous traders with different strategies
• Ecology: Predator-prey ABMs, forest fire spread models, and invasive species simulations capture spatial dynamics that differential equations miss
• Logistics optimization: Ant colony optimization solves the traveling salesman problem, vehicle routing, and network routing in telecommunications
• Social science: Schelling-type models study segregation, opinion dynamics, cultural diffusion, and the emergence of social norms

Key Takeaways

• Agent-based models define individual rules and let macro-level patterns emerge, capturing heterogeneity and spatial effects that equation-based models miss
• Stigmergy (indirect coordination through the environment) explains how ant colonies solve optimization problems without central control
• Schelling's model shows that mild individual preferences can produce extreme collective segregation, a powerful lesson about emergent social dynamics
• ABM simulation cost is $O(T \cdot (n \cdot k + N^2))$, dominated by agent count and grid size
• ABMs are the standard tool in epidemiology, traffic simulation, ecology, and computational social science