System Archetypes and Recurring Patterns

Last Updated June 1, 2026

System archetypes are recurring structures that produce recurring patterns of behavior. They help systems thinkers recognize why different problems across public health, infrastructure, education, organizations, economics, climate systems, technology, and governance can behave in surprisingly similar ways. A backlog returns after every temporary fix. A system grows until it hits a constraint. A short-term solution quietly weakens long-term capacity. Two actors escalate against each other. Success accumulates resources for the already successful. Costs are shifted to people, communities, ecosystems, or future generations outside the official boundary.

Archetypes are not rigid templates. They are diagnostic patterns. They help analysts ask whether a visible problem is being generated by a familiar structure: reinforcing growth, delayed limits, compensating feedback, burden shifting, goal erosion, escalation, resource competition, or policy resistance. The value of archetypes is not that they simplify reality into slogans. Their value is that they help us notice structural repetition beneath different events.

This article examines system archetypes as tools for recognizing recurring patterns in complex systems. It explains how archetypes connect causal-loop thinking with practical diagnosis, why archetypes should be treated as hypotheses rather than labels, and how they can reveal deeper intervention points. It explores major archetypes including limits to growth, fixes that fail, shifting the burden, eroding goals, escalation, success to the successful, tragedy of the commons, growth and underinvestment, and policy resistance. It also asks how archetypes can be used ethically: not to blame individuals for structural outcomes, but to expose recurring patterns of harm, burden shifting, and institutional responsibility.

Why System Archetypes Matter

System archetypes matter because complex systems often repeat themselves. A city expands infrastructure, demand rises, and congestion returns. A public agency adds temporary staff, backlog falls, staff burn out, turnover rises, and backlog returns. A school lowers standards under pressure, short-term performance appears stable, and long-term learning weakens. An organization solves overload with overtime, but overtime creates fatigue, error, rework, and more overload. A climate policy reduces visible emissions in one boundary while outsourcing emissions elsewhere.

These examples differ in content, but they may share structure. The structure is the archetype. Systems thinking becomes more powerful when analysts can recognize that a problem is not unique in every respect. The same pattern may have appeared in another domain, with another vocabulary, under another policy name. Recognizing the pattern helps the analyst ask better questions sooner.

Archetypes are useful because they connect event-level observation to structural explanation. Instead of asking only what happened, the analyst asks: what recurring structure could produce this pattern? Is there a reinforcing loop? Is there a delayed limit? Is the system relying on a short-term fix that weakens long-term capacity? Are costs being shifted outside the boundary? Is success attracting resources away from less successful actors? Are goals being lowered to preserve the appearance of performance?

System archetypes help analysts avoid treating each recurrence as isolated. They also help identify leverage points. If the pattern is shifting the burden, the intervention is not simply more symptomatic relief. It is rebuilding fundamental capacity. If the pattern is limits to growth, the intervention is not simply pushing harder on growth. It is identifying and relieving the limiting constraint. If the pattern is eroding goals, the intervention is not merely accepting new targets. It is protecting the goal and changing the structure that makes the goal hard to meet.

Archetypes help us see that repeated failure may not be accidental. It may be structured.

Back to top ↑

What a System Archetype Is

A system archetype is a recurring feedback structure that generates a characteristic pattern of behavior over time. It is a model of recurrence. Archetypes describe not only what happens, but how the system produces the pattern. They typically involve combinations of reinforcing loops, balancing loops, delays, limits, goals, resource flows, incentives, and boundary effects.

An archetype is not a metaphor alone. It is a causal structure. For example, “fixes that fail” is not just a phrase meaning that a solution did not work. It describes a structure in which a short-term fix reduces a symptom, but produces a delayed unintended consequence that worsens the underlying problem or recreates the symptom. “Limits to growth” is not just a phrase meaning that growth stops. It describes a reinforcing growth process that eventually activates a balancing constraint.

Archetypes sit between abstract systems theory and specific case analysis. They are more general than a single case, but less abstract than the idea of feedback itself. They help analysts recognize patterns across domains without erasing domain-specific details.

A useful archetype diagnosis should identify:

• the recurring behavior over time;
• the main stocks and flows involved;
• the reinforcing and balancing loops;
• the delays that hide consequences;
• the goals or reference points being defended;
• the actors or institutions responding to feedback;
• the costs or burdens shifted across boundaries;
• the leverage points that could alter the pattern.

System archetypes are most useful when they remain connected to evidence. The analyst should be able to show how the archetype appears in behavior-over-time data, stakeholder experience, policy history, causal-loop structure, or institutional behavior. An archetype is a hypothesis about structure, not a label to paste onto a problem.

Back to top ↑

Archetypes Are Patterns, Not Labels

Archetypes should be used carefully. Their purpose is to deepen inquiry, not end it. A poor use of archetypes says, “This is a shifting-the-burden problem,” and stops there. A better use says, “This resembles shifting the burden. What is the symptom? What is the short-term fix? What fundamental solution is being displaced? What delayed consequences are weakening capacity? What evidence supports the diagnosis?”

Archetypes can become shallow if they are treated like naming conventions. Naming the archetype does not solve the problem. The archetype should help the analyst identify variables, loops, delays, actors, incentives, and leverage points. It should sharpen the causal map.

