Agent-Based Models, Network Models, and Systemic Risk

By /

Last Updated May 8, 2026

Agent-based models, network models, and systemic risk belong together because modern crises often emerge from interaction, interdependence, adaptation, and contagion rather than from one isolated failure. A bank does not fail only because of its own balance sheet. A supply chain does not break only because of one supplier. A power grid does not collapse only because of one component. A disease outbreak, misinformation wave, financial panic, cyber disruption, infrastructure outage, climate shock, or institutional failure can spread through networks of agents whose behavior changes under stress. Systemic risk is therefore not just the sum of individual risks. It is the risk produced by connected systems.

Traditional risk models often begin with aggregate variables, representative actors, average behavior, and stable relationships. Those tools remain useful, but they can miss how crises unfold when heterogeneous agents interact, learn, panic, imitate, hoard liquidity, cut supply, withdraw trust, change routes, sell assets, shift demand, or overload shared infrastructure. Agent-based models help represent behavior from the bottom up. Network models help represent the architecture of connection. Together, they allow analysts to examine how local decisions can become systemic events.


Main Library
Publications

Article Map
Risk & Resilience

Related Topic
Scenario Planning

Related Topic
Critical Infrastructure

Related Topic
Cyber Risk

Series context: This article is part of the Risk & Resilience knowledge series, which examines uncertainty, fragility, vulnerability, redundancy, adaptation, infrastructure protection, cascading failure, recovery, and the design of systems capable of preserving function under disturbance.
Editorial illustration showing interconnected agents, infrastructure systems, financial institutions, supply chains, hospitals, data centers, households, and public officials using network models to analyze systemic risk, contagion, and cascading failure.
Agent-based and network models help reveal how local shocks can propagate through financial, infrastructural, digital, health, and social systems before becoming systemic crises.

The central question is not whether these models can predict the next crisis with precision. They cannot. Their value is different: they reveal mechanisms. They show how shocks propagate, where dependencies concentrate, which agents become systemically important, which network structures amplify or absorb stress, which behavioral rules create instability, and which resilience interventions reduce cascading failure. Used well, agent-based and network models become tools for stress testing, scenario planning, institutional design, infrastructure protection, financial stability, cyber resilience, public-health preparedness, and systemic-risk governance.

Why This Topic Matters

This topic matters because many of the most serious risks facing modern societies are systemic. They do not remain contained within the first institution, infrastructure asset, platform, region, or community that experiences stress. They move. They are transmitted through financial exposures, supply contracts, cloud dependencies, power grids, transportation routes, social behavior, public trust, information systems, ecological feedbacks, and governance failures.

Systemic risk is difficult because the system can appear stable until interaction changes. A bank may be solvent until others sell similar assets and prices fall. A hospital may be prepared until a power outage, staffing shortage, supply delay, and cyber disruption occur together. A public agency may function until digital dependency, call volume, public distrust, and legal uncertainty interact. A city may appear resilient until heat, grid stress, housing precarity, and public-health vulnerability cascade together.

Agent-based models and network models matter because they help analysts represent these interactions explicitly. An agent-based model can represent households, firms, banks, hospitals, utilities, agencies, suppliers, drivers, patients, or platform users as agents with rules, constraints, resources, and adaptive behavior. A network model can represent the links among those agents: credit exposures, supply dependencies, physical connections, information flows, mobility patterns, infrastructure dependencies, or trust relationships.

Together, these tools help reveal why local resilience is not enough. A node can be strong but dependent on fragile links. A system can have many robust components but weak coordination. A network can absorb small shocks but transmit large ones. A policy can protect one sector while shifting risk elsewhere. A crisis can emerge not because every actor is weak, but because their interactions create shared vulnerability.

This article treats agent-based and network models not as abstract computational techniques, but as practical tools for resilience governance. They help ask where fragility is hidden, where contagion pathways run, where buffers are thin, where incentives create harmful behavior, and where interventions can reduce systemic risk before crisis exposes it.

Back to top ↑

What Systemic Risk Means

Systemic risk is the risk that disruption in one part of a system can spread, amplify, or transform into wider failure. It is not only large risk. It is relational risk. It arises when interdependence, feedback, concentration, common exposure, behavioral adaptation, and institutional fragility allow shocks to travel across the system.

In financial systems, systemic risk may arise when banks are linked through interbank lending, common asset holdings, funding markets, derivatives, payment systems, or confidence. A shock to one institution can produce asset sales, liquidity hoarding, margin calls, defaults, or loss of trust that affects others. Network structure matters because the pattern of exposures determines how losses propagate.

In infrastructure systems, systemic risk may arise when power, water, transport, telecommunications, hospitals, fuel supply, emergency services, and digital platforms depend on one another. A power outage can become a water problem, a hospital problem, a transportation problem, a communications problem, and a public-safety problem. The first failure is not the whole event; the cascade is the event.

In public health and social systems, systemic risk may arise when individual behavior, institutional trust, mobility, workplace conditions, misinformation, health capacity, and social vulnerability interact. Transmission is not only biological. It is social, institutional, economic, and informational.

In supply chains, systemic risk may arise when firms depend on common suppliers, just-in-time logistics, concentrated ports, rare materials, geopolitical chokepoints, fragile labor conditions, or digital coordination systems. A disruption in one node can ripple through production networks.

Systemic risk therefore requires a different modeling imagination. It asks not only “What is the probability of this event?” but “How does this event move?” It asks which links transmit stress, which agents adapt in destabilizing ways, which buffers absorb pressure, which thresholds trigger cascades, and which governance mechanisms can interrupt propagation.

The core insight is that systemic risk lives in relationships. To understand it, models must represent relationships.

Back to top ↑

Why Aggregate Models Can Miss Systemic Risk

