Stocks, Flows, and the Architecture of Change

Last Updated June 1, 2026

Stocks and flows are the architecture of change in systems thinking. A stock is something that accumulates or depletes over time: trust, debt, carbon, knowledge, fatigue, biodiversity, maintenance backlog, institutional capacity, groundwater, public legitimacy, or social cohesion. A flow is the rate that changes the stock: hiring and turnover, emissions and absorption, learning and forgetting, investment and depreciation, repair and deterioration, inflow and outflow, formation and erosion. To understand system behavior, it is not enough to know what exists. We need to know what accumulates, what drains away, how quickly it changes, and what feedback controls the flows.

Stocks and flows explain why systems often behave slowly, suddenly, unevenly, or counterintuitively. A system may look stable while a stock is quietly eroding. A crisis may appear sudden even though the underlying accumulation has been building for years. A policy may improve a flow without repairing a damaged stock. A temporary intervention may reduce pressure without changing the deeper architecture of accumulation. Stock-flow thinking helps analysts distinguish symptoms from structure, events from trajectories, and surface activity from durable system change.

This article examines stocks and flows as the structural architecture beneath system behavior. It explains how accumulations form, why flows matter, how delays and feedback shape stock change, why hidden stocks often produce late-visible crises, and how interventions fail when they target flows without repairing stocks. It also examines the ethical stakes of stock-flow thinking: who accumulates advantage, who accumulates harm, what burdens are allowed to build invisibly, and how long-term responsibility requires attention to what systems store, deplete, regenerate, and pass forward.

Why Stocks and Flows Matter

Stocks and flows matter because they explain how systems remember. A system’s current condition is rarely produced only by current events. It is shaped by what has accumulated, what has been depleted, what has been stored, and what has been neglected over time. Trust reflects accumulated experience. Debt reflects accumulated borrowing and interest. Carbon concentration reflects accumulated emissions and absorption. Maintenance backlog reflects accumulated deterioration and under-repair. Institutional capacity reflects accumulated staffing, knowledge, tools, authority, and legitimacy.

Without stock-flow thinking, analysts often misread systems. They focus on visible events or current rates while ignoring the accumulated condition beneath them. A service delay may be treated as a current workflow issue, but it may reflect years of staffing loss, knowledge erosion, rising demand, technology debt, and public distrust. A flood may be treated as an isolated weather event, but it may reflect accumulated land-use change, drainage neglect, wetland loss, climate risk, and infrastructure exposure. A legitimacy crisis may be treated as a reaction to one scandal, but it may reflect accumulated institutional failure.

Stocks and flows help answer systems questions:

• What has accumulated?
• What has been depleted?
• What inflows are increasing the stock?
• What outflows are reducing it?
• How fast is the stock changing?
• What feedback controls the flows?
• What delays hide the change?
• What stock must be repaired for durable change?

Stock-flow thinking changes the analyst’s attention. Instead of asking only what happened, it asks what condition made the event possible. Instead of asking only how to increase activity, it asks whether the activity is building or depleting the stocks that sustain the system.

Back to top ↑

What Is a Stock?

A stock is an accumulated quantity at a point in time. It is something that can build up, drain down, be stored, be depleted, or persist after the flows that created it have changed. Stocks give systems memory because they carry the effects of past flows into the present.

Some stocks are physical: water in a reservoir, carbon in the atmosphere, inventory in a warehouse, buildings in a city, people in a population, soil organic matter, energy stored in a battery, money in an account, or vehicles on a road. Other stocks are social, institutional, cognitive, or ecological: public trust, organizational knowledge, workforce fatigue, policy legitimacy, maintenance backlog, student learning, biodiversity, social cohesion, technical debt, or community resilience.

The key feature of a stock is accumulation. A stock is not merely a condition. It is a condition shaped by inflows and outflows over time. Trust accumulates through reliable behavior and drains through betrayal, neglect, or harm. Workforce capacity accumulates through hiring, training, retention, and experience; it drains through turnover, burnout, retirement, and knowledge loss. A maintenance backlog accumulates through deterioration and deferred repair; it drains through completed maintenance and renewal.

Stocks are often harder to see than flows. We may see workers leaving, but not immediately see the loss of institutional memory. We may see emissions, but not directly experience atmospheric accumulation. We may see service complaints, but not the deeper erosion of trust. We may see road repairs, but not the total maintenance backlog. Because stocks can be hidden, systems can deteriorate quietly before failure becomes visible.

Stocks matter because they shape what the system can do next. A high-trust institution can ask for cooperation more easily than a low-trust one. A healthy ecosystem can absorb disturbance better than a degraded one. A well-maintained infrastructure system can handle stress better than one with hidden backlog. A workforce with capacity and memory can adapt better than one that has been depleted.

A stock is the present condition created by past flows. To change the system, we must understand the stock.

Back to top ↑

What Is a Flow?

A flow is a rate of change that increases or decreases a stock. Inflows add to a stock. Outflows subtract from it. Flows are measured over time: people per month, dollars per year, tons per day, cases per week, emissions per year, repairs per quarter, resignations per month, learning hours per semester, or species lost per decade.