For example, a workforce crisis might be labeled “fixes that fail” because overtime creates fatigue. But it may also contain shifting the burden, because overtime substitutes for staffing and workload redesign. It may contain eroding goals, because quality standards are gradually lowered. It may contain success to the successful, because high-performing teams receive more work and then burn out. Multiple archetypes can coexist in the same system.

The best archetype analysis remains humble. It recognizes that archetypes are simplified patterns. Real systems include history, power, culture, law, ecology, technology, institutions, and lived experience. Archetypes help reveal structure, but they do not replace careful inquiry.

An archetype should open the system, not close the conversation.

Back to top ↑

Limits to Growth

The limits-to-growth archetype describes a pattern in which a reinforcing process produces growth until it activates a limiting constraint. Early success creates momentum. Growth continues. Then a resource, capacity, legitimacy, ecological limit, workforce constraint, infrastructure bottleneck, market saturation, or social tolerance begins to bind. Growth slows, stalls, or collapses.

This archetype is common because reinforcing loops are attractive. Growth brings resources, attention, confidence, investment, political support, or legitimacy. The system interprets early growth as proof of success. But if the system does not identify and manage the limiting condition, the very growth it celebrates can produce the constraint that slows it.

Examples include organizations that grow faster than managerial capacity, cities that expand faster than infrastructure, platforms that scale faster than governance, economic systems that grow through ecological depletion, schools that expand enrollment faster than student support, and public agencies that add programs faster than implementation capacity.

The leverage point is often not pushing harder on growth. It is identifying and relieving the limiting constraint. If the constraint is workforce capacity, invest in capacity. If the constraint is public trust, repair trust. If the constraint is ecological, reduce harmful flows and respect limits. If the constraint is governance, build accountability and learning. If the constraint is infrastructure, invest before backlog accumulates.

The limits-to-growth archetype asks:

• What is producing growth?
• What constraint is growth approaching or creating?
• Is the constraint visible or delayed?
• Is the system trying to push harder on the growth loop?
• What stock, buffer, or capacity must be protected?
• What would sustainable growth require?

The danger of this archetype is overconfidence. Early success can hide the limit. The system may assume that what worked before will continue working. Systems thinking asks what the growth is consuming.

Back to top ↑

Fixes That Fail

The fixes-that-fail archetype occurs when a short-term solution reduces a symptom but creates delayed consequences that worsen the underlying problem or recreate the symptom. The fix appears successful at first. Because the harmful effect is delayed, the system repeats the fix. Over time, the problem becomes harder to solve.

This archetype is common because short-term pressure is real. Backlogs, crises, cost overruns, public complaints, service failures, workforce shortages, and political demands require response. A fix may be necessary. The problem arises when the fix becomes a substitute for structural repair.

Examples include overtime that reduces backlog but increases burnout, road expansion that reduces congestion briefly but induces demand, emergency repair that restores service while crowding out preventive maintenance, short-term debt that relieves pressure but increases future burden, and public messaging that reduces criticism briefly while failing to repair institutional behavior.

The leverage point is to identify the delayed consequence and change the structure that makes the quick fix necessary. Sometimes the quick fix must remain as emergency relief, but it should be paired with a fundamental solution. Overtime may be necessary during a surge, but it must be paired with staffing, workload redesign, automation governance, process simplification, or demand reduction. Emergency repair may be necessary, but it must be paired with preventive maintenance and asset renewal.

The fixes-that-fail archetype asks:

• What symptom is the fix reducing?
• What delayed consequence does the fix create?
• Why is the delayed consequence hard to see?
• What fundamental solution is being avoided?
• Who benefits from the short-term fix?
• Who bears the delayed cost?

Fixes that fail are especially dangerous in institutions that reward short-term appearance. If leaders are rewarded for immediate relief, the delayed consequence may fall on future workers, communities, ecosystems, or budgets. The archetype therefore has an ethical dimension: delayed harm is often shifted to those with less voice.

Back to top ↑

Shifting the Burden

The shifting-the-burden archetype occurs when a system relies on a symptomatic solution that reduces pressure while weakening or delaying the fundamental solution. Over time, dependence on the symptomatic solution grows, and the system’s capacity to solve the underlying problem erodes.

This pattern is related to fixes that fail, but its emphasis is different. Fixes that fail focuses on the delayed harm caused by a quick fix. Shifting the burden focuses on dependence: the more the system relies on symptomatic relief, the less it invests in fundamental capacity.

Examples include using contractors instead of rebuilding internal capacity, relying on emergency rooms because primary care is inaccessible, using policing to manage social distress instead of housing and care systems, using automation to process cases without reducing administrative burden, using debt to cover structural income insecurity, or using heroics and overtime instead of sustainable staffing.

The leverage point is to protect and build the fundamental solution. This may require reducing dependence on the symptomatic fix, creating transition capacity, changing incentives, and measuring long-term capacity rather than short-term relief alone.

The shifting-the-burden archetype asks:

• What symptomatic solution reduces pressure?
• What fundamental solution would reduce the cause?
• How does dependence on the symptomatic solution grow?
• Does the symptomatic solution weaken fundamental capacity?
• What transition strategy is needed?
• What metrics would reveal recovery of fundamental capacity?

Shifting the burden is common in public systems because the fundamental solution is often slower, more expensive, more political, or more redistributive. But without fundamental repair, symptomatic relief becomes a trap.

Back to top ↑

Eroding Goals