Aggregate models remain useful for many purposes. They can identify broad trends, estimate macro-level relationships, simplify complex systems, and support policy analysis. But systemic risk often emerges precisely where aggregation removes critical information. A system average can hide concentrated exposure. A representative agent can hide heterogeneous behavior. A stable correlation can break when agents change strategy under stress.

The problem is not simplification itself. Every model simplifies. The problem is simplification that removes the mechanisms responsible for crisis. If a model assumes smooth adjustment, it may miss panic. If it assumes representative behavior, it may miss herd dynamics. If it assumes stable liquidity, it may miss fire sales. If it treats sectors separately, it may miss cascading infrastructure dependencies. If it assumes independent risks, it may miss common-mode failure.

Systemic crises often involve nonlinear behavior. Small shocks may be absorbed, while slightly larger shocks trigger cascades. Dense connections can diversify risk under normal conditions, but transmit risk under severe stress. Buffers can appear adequate until multiple agents draw on them at the same time. Redundancy can fail if all backup systems depend on the same supplier, cloud platform, grid, or workforce.

Aggregate indicators can also hide distribution. A financial system may appear well capitalized in aggregate while certain institutions are highly exposed. A city may appear resilient overall while specific neighborhoods remain vulnerable. A supply chain may appear diversified globally while relying on a single upstream component. A public institution may meet service targets on average while vulnerable users lose access first.

Agent-based and network models address these problems by preserving structure. They allow agents to differ. They allow connections to matter. They allow behavior to change under stress. They allow shocks to propagate through specific pathways. They can show why the same shock produces different outcomes depending on network topology, behavioral rules, institutional capacity, and intervention timing.

These models are not magic. They can be wrong, overfit, poorly calibrated, or falsely precise. But they ask systemic questions that aggregate models often cannot ask directly.

Back to top ↑

What Agent-Based Models Are

An agent-based model represents a system as a collection of interacting agents. Each agent has characteristics, rules, constraints, information, objectives, and possible behaviors. Agents may be people, households, firms, banks, hospitals, utilities, suppliers, agencies, vehicles, investors, social groups, institutions, or digital systems. The model then simulates how their interactions generate system-level outcomes.

The essential idea is emergence. System behavior is not imposed from the top down. It emerges from local interactions. A financial panic may emerge from many institutions trying to protect themselves. A traffic jam may emerge from many drivers making individually reasonable decisions. A disease outbreak may emerge from mobility patterns, social behavior, workplace constraints, and public-health interventions. A supply-chain shortage may emerge from firms adjusting orders, inventories, and sourcing under uncertainty.

Agent-based models are especially useful when agents are heterogeneous. Real systems rarely consist of identical actors. Banks differ in capital, liquidity, exposures, business models, and risk appetite. Households differ in income, health, mobility, trust, savings, and access to services. Firms differ in suppliers, inventory, debt, market power, and flexibility. Public institutions differ in authority, staffing, digital resilience, legitimacy, and learning capacity.

They are also useful when behavior changes under stress. Agents may hoard liquidity, imitate others, withdraw from markets, reroute supplies, avoid institutions, spread information, cut lending, delay investment, or overload public services. These behaviors can amplify or dampen shocks.

Agent-based models often proceed through simulation. The analyst defines agents, rules, networks, initial conditions, shocks, and time steps. The model then generates possible trajectories. The goal is not to predict one future with certainty. It is to explore mechanisms, stress-test assumptions, compare interventions, and identify conditions under which systemic risk emerges.

A good agent-based model should make behavior explicit. What do agents know? What do they value? What constraints do they face? How do they adapt? How do they interact? Which behavioral assumptions drive the results? These questions are not technical details. They are the substance of the model.

Back to top ↑

What Network Models Are

A network model represents a system as nodes connected by edges. Nodes may be institutions, people, firms, infrastructure assets, ecosystems, data systems, agencies, households, ports, hospitals, banks, suppliers, or communities. Edges represent relationships: financial exposures, physical connections, supply dependencies, information flows, trust ties, mobility patterns, contractual obligations, shared assets, or operational dependencies.

Network models matter because structure matters. A system with the same number of nodes and links can behave very differently depending on how those links are arranged. Some networks are centralized around hubs. Some are modular. Some are dense. Some have bridges between communities. Some have hidden dependencies. Some are robust to random failure but fragile to targeted attacks on central nodes. Some absorb local shocks but transmit large shocks quickly.

Network analysis provides tools for identifying systemic importance. Degree centrality may show highly connected nodes. Betweenness centrality may show nodes that connect otherwise separate parts of a system. Eigenvector centrality may show nodes connected to other important nodes. Clustering may show tightly connected groups. Assortativity may show whether similar nodes connect to one another. Community detection may reveal modules. Cascading models may estimate how failures propagate.

But systemic risk cannot be understood through centrality alone. A node may have few links but connect to a critical function. A highly connected node may be resilient. A peripheral node may hold a unique dependency. A network may appear diversified but carry common exposure. A hidden shared supplier may matter more than visible direct links. Network metrics are useful, but they require domain interpretation.

Network models can represent single-layer or multilayer systems. A financial network may include interbank loans, derivatives, securities holdings, payment flows, and common asset exposures. A city network may include power, water, roads, hospitals, communications, and emergency services. A supply-chain network may include suppliers, transport links, inventories, contracts, and demand relationships. Multilayer networks are often more realistic because systemic risk travels across layers.

The core value of network models is that they make interdependence visible. They show that resilience depends not only on components, but on connection patterns.

Back to top ↑

Why Agent-Based and Network Models Belong Together

Agent-based models and network models are powerful separately, but they are especially useful together. Agent-based models represent behavior. Network models represent connection. Systemic risk usually requires both. Shocks propagate through networks, but propagation depends on how agents respond. Agents adapt under stress, but the consequences of adaptation depend on where they sit in the network.