Flows are the movement through which system change occurs. They are often easier to observe than stocks because they appear as activity. Hiring, spending, emitting, producing, repairing, learning, forgetting, enrolling, graduating, joining, leaving, investing, extracting, saving, and consuming are flows. But flow activity can be misleading unless connected to the stock it changes.

A large inflow does not necessarily mean a stock is growing if the outflow is larger. A city can build housing and still face a housing shortage if population growth, displacement, speculation, or loss of affordable units outpaces construction. An organization can hire and still lose capacity if turnover, burnout, and knowledge loss exceed onboarding. A restoration project can plant trees and still lose forest cover if clearing and mortality exceed regeneration.

Flows can be controlled by feedback. A high backlog may increase pressure to process cases. High failure risk may increase maintenance spending. Low trust may reduce cooperation. High demand may increase investment. High debt may increase interest burden. These feedback relationships regulate the rates that change stocks.

Flows can also be delayed. Training may not immediately increase capacity. Emissions may not immediately produce full climate impact. Restoration may not immediately rebuild biodiversity. Policy reform may not immediately rebuild trust. A flow may begin now while its effect on the stock becomes visible later.

Flows are important because interventions often target them. Increase hiring. Reduce emissions. Accelerate processing. Expand training. Increase maintenance. Decrease withdrawals. But flow interventions must be evaluated by their effect on the stock. More activity is not the same as structural change. The question is whether the flow changes the accumulated condition in the desired direction at the necessary scale and time horizon.

Back to top ↑

Stocks, Flows, and the Architecture of Change

Stocks and flows form the architecture of change because they define what can change quickly, what changes slowly, what persists, what accumulates, and what resists intervention. A system’s structure is not only its visible parts. It includes the accumulations that hold past behavior in place and the flows that alter those accumulations over time.

Stocks create inertia. A large stock changes slowly unless flows are large enough to move it. This is why some systems do not respond quickly to policy. A school system cannot instantly rebuild learning gaps that accumulated over years. A city cannot quickly eliminate infrastructure backlog after decades of deferred maintenance. A public institution cannot immediately restore trust after repeated failure. An ecosystem cannot instantly rebuild soil, biodiversity, or hydrological stability after long degradation.

Flows create movement. They are the pathways through which change enters the system. But flows must be sustained and scaled relative to the stock. A small flow into a large depleted stock may be symbolically important but structurally insufficient. A temporary flow may create short-term improvement without durable change. A flow aimed at the wrong stock may produce activity without transformation.

The architecture of change becomes visible when we ask what must accumulate differently. If a public agency wants better access, it may need to reduce administrative burden, increase staffing capacity, rebuild trust, improve data quality, and reduce backlog. If an organization wants sustainable performance, it may need to build workforce capacity, reduce fatigue, improve coordination, and preserve institutional memory. If a city wants resilience, it may need to rebuild ecological buffers, infrastructure condition, social trust, and emergency preparedness.

Systems change often fails when it mistakes a flow adjustment for stock repair. Increasing communication does not automatically rebuild trust. Adding a dashboard does not automatically improve data quality. Increasing output does not automatically increase capacity. Funding a pilot does not automatically change institutional structure. Announcing a reform does not automatically repair legitimacy. The stock must actually change.

Stock-flow architecture asks:

• What stock must change for the system to behave differently?
• What flows increase that stock?
• What flows decrease it?
• Are the flows large enough relative to the stock?
• How long will change take?
• What feedback controls the flows?
• What delays may hide progress or harm?
• What must be protected from depletion?

To understand change, do not begin only with action. Begin with accumulation.

Back to top ↑

Accumulation, Depletion, and Hidden Change

Accumulation and depletion explain why systems often surprise people. A stock can change slowly beneath the surface until a threshold is crossed. The visible event appears sudden, but the accumulated condition has been changing for a long time.

Maintenance backlog is a clear example. Roads, pipes, bridges, grids, and buildings can deteriorate gradually while remaining functional. If repair flows are smaller than deterioration flows, backlog accumulates. The system may appear stable until failure frequency rises, emergency costs increase, or a major asset fails. The event is sudden; the depletion was gradual.

Trust behaves similarly. An institution may lose trust through repeated delays, unkept promises, exclusion, opacity, or harm. The decline may not be visible in official metrics until a crisis triggers public reaction. The crisis is treated as the cause, but the stock of trust had already been depleted.

Workforce fatigue also accumulates. People can absorb pressure temporarily. Output may remain high for a while. But if recovery is insufficient, fatigue accumulates as a stock. Eventually errors, conflict, disengagement, absenteeism, or turnover rise. The organization may blame the final resignation wave rather than the long depletion of human capacity.

Hidden accumulation can be harmful or beneficial. A community can quietly build resilience through mutual aid, local knowledge, trust, and preparedness. A student can accumulate skill through practice before visible achievement appears. An ecosystem can regenerate slowly before recovery becomes obvious. A public institution can rebuild legitimacy through repeated reliable action before trust metrics improve.