The eroding-goals archetype occurs when a gap between desired performance and actual performance is closed by lowering the goal rather than improving the system. The decline may be gradual. Each adjustment seems reasonable under pressure. Over time, the system normalizes weaker standards, lower expectations, or reduced responsibility.

This archetype is especially dangerous because it can look like adaptation. A public agency extends acceptable wait times. A school lowers expectations for learning. A workplace normalizes chronic overwork. A city accepts more frequent flooding. An infrastructure system accepts more failures. A platform accepts more harm as the cost of engagement. The system becomes accustomed to degraded performance.

The leverage point is to protect the goal while changing the structure that makes the goal hard to meet. This does not mean goals should never be revised. Some goals may be unrealistic, unjust, or poorly designed. But eroding goals occurs when the system lowers expectations to avoid structural repair.

The eroding-goals archetype asks:

• What goal is being lowered?
• What pressure makes the lower goal attractive?
• Is the goal unrealistic, or is capacity inadequate?
• Who benefits from lowering the goal?
• Who bears the cost of reduced expectations?
• What investment, rule change, or feedback would make the original goal achievable?

Ethically, eroding goals often harms those already exposed to weak systems. If wait times, service quality, environmental standards, safety expectations, or educational goals are lowered, the burden often falls on people with fewer alternatives. Protecting goals can be a justice issue, especially when the goal concerns rights, safety, dignity, or ecological responsibility.

Back to top ↑

Escalation

The escalation archetype occurs when two or more actors compare themselves to one another and respond by intensifying their own behavior. Each side’s action becomes the other side’s justification for further action. The pattern can produce arms races, price wars, political polarization, workplace conflict, enforcement cycles, litigation spirals, and retaliatory policy.

Escalation is driven by relative comparison. Each actor may believe it is responding defensively. But the feedback loop creates mutual intensification. The system-level result can be worse for everyone.

Examples include departments competing for budget, organizations escalating workload expectations, political parties intensifying rhetoric, cities competing through tax incentives, platforms competing for attention, nations increasing military spending, or institutions increasing surveillance in response to public distrust while distrust rises in response to surveillance.

The leverage point is to change the comparison logic. This may require shared goals, trusted mediation, transparency, confidence-building measures, rule changes, mutual constraints, or reframing success away from relative dominance. In some cases, one actor may need to stop feeding the escalation loop. In others, external governance may be required.

The escalation archetype asks:

• Who is comparing against whom?
• What variable is being compared?
• What action does each actor take in response?
• Does each action increase perceived threat or competition?
• What shared goal could reduce escalation?
• What rule or constraint could limit harmful intensification?

Escalation is often emotionally and politically charged because each side can point to the other side’s behavior as justification. Systems thinking helps shift the question from who started it to what structure keeps it going.

Back to top ↑

Success to the Successful

The success-to-the-successful archetype occurs when early success attracts resources that create more success, while less successful actors receive fewer resources and fall further behind. The pattern produces cumulative advantage and cumulative disadvantage.

This archetype appears in education, wealth, organizational attention, research funding, platform visibility, neighborhood investment, political influence, and institutional capacity. Once a person, place, program, or institution is seen as successful, resources flow toward it. Those resources improve future performance. Others receive less support, making success harder. The system then treats the resulting difference as evidence of merit.

The leverage point is to examine resource allocation rules. Does funding follow need or prior performance? Does visibility follow quality or existing audience? Do high-capacity institutions become better at winning grants while low-capacity institutions lack grant-writing capacity? Do wealthy neighborhoods attract more investment while disinvested neighborhoods are judged by the outcomes that disinvestment helped produce?

The success-to-the-successful archetype asks:

• What early advantage is being reinforced?
• How are resources allocated?
• Does the system treat accumulated advantage as individual merit?
• What barriers prevent less successful actors from building capacity?
• What redistribution, capacity-building, or rule change would interrupt the loop?

Ethically, this archetype is central to inequality. It shows that unequal outcomes may be produced by feedback, not simply by individual differences. Systems can manufacture evidence of superiority by giving more support to those already ahead.

Back to top ↑

Tragedy of the Commons

The tragedy-of-the-commons archetype occurs when individual actors benefit from using a shared resource while the costs of overuse are distributed across the whole system. Each actor’s use may seem rational from an individual perspective, but collective use depletes the commons. The resource may be ecological, institutional, social, informational, or infrastructural.

Commons include fisheries, forests, groundwater, atmosphere, public trust, social attention, shared infrastructure, democratic legitimacy, antimicrobial effectiveness, workplace capacity, and community resilience. The tragedy occurs when the system lacks feedback, rules, trust, governance, or shared responsibility to protect the resource.

The leverage point is governance of the commons. This may involve rules, monitoring, sanctions, shared norms, participatory management, boundaries, restoration, quotas, pricing, stewardship obligations, or redesigned incentives. The goal is not necessarily centralized control. Many commons are governed through local institutions, shared norms, and adaptive rules.

The tragedy-of-the-commons archetype asks:

• What shared stock is being depleted?
• Who benefits from individual use?
• Who bears the collective cost?
• Are users receiving accurate feedback about depletion?
• What rules or norms protect the commons?
• Who has authority to govern the shared resource?

Ethically, commons depletion often shifts costs to those with less power and to future generations. A system can privatize gain while socializing loss. Archetype analysis makes that structure visible.

Back to top ↑

Growth and Underinvestment