In a financial system, a network model may show exposures among banks. But whether a shock becomes systemic depends on agent behavior: do banks sell assets, hoard liquidity, call loans, withdraw from counterparties, or seek emergency funding? An agent-based layer can model those behavioral responses. A network layer can model how those responses affect others.

In a supply chain, a network model may show supplier dependencies. But systemic outcomes depend on firm behavior: do firms reroute, substitute inputs, ration inventory, raise prices, delay production, or panic-order? The network shows possible pathways; the agents determine whether those pathways become cascades.

In a public-health model, the network may show contact patterns, mobility, households, workplaces, schools, and care facilities. Agents determine behavior: compliance, risk perception, isolation, vaccination, care-seeking, work attendance, and trust. The outcome emerges from both structure and behavior.

In infrastructure, network models can show physical dependencies among power, water, telecom, transport, and hospitals. Agent behavior adds operators, emergency managers, households, firms, and public agencies responding under constraints. A blackout is not only an engineering event. It is also a behavioral and institutional event.

Combining agent-based and network modeling helps capture feedback. A shock changes behavior. Behavior changes network flows. Changed flows create new stresses. New stresses change behavior again. This feedback is central to systemic risk. It is why crises often accelerate, shift direction, or reveal hidden dependencies.

The combined approach also supports intervention testing. Analysts can ask: What happens if capital buffers are higher? What happens if firms diversify suppliers? What happens if backup power is added to hospitals? What happens if public communication improves trust? What happens if a central node is protected? What happens if a network becomes more modular? The model can compare mechanisms rather than merely describe risks.

The goal is not perfect prediction. The goal is systemic insight.

Back to top ↑

Contagion, Cascades, and Feedback Loops

Systemic risk often becomes visible through contagion, cascades, and feedback loops. These terms are related but distinct. Contagion refers to stress spreading from one agent or node to another. Cascades refer to sequences of failures in which one failure triggers others. Feedback loops refer to processes where outcomes reinforce or dampen the conditions that produced them.

Financial contagion may occur through direct credit exposure, asset-price declines, funding stress, margin calls, confidence loss, or common asset sales. A bank under stress may sell assets to raise liquidity. Those sales lower prices. Lower prices weaken other balance sheets. Other banks sell too. What began as a local balance-sheet problem becomes a systemwide fire-sale dynamic.

Infrastructure cascades may occur when one system depends on another. A power outage disables pumps. Water pressure falls. Hospitals lose service. Communications fail. Traffic signals stop. Emergency response slows. Public trust declines. The system does not fail because each component was weak in isolation; it fails because dependencies amplify the first disruption.

Social contagion may involve behavior, information, trust, fear, or coordination. People may imitate evacuation decisions, withdraw deposits, panic-buy supplies, ignore warnings, spread misinformation, or avoid public institutions. These behaviors can amplify risk or reduce it, depending on context.

Feedback loops can be stabilizing or destabilizing. Stabilizing feedback may include automatic stabilizers, emergency liquidity, mutual aid, backup systems, trusted communication, or adaptive routing. Destabilizing feedback may include panic selling, hoarding, misinformation, cascading defaults, public distrust, or infrastructure overload.

Agent-based network models can represent these mechanisms explicitly. They can show when contagion stops, when cascades accelerate, and which feedback loops dominate. They can test whether interventions dampen propagation. They can reveal thresholds: levels of shock, exposure, or behavioral response beyond which the system changes regime.

The key lesson is that systemic risk is dynamic. It cannot be fully understood from a static list of assets, hazards, or institutions. The dangerous question is not only “What fails?” but “What happens next?”

Back to top ↑

Financial Systemic Risk

Financial systems are one of the most developed domains for agent-based and network systemic-risk modeling. The reason is clear: financial institutions are connected through lending, borrowing, payments, derivatives, securities holdings, funding markets, confidence, collateral, and common exposures. These connections can distribute risk, but they can also transmit it.

Network models help identify how financial exposures are structured. They can reveal concentration, centrality, interbank dependencies, common asset holdings, and potential contagion paths. They can show how one institution’s distress may affect others through balance-sheet linkages. They can also help assess systemic importance: not only who is large, but who is positioned in ways that transmit stress.

Agent-based models add behavioral realism. Banks, funds, households, firms, and investors do not passively absorb shocks. They respond. They may deleverage, hoard liquidity, cut lending, sell assets, call collateral, shorten maturities, or reduce exposures. These responses may be individually rational but collectively destabilizing. A system can become fragile when many agents take defensive actions at the same time.

The global financial crisis demonstrated why systemic modeling matters. Risk was not contained within individual balance sheets. It moved through mortgage markets, securitization chains, funding markets, derivatives, ratings, leverage, trust, and policy responses. Network and agent-based approaches help represent how such linkages and behaviors can generate amplification.

Financial applications include interbank contagion, liquidity hoarding, fire sales, common asset exposure, funding runs, derivatives networks, payment-system resilience, macroprudential stress testing, climate-related financial risk, cyber-related financial contagion, and systemic importance analysis. These tools can support regulators, central banks, risk managers, and public institutions.

But financial systemic-risk modeling also requires caution. Data on exposures may be incomplete or confidential. Behavioral assumptions may be contestable. Market behavior can change under regulation. Models can create false confidence if treated as forecasts. The strongest use is comparative and diagnostic: which structures amplify stress, which agents matter, which buffers help, and which interventions reduce contagion.

Financial systemic risk shows the broader lesson for all resilience work: risk is not held only by individual units. It is generated by system architecture.

Back to top ↑

Critical Infrastructure and Interdependent Systems

Critical infrastructure systems are natural candidates for agent-based and network models because they are deeply interdependent. Power, water, transport, telecommunications, healthcare, fuel, food logistics, emergency services, public administration, and digital platforms do not function independently. They depend on one another in ways that may be invisible during normal operation and decisive during crisis.