The problem is that institutions often measure visible flows more easily than hidden stocks. They track cases processed, dollars spent, messages sent, hours worked, policies passed, or projects completed. These measures may matter, but they do not necessarily show whether trust, capacity, resilience, knowledge, legitimacy, or ecological health is improving.

Stock-flow analysis asks what is changing even when events appear stable. It is a way to see slow violence, slow repair, slow learning, slow collapse, and slow renewal before they become visible as dramatic events.

Back to top ↑

Inflows, Outflows, and Net Change

A stock changes through the balance between inflows and outflows. This seems simple, but it is one of the most frequently misunderstood principles in systems thinking. People often focus on one flow and ignore the other. They celebrate hiring while ignoring turnover. They count housing construction while ignoring displacement or loss of affordable units. They report emissions reductions while ignoring cumulative concentration. They increase training while ignoring knowledge loss through attrition.

Net change is the difference between what enters and what leaves. If inflow exceeds outflow, the stock grows. If outflow exceeds inflow, the stock shrinks. If inflow equals outflow, the stock remains stable, even though there may be much activity.

This principle explains why activity can be misleading. A school may invest in student support, but if stress, instability, exclusion, and absenteeism outflow learning faster than support builds it, learning gaps persist. An organization may hire aggressively, but if burnout and turnover remain high, capacity does not grow. A government may fund maintenance, but if deterioration and climate stress exceed repair, backlog continues to rise.

Stock-flow analysis therefore asks both sides of the equation:

• What is entering the stock?
• What is leaving the stock?
• Which flow is larger?
• How do the flows change over time?
• What feedback increases or decreases each flow?
• Are we measuring gross activity or net change?
• Are we treating a flow increase as success without confirming stock improvement?

The central lesson is that flows must be interpreted together. A system can be busy and still deteriorating. It can invest and still lose capacity. It can repair and still accumulate backlog. It can communicate and still lose trust. Stock-flow thinking asks whether the net movement is actually changing the condition that matters.

Back to top ↑

How Feedback Controls Flows

Flows are often controlled by feedback loops. A stock changes, and that change affects the flows that increase or decrease the stock. This is where stock-flow thinking connects directly to causal loop diagrams and system behavior.

Consider maintenance backlog. As backlog grows, failure risk increases. More failures create political pressure and emergency repairs. Emergency repairs may reduce some immediate failures, but they can also consume funds that might have gone to preventive maintenance. If preventive maintenance declines, backlog grows further. The stock is backlog. The flows are deterioration, deferred repair, preventive maintenance, and emergency repair. Feedback controls the rates.

Consider public trust. Trust affects cooperation. Cooperation affects program performance. Performance affects trust. Trust is a stock. Cooperation and institutional performance shape the inflows and outflows of trust. Repeated reliable performance builds trust. Repeated harm drains it. The stock changes through experience over time.

Feedback can create reinforcing accumulation. The more skill someone has, the easier it may be to learn related skills, increasing the inflow of knowledge. The more wealth a household has, the easier it may be to access investment, education, housing, and healthcare, increasing future wealth. The more trust an institution has, the easier it may be to gain cooperation, improving performance and building more trust.

Feedback can also create reinforcing depletion. The more debt a household carries, the more interest burden may accumulate, increasing future debt. The more backlog an agency has, the more delays and errors may increase rework, increasing backlog further. The more fatigue workers carry, the more errors, rework, and turnover may reduce capacity, increasing workload and fatigue.

Balancing feedback can regulate stocks. High inventory may reduce ordering. Low staffing may increase hiring pressure. Rising risk may increase preventive action. Declining groundwater may trigger water-use restrictions. But balancing feedback works only if signals are accurate, timely, legitimate, and connected to action.

Stock-flow thinking asks not only what the stock is, but what feedback governs the flows. The architecture of change is dynamic because stocks and flows influence one another.

Back to top ↑

Delay, Inertia, and Late Visibility

Stocks create delay and inertia. A large stock usually does not change instantly. Even if inflows or outflows change today, the stock may respond slowly. This is why systems often resist quick interpretation. A policy may change a flow before the stock visibly changes. A harmful practice may continue draining a stock before damage becomes undeniable. A repair effort may take time before recovery is visible.

Atmospheric carbon is the classic example. Annual emissions are flows. Atmospheric concentration is a stock. Reducing emissions slows the growth of the stock, but does not immediately remove the accumulated carbon. Climate effects are shaped by accumulated concentration, not only current emissions. This is why flow reductions are essential but not identical to stock repair.

Trust works similarly. A public institution can improve communication immediately, but trust may recover slowly because the stock reflects accumulated experience. A single apology does not erase years of harm. Repeated reliable action must create inflows of trust that exceed ongoing outflows of distrust.

Workforce capacity also changes slowly. Hiring is a flow, but new staff require onboarding, training, experience, relationships, and institutional knowledge. Capacity does not rise the moment a position is filled. If experienced people continue leaving, the stock of capacity may keep declining despite hiring activity.

