System Dynamics Modeling: Feedback Loops, Stocks, and Flows

Last Updated June 6, 2026

System dynamics modeling is a formal method for analyzing complex systems by representing how stocks, flows, feedback loops, time delays, and nonlinear relationships interact to generate behavior over time. Instead of treating a system as a static collection of variables, system dynamics asks how system structure produces patterns such as growth, overshoot, oscillation, stagnation, collapse, policy resistance, and recovery.

Developed in the mid-twentieth century by Jay W. Forrester at MIT, system dynamics emerged from the recognition that many recurring problems in industry, management, public policy, sustainability, and infrastructure do not arise from external shocks alone. They are often generated endogenously by the internal structure of the system: the way information moves, decisions are made, stocks accumulate, feedback loops operate, and delays distort response.

System dynamics is one of the foundational paradigms in systems modeling because it provides a disciplined way to translate systems thinking into executable models. It turns conceptual ideas such as “feedback,” “accumulation,” “delay,” and “policy resistance” into formal structures that can be simulated, tested, revised, and communicated.

This article explains system dynamics modeling as a major paradigm within systems modeling. It covers origins, causal loop diagrams, stocks and flows, feedback loops, delays, simulation, policy analysis, calibration, validation, software tools, sustainability applications, mathematical foundations, professional workflows, Python and R examples, strengths, limitations, and responsible use.

What Is System Dynamics Modeling?

System dynamics modeling is a method for representing complex systems as dynamic structures composed of accumulations, flows, feedback loops, delays, decision rules, and nonlinear relationships. Its central claim is that behavior over time is often produced by system structure. To understand why a system grows, oscillates, resists intervention, or collapses, analysts must examine the relationships that generate those patterns.

In system dynamics, the model is not merely a diagram or a list of variables. It is an executable representation of how a system changes over time. Variables are connected through equations. Stocks accumulate. Flows change stocks. Feedback loops influence future behavior. Delays separate action from consequence. Scenarios test alternative assumptions.

This makes system dynamics especially useful for problems where short-term events are symptoms of deeper structural dynamics. A company may experience recurring inventory swings. A city may repeatedly underinvest in infrastructure. A public agency may respond to backlog by increasing pressure, only to generate rework and burnout. A resource system may appear stable until slow depletion crosses a threshold. In each case, the question is not only “What happened?” but “What structure keeps producing this pattern?”

System dynamics is therefore both conceptual and quantitative. It begins with systems thinking, but it moves toward formal representation, simulation, diagnostic testing, and disciplined interpretation.

Back to top ↑

Origins of System Dynamics

System dynamics was pioneered by Jay W. Forrester at the Massachusetts Institute of Technology during the 1950s. Forrester originally developed the method to study industrial production and management systems, where decision-makers struggled to explain recurring fluctuations in inventory, production, labor, delivery, and demand.

Forrester’s key insight was that many instabilities did not originate primarily from external disruption. They emerged from the internal decision structure of the system itself. Managers adjusted production based on delayed information. Inventories accumulated and depleted. Corrective decisions arrived late. Feedback amplified local decisions into system-wide oscillation.

This marked a major shift in analytical reasoning. Instead of treating instability as a series of isolated events, system dynamics represented instability as a pattern generated by structure. This approach later expanded from industrial systems into urban development, macroeconomics, public policy, environmental management, health systems, energy transitions, sustainability research, and organizational strategy.

System dynamics also became central to global modeling. The World3 model used in The Limits to Growth applied system dynamics principles to population, industrial output, food production, pollution, and nonrenewable resources. Whether one agrees with every assumption in that model or not, its historical importance lies in showing how coupled human-environment systems could be represented as feedback-driven dynamic structures.

The enduring lesson is that recurring patterns often require structural explanation. System dynamics gave analysts a way to formalize that explanation.

Back to top ↑

Why Structure Generates Behavior

The central principle of system dynamics is that system structure generates system behavior. Structure includes stocks, flows, feedback loops, decision rules, information delays, constraints, goals, and nonlinear relationships. These elements shape what the system can do over time.

This principle is important because many systems appear to be driven by events. A stockout occurs. A service backlog grows. A population collapses. A budget crisis appears. A supply chain fails. A city experiences congestion. A policy produces unintended consequences. Event-based reasoning asks what immediately preceded the event. System dynamics asks what structure made the event likely.