Network models can represent physical and operational dependencies. A hospital depends on electricity, water, roads, staff, fuel, medical supplies, communications, and digital records. A water system depends on power, chemicals, pumps, treatment plants, distribution networks, operators, sensors, and billing systems. A transport system depends on fuel, power, roads, bridges, signaling, digital coordination, and labor.

Agent-based models can represent how people and institutions behave during infrastructure stress. Households change mobility patterns, seek supplies, call emergency services, use backup power, or overload communication channels. Firms alter operations, shift demand, ration inventory, or close. Public agencies prioritize services, reroute resources, issue warnings, and activate emergency plans. Operators restore systems under resource constraints.

Together, these models can examine cascading failure. What happens if a substation fails during a heat wave? Which water pumps lose power? Which hospitals rely on affected circuits? Which roads become congested? Which neighborhoods lose cooling? Which emergency services are delayed? Which vulnerable groups are exposed first? A static risk register may list these assets separately; a network model shows how they interact.

They can also support resilience design. Redundancy, modularity, distributed generation, backup communications, mutual aid, spare parts, manual fallback, local storage, and critical-node protection can all be tested. The model can ask whether an intervention reduces cascading failure or merely protects one asset while leaving dependencies exposed.

Critical infrastructure modeling must include social consequences. A technically resilient system that preserves service for wealthy districts while vulnerable communities lose access is not resilient in a meaningful public sense. Network models should therefore connect infrastructure nodes to population vulnerability, service access, and recovery equity.

Infrastructure resilience is not only engineering. It is interdependence, governance, and justice under stress.

Back to top ↑

Cyber Risk, Digital Dependency, and Common-Mode Failure

Cyber risk increasingly has systemic characteristics because digital systems create shared dependencies. Cloud providers, identity systems, payment platforms, software libraries, operating systems, managed service providers, communication tools, data centers, APIs, and cybersecurity vendors can become common infrastructure for many institutions at once. When many organizations depend on the same digital layer, a failure can become systemic.

Network models can represent digital dependency. Nodes may include agencies, firms, hospitals, banks, platforms, vendors, cloud regions, identity providers, payment systems, data centers, or software components. Edges may represent service dependency, data flow, authentication, contractual reliance, API connection, or operational integration. Such models can reveal concentration, shared exposure, and common-mode failure.

Agent-based models can represent attackers, defenders, users, institutions, vendors, and response teams. They can examine patching behavior, detection delays, incident response, user behavior, misinformation, backup activation, ransom decisions, service restoration, and cross-institution coordination. Cyber incidents are not only technical events; they involve organizational behavior and public trust.

Systemic cyber risk can emerge through several pathways. A widely used software vulnerability can expose many organizations simultaneously. A cloud outage can disable services across sectors. A payment-system disruption can affect commerce, benefits, payroll, and financial markets. A cyberattack on a hospital system can cascade into public health, emergency response, and regional care capacity. A digital identity failure can block access to public services.

Cyber resilience therefore requires more than organization-level security. It requires understanding shared dependencies, vendor concentration, interoperability, backup systems, manual fallback, mutual aid, incident communication, legal authority, and public accountability. Agent-based network models can help identify where the digital system is too concentrated, too opaque, or too dependent on untested assumptions.

The major blind spot is that digital efficiency can reduce visible friction while increasing systemic dependency. A platform may make services faster, cheaper, and more integrated under normal conditions, but more fragile when the platform fails. Modeling should therefore ask not only how digital systems perform when working, but what happens when many institutions lose the same dependency at once.

Cyber systemic risk is the risk of correlated digital failure across connected institutions.

Back to top ↑

Public Health, Social Behavior, and Collective Risk

Public-health risk is deeply behavioral and networked. Disease transmission, care access, vaccination, risk perception, trust, misinformation, workplace exposure, household structure, mobility, and institutional capacity all shape outcomes. Agent-based and network models are therefore useful for understanding how health risks move through populations and systems.

A network model can represent contacts among households, schools, workplaces, care facilities, transport systems, communities, and regions. It can show how disease, information, or behavior spreads through social and mobility networks. It can also reveal which nodes or settings are especially important for transmission or protection.

An agent-based model can represent individual and institutional behavior. People may seek care, avoid care, isolate, continue working, comply with guidance, distrust institutions, share information, respond to incentives, or adapt to perceived risk. Hospitals may triage, expand capacity, ration resources, transfer patients, or experience staff shortages. Public agencies may issue guidance, deploy resources, and revise policy.

Public-health systemic risk emerges when biological, social, and institutional systems interact. A disease outbreak can become a hospital-capacity crisis, workforce crisis, school crisis, supply-chain crisis, misinformation crisis, and legitimacy crisis. The same pathogen can produce different outcomes depending on social vulnerability, housing, labor, trust, insurance, transport, and health-system capacity.

Agent-based models can test interventions such as targeted vaccination, school closure, ventilation, masking, testing, workplace protections, communication strategies, hospital surge capacity, and social support. Network models can show how interventions affect transmission pathways. Combined models can ask whether a policy works equally across groups or whether it shifts burdens onto already vulnerable people.

Public-health modeling also shows the ethical importance of assumptions. Whose behavior is modeled as choice, and whose behavior is constrained by work, housing, disability, care responsibilities, or immigration status? Does the model include trust? Does it include unequal access to care? Does it include public-service capacity? A model that treats people as identical risk processors may miss the social structure of vulnerability.

Systemic public-health resilience requires modeling people as embedded in networks of care, work, trust, exposure, and institutional protection.

Back to top ↑

Supply Chains, Production Networks, and Fragility

Supply chains are networks of production, transport, contracts, inventories, suppliers, labor, infrastructure, finance, and information. They are efficient when coordination works, but fragile when dependencies are concentrated, buffers are thin, or shocks occur across multiple nodes. Agent-based and network models can help reveal why supply-chain disruptions become systemic.