The growth-and-underinvestment archetype occurs when demand grows but investment in capacity lags. As capacity becomes strained, performance declines. Declining performance reduces demand, legitimacy, funding, or willingness to invest, which further weakens capacity. The system creates its own limit through underinvestment.

This archetype is common in infrastructure, public services, education, healthcare, organizations, technology governance, and civic institutions. A service becomes popular, demand increases, capacity is not expanded, quality falls, trust declines, and support weakens. Leaders may then conclude that demand is lower or that the service is failing, when the real problem is underinvestment in capacity.

The leverage point is timely capacity investment. The system must invest before quality deterioration undermines support. This may require leading indicators, protected funding, capacity planning, maintenance of buffers, and recognition that growth without capacity is not success.

The growth-and-underinvestment archetype asks:

• What demand or workload is growing?
• What capacity is required to sustain quality?
• Is investment delayed until after performance declines?
• Does declining quality reduce support for investment?
• What leading indicators should trigger capacity expansion?
• What stock must be built before stress becomes visible?

This archetype is especially relevant to public institutions because underinvestment can be misread as evidence that the public service does not work. The system is blamed for failure after being denied the capacity to succeed.

Back to top ↑

Policy Resistance and Compensating Feedback

Policy resistance occurs when a system responds to an intervention in ways that offset, weaken, or reverse the intended effect. The intervention may be reasonable in isolation, but the system adapts. Actors change behavior. Incentives shift. Burdens move. Demand returns. Trust changes. A hidden loop compensates.

Policy resistance is often not irrational resistance. It is feedback. People, institutions, markets, ecosystems, and technologies respond to interventions based on their constraints, incentives, perceptions, and goals. A policy that ignores these responses may fail even if its direct logic is sound.

Examples include road expansion followed by induced demand, performance metrics followed by gaming, strict verification followed by reduced access and increased appeals, enforcement followed by distrust and avoidance, automation followed by oversight dependency and hidden error, and austerity followed by capacity loss and higher future cost.

The leverage point is to understand the system response before intervention. Policy design should identify incentives, constraints, adaptive actors, feedback loops, and boundary effects. It should ask how the system might compensate and where harm might be shifted.

The policy-resistance archetype asks:

• What behavior does the intervention assume?
• How might actors adapt?
• What incentives change?
• What feedback could offset the intended effect?
• What costs might shift outside the boundary?
• What monitoring would reveal compensation early?

Policy resistance reminds systems thinkers that interventions enter living systems, not passive machines. The system acts back.

Back to top ↑

Ethics: Archetypes, Blame, and Responsibility

System archetypes have ethical stakes because they change how responsibility is understood. A recurring problem may be blamed on individuals: workers are not resilient enough, applicants are noncompliant, students are unmotivated, residents are irrational, users are careless, communities are distrustful, or agencies are lazy. Archetype analysis can reveal that behavior is being produced by structure.

This does not mean individuals have no agency. It means agency operates within feedback, incentives, constraints, histories, and power relations. A person may make choices, but those choices are shaped by administrative burden, debt, trust, time poverty, housing instability, surveillance, workplace pressure, or lack of alternatives. Archetypes help prevent moralizing symptoms while ignoring structure.

Ethical archetype analysis asks:

• Who is being blamed for a pattern the system produces?
• What structure makes the behavior likely?
• Who benefits from the recurring pattern?
• Who bears delayed consequences?
• What costs are shifted outside the official boundary?
• What stock is being depleted?
• What fundamental solution is being avoided?
• What repair obligations become visible?

Archetypes can also be misused. A powerful institution might use archetype language to make harm sound inevitable or impersonal. “The system produced this” should not become an excuse for nobody being accountable. Structures are designed, maintained, funded, defended, and changed by people and institutions. Complexity should clarify responsibility, not dissolve it.

The ethical value of archetypes is that they make repeated harm harder to dismiss as accident. If the same pattern keeps appearing, the question becomes: why has the structure not changed?

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

System archetypes can be represented using causal-loop diagrams, signed graphs, stock-flow models, recurrence equations, scenario simulations, and network structures. The purpose of modeling archetypes is not to force every case into a formula. It is to make recurring feedback structures explicit enough to test, compare, and revise.

A generic feedback model can be written as:

A limits-to-growth structure can be represented as:

A fixes-that-fail structure can be represented as:

A shifting-the-burden structure can be represented as:

An eroding-goals structure can be represented as:

A success-to-the-successful structure can be represented as:

Computational models can help test whether an archetype could plausibly generate observed behavior. But archetype modeling should remain transparent and interpretive. Equations do not prove the archetype. They help clarify the causal logic. The analyst must still examine evidence, history, stakeholder knowledge, power, and boundary choices.

Back to top ↑

Python Workflow: Archetype Detection, Pattern Simulation, and Scenario Diagnostics

The Python workflow below turns system archetypes into a small reproducible simulation. It compares limits to growth, fixes that fail, success to the successful, and a structural repair intervention. 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.

# system_archetypes_recurring_patterns_workflow.py
# Dependency-light workflow for system archetype diagnostics,
# recurring-pattern simulation, delay testing, goal erosion,
# commons depletion, escalation, and scenario comparison.
# 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 ArchetypeScenario:
    name: str
    archetype: str
    reinforcing_pressure: float
    balancing_capacity: float
    delay_strength: float
    symptomatic_fix: float
    fundamental_repair: float
    resource_allocation_bias: float
    commons_pressure: float
    goal_protection: float
    accountability: float
    distributional_safeguard: float


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