For example, a recurring supply shortage may not be caused by a single bad forecast. It may be caused by delayed demand information, aggressive ordering rules, insufficient inventory buffers, supplier lead times, and overcorrection. A public agency’s backlog may not be caused by staff laziness. It may arise from demand growth, capacity constraints, rework loops, burnout, and delayed hiring. A resource collapse may not be caused by one extraction decision. It may emerge from cumulative depletion, delayed ecological response, and weak balancing feedback.

This is why system dynamics is often used for policy learning. It helps analysts move from reactive problem solving toward structural diagnosis. The goal is not only to respond to symptoms, but to understand the feedback architecture producing them.

Back to top ↑

Causal Loop Diagrams

Causal loop diagrams are often an early step in system dynamics modeling. They visually represent how components of a system influence one another through causal relationships and feedback loops. A causal loop diagram helps analysts identify circular causality before translating the system into a quantitative stock-and-flow model.

These diagrams usually distinguish between two types of feedback. Reinforcing loops amplify change. They can produce growth, decline, escalation, compounding advantage, or collapse. Balancing loops counteract change. They can produce stabilization, correction, resistance, or recovery.

Causal loop diagrams are useful because they make assumptions visible. They allow analysts, stakeholders, and decision-makers to discuss whether the proposed structure makes sense. They can reveal missing feedback, hidden delays, unintended consequences, and competing interpretations of the system.

However, causal loop diagrams are not full system dynamics models. They do not by themselves specify stocks, flows, units, equations, parameter values, or simulation behavior. A causal loop diagram can suggest a structure, but a stock-and-flow model is needed to test whether that structure can generate the behavior of interest.

Causal loop diagrams are best understood as a bridge between qualitative systems thinking and formal simulation. They clarify structure, but they must be translated carefully before quantitative claims are made.

Back to top ↑

Stocks and Flows

Stocks and flows are the core building blocks of system dynamics. A stock is an accumulation. A flow is a rate that changes an accumulation. Stocks are central because they give systems memory. They preserve the consequences of past inflows and outflows.

Examples of stocks include population, inventory, capital, atmospheric carbon, institutional trust, workforce capacity, disease prevalence, groundwater, infrastructure condition, and organizational knowledge. Examples of flows include births, deaths, investment, depreciation, emissions, sequestration, hiring, attrition, infection, recovery, extraction, replenishment, learning, and forgetting.

The stock-flow distinction prevents a common analytical error: confusing a level with a rate. A high emissions flow increases the atmospheric carbon stock. Reducing emissions slows the growth of the stock, but it does not immediately reduce accumulated concentration. Hiring increases staffing flow, but institutional capacity may recover slowly if knowledge has already been depleted. Maintenance spending may increase repair flow, but infrastructure condition may remain poor if deterioration has accumulated over many years.

System dynamics forces analysts to specify which accumulations matter, how they change, and how they feed back into the rest of the system. This is one of its greatest strengths.

Back to top ↑

Feedback Loops

Feedback loops are causal structures in which the consequences of an action eventually influence future actions or system conditions. In system dynamics, feedback is not an optional feature. It is the central mechanism by which systems generate behavior.

Reinforcing feedback amplifies change. More adoption can increase visibility, which increases adoption. More debt can increase interest burden, which increases debt. More mistrust can reduce cooperation, which produces worse outcomes, which increases mistrust.

Balancing feedback counteracts change. Rising inventory may reduce production orders. Rising temperature may activate cooling. Rising backlog may trigger hiring or process redesign. Rising prices may reduce demand. Balancing loops are often goal-seeking, but they can also produce instability if information is delayed or correction is too strong.

Most important systems contain multiple feedback loops operating at the same time. A growing city may have reinforcing loops of jobs, population, and investment while also facing balancing constraints from housing prices, congestion, land availability, infrastructure capacity, and environmental stress. An organization may have a reinforcing loop of demand growth and visibility but a balancing loop of capacity exhaustion and quality decline.

System dynamics models are often valuable because they reveal which feedback loops dominate under which conditions. The dominant loop may change over time, which is why simulation matters.

Back to top ↑

Time Delays

Time delays are among the most important causes of instability in dynamic systems. A delay separates action from consequence. It may delay information, recognition, decision-making, implementation, physical response, learning, recovery, or institutional adaptation.