Network models can represent firms, suppliers, transport corridors, ports, warehouses, inventories, materials, and customers. They can identify central suppliers, chokepoints, substitute pathways, geographic concentration, and common dependencies. They can show whether a system is diversified in appearance but dependent on one critical input, region, port, supplier, or digital platform.

Agent-based models can represent firm behavior. Firms may reorder, ration, substitute, hoard inventory, raise prices, delay production, switch suppliers, cut labor, or pass costs downstream. These responses can amplify disruption. Panic ordering can create artificial scarcity. Just-in-time inventory can reduce normal costs while increasing shock sensitivity. Supplier switching can overload alternatives. Price spikes can shift risk to households and small firms.

Supply-chain systemic risk is especially important for food, medicine, energy, semiconductors, construction materials, water-treatment chemicals, emergency equipment, and critical infrastructure components. A disruption in one upstream input can affect many downstream systems. When multiple sectors depend on the same supplier or logistics corridor, common-mode failure becomes possible.

Models can test resilience interventions: inventory buffers, supplier diversification, regional production, substitution capacity, transparent dependency mapping, public stockpiles, priority allocation, transport redundancy, contract flexibility, and mutual aid. They can also identify trade-offs. More redundancy may cost more. More localization may reduce some risks but increase others. More inventory may improve resilience but create waste or financial burden.

Supply-chain models should also include equity. Disruptions do not affect all people equally. Shortages can raise prices, reduce access, harm low-income households, disrupt public services, and expose workers. A system may restore aggregate flows while vulnerable groups remain excluded.

The key lesson is that supply-chain resilience depends on both network structure and agent behavior. A map of suppliers is not enough. The model must ask how firms act when the map is stressed.

Back to top ↑

Resilience Interventions: Redundancy, Buffers, Modularity, and Governance

Agent-based and network models are most useful when they help compare resilience interventions. A model that only describes fragility is incomplete. The purpose is to understand which changes reduce systemic risk and under what conditions.

Redundancy is one intervention. Multiple suppliers, backup power, parallel communication channels, alternative transport routes, reserve staff, duplicate data systems, and mutual aid agreements can reduce dependence on single points of failure. But redundancy must be real. A backup system that depends on the same cloud provider, power source, vendor, or workforce may not reduce systemic risk.

Buffers are another intervention. Capital buffers, liquidity reserves, inventory, emergency funds, spare parts, surge capacity, food stocks, public-health capacity, and time margins can absorb shocks. Agent-based models can test how much buffer is needed and when buffers are drawn down simultaneously.

Modularity can reduce contagion. A modular system can isolate failure so that disruption in one part does not spread everywhere. In financial systems, this may involve clearing, capital requirements, exposure limits, or firebreaks. In infrastructure, it may involve microgrids, distributed systems, compartmentalization, or local fallback. In digital systems, it may involve segmentation and zero-trust architectures. In public services, it may involve decentralized capacity.

Diversity is also important. Systems composed of identical agents can fail together when they share the same vulnerability. Diversity of suppliers, technologies, institutions, strategies, crops, infrastructure designs, and communication channels can reduce correlated failure. But diversity must be balanced with coordination.

Governance interventions matter because systems do not self-correct automatically. Transparency, stress testing, disclosure, regulation, public accountability, maintenance, community participation, and institutional learning can reduce hidden fragility. Models can help identify where governance changes matter most.

The best interventions are often robust across scenarios. They reduce risk under many plausible futures. Agent-based network models can help identify these robust strategies by simulating different shocks, behavioral rules, network structures, and policy responses.

The point is not to optimize for one predicted future. It is to build systems that remain functional when assumptions fail.

Back to top ↑

Model Governance, Validation, and Ethical Limits

Agent-based and network models require careful governance. Because these models can be complex, visual, and computationally impressive, they can create false authority. A simulation animation or network diagram may look persuasive even when assumptions are weak. Model governance ensures that these tools support judgment rather than replace it.

Validation is difficult. Systemic crises are rare, changing, and context-dependent. A model may reproduce past patterns but fail under new conditions. Calibration data may be incomplete. Network edges may be hidden. Behavioral rules may be uncertain. Some relationships may be confidential, informal, or politically sensitive. Good model governance requires transparency about these limits.

Models should document assumptions. What agents are included? What networks are included? What is excluded? What behavioral rules are used? What data sources support them? How are shocks introduced? How are interventions tested? What sensitivity analysis was performed? Which results are robust and which depend on fragile assumptions?

Sensitivity testing is essential. Analysts should vary parameters, behavioral rules, network structures, shock severity, intervention timing, and data assumptions. If results change dramatically under small assumption changes, the model may still be useful, but its uncertainty must be visible.

Ethics also matter. Models can affect policy decisions that shape lives. A model that identifies a community as high risk may direct investment, but it may also stigmatize or justify withdrawal. A model that omits informal workers, undocumented residents, disabled people, or low-income renters may understate vulnerability. A model that optimizes system continuity may ignore justice.

Participation improves model quality. Frontline workers, community organizations, infrastructure operators, public agencies, and affected residents often know pathways of fragility that formal data miss. Model governance should include review, challenge, and revision by people who understand the system from different positions.

The goal is not model worship. The goal is disciplined learning. Agent-based and network models should be treated as structured arguments about how systems behave, not as final truth.

Back to top ↑

Toward Systemic Risk Intelligence

Systemic-risk intelligence means building the capacity to see, test, govern, and reduce risk across interconnected systems. It is not only a modeling capability. It is an institutional capability. It requires data, methods, governance, public accountability, and the willingness to act on uncomfortable evidence.

