Modelling Complex Systems

Kingman’s Formula (Queuing Theory)

• Origin: John Kingman, 1961.
• Concept: Wait time (Wq) does not increase linearly with utilisation (ρ); it increases exponentially as utilisation approaches 100%.

// Calculate utilisation (capped at 99% to prevent infinite wait times)
const utilisation = Math.min(0.99, this.cognitiveLoad / 100);

// Apply cubic decay to processing speed as utilisation approaches 100%
// This approximates the sharp "hockey stick" curve of Kingman's Formula
this.processingSpeedMod = 1.0 - Math.pow(utilisation, 3);

In Simulation: Nodes have a Cognitive Load capacity. As a node’s load exceeds 80%, its processing speed drops according to a cubic decay curve $(1-\rho^3)$. This visually demonstrates why “busy” teams suddenly gridlock.

Little’s Law

• Origin: John Little, 1954.

• Concept: The long-term average number of items in a stable system (L) is equal to the long-term average effective arrival rate (λ) multiplied by the average time an item spends in the system (W).

In Simulation: The WIP (Work In Progress) metric tracks L. Users can observe that increasing Frequency (λ) without increasing node speed results in an explosion of Lead Time (W), which is similar to a traffic jam forming when cars enter a highway faster than they exit.

// L (WIP) = λ (Arrival Rate) * W (Lead Time)
// In simulation, we track L directly as the number of active items
const L = workItems.length;

// Lead time (W) accumulates as items wait in queues
if (blocked) {
    this.timeWaiting++;
} else {
    this.timeActive++;
}

Brooks’ Law

• Origin: Fred Brooks, The Mythical Man-Month, 1975.
• Concept: “Adding manpower to a late software project makes it later.” This is due to the combinatorial explosion of communication channels, calculated as $\frac{N(N-1)}{2}$.

In Simulation: The Coordination Penalty increases automatically as you add Value Units (nodes). This adds a global “noise” factor to the system, simulating the friction of alignment in larger groups.

// Metcalfe's Law / Brooks' Law derivative
// Coordination Penalty ∝ N(N-1)/2
const pairs = (nodeCount * (nodeCount - 1)) / 2;
const penalty = pairs * 0.0015;

// Applied as 'noise' to every action
const totalNoise = config.noiseLevel + penalty;

Shannon Entropy (Information Theory)

• Origin: Claude Shannon, 1948.
• Concept: Entropy measures the level of uncertainty or disorder in a system.

In Simulation: The System Entropy metric analyses the spatial distribution of work items. Low entropy indicates structured, predictable pulses of work. High entropy indicates scattered, unpredictable jitter, which is a hallmark of unstable systems.

// Calculate Shannon Entropy H(X) = -Σ P(x) log P(x)
let entropy = 0;
workItems.forEach(w => {
    // distribution of work items across links
    const idx = links.indexOf(w.link); 
    if (idx > -1) distribution[idx]++;
});

distribution.forEach(count => {
    if (count > 0) {
        const p = count / workItems.length;
        entropy -= p * Math.log(p);
    }
});

The Kalman Filter

• Origin: Rudolf Kalman, 1960.
• Concept: An algorithm that uses a series of measurements observed over time, containing statistical noise, to produce estimates of unknown variables.

In Simulation: When enabled, the Prediction Layer (represented by a cyan dashed ring) attempts to ‘chase’ and estimate the true Cognitive Load (the solid ring), filtering out stochastic jitter. It visually demonstrates the difficulty management faces in distinguishing “signal” (true capacity issues) from “noise” (random fluctuations).

// 1. Predict (Time Update)
let predNext = this.kfEstimate;
this.kfErrorCov = this.kfErrorCov + this.kfProcessNoise;

// 2. Update (Measurement)
const K = this.kfErrorCov / (this.kfErrorCov + this.kfMeasureNoise);
this.kfEstimate = this.kfEstimate + K * (measuredLoad - this.kfEstimate);
this.kfErrorCov = (1 - K) * this.kfErrorCov;

The Hidden Factory (Rework)

• Origin: Armand Feigenbaum / Six Sigma.
• Concept: A significant portion of capacity is often consumed by correcting defects that were not caught at the source.

In Simulation: When Psychological Safety is low, errors are hidden (purple dots). These have a 50% chance of being rejected at the end of the line and sent back to the start, consuming capacity without generating value.

if (Math.random() < errorChance) {
    if (Math.random() < config.psychSafety) {
        // High Safety: Stop the line (Visible Error)
        this.blockTimer = 40; 
        return false;
    } else {
        // Low Safety: Hide the error (Latent Defect)
        workItem.isDefect = true; 
        return true;
    }
}

Psychological Safety

Definition: The belief that one will not be punished or humiliated for speaking up with ideas, questions, concerns, or mistakes (Amy Edmondson).

• High Safety: Teams stop the line when an error occurs (red blockage). This hurts short-term flow but prevents technical debt.
• Low Safety: Teams pass the error downstream to avoid blame. The dot turns purple (Hidden Defect) and continues moving, creating false flow metrics but eventual rework.

Cognitive Load

Definition: The total amount of mental effort being used in the working memory (John Sweller).

Mechanism: Represented by the coloured ring around a node. Work items add load; time decays it. High load triggers the Kingman effect (slowdown) and increases the probability of error generation.

Environmental Noise (Occasion Noise)

Definition: Transient variability in judgement or performance caused by external factors (mood, weather, interruptions) (Daniel Kahneman).

Mechanism: Adds random “jitter” to particle movement speed and increases the base probability of gate failure, independent of structural design.