In supply chains, delayed information can cause over-ordering and under-ordering cycles. In infrastructure, delayed maintenance can allow hidden deterioration to accumulate. In climate systems, delayed environmental response can make current stability misleading. In organizations, delayed burnout effects can make workload pressure appear productive until capacity collapses.

System dynamics treats delays explicitly because timing changes behavior. A balancing loop that would stabilize a system under immediate response may create oscillation when response is delayed. Decision-makers may continue corrective action after the system has already changed. They may overcorrect because they are responding to old information.

Ignoring delay is one of the fastest ways to misread a dynamic system. System dynamics makes delay visible and testable.

Back to top ↑

Nonlinearity and Policy Resistance

System dynamics models often include nonlinear relationships. A nonlinear relationship means that the effect is not proportional to the input. A system may respond weakly at first, strongly near a threshold, and weakly again after saturation. A policy may work under one condition and fail under another.

Policy resistance occurs when a system responds to intervention in a way that weakens, offsets, or reverses the intended effect. The intervention may treat a symptom while leaving the feedback structure intact. It may trigger an unintended balancing loop. It may shift burden elsewhere. It may improve short-term metrics while worsening long-term capacity.

For example, increasing work pressure may raise short-term output, but it can also increase rework, burnout, turnover, and knowledge loss. Expanding road capacity may reduce congestion temporarily but induce more demand. Suppressing fire in fire-adapted ecosystems may reduce immediate damage while increasing long-term fuel accumulation. Subsidizing extraction may support production while accelerating depletion.

System dynamics is especially valuable for policy analysis because it can test whether an intervention changes structure or merely pushes pressure around inside the same system.

Back to top ↑

Simulation and Policy Analysis

System dynamics models are frequently used to explore policy interventions, strategic choices, and long-term scenarios. Because the models are executable, analysts can ask how a system behaves under alternative assumptions before interventions are implemented in the real world.

Simulation is not the same as prediction. A system dynamics model does not need to claim that one future will happen. Its value often lies in exploring how different assumptions, structures, delays, and interventions produce different trajectories. This makes it useful for learning, stress testing, policy comparison, and identifying unintended consequences.

Policy-oriented system dynamics models may examine:

• how infrastructure investment affects backlog, reliability, and failure risk;
• how emissions policy affects cumulative atmospheric concentrations;
• how staffing policy affects service capacity, burnout, and care quality;
• how supply-chain ordering rules generate oscillation;
• how resource extraction interacts with regeneration and demand;
• how public trust influences compliance, service use, or cooperation;
• how intervention timing changes long-run outcomes.

System dynamics is therefore best used as a learning system, not as a black-box forecasting machine. It helps analysts reason more clearly about structure, assumptions, timing, and consequence.

Back to top ↑

Calibration, Validation, and Credibility

Because system dynamics models are abstractions, their usefulness depends on how carefully they are specified, calibrated, validated, and interpreted. A model may be technically elaborate but analytically weak if its boundary, feedback structure, delays, or parameter values are poorly justified.

Calibration involves selecting parameter values so model behavior aligns with observed data, known system characteristics, or plausible ranges. Validation evaluates whether the model is credible for its intended purpose. Validation does not prove that a model is true. It tests whether the model is useful, transparent, and appropriate for the question being asked.

System dynamics validation often includes structural validity as well as numerical fit. A model can reproduce historical data while misrepresenting causality. Conversely, an exploratory model may be useful for learning even if it is not calibrated for forecasting. The standard of credibility depends on purpose.

Model credibility is not only technical. It also depends on documentation, transparency, reproducibility, and responsible communication.

Back to top ↑

Software Tools for System Dynamics

Modern system dynamics work often uses specialized software environments that allow analysts to build stock-and-flow diagrams, define equations, run simulations, compare scenarios, visualize trajectories, and communicate models to stakeholders.

Common platforms include Vensim, Stella Architect, Stella Online, Powersim Studio, AnyLogic, Insight Maker, and other simulation environments. These tools vary in interface, licensing, integration, visualization, collaboration, and support for hybrid modeling.

Software can make model construction easier, but it does not replace modeling judgment. A polished stock-flow diagram can still encode weak assumptions. A dashboard can still hide uncertainty. A simulation can still be invalid for its intended purpose. The quality of a system dynamics model depends on structural clarity, evidence, testing, interpretation, and documentation.