Delay creates several interpretive risks:

• assuming a policy has failed because the stock has not changed yet;
• assuming a system is healthy because the stock has not visibly collapsed yet;
• mistaking a flow improvement for stock recovery;
• continuing harmful behavior because stock depletion is delayed;
• abandoning beneficial repair because recovery is slow;
• overcorrecting when delayed signals finally appear.

Stocks make time visible. They force analysts to ask how long recovery should take, how much accumulated damage exists, and whether current flows are sufficient to change the stock before further harm occurs. A system that ignores stock delay will often misjudge both danger and progress.

Back to top ↑

Why Policy Often Misreads Stocks and Flows

Policy often misreads stocks and flows because institutions are drawn to visible activity. A policy can fund programs, issue rules, process cases, send communications, build units, publish dashboards, hire staff, or launch pilots. These activities are flows. They matter, but they are not the same as stock change.

A housing policy may count new construction while ignoring loss of affordable units. A public-health policy may count outreach messages while ignoring trust. A workforce policy may count training sessions while ignoring job quality, burnout, and retention. A climate policy may count annual emissions reductions while ignoring cumulative concentration. An infrastructure policy may count annual repair spending while ignoring total backlog and asset condition.

Policy failure often occurs when the wrong stock is targeted or when flows are too weak to change the stock. If the stock is public trust, communication alone may not be enough; reliable service, accountability, and repair may be required. If the stock is maintenance backlog, one-time funding may not be enough; ongoing preventive maintenance must exceed deterioration. If the stock is workforce capacity, hiring without retention and recovery may fail. If the stock is ecological resilience, restoration must exceed ongoing degradation.

Policy systems also misread stocks because evaluation windows are short. A stock may take years to change. A prevention policy may look expensive before avoided harm becomes visible. A repair policy may appear ineffective before the depleted stock recovers. A harmful policy may look successful before delayed stock depletion appears.

Better policy begins by naming the stock that must change. Then it designs flows that are large enough, sustained enough, and legitimate enough to change that stock. It also tracks outflows that may be undoing the intervention.

Policy should not ask only, “What are we doing?” It should ask, “What are we accumulating or depleting?”

Back to top ↑

Ethics, Power, and Unequal Accumulation

Stocks and flows have ethical stakes because systems do not accumulate benefits and burdens equally. Wealth accumulates for some while debt accumulates for others. Trust accumulates in some institutions and erodes in others. Pollution accumulates in particular neighborhoods. Administrative burden accumulates for people with less power. Maintenance backlog accumulates in neglected communities. Climate risk accumulates across generations. Institutional knowledge accumulates in some organizations and is stripped from others through turnover, outsourcing, or austerity.

Stock-flow thinking makes inequality visible as accumulation. It shows that unequal outcomes are not only isolated events. They are produced by repeated flows over time. A neighborhood does not become underinvested in one moment. Disinvestment accumulates. A household does not become debt-burdened in one transaction. Debt, interest, income instability, healthcare costs, housing costs, and exclusion accumulate. A community does not lose trust in institutions from one interaction alone. Distrust often accumulates through repeated experience.

Power shapes which stocks are measured. Financial reserves may be tracked carefully. Worker fatigue may not. Infrastructure assets may be inventoried in some places and neglected in others. Carbon emissions may be counted within one boundary while outsourced emissions are excluded. Public agencies may track completed cases but not the stock of discouraged applicants. Platforms may track engagement but not accumulated distrust, misinformation exposure, or social harm.

Ethical stock-flow analysis asks:

• What benefits are accumulating?
• What harms are accumulating?
• Who receives the inflows?
• Who experiences the outflows?
• What stocks are measured, and what stocks are ignored?
• Which accumulations are treated as private success?
• Which depletions are externalized to workers, communities, ecosystems, or future generations?
• What repair flows are owed to depleted stocks?

Unequal accumulation is especially important in sustainability and governance. If one group accumulates wealth through extraction while another accumulates exposure, illness, displacement, debt, or ecological loss, the system is not merely inefficient. It is unjust. If present actors accumulate benefits while future generations inherit depleted ecological stocks, the system is temporally unjust.

Stock-flow thinking strengthens ethical analysis because it turns vague concerns about inequality into structural questions about accumulation, depletion, inflows, outflows, and responsibility. It asks not only who has what, but how they came to have it and what flows continue to reproduce the pattern.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Stock-flow modeling provides one of the strongest formal foundations for systems thinking. It helps analysts represent accumulation, depletion, delay, feedback, and intervention over time. A stock-flow model can be qualitative, visual, mathematical, computational, or simulation-based. The purpose is to clarify how system conditions change through inflows and outflows.

The core stock-flow equation is:

In continuous time, the same idea can be written as:

When feedback controls flows, the model becomes dynamic:

A stock with delayed perception can be represented as:

A policy intervention can be represented as a change in flows:

Stock-flow models should be interpreted with humility. They require assumptions about boundaries, measurements, rates, feedback, delays, and thresholds. A model may capture the arithmetic of accumulation while missing lived experience, power, history, or institutional constraint. Good modeling makes assumptions visible and invites revision. It does not replace judgment; it disciplines it.

Back to top ↑

Python Workflow: Stock, Flow, Accumulation, Delay, and Intervention Diagnostics

The Python workflow below turns stock-flow analysis into a small reproducible model. It compares four scenarios: activity without stock repair, inflow-focused reform, net-flow correction, and accountable stock repair. The script uses only the Python standard library, writes CSV outputs relative to the article folder, and is designed as a clear starting point for companion repository work.

# stock_flow_architecture_change_workflow.py
# Dependency-light workflow for stocks, flows, accumulation, depletion,
# delayed perception, feedback-controlled flows, and intervention scenarios.
# Writes outputs relative to the article root.

from __future__ import annotations

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

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


@dataclass
class StockFlowScenario:
    name: str
    initial_stock: float
    baseline_inflow: float
    baseline_outflow: float
    feedback_strength: float
    perception_delay: float
    repair_investment: float
    outflow_reduction: float
    measurement_quality: float
    accountability: float
    shock_pressure: float


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


def run_scenario(scenario: StockFlowScenario, periods: int = 60) -> list[dict[str, object]]:
    stock = scenario.initial_stock
    desired_stock = 72.0
    perceived_stock = stock * (0.65 + scenario.measurement_quality * 0.20)
    hidden_depletion = max(0.0, desired_stock - stock)
    system_capacity = 30.0 + scenario.repair_investment * 32.0
    trust_or_legitimacy = 32.0 + scenario.accountability * 30.0
    stock_history: list[float] = [stock]
    rows: list[dict[str, object]] = []

    delay_steps = max(0, int(round(scenario.perception_delay * 10.0)))

    for period in range(periods + 1):
        delayed_index = max(0, len(stock_history) - 1 - delay_steps)
        delayed_stock = stock_history[delayed_index]

        perceived_stock = clamp(
            perceived_stock
            + scenario.measurement_quality * 0.22 * (delayed_stock - perceived_stock)
            + scenario.accountability * 0.04 * (stock - perceived_stock),
            0.0,
            140.0
        )

        stock_gap = desired_stock - stock
        perceived_gap = desired_stock - perceived_stock

        feedback_inflow = clamp(
            scenario.feedback_strength * max(0.0, perceived_gap) * 0.22
            + scenario.repair_investment * 18.0
            + scenario.accountability * 7.0
            + system_capacity * 0.06,
            0.0,
            100.0
        )

        inflow = clamp(
            scenario.baseline_inflow
            + feedback_inflow
            + scenario.repair_investment * 7.0,
            0.0,
            120.0
        )

        pressure_outflow = clamp(
            scenario.baseline_outflow
            + scenario.shock_pressure * 14.0
            + hidden_depletion * 0.10
            - scenario.outflow_reduction * 12.0
            - scenario.accountability * 4.0,
            0.0,
            120.0
        )

        outflow = clamp(
            pressure_outflow
            + max(0.0, 45.0 - trust_or_legitimacy) * 0.08
            - system_capacity * 0.04,
            0.0,
            120.0
        )

        net_flow = inflow - outflow

        stock = clamp(stock + net_flow * 0.16, 0.0, 140.0)

        hidden_depletion = clamp(
            max(0.0, desired_stock - stock)
            + scenario.perception_delay * 6.0
            + max(0.0, outflow - inflow) * 0.12,
            0.0,
            100.0
        )

        system_capacity = clamp(
            system_capacity
            + scenario.repair_investment * 1.8
            + scenario.accountability * 1.2
            - hidden_depletion * 0.04
            - scenario.shock_pressure * 0.7,
            0.0,
            100.0
        )

        trust_or_legitimacy = clamp(
            trust_or_legitimacy
            + scenario.accountability * 1.5
            + max(0.0, stock - desired_stock * 0.75) * 0.035
            - hidden_depletion * 0.05
            - max(0.0, outflow - inflow) * 0.04,
            0.0,
            100.0
        )

        false_progress_risk = clamp(
            max(0.0, perceived_stock - stock) * 0.30
            + scenario.perception_delay * 8.0
            + max(0.0, inflow - outflow) * 0.03
            - scenario.measurement_quality * 4.0
            - scenario.accountability * 3.0,
            0.0,
            100.0
        )

        stock_repair_score = clamp(
            stock * 0.30
            + system_capacity * 0.18
            + trust_or_legitimacy * 0.16
            + scenario.measurement_quality * 12.0
            + scenario.accountability * 12.0
            - hidden_depletion * 0.18
            - false_progress_risk * 0.12
            - max(0.0, outflow - inflow) * 0.10,
            0.0,
            100.0
        )

        rows.append({
            "period": period,
            "scenario": scenario.name,
            "stock": round(stock, 3),
            "perceived_stock": round(perceived_stock, 3),
            "delayed_stock": round(delayed_stock, 3),
            "desired_stock": round(desired_stock, 3),
            "inflow": round(inflow, 3),
            "outflow": round(outflow, 3),
            "net_flow": round(net_flow, 3),
            "hidden_depletion": round(hidden_depletion, 3),
            "system_capacity": round(system_capacity, 3),
            "trust_or_legitimacy": round(trust_or_legitimacy, 3),
            "false_progress_risk": round(false_progress_risk, 3),
            "stock_repair_score": round(stock_repair_score, 3),
        })

        stock_history.append(stock)

    return rows


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 summarize(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    output: list[dict[str, object]] = []
    for scenario_name in sorted({row["scenario"] for row in rows}):
        subset = [row for row in rows if row["scenario"] == scenario_name]
        final = subset[-1]
        avg_net_flow = mean(float(row["net_flow"]) for row in subset)
        avg_depletion = mean(float(row["hidden_depletion"]) for row in subset)
        avg_false_progress = mean(float(row["false_progress_risk"]) for row in subset)
        avg_score = mean(float(row["stock_repair_score"]) for row in subset)

        if float(final["stock_repair_score"]) >= 65 and float(final["hidden_depletion"]) <= 30:
            diagnostic = "stock repair is durable and visible"
        elif avg_depletion >= 55:
            diagnostic = "hidden depletion dominates the stock-flow structure"
        elif avg_false_progress >= 45:
            diagnostic = "flow activity risks being mistaken for stock repair"
        elif avg_net_flow < 0:
            diagnostic = "outflows exceed inflows; stock is eroding"
        elif avg_score >= 55:
            diagnostic = "partial stock repair with remaining delay or measurement risk"
        else:
            diagnostic = "weak stock-flow alignment"

        output.append({
            "scenario": scenario_name,
            "final_stock_repair_score": final["stock_repair_score"],
            "final_stock": final["stock"],
            "final_perceived_stock": final["perceived_stock"],
            "final_net_flow": final["net_flow"],
            "final_hidden_depletion": final["hidden_depletion"],
            "average_net_flow": round(avg_net_flow, 3),
            "average_hidden_depletion": round(avg_depletion, 3),
            "average_false_progress_risk": round(avg_false_progress, 3),
            "average_stock_repair_score": round(avg_score, 3),
            "diagnostic": diagnostic,
        })

    return output


def main() -> None:
    scenarios = [
        StockFlowScenario("Activity without stock repair", 46.0, 18.0, 24.0, 0.34, 0.68, 0.22, 0.18, 0.34, 0.24, 0.64),
        StockFlowScenario("Inflow-focused reform", 48.0, 26.0, 24.0, 0.48, 0.56, 0.42, 0.26, 0.48, 0.38, 0.52),
        StockFlowScenario("Net-flow correction", 52.0, 24.0, 20.0, 0.66, 0.38, 0.64, 0.62, 0.68, 0.62, 0.38),
        StockFlowScenario("Accountable stock repair", 56.0, 24.0, 18.0, 0.82, 0.24, 0.82, 0.80, 0.84, 0.82, 0.28),
    ]

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

    write_csv(TABLES / "stock_flow_architecture_change_timeseries.csv", rows)
    write_csv(TABLES / "stock_flow_architecture_change_summary.csv", summarize(rows))

    print("Stock-flow architecture workflow complete.")
    print(TABLES / "stock_flow_architecture_change_timeseries.csv")


if __name__ == "__main__":
    main()

The workflow is intentionally simple enough to inspect. It shows how visible activity can fail to repair the stock that matters, how outflows can erase inflow gains, how delayed perception can hide depletion, and how measurement quality, accountability, repair investment, and outflow reduction can produce durable stock change. The model is synthetic and illustrative; it supports disciplined inquiry rather than replacing domain expertise, stakeholder evidence, or ethical judgment.

Back to top ↑

R Workflow: Stock-Flow Summary and Scenario Visualization

The R workflow reads the Python-generated time-series output, creates stock-flow summaries, and exports base R plots for stock, perceived stock, net flow, hidden depletion, false progress risk, and stock repair score. It uses only base R so it remains portable across simple local environments.

# stock_flow_architecture_change_diagnostics.R
# Base R workflow for stock-flow summary and scenario visualization.

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 <- getwd()
}