Agent-based and network models can support this capacity by making hidden interdependence visible. They can show where shocks may travel, where behavior may amplify stress, where common dependencies exist, and where interventions may reduce cascading failure. They can connect scenario planning to stress testing, infrastructure planning, public finance, cyber resilience, public health, and social protection.

A systemic-risk intelligence framework should include several practices. First, dependency mapping: identifying how institutions, infrastructure, firms, communities, and ecosystems depend on one another. Second, behavioral modeling: understanding how agents may adapt under stress. Third, network stress testing: testing shocks across connection structures. Fourth, equity analysis: identifying who is exposed, who is protected, and who is invisible. Fifth, intervention comparison: evaluating which investments reduce contagion and cascades. Sixth, governance review: ensuring results change decisions.

This framework should also be iterative. Networks change. Agents learn. Institutions reform or degrade. New dependencies emerge. Digital platforms become more central. Climate risks intensify. Supply chains shift. Public trust rises or falls. Models must be updated as systems change.

The future of resilience will require more than hazard lists and emergency plans. It will require systems that can understand their own interdependence. Agent-based and network models are not sufficient by themselves, but they are among the most important tools for that task.

Systemic risk is produced by connected life. Systemic resilience must be designed with connection in view.

Back to top ↑

Mathematical Lens

A networked systemic-risk model can represent system fragility as a function of shock severity, exposure, vulnerability, connectivity, agent behavior, and capacity. Let \(R_s\) represent systemic-risk pressure:

\[
R_s = \alpha H + \beta E + \gamma V + \delta K + \epsilon B_a – \lambda C – \mu M – \nu G
\]

Interpretation: Systemic-risk pressure increases with hazard severity, exposure, vulnerability, network connectivity, and destabilizing agent behavior. It decreases when capacity, modularity, and governance are strong.

A simple contagion rule can be written as:

\[
s_i(t+1) = f\left(s_i(t), \sum_{j=1}^{n} w_{ji}s_j(t), c_i, b_i(t)\right)
\]

Interpretation: The state of node or agent \(i\) at the next time step depends on its current state, weighted stress arriving from connected nodes, its internal capacity, and its behavioral response under stress.

A network amplification measure can be expressed as:

\[
A_n = \frac{L_T}{L_0}
\]

Interpretation: Network amplification compares total system losses after propagation with the initial loss. Values above 1 indicate that network dynamics amplified the original shock.

Term Meaning Interpretive role
\(R_s\) Systemic-risk pressure Represents the combined pressure created by shocks, vulnerability, connectivity, behavior, and limited capacity.
\(H\) Hazard severity Represents the magnitude of the initiating shock.
\(E\) Exposure Represents people, assets, institutions, services, or systems located in the path of disruption.
\(V\) Vulnerability Represents susceptibility to harm due to social, financial, technical, institutional, or ecological conditions.
\(K\) Connectivity Represents network density, centrality, interdependence, and dependency structure.
\(B_a\) Destabilizing agent behavior Represents panic, hoarding, fire sales, withdrawal, overload, imitation, or other stress responses.
\(C\) Capacity Represents buffers, reserves, redundancy, skills, institutional readiness, and adaptive capability.
\(M\) Modularity Represents the ability to isolate failure and prevent systemwide contagion.
\(G\) Governance Represents coordination, rules, accountability, warning, intervention, and learning capacity.
\(s_i(t)\) Agent or node state Represents whether an agent is functioning, stressed, failed, recovering, or adapting at time \(t\).
\(w_{ji}\) Network weight Represents the strength of dependency or exposure from node \(j\) to node \(i\).
\(A_n\) Network amplification Represents how much the network magnifies the initial loss after propagation.

The equations are conceptual rather than predictive. Their value is to make systemic-risk logic explicit: risk depends not only on shock size, but on network structure, behavioral response, capacity, modularity, and governance.

Back to top ↑

Advanced Python Workflow: Agent-Based Network Systemic-Risk Simulation

This Python workflow creates a simplified agent-based network model. Agents have capacity, vulnerability, exposure, and behavioral sensitivity. A shock begins at selected nodes, spreads through weighted network links, and is amplified or dampened by capacity and behavioral response.

from __future__ import annotations

import random
from dataclasses import dataclass
from typing import Dict, List, Tuple

import networkx as nx
import numpy as np
import pandas as pd


@dataclass
class AgentState:
    """
    State variables for a modeled agent or node.

    All index values are normalized to [0, 1].
    Higher capacity and governance reduce systemic risk.
    Higher vulnerability, exposure, and behavioral sensitivity increase systemic risk.
    """
    capacity: float
    vulnerability: float
    exposure: float
    behavioral_sensitivity: float
    governance_support: float
    stress: float = 0.0
    failed: bool = False


def clamp_01(value: float) -> float:
    return max(0.0, min(1.0, value))


def build_system_network(
    n_agents: int = 40,
    connection_probability: float = 0.08,
    seed: int = 42,
) -> nx.DiGraph:
    """
    Build a directed weighted network representing dependencies among agents.

    In a real model, edges could represent interbank exposures, supplier relationships,
    infrastructure dependencies, cyber dependencies, patient transfers, data flows,
    or public-service dependencies.
    """
    random.seed(seed)
    np.random.seed(seed)

    graph = nx.gnp_random_graph(
        n=n_agents,
        p=connection_probability,
        seed=seed,
        directed=True,
    )

    for source, target in graph.edges():
        graph[source][target]["weight"] = float(np.random.uniform(0.05, 0.35))

    return graph


def assign_agent_states(graph: nx.DiGraph, seed: int = 42) -> Dict[int, AgentState]:
    """
    Assign heterogeneous capacity, vulnerability, exposure, behavior, and governance values.
    """
    random.seed(seed)
    np.random.seed(seed)

    states: Dict[int, AgentState] = {}

    for node in graph.nodes():
        states[node] = AgentState(
            capacity=float(np.random.uniform(0.35, 0.90)),
            vulnerability=float(np.random.uniform(0.10, 0.75)),
            exposure=float(np.random.uniform(0.10, 0.85)),
            behavioral_sensitivity=float(np.random.uniform(0.05, 0.70)),
            governance_support=float(np.random.uniform(0.25, 0.90)),
        )

    return states