The best tool depends on the purpose. A teaching model, stakeholder workshop model, policy analysis model, production-grade decision-support model, and research model may require different software choices.

Back to top ↑

Applications Across Complex Systems

System dynamics is used wherever behavior unfolds through feedback, accumulation, delay, and nonlinear response. Its strength is not domain specificity; it is structural reasoning. The same stock-flow and feedback logic can be adapted to many systems.

Across these domains, system dynamics helps explain why well-intended interventions can produce delayed or counterintuitive consequences.

Back to top ↑

Applications in Sustainability Science

System dynamics is especially important in sustainability science because sustainability problems involve accumulations, feedback loops, delays, constraints, and long time horizons. Climate change, biodiversity loss, resource depletion, food systems, water systems, infrastructure resilience, and energy transitions all require dynamic reasoning.

Climate systems illustrate the value of stock-flow reasoning. Emissions are flows. Atmospheric concentrations are stocks. Temperature response is delayed. Ecological and social consequences unfold unevenly over time. Policy action affects future flows but may not immediately reduce accumulated stocks.

Resource systems also fit the system dynamics framework. Extraction reduces resource stocks. Regeneration restores them. Demand, price, technology, governance, and social behavior influence flows. If extraction exceeds regeneration for long enough, the stock declines and may cross a threshold. Delayed recognition can produce collapse even when early indicators seem manageable.

Urban sustainability similarly depends on dynamic interaction. Population growth, housing supply, infrastructure capacity, transit investment, land use, emissions, and public finance form feedback loops. Short-term optimization can create long-term lock-in.

System dynamics does not solve sustainability problems by itself. It provides a structured way to examine the long-term consequences of choices made inside complex human-environment systems.

Back to top ↑

Mathematical Lens: Stocks, Flows, Feedback, and Delay

A stock in system dynamics is commonly represented as an accumulation:

In discrete-time simulation, the same idea can be represented as:

Reinforcing feedback occurs when an inflow depends positively on the current stock:

A balancing process may make outflow depend on the gap between current state and target:

A delay can be represented by basing the response on a past state:

A capacity-limited reinforcing process can be represented as:

These equations are simplified, but they illustrate the core logic of system dynamics: behavior emerges from accumulation, feedback, delay, and constraint.

Back to top ↑

Back to top ↑

Strengths and Limitations

System dynamics has major strengths. It is strong for representing feedback, accumulation, delay, nonlinear response, policy resistance, and long-term behavior. It is interpretable enough to support communication while formal enough to support simulation. It helps analysts see why local decisions can generate system-wide patterns.

At the same time, system dynamics has limitations. It often works at an aggregate level. It may not represent individual heterogeneity as richly as agent-based modeling. It may not represent topology as explicitly as network modeling. It may not represent operational event sequences as naturally as discrete-event simulation. It may also become misleading if the model boundary, structure, or parameter values are weak.

System dynamics is best understood as a disciplined method for learning about system structure under uncertainty. It is not a substitute for evidence, judgment, or accountability.

Back to top ↑

Python Workflow: Delay-Driven Overshoot, Correction, and Sensitivity

The Python workflow below uses only the standard library. It simulates a stock with capacity-limited reinforcing growth, delayed balancing feedback, threshold-sensitive correction, a discrete shock, scenario comparison, validation checks, and sensitivity analysis.

# system_dynamics_modeling_workflow.py
# Dependency-light system dynamics workflow:
# stocks, flows, feedback, delay, threshold correction, scenarios, and sensitivity.
#
# Suggested repository placement:
# articles/system-dynamics-modeling/python/system_dynamics_modeling_workflow.py

from __future__ import annotations

from dataclasses import dataclass, replace
from pathlib import Path
import csv
from statistics import mean


ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"


@dataclass(frozen=True)
class Scenario:
    name: str
    growth_rate: float
    balancing_strength: float
    target: float
    delay: int
    capacity: float
    threshold: float
    threshold_correction: float
    shock_time: int
    shock_size: float
    periods: int = 160


def clamp(value: float, low: float = 0.0, high: float = 250.0) -> float:
    return max(low, min(high, value))