setwd(article_root)

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

if (!dir.exists(tables_dir)) {
  dir.create(tables_dir, recursive = TRUE)
}

if (!dir.exists(figures_dir)) {
  dir.create(figures_dir, recursive = TRUE)
}

timeseries_path <- file.path(tables_dir, "stock_flow_architecture_change_timeseries.csv")

if (!file.exists(timeseries_path)) {
  stop(paste("Missing", timeseries_path, "Run the Python workflow first."))
}

data <- read.csv(timeseries_path, stringsAsFactors = FALSE)

last_by_scenario <- do.call(
  rbind,
  lapply(split(data, data$scenario), function(df) df[nrow(df), ])
)

avg_net_flow <- aggregate(net_flow ~ scenario, data = data, FUN = mean)
avg_depletion <- aggregate(hidden_depletion ~ scenario, data = data, FUN = mean)
avg_false_progress <- aggregate(false_progress_risk ~ scenario, data = data, FUN = mean)
avg_score <- aggregate(stock_repair_score ~ scenario, data = data, FUN = mean)

names(avg_net_flow)[2] <- "average_net_flow"
names(avg_depletion)[2] <- "average_hidden_depletion"
names(avg_false_progress)[2] <- "average_false_progress_risk"
names(avg_score)[2] <- "average_stock_repair_score"