def run_scenario(scenario: ArchetypeScenario, periods: int = 60) -> list[dict[str, object]]:
    problem_stock = 42.0 + scenario.reinforcing_pressure * 20.0
    capacity_stock = 52.0 + scenario.balancing_capacity * 18.0
    goal_level = 74.0
    commons_stock = 78.0 - scenario.commons_pressure * 12.0
    trust_stock = 46.0 + scenario.accountability * 20.0
    advantaged_resource = 52.0 + scenario.resource_allocation_bias * 18.0
    disadvantaged_resource = 48.0 - scenario.resource_allocation_bias * 14.0
    delayed_harm_stock = 20.0 + scenario.delay_strength * 18.0
    vulnerable_burden = 32.0 + scenario.commons_pressure * 18.0
    problem_history: list[float] = [problem_stock]
    rows: list[dict[str, object]] = []

    delay_steps = max(0, int(round(scenario.delay_strength * 8.0)))

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

        growth_engine = clamp(
            scenario.reinforcing_pressure * 18.0
            + max(0.0, 65.0 - problem_stock) * 0.05
            + scenario.resource_allocation_bias * 6.0,
            0.0,
            100.0,
        )

        constraint_pressure = clamp(
            max(0.0, problem_stock - capacity_stock) * 0.20
            + max(0.0, 60.0 - commons_stock) * 0.18
            + delayed_harm_stock * 0.10
            - scenario.balancing_capacity * 5.0,
            0.0,
            100.0,
        )

        quick_relief = clamp(
            scenario.symptomatic_fix * 18.0
            + max(0.0, delayed_problem - 50.0) * 0.12
            - scenario.accountability * 2.0,
            0.0,
            100.0,
        )

        repair_effect = clamp(
            scenario.fundamental_repair * 20.0
            + scenario.goal_protection * 8.0
            + scenario.accountability * 7.0
            + scenario.distributional_safeguard * 6.0
            - scenario.delay_strength * 3.0,
            0.0,
            100.0,
        )

        unintended_consequence = clamp(
            scenario.symptomatic_fix * 14.0
            + scenario.delay_strength * 10.0
            + max(0.0, quick_relief - repair_effect) * 0.12
            - scenario.accountability * 3.0,
            0.0,
            100.0,
        )

        goal_erosion = clamp(
            max(0.0, goal_level - capacity_stock) * 0.08
            + scenario.symptomatic_fix * 4.0
            + max(0.0, problem_stock - 65.0) * 0.06
            - scenario.goal_protection * 5.0
            - scenario.accountability * 2.5,
            0.0,
            100.0,
        )

        commons_depletion = clamp(
            scenario.commons_pressure * 16.0
            + growth_engine * 0.10
            + scenario.reinforcing_pressure * 5.0
            - scenario.distributional_safeguard * 5.0
            - scenario.accountability * 2.0,
            0.0,
            100.0,
        )

        success_compounding = clamp(
            scenario.resource_allocation_bias * 15.0
            + max(0.0, advantaged_resource - disadvantaged_resource) * 0.10
            - scenario.distributional_safeguard * 5.0,
            0.0,
            100.0,
        )

        problem_stock = clamp(
            problem_stock
            + growth_engine * 0.14
            + unintended_consequence * 0.10
            + constraint_pressure * 0.08
            - quick_relief * 0.12
            - repair_effect * 0.14,
            0.0,
            140.0,
        )

        capacity_stock = clamp(
            capacity_stock
            + repair_effect * 0.13
            + scenario.fundamental_repair * 1.4
            - scenario.symptomatic_fix * 0.8
            - constraint_pressure * 0.05,
            0.0,
            100.0,
        )

        goal_level = clamp(
            goal_level
            - goal_erosion * 0.10
            + scenario.goal_protection * 1.4
            + scenario.accountability * 0.8,
            30.0,
            100.0,
        )

        commons_stock = clamp(
            commons_stock
            - commons_depletion * 0.12
            + scenario.distributional_safeguard * 1.2
            + scenario.accountability * 0.8,
            0.0,
            100.0,
        )

        trust_stock = clamp(
            trust_stock
            + repair_effect * 0.05
            + scenario.accountability * 1.3
            + scenario.distributional_safeguard * 1.0
            - delayed_harm_stock * 0.04
            - vulnerable_burden * 0.04,
            0.0,
            100.0,
        )

        advantaged_resource = clamp(
            advantaged_resource
            + success_compounding * 0.10
            + scenario.resource_allocation_bias * 1.0
            - scenario.distributional_safeguard * 0.8,
            0.0,
            100.0,
        )

        disadvantaged_resource = clamp(
            disadvantaged_resource
            - success_compounding * 0.07
            + scenario.distributional_safeguard * 1.4
            + scenario.accountability * 0.6,
            0.0,
            100.0,
        )

        delayed_harm_stock = clamp(
            delayed_harm_stock
            + unintended_consequence * 0.13
            + commons_depletion * 0.07
            - scenario.fundamental_repair * 1.0
            - scenario.accountability * 0.8,
            0.0,
            100.0,
        )

        vulnerable_burden = clamp(
            vulnerable_burden
            + delayed_harm_stock * 0.05
            + commons_depletion * 0.06
            + max(0.0, advantaged_resource - disadvantaged_resource) * 0.03
            - scenario.distributional_safeguard * 1.6
            - scenario.accountability * 0.8,
            0.0,
            100.0,
        )

        archetype_risk_score = clamp(
            problem_stock * 0.16
            + delayed_harm_stock * 0.16
            + vulnerable_burden * 0.18
            + max(0.0, 70.0 - goal_level) * 0.18
            + max(0.0, 60.0 - commons_stock) * 0.16
            + max(0.0, advantaged_resource - disadvantaged_resource) * 0.08
            - capacity_stock * 0.10
            - trust_stock * 0.08,
            0.0,
            100.0,
        )

        structural_repair_score = clamp(
            capacity_stock * 0.18
            + goal_level * 0.14
            + commons_stock * 0.14
            + trust_stock * 0.16
            + repair_effect * 0.16
            + scenario.accountability * 10.0
            + scenario.distributional_safeguard * 10.0
            - archetype_risk_score * 0.18
            - problem_stock * 0.12,
            0.0,
            100.0,
        )

        rows.append({
            "period": period,
            "scenario": scenario.name,
            "archetype": scenario.archetype,
            "problem_stock": round(problem_stock, 3),
            "capacity_stock": round(capacity_stock, 3),
            "goal_level": round(goal_level, 3),
            "commons_stock": round(commons_stock, 3),
            "trust_stock": round(trust_stock, 3),
            "advantaged_resource": round(advantaged_resource, 3),
            "disadvantaged_resource": round(disadvantaged_resource, 3),
            "delayed_harm_stock": round(delayed_harm_stock, 3),
            "vulnerable_burden": round(vulnerable_burden, 3),
            "quick_relief": round(quick_relief, 3),
            "repair_effect": round(repair_effect, 3),
            "unintended_consequence": round(unintended_consequence, 3),
            "goal_erosion": round(goal_erosion, 3),
            "commons_depletion": round(commons_depletion, 3),
            "success_compounding": round(success_compounding, 3),
            "archetype_risk_score": round(archetype_risk_score, 3),
            "structural_repair_score": round(structural_repair_score, 3),
        })

        problem_history.append(problem_stock)

    return 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_risk = mean(float(row["archetype_risk_score"]) for row in subset)
        avg_repair = mean(float(row["structural_repair_score"]) for row in subset)
        avg_vulnerable = mean(float(row["vulnerable_burden"]) for row in subset)
        avg_delayed_harm = mean(float(row["delayed_harm_stock"]) for row in subset)

        if float(final["structural_repair_score"]) >= 65 and float(final["archetype_risk_score"]) <= 35:
            diagnostic = "structural repair changes the recurring pattern"
        elif avg_risk >= 55:
            diagnostic = "archetype risk dominates behavior over time"
        elif avg_delayed_harm >= 55:
            diagnostic = "delayed consequences are recreating the problem"
        elif avg_vulnerable >= 55:
            diagnostic = "recurring pattern shifts burden to vulnerable groups"
        elif avg_repair >= 55:
            diagnostic = "partial repair with remaining archetype risk"
        else:
            diagnostic = "weak evidence of structural repair"

        output.append({
            "scenario": scenario_name,
            "archetype": final["archetype"],
            "final_structural_repair_score": final["structural_repair_score"],
            "final_archetype_risk_score": final["archetype_risk_score"],
            "final_problem_stock": final["problem_stock"],
            "final_capacity_stock": final["capacity_stock"],
            "final_goal_level": final["goal_level"],
            "final_commons_stock": final["commons_stock"],
            "final_vulnerable_burden": final["vulnerable_burden"],
            "average_archetype_risk_score": round(avg_risk, 3),
            "average_structural_repair_score": round(avg_repair, 3),
            "average_vulnerable_burden": round(avg_vulnerable, 3),
            "average_delayed_harm_stock": round(avg_delayed_harm, 3),
            "diagnostic": diagnostic,
        })

    return output


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:
    scenarios = [
        ArchetypeScenario("Limits to growth pattern", "limits_to_growth", 0.78, 0.34, 0.54, 0.28, 0.34, 0.30, 0.38, 0.36, 0.34, 0.28),
        ArchetypeScenario("Fixes that fail pattern", "fixes_that_fail", 0.58, 0.40, 0.76, 0.82, 0.26, 0.34, 0.42, 0.34, 0.30, 0.30),
        ArchetypeScenario("Success to the successful pattern", "success_to_the_successful", 0.56, 0.44, 0.42, 0.38, 0.40, 0.82, 0.36, 0.42, 0.36, 0.28),
        ArchetypeScenario("Structural repair intervention", "integrated_repair", 0.42, 0.76, 0.32, 0.32, 0.82, 0.34, 0.30, 0.82, 0.82, 0.84),
    ]

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

    write_csv(TABLES / "system_archetypes_timeseries.csv", rows)
    write_csv(TABLES / "system_archetypes_summary.csv", summarize(rows))

    print("System archetypes workflow complete.")
    print(TABLES / "system_archetypes_timeseries.csv")