def simulate(scenario: Scenario) -> list[dict[str, object]]:
    stock = [20.0]
    rows: list[dict[str, object]] = []

    for time in range(scenario.periods + 1):
        current = stock[-1]
        delayed_index = max(0, len(stock) - 1 - scenario.delay)
        delayed_stock = stock[delayed_index]

        inflow = scenario.growth_rate * current * (1.0 - current / scenario.capacity)
        outflow = scenario.balancing_strength * max(delayed_stock - scenario.target, 0.0)

        threshold_penalty = 0.0
        if current >= scenario.threshold:
            threshold_penalty = scenario.threshold_correction * (current - scenario.threshold)

        shock = scenario.shock_size if time == scenario.shock_time else 0.0
        next_stock = clamp(current + inflow - outflow - threshold_penalty + shock)

        rows.append({
            "scenario": scenario.name,
            "time": time,
            "stock": round(current, 6),
            "delayed_stock": round(delayed_stock, 6),
            "inflow": round(inflow, 6),
            "outflow": round(outflow, 6),
            "threshold_penalty": round(threshold_penalty, 6),
            "shock": round(shock, 6),
            "next_stock": round(next_stock, 6),
        })

        stock.append(next_stock)

    return rows


def summarize(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    output: list[dict[str, object]] = []

    for scenario in sorted(set(str(row["scenario"]) for row in rows)):
        subset = [row for row in rows if row["scenario"] == scenario]
        stocks = [float(row["stock"]) for row in subset]
        inflows = [float(row["inflow"]) for row in subset]
        outflows = [float(row["outflow"]) for row in subset]
        penalties = [float(row["threshold_penalty"]) for row in subset]

        maximum_stock = max(stocks)
        minimum_stock = min(stocks)
        final_stock = stocks[-1]
        time_to_peak = int(subset[stocks.index(maximum_stock)]["time"])

        if maximum_stock > 125:
            diagnostic = "large overshoot from reinforcing growth and delayed correction"
        elif sum(1 for value in penalties if value > 0) > 45:
            diagnostic = "persistent nonlinear threshold pressure"
        elif max(outflows) > max(inflows):
            diagnostic = "balancing feedback eventually dominates reinforcing inflow"
        else:
            diagnostic = "contained trajectory under current assumptions"

        output.append({
            "scenario": scenario,
            "minimum_stock": round(minimum_stock, 6),
            "maximum_stock": round(maximum_stock, 6),
            "final_stock": round(final_stock, 6),
            "average_stock": round(mean(stocks), 6),
            "time_to_peak": time_to_peak,
            "maximum_inflow": round(max(inflows), 6),
            "maximum_outflow": round(max(outflows), 6),
            "threshold_active_periods": sum(1 for value in penalties if value > 0),
            "diagnostic": diagnostic,
        })

    return output


def sensitivity(base: Scenario) -> list[dict[str, object]]:
    parameters = [
        ("growth_rate", 0.01),
        ("balancing_strength", 0.01),
        ("target", 5.0),
        ("delay", 2),
        ("capacity", 10.0),
        ("threshold", 5.0),
        ("threshold_correction", 0.01),
        ("shock_size", 5.0),
    ]

    base_summary = summarize(simulate(base))[0]
    base_peak = float(base_summary["maximum_stock"])

    rows: list[dict[str, object]] = []

    for parameter, delta in parameters:
        current = getattr(base, parameter)

        for direction in [-1, 1]:
            if parameter == "delay":
                revised_value = max(0, int(current + direction * delta))
            else:
                revised_value = max(0.0, float(current) + direction * float(delta))

            revised = replace(base, name=f"{base.name}_{parameter}_{direction}", **{parameter: revised_value})
            revised_summary = summarize(simulate(revised))[0]
            revised_peak = float(revised_summary["maximum_stock"])

            rows.append({
                "parameter": parameter,
                "direction": direction,
                "base_value": current,
                "revised_value": revised_value,
                "base_peak_stock": round(base_peak, 6),
                "revised_peak_stock": round(revised_peak, 6),
                "peak_change": round(revised_peak - base_peak, 6),
                "absolute_peak_change": round(abs(revised_peak - base_peak), 6),
            })

    return sorted(rows, key=lambda row: float(row["absolute_peak_change"]), reverse=True)


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows to write: {path}")

    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def main() -> None:
    baseline = Scenario(
        name="baseline_system_dynamics",
        growth_rate=0.09,
        balancing_strength=0.055,
        target=62.0,
        delay=7,
        capacity=100.0,
        threshold=82.0,
        threshold_correction=0.04,
        shock_time=95,
        shock_size=-10.0,
    )

    scenarios = [
        baseline,
        replace(baseline, name="short_delay", delay=2),
        replace(baseline, name="long_delay", delay=14),
        replace(baseline, name="weak_balancing", balancing_strength=0.025),
        replace(baseline, name="strong_balancing", balancing_strength=0.090),
        replace(baseline, name="lower_capacity", capacity=75.0),
        replace(baseline, name="strong_threshold_correction", threshold_correction=0.090),
    ]

    rows: list[dict[str, object]] = []
    for scenario in scenarios:
        rows.extend(simulate(scenario))

    write_csv(TABLES / "python_system_dynamics_timeseries.csv", rows)
    write_csv(TABLES / "python_system_dynamics_summary.csv", summarize(rows))
    write_csv(TABLES / "python_system_dynamics_sensitivity.csv", sensitivity(baseline))

    print("System dynamics modeling workflow complete.")
    print(TABLES / "python_system_dynamics_summary.csv")


if __name__ == "__main__":
    main()

This workflow demonstrates why system dynamics modeling is useful. The initial stock is the same across scenarios, but changing feedback strength, delay length, capacity, and threshold correction changes the system trajectory. The model makes those structural consequences visible.

Back to top ↑

R Workflow: Stock-and-Flow Dynamics with Feedback Diagnostics

The R workflow below uses base R. It simulates stock-and-flow dynamics with reinforcing inflow, delayed balancing outflow, threshold correction, scenario comparison, and reproducible output tables and figures.

# system_dynamics_modeling_diagnostics.R
# Base R workflow:
# stock-flow dynamics, feedback, delay, thresholds, and scenario diagnostics.
#
# Suggested repository placement:
# articles/system-dynamics-modeling/r/system_dynamics_modeling_diagnostics.R

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- normalizePath(getwd(), mustWork = TRUE)
}

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")

dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

simulate_sd <- function(
  scenario,
  growth_rate = 0.09,
  balancing_strength = 0.055,
  target = 62,
  delay = 7,
  capacity = 100,
  threshold = 82,
  threshold_correction = 0.04,
  shock_time = 95,
  shock_size = -10,
  periods = 160
) {
  time <- 0:periods
  stock <- numeric(length(time))
  delayed_stock <- numeric(length(time))
  inflow <- numeric(length(time))
  outflow <- numeric(length(time))
  threshold_penalty <- numeric(length(time))
  shock <- numeric(length(time))

  stock[1] <- 20

  for (t in 2:length(time)) {
    delayed_index <- max(1, t - delay)
    delayed_stock[t] <- stock[delayed_index]

    inflow[t] <- growth_rate * stock[t - 1] * (1 - stock[t - 1] / capacity)
    outflow[t] <- balancing_strength * max(delayed_stock[t] - target, 0)

    if (stock[t - 1] >= threshold) {
      threshold_penalty[t] <- threshold_correction * (stock[t - 1] - threshold)
    }

    if ((t - 1) == shock_time) {
      shock[t] <- shock_size
    }

    stock[t] <- max(0, min(250, stock[t - 1] + inflow[t] - outflow[t] - threshold_penalty[t] + shock[t]))
  }

  data.frame(
    scenario = scenario,
    time = time,
    stock = stock,
    delayed_stock = delayed_stock,
    inflow = inflow,
    outflow = outflow,
    threshold_penalty = threshold_penalty,
    shock = shock
  )
}

data <- rbind(
  simulate_sd("baseline_system_dynamics"),
  simulate_sd("short_delay", delay = 2),
  simulate_sd("long_delay", delay = 14),
  simulate_sd("weak_balancing", balancing_strength = 0.025),
  simulate_sd("strong_balancing", balancing_strength = 0.090),
  simulate_sd("lower_capacity", capacity = 75),
  simulate_sd("strong_threshold_correction", threshold_correction = 0.090)
)

scenario_names <- unique(data$scenario)
summary_rows <- data.frame()