final_fields <- last_by_scenario[, c(
  "scenario",
  "stock_repair_score",
  "stock",
  "perceived_stock",
  "net_flow",
  "hidden_depletion"
)]

names(final_fields) <- c(
  "scenario",
  "final_stock_repair_score",
  "final_stock",
  "final_perceived_stock",
  "final_net_flow",
  "final_hidden_depletion"
)

summary_table <- Reduce(
  function(x, y) merge(x, y, by = "scenario"),
  list(avg_net_flow, avg_depletion, avg_false_progress, avg_score, final_fields)
)

summary_table$diagnostic <- ifelse(
  summary_table$final_stock_repair_score >= 65 &
    summary_table$final_hidden_depletion <= 30,
  "stock repair is durable and visible",
  ifelse(
    summary_table$average_hidden_depletion >= 55,
    "hidden depletion dominates the stock-flow structure",
    ifelse(
      summary_table$average_false_progress_risk >= 45,
      "flow activity risks being mistaken for stock repair",
      ifelse(
        summary_table$average_net_flow < 0,
        "outflows exceed inflows; stock is eroding",
        ifelse(
          summary_table$average_stock_repair_score >= 55,
          "partial stock repair with remaining delay or measurement risk",
          "weak stock-flow alignment"
        )
      )
    )
  )
)

write.csv(
  summary_table,
  file.path(tables_dir, "stock_flow_architecture_change_r_summary.csv"),
  row.names = FALSE
)

plot_metric <- function(metric, label, file_name) {
  png(file.path(figures_dir, file_name), width = 1200, height = 700)
  scenarios <- unique(data$scenario)
  plot(
    NA,
    xlim = range(data$period),
    ylim = range(data[[metric]], na.rm = TRUE),
    xlab = "Period",
    ylab = label,
    main = paste(label, "by Stock-Flow Scenario")
  )
  for (scenario_name in scenarios) {
    subset_data <- data[data$scenario == scenario_name, ]
    lines(subset_data$period, subset_data[[metric]], lwd = 2)
  }
  legend("topleft", legend = scenarios, lwd = 2, cex = 0.8, bty = "n")
  grid()
  dev.off()
}

plot_metric("stock", "Stock", "stock_trajectories.png")
plot_metric("perceived_stock", "Perceived stock", "perceived_stock_trajectories.png")
plot_metric("net_flow", "Net flow", "net_flow_trajectories.png")
plot_metric("hidden_depletion", "Hidden depletion", "hidden_depletion_trajectories.png")
plot_metric("false_progress_risk", "False progress risk", "false_progress_risk_trajectories.png")
plot_metric("stock_repair_score", "Stock repair score", "stock_repair_score_trajectories.png")

print(summary_table)

This workflow supports the article’s central methodological claim: activity should be evaluated by whether it changes the accumulated condition that matters. The R outputs help readers compare flow activity, net-flow correction, and durable stock repair over time.

Back to top ↑

GitHub Repository

The companion repository for this article should help readers model stocks, flows, accumulation, depletion, feedback-controlled flows, delayed perception, intervention scenarios, and stock-flow diagnostics using synthetic datasets and reproducible workflows.

articles/stocks-flows-and-the-architecture-of-change/
├── python/
│   ├── stock_flow_architecture_change_workflow.py
│   ├── stock_flow_simulation.py
│   ├── accumulation_depletion_model.py
│   ├── feedback_controlled_flows.py
│   ├── delayed_stock_perception.py
│   ├── policy_intervention_scenarios.py
│   ├── stock_flow_diagnostics.py
│   ├── validation_checks.py
│   └── run_all_stock_flow_workflows.py
├── r/
│   ├── stock_flow_architecture_change_diagnostics.R
│   ├── stock_flow_plots.R
│   ├── accumulation_depletion_visualization.R
│   ├── inflow_outflow_summary.R
│   ├── delayed_stock_response.R
│   ├── scenario_comparison.R
│   └── run_all_stock_flow_workflows.R
├── julia/
│   ├── continuous_stock_flow_model.jl
│   └── nonlinear_accumulation_dynamics.jl
├── sql/
│   ├── schema_system_stocks.sql
│   ├── schema_system_flows.sql
│   ├── schema_stock_flow_observations.sql
│   ├── schema_feedback_controls.sql
│   ├── schema_scenarios.sql
│   └── schema_model_runs.sql
├── rust/
│   └── stock_flow_diagnostics_cli.rs
├── go/
│   └── stock_flow_pathway_utility.go
├── cpp/
│   ├── efficient_stock_flow_simulation.cpp
│   └── accumulation_threshold_scan.cpp
├── fortran/
│   └── recurrence_stock_flow_model.f90
├── c/
│   └── low_level_stock_flow_simulation.c
├── docs/
│   ├── modeling_principles.md
│   ├── article_notes.md
│   ├── stock_flow_framework.md
│   ├── assumptions_and_limitations.md
│   └── responsible_use.md
├── data/
│   ├── synthetic_system_stocks.csv
│   ├── synthetic_system_flows.csv
│   ├── synthetic_stock_flow_observations.csv
│   ├── synthetic_feedback_controls.csv
│   ├── synthetic_scenarios.csv
│   └── synthetic_indicators.csv
├── outputs/
│   ├── figures/
│   └── tables/
└── notebooks/
    ├── python_stock_flow_walkthrough.ipynb
    └── r_stock_flow_visualization_placeholder.ipynb