def apply_initial_shock(
    states: Dict[int, AgentState],
    shocked_nodes: List[int],
    shock_intensity: float,
) -> None:
    """Apply an initial shock to selected agents."""
    for node in shocked_nodes:
        agent = states[node]

        initial_stress = (
            shock_intensity *
            agent.exposure *
            (0.50 + 0.50 * agent.vulnerability) *
            (1.0 - 0.40 * agent.capacity)
        )

        agent.stress = clamp_01(agent.stress + initial_stress)


def update_failures(
    states: Dict[int, AgentState],
    failure_threshold: float = 0.75,
) -> None:
    """Mark agents as failed when stress exceeds threshold."""
    for agent in states.values():
        if agent.stress >= failure_threshold:
            agent.failed = True


def propagate_stress(
    graph: nx.DiGraph,
    states: Dict[int, AgentState],
    behavioral_amplification: float = 0.35,
    governance_damping: float = 0.30,
) -> Dict[int, float]:
    """
    Propagate stress through weighted network dependencies.

    Stress transmitted to a target increases with:
    - source stress
    - edge dependency weight
    - target vulnerability
    - target behavioral sensitivity

    Stress is dampened by:
    - target capacity
    - target governance support
    """
    incoming_stress: Dict[int, float] = {node: 0.0 for node in graph.nodes()}

    for source, target, data in graph.edges(data=True):
        source_agent = states[source]
        target_agent = states[target]
        weight = float(data.get("weight", 0.0))

        behavioral_term = 1.0 + behavioral_amplification * target_agent.behavioral_sensitivity
        damping_term = (
            1.0 -
            0.45 * target_agent.capacity -
            governance_damping * target_agent.governance_support
        )

        transmitted = (
            source_agent.stress *
            weight *
            (0.50 + target_agent.vulnerability) *
            behavioral_term *
            max(0.05, damping_term)
        )

        incoming_stress[target] += transmitted

    return incoming_stress


def simulate_systemic_risk(
    graph: nx.DiGraph,
    states: Dict[int, AgentState],
    shocked_nodes: List[int],
    shock_intensity: float = 0.95,
    n_steps: int = 12,
    recovery_rate: float = 0.06,
) -> pd.DataFrame:
    """
    Simulate systemic-risk propagation over time.

    Recovery is simplified as a constant stress-reduction term multiplied by capacity.
    """
    apply_initial_shock(states, shocked_nodes, shock_intensity)

    records = []

    for step in range(n_steps + 1):
        update_failures(states)

        total_stress = sum(agent.stress for agent in states.values())
        failed_agents = sum(agent.failed for agent in states.values())
        mean_stress = np.mean([agent.stress for agent in states.values()])

        records.append(
            {
                "step": step,
                "total_system_stress": total_stress,
                "mean_agent_stress": mean_stress,
                "failed_agents": failed_agents,
                "failed_share": failed_agents / len(states),
            }
        )

        incoming = propagate_stress(graph, states)

        for node, agent in states.items():
            recovery = recovery_rate * agent.capacity * (0.50 + agent.governance_support)
            agent.stress = clamp_01(agent.stress + incoming[node] - recovery)

    return pd.DataFrame(records)


def summarize_network(graph: nx.DiGraph, states: Dict[int, AgentState]) -> pd.DataFrame:
    """Create a node-level systemic importance and fragility summary."""
    pagerank = nx.pagerank(graph, weight="weight")
    betweenness = nx.betweenness_centrality(graph, weight="weight", normalized=True)
    in_strength = dict(graph.in_degree(weight="weight"))
    out_strength = dict(graph.out_degree(weight="weight"))

    rows = []

    for node, agent in states.items():
        systemic_fragility_score = (
            0.25 * agent.vulnerability +
            0.20 * agent.exposure +
            0.20 * agent.behavioral_sensitivity +
            0.15 * pagerank[node] +
            0.10 * betweenness[node] +
            0.10 * (1 - agent.capacity)
        )

        rows.append(
            {
                "node": node,
                "capacity": agent.capacity,
                "vulnerability": agent.vulnerability,
                "exposure": agent.exposure,
                "behavioral_sensitivity": agent.behavioral_sensitivity,
                "governance_support": agent.governance_support,
                "pagerank": pagerank[node],
                "betweenness": betweenness[node],
                "in_strength": in_strength.get(node, 0.0),
                "out_strength": out_strength.get(node, 0.0),
                "systemic_fragility_score": systemic_fragility_score,
            }
        )

    return (
        pd.DataFrame(rows)
        .sort_values("systemic_fragility_score", ascending=False)
        .reset_index(drop=True)
    )


def main() -> None:
    graph = build_system_network(n_agents=50, connection_probability=0.07, seed=7)
    states = assign_agent_states(graph, seed=7)

    node_summary = summarize_network(graph, states)
    high_fragility_nodes = node_summary.head(3)["node"].tolist()

    simulation = simulate_systemic_risk(
        graph=graph,
        states=states,
        shocked_nodes=high_fragility_nodes,
        shock_intensity=0.90,
        n_steps=15,
        recovery_rate=0.05,
    )

    node_summary.to_csv("agent_network_systemic_fragility_summary.csv", index=False)
    simulation.to_csv("agent_network_systemic_risk_simulation.csv", index=False)

    print("Top systemic-fragility nodes:")
    print(node_summary.head(10).to_string(index=False))

    print("\nSystemic-risk simulation:")
    print(simulation.to_string(index=False))