if __name__ == "__main__":
    main()

The workflow is intentionally simple enough to inspect. It shows how recurring patterns can arise from reinforcing pressure, delayed consequences, symptomatic fixes, weak repair, commons depletion, goal erosion, and resource-allocation bias. It also shows why archetype diagnosis should lead to structural repair rather than pattern naming alone. 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: Archetype Summary and Behavior-Pattern Visualization

The R workflow reads the Python-generated time-series output, creates archetype summaries, and exports base R plots for problem stock, capacity stock, goal level, commons stock, archetype risk, and structural repair. It uses only base R so it remains portable across simple local environments.

# system_archetypes_recurring_patterns_diagnostics.R
# Base R workflow for archetype summary and behavior-pattern 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, "system_archetypes_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_risk <- aggregate(archetype_risk_score ~ scenario, data = data, FUN = mean)
avg_repair <- aggregate(structural_repair_score ~ scenario, data = data, FUN = mean)
avg_vulnerable <- aggregate(vulnerable_burden ~ scenario, data = data, FUN = mean)
avg_delayed_harm <- aggregate(delayed_harm_stock ~ scenario, data = data, FUN = mean)

names(avg_risk)[2] <- "average_archetype_risk_score"
names(avg_repair)[2] <- "average_structural_repair_score"
names(avg_vulnerable)[2] <- "average_vulnerable_burden"
names(avg_delayed_harm)[2] <- "average_delayed_harm_stock"