for (scenario_name in scenario_names) {
  subset_data <- data[data$scenario == scenario_name, ]

  maximum_stock <- max(subset_data$stock)
  minimum_stock <- min(subset_data$stock)
  final_stock <- tail(subset_data$stock, 1)
  average_stock <- mean(subset_data$stock)
  time_to_peak <- subset_data$time[which.max(subset_data$stock)]
  threshold_active_periods <- sum(subset_data$threshold_penalty > 0)
  maximum_inflow <- max(subset_data$inflow)
  maximum_outflow <- max(subset_data$outflow)

  diagnostic <- ifelse(
    maximum_stock > 125,
    "large overshoot from reinforcing growth and delayed correction",
    ifelse(
      threshold_active_periods > 45,
      "persistent nonlinear threshold pressure",
      ifelse(
        maximum_outflow > maximum_inflow,
        "balancing feedback eventually dominates reinforcing inflow",
        "contained trajectory under current assumptions"
      )
    )
  )

  summary_rows <- rbind(summary_rows, data.frame(
    scenario = scenario_name,
    minimum_stock = minimum_stock,
    maximum_stock = maximum_stock,
    final_stock = final_stock,
    average_stock = average_stock,
    time_to_peak = time_to_peak,
    maximum_inflow = maximum_inflow,
    maximum_outflow = maximum_outflow,
    threshold_active_periods = threshold_active_periods,
    diagnostic = diagnostic
  ))
}

write.csv(data, file.path(tables_dir, "r_system_dynamics_timeseries.csv"), row.names = FALSE)
write.csv(summary_rows, file.path(tables_dir, "r_system_dynamics_summary.csv"), row.names = FALSE)

png(file.path(figures_dir, "r_system_dynamics_stock_trajectories.png"), width = 1200, height = 700)
plot(
  NA,
  xlim = range(data$time),
  ylim = range(data$stock),
  xlab = "Time",
  ylab = "Stock",
  main = "System Dynamics Stock Trajectories Across Scenarios"
)

for (scenario_name in scenario_names) {
  subset_data <- data[data$scenario == scenario_name, ]
  lines(subset_data$time, subset_data$stock, lwd = 2)
}

legend("topright", legend = scenario_names, lwd = 2, bty = "n", cex = 0.75)
grid()
dev.off()

png(file.path(figures_dir, "r_system_dynamics_feedback_components.png"), width = 1200, height = 700)
baseline <- data[data$scenario == "baseline_system_dynamics", ]

plot(
  baseline$time,
  baseline$stock,
  type = "l",
  lwd = 2,
  ylim = range(c(baseline$stock, baseline$inflow, baseline$outflow, baseline$threshold_penalty)),
  xlab = "Time",
  ylab = "Value",
  main = "Feedback Components in Baseline System Dynamics Scenario"
)
lines(baseline$time, baseline$inflow, lty = 2, lwd = 2)
lines(baseline$time, baseline$outflow, lty = 3, lwd = 2)
lines(baseline$time, baseline$threshold_penalty, lty = 4, lwd = 2)
legend(
  "topright",
  legend = c("Stock", "Inflow", "Outflow", "Threshold penalty"),
  lty = c(1, 2, 3, 4),
  lwd = 2,
  bty = "n"
)
grid()
dev.off()

print(summary_rows)
cat("R system dynamics diagnostics complete.\n")

This workflow reinforces the central system dynamics claim: behavior depends on structure. The same initial state can produce different trajectories when feedback strength, delay, capacity, and nonlinear correction change.

Back to top ↑

GitHub Repository

Back to top ↑

Ethics and Responsible Use

System dynamics models can influence policy, investment, management, and public reasoning. This gives them ethical significance. A model can clarify long-term risk, but it can also hide assumptions, exclude affected groups, or create false confidence.

Boundary choices matter. A model of transportation performance that optimizes vehicle speed may ignore emissions, safety, disability access, displacement, and public health. A model of health-system capacity may include hospital beds while excluding trust, access, labor conditions, or community vulnerability. A model of organizational productivity may include output while excluding burnout and institutional knowledge loss.

Responsible system dynamics modeling requires transparency about purpose, assumptions, boundaries, parameters, data sources, uncertainty, validation, and appropriate use. It also requires humility: a model is a structured representation, not the system itself.

A good system dynamics model should improve the quality of judgment. It should not replace judgment with technical authority.

Back to top ↑

Common Pitfalls

System dynamics is powerful, but it is easy to misuse. The most common errors involve weak boundaries, vague variables, missing stocks, hidden delays, overconfident calibration, and overclaiming predictive precision.