if __name__ == "__main__":
    main()

This workflow is intentionally simplified. Its purpose is to show how agent heterogeneity, network position, behavioral response, governance support, and capacity interact. A production model would require validated data, domain-specific behavioral rules, sensitivity analysis, uncertainty reporting, and careful model governance.

Back to top ↑

Advanced R Workflow: Network Fragility and Systemic-Risk Diagnostics

This R workflow evaluates network fragility using node-level indicators, centrality metrics, and resilience characteristics. It is designed for diagnostic analysis of systemic importance, dependency concentration, and fragility pressure.

library(readr)
library(dplyr)
library(igraph)

edge_file <- "systemic_risk_edges.csv"
node_file <- "systemic_risk_nodes.csv"

edge_df <- read_csv(edge_file, show_col_types = FALSE)
node_df <- read_csv(node_file, show_col_types = FALSE)

required_edge_cols <- c("source", "target", "weight")
required_node_cols <- c(
  "node",
  "system_type",
  "capacity_index",
  "vulnerability_index",
  "exposure_index",
  "governance_support_index",
  "redundancy_index",
  "behavioral_sensitivity_index"
)

missing_edge_cols <- setdiff(required_edge_cols, names(edge_df))
missing_node_cols <- setdiff(required_node_cols, names(node_df)) if (length(missing_edge_cols) > 0) {
  stop(paste("Missing edge columns:", paste(missing_edge_cols, collapse = ", ")))
}

if (length(missing_node_cols) > 0) {
  stop(paste("Missing node columns:", paste(missing_node_cols, collapse = ", ")))
}

index_cols <- names(node_df)[grepl("_index$", names(node_df))]

invalid_index_cols <- index_cols[
  vapply(
    node_df[index_cols],
    function(x) any(is.na(x) | x < 0 | x > 1),
    logical(1)
  )
]

if (length(invalid_index_cols) > 0) {
  stop(
    paste(
      "Index columns must be complete and normalized to [0, 1]:",
      paste(invalid_index_cols, collapse = ", ")
    )
  )
}

graph <- graph_from_data_frame(
  d = edge_df,
  vertices = node_df,
  directed = TRUE
)

E(graph)$weight <- edge_df$weight

node_metrics <- tibble(
  node = V(graph)$name,
  degree_total = degree(graph, mode = "all"),
  degree_in = degree(graph, mode = "in"),
  degree_out = degree(graph, mode = "out"),
  strength_in = strength(graph, mode = "in", weights = E(graph)$weight),
  strength_out = strength(graph, mode = "out", weights = E(graph)$weight),
  betweenness = betweenness(graph, directed = TRUE, weights = E(graph)$weight, normalized = TRUE),
  page_rank = page_rank(graph, directed = TRUE, weights = E(graph)$weight)$vector
)

diagnostics <- node_df %>%
  left_join(node_metrics, by = "node") %>%
  mutate(
    centrality_pressure = percent_rank(page_rank + betweenness + strength_in + strength_out),
    internal_fragility = (
      vulnerability_index +
        exposure_index +
        behavioral_sensitivity_index +
        (1 - capacity_index) +
        (1 - governance_support_index) +
        (1 - redundancy_index)
    ) / 6,
    systemic_fragility_score = (
      0.35 * internal_fragility +
        0.25 * centrality_pressure +
        0.15 * behavioral_sensitivity_index +
        0.15 * vulnerability_index +
        0.10 * exposure_index
    ),
    resilience_buffer_score = (
      capacity_index +
        governance_support_index +
        redundancy_index
    ) / 3,
    systemic_risk_band = case_when(
      systemic_fragility_score >= 0.75 ~ "Extreme systemic fragility",
      systemic_fragility_score >= 0.55 ~ "High systemic fragility",
      systemic_fragility_score >= 0.35 ~ "Moderate systemic fragility",
      TRUE ~ "Lower systemic fragility"
    )
  ) %>%
  arrange(desc(systemic_fragility_score))

system_type_summary <- diagnostics %>%
  group_by(system_type) %>%
  summarise(
    avg_systemic_fragility = mean(systemic_fragility_score, na.rm = TRUE),
    avg_resilience_buffer = mean(resilience_buffer_score, na.rm = TRUE),
    avg_centrality_pressure = mean(centrality_pressure, na.rm = TRUE),
    avg_internal_fragility = mean(internal_fragility, na.rm = TRUE),
    avg_capacity = mean(capacity_index, na.rm = TRUE),
    avg_vulnerability = mean(vulnerability_index, na.rm = TRUE),
    avg_exposure = mean(exposure_index, na.rm = TRUE),
    avg_governance_support = mean(governance_support_index, na.rm = TRUE),
    avg_redundancy = mean(redundancy_index, na.rm = TRUE),
    observations = n(),
    .groups = "drop"
  ) %>%
  arrange(desc(avg_systemic_fragility))

write_csv(diagnostics, "network_systemic_fragility_diagnostics.csv")
write_csv(system_type_summary, "network_systemic_fragility_system_type_summary.csv")

cat("Node-level systemic fragility diagnostics:\n")
print(diagnostics)

cat("\nSystem-type summary:\n")
print(system_type_summary)

This workflow helps identify whether systemic risk is concentrated in highly connected nodes, vulnerable nodes, exposed nodes, behaviorally sensitive nodes, or nodes with weak capacity and governance support. It is most useful when paired with scenario analysis and stress testing.

Back to top ↑

GitHub Repository

Complete Code Repository

The full code distribution for this article, including agent-based network simulation workflows, systemic-risk propagation diagnostics, network fragility scoring, SQL materials, optional model-governance support tools, and supporting documentation, is available on GitHub.

View the Full GitHub Repository

Back to top ↑

Back to top ↑

Further Reading

Back to top ↑

References

Back to top ↑

Scroll to Top