final_fields <- last_by_scenario[, c(
  "scenario",
  "archetype",
  "structural_repair_score",
  "archetype_risk_score",
  "problem_stock",
  "capacity_stock",
  "goal_level",
  "commons_stock",
  "vulnerable_burden"
)]

names(final_fields) <- c(
  "scenario",
  "archetype",
  "final_structural_repair_score",
  "final_archetype_risk_score",
  "final_problem_stock",
  "final_capacity_stock",
  "final_goal_level",
  "final_commons_stock",
  "final_vulnerable_burden"
)

summary_table <- Reduce(
  function(x, y) merge(x, y, by = "scenario"),
  list(avg_risk, avg_repair, avg_vulnerable, avg_delayed_harm, final_fields)
)

summary_table$diagnostic <- ifelse(
  summary_table$final_structural_repair_score >= 65 &
    summary_table$final_archetype_risk_score <= 35,
  "structural repair changes the recurring pattern",
  ifelse(
    summary_table$average_archetype_risk_score >= 55,
    "archetype risk dominates behavior over time",
    ifelse(
      summary_table$average_delayed_harm_stock >= 55,
      "delayed consequences are recreating the problem",
      ifelse(
        summary_table$average_vulnerable_burden >= 55,
        "recurring pattern shifts burden to vulnerable groups",
        ifelse(
          summary_table$average_structural_repair_score >= 55,
          "partial repair with remaining archetype risk",
          "weak evidence of structural repair"
        )
      )
    )
  )
)

summary_table <- summary_table[order(summary_table$final_structural_repair_score, decreasing = TRUE), ]