This repository structure supports the article’s central argument: system behavior is shaped by accumulation. The data/ folder separates stocks, flows, observations, feedback controls, scenarios, and indicators. The python/ and r/ folders support stock-flow simulation, accumulation and depletion analysis, delayed perception, feedback-controlled flows, and scenario comparison. The julia folder supports continuous-time and nonlinear stock-flow dynamics. The sql folder defines schemas for stocks, flows, observations, feedback controls, scenarios, and model runs. The lower-level language folders provide scaffolds for efficient diagnostics, threshold scanning, pathway tracing, recurrence modeling, and low-level simulation.

Back to top ↑

Back to top ↑

Back to top ↑

Why Stock-Flow Thinking Matters

Stock-flow thinking matters because it reveals the architecture of change. It shows that systems are shaped by accumulated conditions, not only by visible events. It explains why some problems return, why some crises appear sudden, why recovery is slow, why policy activity may not produce durable change, and why prevention is often more powerful than repair.

Stocks are where systems store history. Flows are how systems change history. Feedback controls those flows. Delays hide the consequences. Boundaries determine what is counted. Power shapes whose accumulations are measured and whose are ignored.

To think in stocks and flows is to ask what the system is building, what it is draining, what it is preserving, what it is exhausting, and what it is passing forward. It is a way of seeing slow harm and slow repair. It is also a way of recognizing that durable change requires more than motion. It requires changing the accumulated condition that gives the system its current behavior.

Systems change begins when we stop asking only what happened and begin asking what has been accumulating all along.

Back to top ↑

Related Articles

• Causal Loop Diagrams and the Logic of Interaction
• Dynamic Complexity and Policy Resistance
• Overshoot, Collapse, and Correction
• System Dynamics and Simulation Modeling
• Stock and Flow Diagrams
• Nonlinear Change and Threshold Effects
• Thresholds, Regime Shifts, and System Transformation
• Resilience, Adaptation, and System Capacity

Further Reading

• Meadows, Donella H. Thinking in Systems: A Primer. Chelsea Green Publishing.
• Sterman, John D. Business Dynamics: Systems Thinking and Modeling for a Complex World. Irwin/McGraw-Hill.
• Forrester, Jay W. Industrial Dynamics. MIT Press.
• Forrester, Jay W. World Dynamics. Wright-Allen Press.
• Senge, Peter M. The Fifth Discipline: The Art and Practice of the Learning Organization. Doubleday/Currency.
• Richardson, George P. Feedback Thought in Social Science and Systems Theory. University of Pennsylvania Press.
• Holling, C.S. “Resilience and Stability of Ecological Systems.” Annual Review of Ecology and Systematics.
• Walker, Brian and Salt, David. Resilience Thinking: Sustaining Ecosystems and People in a Changing World. Island Press.

Back to top ↑

References

• Forrester, J.W. (1961) Industrial Dynamics. Cambridge, MA: MIT Press.
• Forrester, J.W. (1971) World Dynamics. Cambridge, MA: Wright-Allen Press.
• Holling, C.S. (1973) “Resilience and Stability of Ecological Systems.” Annual Review of Ecology and Systematics, 4, pp. 1–23.
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green Publishing. Available at: https://www.chelseagreen.com/product/thinking-in-systems/
• MIT OpenCourseWare (2013) Introduction to System Dynamics. Massachusetts Institute of Technology. Available at: https://ocw.mit.edu/courses/15-871-introduction-to-system-dynamics-fall-2013/
• Richardson, G.P. (1991) Feedback Thought in Social Science and Systems Theory. Philadelphia: University of Pennsylvania Press.
• Senge, P.M. (1990) The Fifth Discipline: The Art and Practice of the Learning Organization. New York: Doubleday/Currency.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.
• Walker, B. and Salt, D. (2006) Resilience Thinking: Sustaining Ecosystems and People in a Changing World. Washington, DC: Island Press.

Back to top ↑