The strongest system dynamics models are not necessarily the largest. They are the ones whose structure fits the question, whose assumptions are clear, whose behavior is tested, and whose limits are communicated responsibly.

Back to top ↑

Conclusion

System dynamics modeling remains one of the most important methods in systems analysis because it shows how structure generates behavior across time. By representing stocks, flows, feedback loops, delays, nonlinear relationships, and decision rules explicitly, it helps analysts understand why systems grow, stabilize, oscillate, overshoot, resist intervention, or collapse.

Its value lies not only in simulation, but in disciplined structural reasoning. System dynamics asks what accumulates, what changes it, what feeds back, what is delayed, what is constrained, and what behavior those structures produce. This makes it especially useful for long-horizon problems in sustainability, public policy, infrastructure, organizations, supply chains, health systems, energy transitions, and ecological governance.

System dynamics does not eliminate uncertainty. It makes uncertainty, assumptions, and structure visible enough to examine. Used responsibly, it becomes a learning tool: a way to test assumptions, compare scenarios, reveal unintended consequences, and improve judgment under complexity.

Back to top ↑

Related Articles

• What Is Systems Modeling?
• Systems Thinking vs Systems Modeling
• Why Complex Systems Require Models
• The History of Systems Modeling
• Core Principles of Systems Modeling
• Agent-Based Modeling
• Network Models
• Scenario Modeling and Simulation
• Calibration and Validation of Models

Further Reading

• MIT Sloan System Dynamics Group. About Us. Available at: MIT Sloan System Dynamics Group.
• MIT Sloan. System Dynamics PhD Program. Available at: MIT Sloan System Dynamics PhD.
• System Dynamics Society. What is System Dynamics? Available at: System Dynamics Society.
• System Dynamics Society. Origin of System Dynamics. Available at: System Dynamics Society.
• Ventana Systems. Vensim. Available at: Vensim.
• isee systems. Stella Architect. Available at: Stella Architect.
• Powersim. Powersim Studio. Available at: Powersim Studio.
• AnyLogic. System Dynamics Simulation. Available at: AnyLogic System Dynamics.
• Insight Maker. Build Simulations and Models. Available at: Insight Maker.
• Club of Rome. The Limits to Growth. Available at: Club of Rome.
• Santa Fe Institute. What is Complex Systems Science? Available at: Santa Fe Institute.
• Forrester, J.W. (1961) Industrial Dynamics. Cambridge, MA: MIT Press.
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green Publishing.
• Richardson, G.P. (1991) Feedback Thought in Social Science and Systems Theory. Philadelphia: University of Pennsylvania Press.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.

Back to top ↑

References

• AnyLogic. (n.d.) System Dynamics Simulation. Available at: https://www.anylogic.com/use-of-simulation/system-dynamics/.
• Club of Rome. (n.d.) The Limits to Growth. Available at: https://www.clubofrome.org/publication/the-limits-to-growth/.
• Forrester, J.W. (1961) Industrial Dynamics. Cambridge, MA: MIT Press.
• Insight Maker. (n.d.) Build Simulations and Models. Available at: https://insightmaker.com/.
• isee systems. (n.d.) Stella Architect. Available at: https://www.iseesystems.com/store/products/stella-architect.aspx.
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green Publishing.
• MIT Sloan. (n.d.) System Dynamics PhD Program. Available at: https://mitsloan.mit.edu/programs/phd/system-dynamics.
• MIT Sloan System Dynamics Group. (n.d.) About Us. Available at: https://mitsloan.mit.edu/faculty/academic-groups/system-dynamics/about-us.
• Powersim. (n.d.) Powersim Studio. Available at: https://powersim.com/powersim-studio/.
• Richardson, G.P. (1991) Feedback Thought in Social Science and Systems Theory. Philadelphia: University of Pennsylvania Press.
• Santa Fe Institute. (n.d.) What is Complex Systems Science?. Available at: https://www.santafe.edu/what-is-complex-systems-science.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.
• System Dynamics Society. (n.d.) Origin of System Dynamics. Available at: https://systemdynamics.org/origin-of-system-dynamics/.
• System Dynamics Society. (n.d.) What is System Dynamics?. Available at: https://systemdynamics.org/what-is-system-dynamics/.
• Ventana Systems. (n.d.) Vensim. Available at: https://vensim.com/.

Back to top ↑