write.csv(
  summary_table,
  file.path(tables_dir, "system_archetypes_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 Archetype 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("problem_stock", "Problem stock", "problem_stock_trajectories.png")
plot_metric("capacity_stock", "Capacity stock", "capacity_stock_trajectories.png")
plot_metric("goal_level", "Goal level", "goal_level_trajectories.png")
plot_metric("commons_stock", "Commons stock", "commons_stock_trajectories.png")
plot_metric("archetype_risk_score", "Archetype risk score", "archetype_risk_trajectories.png")
plot_metric("structural_repair_score", "Structural repair score", "structural_repair_trajectories.png")

png(file.path(figures_dir, "final_structural_repair_scores.png"), width = 1200, height = 700)
barplot(
  summary_table$final_structural_repair_score,
  names.arg = summary_table$scenario,
  las = 2,
  ylab = "Final structural repair score",
  main = "Final Structural Repair Score by Archetype Scenario"
)
grid()
dev.off()

print(summary_table)

This workflow supports the article’s central methodological claim: archetypes are recurring structures that should be tested against behavior over time, not labels applied by intuition alone. The R outputs help readers compare archetype patterns and evaluate whether interventions change the structure that reproduces recurrence.

Back to top ↑

GitHub Repository

The companion repository for this article should help readers identify, model, and compare system archetypes using causal-loop diagrams, stock-flow simulations, behavior-over-time examples, archetype diagnostics, scenario comparison, and synthetic datasets.

articles/system-archetypes-and-recurring-patterns/
├── python/
│   ├── system_archetypes_recurring_patterns_workflow.py
│   ├── archetype_diagnostics.py
│   ├── limits_to_growth_simulation.py
│   ├── fixes_that_fail_model.py
│   ├── shifting_the_burden_model.py
│   ├── eroding_goals_simulation.py
│   ├── escalation_model.py
│   ├── success_to_the_successful_model.py
│   ├── commons_depletion_model.py
│   ├── archetype_scenario_comparison.py
│   ├── validation_checks.py
│   └── run_all_archetype_workflows.py
├── r/
│   ├── system_archetypes_recurring_patterns_diagnostics.R
│   ├── archetype_behavior_plots.R
│   ├── limits_to_growth_visualization.R
│   ├── fixes_that_fail_tables.R
│   ├── shifting_burden_summary.R
│   ├── eroding_goals_visualization.R
│   ├── recurring_pattern_comparison.R
│   └── run_all_archetype_workflows.R
├── julia/
│   ├── nonlinear_archetype_dynamics.jl
│   ├── delayed_feedback_archetypes.jl
│   └── commons_and_escalation_models.jl
├── sql/
│   ├── schema_archetypes.sql
│   ├── schema_system_variables.sql
│   ├── schema_feedback_loops.sql
│   ├── schema_archetype_cases.sql
│   ├── schema_scenarios.sql
│   ├── schema_model_runs.sql
│   └── schema_outputs.sql
├── rust/
│   └── archetype_diagnostics_cli.rs
├── go/
│   └── archetype_scenario_runner.go
├── cpp/
│   ├── efficient_archetype_scan.cpp
│   └── delayed_feedback_solver.cpp
├── fortran/
│   └── recurrence_archetype_model.f90
├── c/
│   └── low_level_archetype_engine.c
├── docs/
│   ├── modeling_principles.md
│   ├── article_notes.md
│   ├── archetype_framework.md
│   ├── archetype_diagnostic_questions.md
│   ├── ethics_and_responsibility_notes.md
│   ├── assumptions_and_limitations.md
│   └── responsible_use.md
├── data/
│   ├── synthetic_archetypes.csv
│   ├── synthetic_system_variables.csv
│   ├── synthetic_feedback_loops.csv
│   ├── synthetic_archetype_cases.csv
│   ├── synthetic_scenarios.csv
│   ├── synthetic_model_runs.csv
│   └── synthetic_outputs.csv
├── outputs/
│   ├── README.md
│   ├── figures/
│   └── tables/
└── notebooks/
    ├── python_system_archetypes_walkthrough.ipynb
    └── r_archetype_visualization_placeholder.ipynb

This repository structure supports the article’s central argument: recurring system behavior often comes from recurring feedback structures. The data/ folder separates archetypes, variables, feedback loops, cases, scenarios, model runs, and outputs. The python/ and r/ folders support archetype diagnostics, limits-to-growth modeling, fixes-that-fail simulations, shifting-the-burden examples, eroding-goals patterns, escalation models, commons depletion, and scenario comparison. The julia folder supports nonlinear and delayed-feedback archetype dynamics. The sql folder defines schemas for archetypes, cases, scenarios, runs, and outputs. The lower-level language folders provide scaffolds for diagnostics, recurrence modeling, efficient scans, delayed feedback solving, and low-level simulation.

Back to top ↑

Back to top ↑

Back to top ↑

Why Archetype Thinking Matters

System archetypes matter because they reveal recurrence. They help systems thinkers see that different problems may share similar feedback structures. Limits to growth, fixes that fail, shifting the burden, eroding goals, escalation, success to the successful, tragedy of the commons, growth and underinvestment, and policy resistance all show how systems can produce familiar patterns across very different domains.

Archetype thinking helps move analysis beyond the latest event. It asks why the pattern keeps returning. It asks what feedback loops, delays, goals, resource flows, and boundary choices reproduce the behavior. It also asks what intervention would change the structure rather than merely reduce pressure for the moment.

Used well, archetypes prevent shallow reform. They reveal when quick fixes create delayed harm, when goals are being lowered, when advantage is compounding, when common resources are being depleted, when growth is creating its own constraint, and when systems are shifting burdens to people or places outside the official frame.

Used ethically, archetypes also change responsibility. They show that repeated harm is rarely accidental. If the same pattern keeps appearing, the system is teaching us something. The task is to listen structurally, intervene wisely, and repair what the pattern has been allowed to reproduce.

Back to top ↑

Related Articles

• Paradigms, Goals, and Deep System Change
• Leverage Points and Places to Intervene in a System
• Sensitivity Analysis for System Interventions
• Scenario Modeling in Systems Thinking
• System Dynamics and Simulation Modeling
• Stocks, Flows, and the Architecture of Change
• Dynamic Complexity and Policy Resistance
• Limits to Growth

Further Reading

• Senge, Peter M. The Fifth Discipline: The Art and Practice of the Learning Organization. Doubleday/Currency.
• Senge, Peter M., Kleiner, Art, Roberts, Charlotte, Ross, Richard B., and Smith, Bryan J. The Fifth Discipline Fieldbook: Strategies and Tools for Building a Learning Organization. Doubleday.
• Kim, Daniel H. and Anderson, Virginia. Systems Archetype Basics: From Story to Structure. Pegasus Communications.
• Wolstenholme, Eric F. “Towards the Definition and Use of a Core Set of Archetypal Structures in System Dynamics.” System Dynamics Review.
• 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.
• Ostrom, Elinor. Governing the Commons: The Evolution of Institutions for Collective Action. Cambridge University Press.

Back to top ↑

References

• Forrester, J.W. (1961) Industrial Dynamics. Cambridge, MA: MIT Press.
• Kim, D.H. and Anderson, V. (1998) Systems Archetype Basics: From Story to Structure. Waltham, MA: Pegasus Communications.
• 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/
• Ostrom, E. (1990) Governing the Commons: The Evolution of Institutions for Collective Action. Cambridge: Cambridge University Press.
• Senge, P.M. (1990) The Fifth Discipline: The Art and Practice of the Learning Organization. New York: Doubleday/Currency.
• Senge, P.M., Kleiner, A., Roberts, C., Ross, R.B. and Smith, B.J. (1994) The Fifth Discipline Fieldbook: Strategies and Tools for Building a Learning Organization. New York: Doubleday.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.
• Wolstenholme, E.F. (2003) “Towards the Definition and Use of a Core Set of Archetypal Structures in System Dynamics.” System Dynamics Review, 19(1), pp. 7–26.

Back to top ↑