Agent-Based Modeling of Adoption and Diffusion: A Systems Modeling Case Study

Last Updated June 7, 2026

Agent-based modeling of adoption and diffusion shows how individual choices can produce system-level adoption patterns. A new technology, practice, policy, product, behavior, platform, standard, or social norm rarely spreads because everyone evaluates it in the same way at the same time. Diffusion occurs through heterogeneous agents: some are open to novelty, some wait for evidence, some follow trusted peers, some face cost barriers, some need institutional approval, some resist change, and some adopt only when adoption becomes socially or economically unavoidable.

This case study builds a practical agent-based model of adoption and diffusion. Agents differ in adoption threshold, social influence, perceived benefit, cost sensitivity, network position, trust, exposure, and resistance. Some agents are seeded as early adopters. Over time, each agent observes neighbors, updates perceived value, evaluates adoption conditions, and either adopts or waits. The model then tracks aggregate adoption curves, adoption timing, adoption clusters, network effects, tipping behavior, saturation, failed diffusion, and the effect of intervention strategies.

The purpose is not to predict the exact spread of a real technology, policy, or behavior. The purpose is to show how micro-level rules generate macro-level diffusion patterns. Agent-based modeling is useful when adoption depends on heterogeneity, peer influence, network structure, social learning, local thresholds, trust, geography, institutional constraints, and path dependence.

This article works through the case as a model-building exercise. It defines the diffusion problem, agents, states, networks, adoption rules, scenarios, metrics, assumptions, equations, diagnostics, uncertainty, R and Python workflows, interpretation limits, and responsible communication practices.

This case study covers model purpose, agent design, adoption states, social networks, peer influence, thresholds, seeding strategies, adoption scenarios, diffusion diagnostics, uncertainty, validation, mathematical framing, R and Python workflows, common pitfalls, and responsible interpretation.

Case Study Purpose

The purpose of this case study is to show how agent-based modeling can represent adoption and diffusion as a process of heterogeneous individual decision-making. Instead of assuming that adoption spreads smoothly through a population, the model represents agents with different thresholds, network positions, costs, benefits, trust levels, resistance levels, and exposure to adopters.

The case can be interpreted across many domains: technology adoption, renewable-energy adoption, public-health behavior, organizational practice change, policy diffusion, agricultural technology, software platform adoption, safety practices, education interventions, consumer behavior, or infrastructure standards. The model is generic by design so the logic can be adapted to different adoption contexts.

The case is a learning model. It is designed to clarify diffusion mechanisms, not to produce a calibrated forecast for a specific technology, policy, or behavior.

Back to top ↑

The System Being Modeled

The modeled system is a population of agents connected by a social or institutional network. Each agent begins in a non-adopted state unless seeded as an initial adopter. At each time step, agents observe their neighbors, evaluate perceived benefit, compare adoption pressure against their threshold, and decide whether to adopt. Adoption is irreversible in the simple version of the model, though more advanced versions can include abandonment, switching, churn, or competing innovations.

The model turns adoption into a dynamic interaction between agent attributes and network structure. The same innovation may spread quickly in one network and stall in another because influence pathways, thresholds, trust, and costs differ.

Back to top ↑

Why Adoption and Diffusion Need Agent-Based Modeling

Adoption and diffusion need agent-based modeling when aggregate curves hide the local mechanisms that produce them. A smooth S-shaped adoption curve may emerge from many different micro-level processes: strong peer influence, declining cost, targeted seeding, institutional mandates, network hubs, social learning, trust-building, threshold crossing, or repeated exposure. Without modeling agents and interactions, those mechanisms remain hidden.

Agent-based modeling is especially useful when diffusion is social, local, uneven, threshold-dependent, or policy-sensitive.

Back to top ↑

Core Agent-Based Structure

The core structure has agents, a network, adoption states, decision rules, and time steps. At each time step, each non-adopter evaluates adoption pressure. That pressure depends on agent-specific benefit, cost, trust, peer influence, and the share of neighboring agents who have already adopted.

The model is simple, but it can generate complex results: slow diffusion, rapid takeoff, tipping points, clustered adoption, persistent non-adoption, and unequal diffusion across groups.

Back to top ↑

Agents, States, and Attributes

Each agent has a state and a set of attributes. The state records whether the agent has adopted. Attributes influence the adoption decision.

Heterogeneity is not a detail. It is the reason agent-based models are valuable for adoption and diffusion. Diffusion depends on who is connected, who is trusted, who faces barriers, and who changes first.

Back to top ↑

Social Network Structure

The network defines how adoption influence travels. A fully mixed population assumes everyone can influence everyone else. A local network assumes influence travels mainly through nearby or connected agents. A clustered network can produce pockets of adoption and pockets of resistance. A hub network can produce rapid spread if central actors adopt, but weak spread if hubs resist.

Network structure can determine whether adoption becomes widespread or remains confined to early clusters. The same number of seed adopters can produce different results depending on where they are placed.

Back to top ↑

Adoption Rules

The adoption rule converts agent attributes and social influence into a decision. In the simple case, a non-adopter adopts when adoption pressure exceeds the agent’s threshold. Adoption pressure is a weighted combination of perceived benefit, peer adoption, trust, intervention effect, cost, and resistance.

This case uses a transparent threshold rule. More advanced versions can add probabilistic adoption, competing innovations, abandonment, learning, marketing effects, pricing, policy mandates, or multi-stage adoption.

Back to top ↑

Model Boundary

The model boundary includes agents, network ties, adoption states, adoption thresholds, perceived benefit, cost sensitivity, trust, resistance, peer influence, seeding, and intervention effects. It excludes detailed economics, media systems, regulatory enforcement, marketing budgets, institutional procurement, supply constraints, demographic change, geography, and competing innovations. These exclusions keep the case focused on agent-level diffusion logic.

For real decision use, the boundary should expand to include domain evidence, stakeholder knowledge, adoption data, institutional context, distributional consequences, and validation.

Back to top ↑

Variables and Parameters

The model uses variables that describe agents, networks, adoption states, and scenario conditions.

These variables support a basic but flexible adoption model. More advanced models can add price changes, social media exposure, institutional mandates, multiple adoption stages, network rewiring, geography, competing innovations, and abandonment.

Back to top ↑

Baseline Assumptions

The baseline assumptions define the simplified case. They should be treated as modeling choices, not claims about any specific adoption system.

These assumptions keep the model transparent. Applied work should test how results change when assumptions are relaxed.

Back to top ↑

Governing Equations

The model uses discrete-time adoption logic. Each agent’s adoption state updates at each time step.

The local neighbor adoption share is:

Adoption pressure combines benefit, peer influence, trust, intervention support, cost, and resistance:

The deterministic threshold rule is:

Aggregate adoption share is:

A simple adoption acceleration measure is:

These equations produce diffusion dynamics from local interaction. The aggregate curve is an emergent outcome, not a directly imposed assumption.

Back to top ↑

Scenario Design

Scenario design tests how diffusion changes under different assumptions about social influence, cost, trust, network structure, seeding strategy, and resistance. Each scenario is a structured experiment.

Scenarios should not be interpreted as forecasts. They are mechanism tests that show which conditions matter most for adoption outcomes.

Back to top ↑

Baseline Diffusion Scenario

The baseline diffusion scenario uses moderate peer influence, moderate cost, moderate perceived benefit, and a small number of randomly selected seed adopters. It provides a reference case for comparison.

If adoption grows slowly in the baseline scenario, the model suggests that peer influence or perceived value may be too weak to overcome thresholds. If adoption accelerates after a delay, the system may contain a tipping dynamic.

Back to top ↑

High Social Influence Scenario

The high social influence scenario increases the weight of adopted neighbors in the adoption decision. This scenario represents strong peer learning, visible adoption, reputational pressure, social proof, community norms, professional imitation, or network-based trust.

High social influence can help diffusion, but it can also intensify inequality if some groups are poorly connected to adopters.

Back to top ↑

High Cost Barrier Scenario

The high cost barrier scenario increases the weight of cost in the adoption decision. Cost can include price, training, time, switching effort, uncertainty, maintenance, disruption, risk, or administrative burden.

This scenario often shows that social influence alone may not overcome material barriers. Adoption strategies that ignore cost and capacity can overestimate diffusion speed.

Back to top ↑

Targeted Seeding Scenario

The targeted seeding scenario selects initial adopters strategically. Instead of choosing seed adopters at random, the model seeds agents with high degree, high influence, high trust, or bridge positions between clusters.

Targeted seeding can increase adoption speed, but it can also reinforce inequality if only already-central or advantaged agents are targeted. Strategy should be evaluated for both total adoption and distributional reach.

Back to top ↑

Network Fragmentation Scenario

The network fragmentation scenario weakens connections between groups. Adoption may spread inside clusters but fail to cross into disconnected or weakly connected parts of the network.

Fragmentation is a major reason adoption can appear successful in aggregate while leaving specific communities, firms, organizations, or regions behind.

Back to top ↑

Trust and Resistance Scenario

The trust and resistance scenario lowers trust and raises resistance for some agents or groups. This represents skepticism, distrust of institutions, past harm, poor communication, cultural mismatch, political contestation, technical uncertainty, or negative experience with previous interventions.

This scenario is important because adoption failure is not always a communication problem. It may reflect mistrust, burden, exclusion, misaligned incentives, or legitimate concern.

Back to top ↑

Diagnostics and Output Measures

A useful adoption-diffusion model should report more than final adoption share. Final adoption may hide timing, inequality, cluster behavior, and failed diffusion in specific groups.

Diffusion success should be evaluated by reach, timing, distribution, and robustness. A model that reports only final adoption share is incomplete.

Back to top ↑

Interpretation of Results

Model results should be interpreted as behavior patterns, not precise predictions. The most important output is the mechanism: did adoption spread because of peer influence, seeding, high perceived benefit, low cost, trust, bridge agents, or network structure?

The model should help explain why adoption unfolds as it does. A good interpretation connects output patterns to agent rules, network structure, and scenario assumptions.

Back to top ↑

Policy and Strategy Leverage Points

The case reveals several leverage points for increasing adoption while avoiding exclusion and overclaiming.

The strongest diffusion strategy may not be the one that maximizes early adoption. It may be the one that reaches across network boundaries, lowers barriers, builds trust, and prevents persistent exclusion.

Back to top ↑

Uncertainty and Sensitivity

Agent-based diffusion models are sensitive to assumptions about thresholds, network structure, seeding, trust, benefit, cost, resistance, and social influence. Responsible interpretation requires sensitivity analysis.

If conclusions change under plausible assumptions, the diffusion strategy is fragile. Fragility should be reported because it identifies where better data, outreach, trust, or intervention design is needed.

Back to top ↑

Model Limitations

This case study is intentionally simplified. It is useful for learning diffusion mechanisms, but it should not be used as a real adoption forecast without major expansion and validation.

The model is best used for conceptual learning, strategy comparison, scenario exploration, and decision-support prototyping. Applied use requires evidence, calibration, and stakeholder review.

Back to top ↑

Relationship to Other Systems Modeling Approaches

Agent-based adoption modeling connects naturally with other systems modeling approaches. Diffusion is often a hybrid problem involving agents, networks, feedback, scenarios, geography, and policy interventions.

A strong diffusion model often combines ABM with network data, scenario design, participatory review, calibration, and decision support outputs.

Back to top ↑

Mathematical Lens: Thresholds, Influence, Networks, and Adoption Curves

The agent population can be represented as a network:

Each agent has an adoption state:

Local adoption exposure is calculated from neighbors:

Adoption pressure combines individual and social factors:

The adoption threshold rule is:

The aggregate adoption curve is:

An adoption inequality measure can compare group adoption rates:

These formulas show how diffusion emerges from local rules. The adoption curve is not imposed directly; it is produced by agent decisions over time.

Back to top ↑

Back to top ↑

R Workflow: Agent-Based Adoption and Diffusion Simulation

The R workflow below uses base R only. It creates a synthetic agent population, generates a social network, simulates adoption under multiple scenarios, and exports adoption diagnostics.

# agent_based_adoption_diffusion_workflow.R
# Base R workflow:
# synthetic agents, network ties, adoption thresholds, peer influence, scenario diagnostics.
#
# Suggested repository placement:
# articles/case-study-agent-based-modeling-of-adoption-and-diffusion/r/agent_based_adoption_diffusion_workflow.R

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

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

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

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

set.seed(42)

create_agents <- function(n = 120) {
  groups <- rep(c("early_access", "mainstream", "high_barrier"), length.out = n)

  data.frame(
    agent_id = seq_len(n),
    group = groups,
    threshold = ifelse(groups == "early_access", runif(n, 0.25, 0.50),
                       ifelse(groups == "mainstream", runif(n, 0.40, 0.70), runif(n, 0.60, 0.90))),
    perceived_benefit = ifelse(groups == "early_access", runif(n, 0.55, 0.85),
                               ifelse(groups == "mainstream", runif(n, 0.45, 0.75), runif(n, 0.30, 0.65))),
    cost_sensitivity = ifelse(groups == "high_barrier", runif(n, 0.55, 0.90), runif(n, 0.25, 0.65)),
    trust = ifelse(groups == "high_barrier", runif(n, 0.25, 0.60), runif(n, 0.45, 0.90)),
    resistance = ifelse(groups == "high_barrier", runif(n, 0.45, 0.80), runif(n, 0.15, 0.55)),
    adopted = 0,
    stringsAsFactors = FALSE
  )
}

create_network <- function(agents, connection_probability = 0.055, bridge_probability = 0.018) {
  edges <- data.frame(from = integer(0), to = integer(0))

  for (i in seq_len(nrow(agents))) {
    for (j in seq_len(nrow(agents))) {
      if (i < j) {
        same_group <- agents$group[i] == agents$group[j]
        probability <- ifelse(same_group, connection_probability, bridge_probability)

        if (runif(1) < probability) {
          edges <- rbind(edges, data.frame(from = i, to = j))
          edges <- rbind(edges, data.frame(from = j, to = i))
        }
      }
    }
  }

  edges
}

neighbor_share <- function(agent_id, agents, edges) {
  neighbors <- edges$to[edges$from == agent_id]

  if (length(neighbors) == 0) {
    return(0)
  }

  mean(agents$adopted[neighbors])
}

simulate_diffusion <- function(
  scenario,
  n_steps = 40,
  social_weight = 0.45,
  benefit_weight = 0.42,
  intervention_weight = 0.10,
  cost_weight = 0.28,
  resistance_weight = 0.20,
  seed_strategy = "random",
  seed_count = 6,
  cost_modifier = 1.0,
  trust_modifier = 1.0,
  connection_probability = 0.055,
  bridge_probability = 0.018
) {
  agents <- create_agents()
  agents$trust <- pmin(1, agents$trust * trust_modifier)
  agents$cost_sensitivity <- pmin(1, agents$cost_sensitivity * cost_modifier)

  edges <- create_network(agents, connection_probability, bridge_probability)

  degree <- sapply(agents$agent_id, function(id) sum(edges$from == id))

  if (seed_strategy == "high_degree") {
    seed_ids <- order(degree, decreasing = TRUE)[seq_len(seed_count)]
  } else if (seed_strategy == "bridge_and_equity") {
    high_barrier_ids <- agents$agent_id[agents$group == "high_barrier"]
    seed_ids <- c(high_barrier_ids[seq_len(min(3, length(high_barrier_ids)))],
                  order(degree, decreasing = TRUE)[seq_len(seed_count)])
    seed_ids <- unique(seed_ids)[seq_len(seed_count)]
  } else {
    seed_ids <- sample(agents$agent_id, seed_count)
  }

  agents$adopted[seed_ids] <- 1

  rows <- data.frame()

  for (step in 0:n_steps) {
    group_summary <- aggregate(adopted ~ group, data = agents, FUN = mean)
    adoption_gap <- max(group_summary$adopted) - min(group_summary$adopted)

    rows <- rbind(
      rows,
      data.frame(
        scenario = scenario,
        step = step,
        adoption_share = mean(agents$adopted),
        adopter_count = sum(agents$adopted),
        adoption_gap = adoption_gap,
        early_access_adoption = group_summary$adopted[group_summary$group == "early_access"],
        mainstream_adoption = group_summary$adopted[group_summary$group == "mainstream"],
        high_barrier_adoption = group_summary$adopted[group_summary$group == "high_barrier"],
        stringsAsFactors = FALSE
      )
    )

    if (step == n_steps) {
      break
    }

    new_adopters <- integer(0)

    for (i in agents$agent_id[agents$adopted == 0]) {
      peer_share <- neighbor_share(i, agents, edges)

      adoption_pressure <-
        benefit_weight * agents$perceived_benefit[i] +
        social_weight * agents$trust[i] * peer_share +
        intervention_weight -
        cost_weight * agents$cost_sensitivity[i] -
        resistance_weight * agents$resistance[i]

      if (adoption_pressure >= agents$threshold[i]) {
        new_adopters <- c(new_adopters, i)
      }
    }

    if (length(new_adopters) > 0) {
      agents$adopted[new_adopters] <- 1
    }
  }

  rows
}

scenarios <- list(
  baseline_diffusion = list(),
  high_social_influence = list(social_weight = 0.75),
  high_cost_barrier = list(cost_modifier = 1.35),
  targeted_seeding = list(seed_strategy = "high_degree"),
  network_fragmentation = list(connection_probability = 0.060, bridge_probability = 0.003),
  trust_and_resistance = list(trust_modifier = 0.65, cost_modifier = 1.10)
)

all_runs <- data.frame()

for (scenario_name in names(scenarios)) {
  params <- scenarios[[scenario_name]]
  run <- do.call(simulate_diffusion, c(list(scenario = scenario_name), params))
  all_runs <- rbind(all_runs, run)
}

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

for (scenario_name in scenario_names) {
  subset_rows <- all_runs[all_runs$scenario == scenario_name, ]

  time_to_25 <- subset_rows$step[subset_rows$adoption_share >= 0.25]
  time_to_50 <- subset_rows$step[subset_rows$adoption_share >= 0.50]

  summary_rows <- rbind(
    summary_rows,
    data.frame(
      scenario = scenario_name,
      final_adoption_share = subset_rows$adoption_share[nrow(subset_rows)],
      final_adopter_count = subset_rows$adopter_count[nrow(subset_rows)],
      maximum_adoption_gap = max(subset_rows$adoption_gap),
      final_adoption_gap = subset_rows$adoption_gap[nrow(subset_rows)],
      time_to_25_percent = ifelse(length(time_to_25) == 0, NA, min(time_to_25)),
      time_to_50_percent = ifelse(length(time_to_50) == 0, NA, min(time_to_50)),
      stringsAsFactors = FALSE
    )
  )
}

validation_checks <- data.frame(
  check = c(
    "scenario_runs_created",
    "adoption_share_normalized",
    "adopter_count_nonnegative",
    "summary_created"
  ),
  passed = c(
    nrow(all_runs) > 0,
    all(all_runs$adoption_share >= 0 & all_runs$adoption_share <= 1),
    all(all_runs$adopter_count >= 0),
    nrow(summary_rows) > 0
  )
)

write.csv(all_runs, file.path(tables_dir, "r_adoption_diffusion_timeseries.csv"), row.names = FALSE)
write.csv(summary_rows, file.path(tables_dir, "r_adoption_diffusion_summary.csv"), row.names = FALSE)
write.csv(validation_checks, file.path(tables_dir, "r_adoption_diffusion_validation_checks.csv"), row.names = FALSE)

png(file.path(figures_dir, "r_adoption_diffusion_curves.png"), width = 1000, height = 700)
plot(
  NULL,
  xlim = range(all_runs$step),
  ylim = c(0, 1),
  xlab = "Time Step",
  ylab = "Adoption Share",
  main = "Agent-Based Adoption and Diffusion Scenarios"
)

for (scenario_name in scenario_names) {
  subset_rows <- all_runs[all_runs$scenario == scenario_name, ]
  lines(subset_rows$step, subset_rows$adoption_share, lwd = 2)
}

legend("bottomright", legend = scenario_names, lwd = 2, cex = 0.75)
grid()
dev.off()

print(summary_rows)
print(validation_checks)
cat("R agent-based adoption and diffusion workflow complete.\n")

This workflow creates a transparent agent-based diffusion experiment. It can be extended with empirical networks, multi-stage adoption, abandonment, geographic layers, competing innovations, and calibration against real adoption data.

Back to top ↑

Python Workflow: Agent-Based Adoption and Diffusion Model

The Python workflow below uses only the standard library. It creates synthetic agents, builds a network, simulates adoption under several scenarios, and exports adoption diagnostics.

#!/usr/bin/env python3
"""
Case study: agent-based modeling of adoption and diffusion.

Dependency-light workflow demonstrating:

1. Synthetic heterogeneous agents
2. Social network generation
3. Threshold-based adoption rules
4. Peer influence and trust
5. Scenario comparison
6. Adoption diagnostics and validation checks

All data are synthetic.
"""

from __future__ import annotations

from dataclasses import dataclass, asdict
from pathlib import Path
import csv
import random


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


@dataclass
class Agent:
    agent_id: int
    group: str
    threshold: float
    perceived_benefit: float
    cost_sensitivity: float
    trust: float
    resistance: float
    adopted: int = 0


@dataclass(frozen=True)
class Scenario:
    name: str
    social_weight: float = 0.45
    benefit_weight: float = 0.42
    intervention_weight: float = 0.10
    cost_weight: float = 0.28
    resistance_weight: float = 0.20
    seed_strategy: str = "random"
    seed_count: int = 6
    cost_modifier: float = 1.0
    trust_modifier: float = 1.0
    connection_probability: float = 0.055
    bridge_probability: float = 0.018
    steps: int = 40


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}")

    fieldnames: list[str] = []
    for row in rows:
        for key in row:
            if key not in fieldnames:
                fieldnames.append(key)

    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


def create_agents(n: int = 120, seed: int = 42) -> list[Agent]:
    random.seed(seed)
    groups = ["early_access", "mainstream", "high_barrier"]
    agents: list[Agent] = []

    for agent_id in range(1, n + 1):
        group = groups[(agent_id - 1) % len(groups)]

        if group == "early_access":
            threshold = random.uniform(0.25, 0.50)
            benefit = random.uniform(0.55, 0.85)
            cost = random.uniform(0.25, 0.55)
            trust = random.uniform(0.55, 0.90)
            resistance = random.uniform(0.15, 0.45)
        elif group == "mainstream":
            threshold = random.uniform(0.40, 0.70)
            benefit = random.uniform(0.45, 0.75)
            cost = random.uniform(0.30, 0.65)
            trust = random.uniform(0.45, 0.80)
            resistance = random.uniform(0.25, 0.55)
        else:
            threshold = random.uniform(0.60, 0.90)
            benefit = random.uniform(0.30, 0.65)
            cost = random.uniform(0.55, 0.90)
            trust = random.uniform(0.25, 0.60)
            resistance = random.uniform(0.45, 0.80)

        agents.append(
            Agent(
                agent_id=agent_id,
                group=group,
                threshold=round(threshold, 6),
                perceived_benefit=round(benefit, 6),
                cost_sensitivity=round(cost, 6),
                trust=round(trust, 6),
                resistance=round(resistance, 6),
            )
        )

    return agents


def create_network(
    agents: list[Agent],
    connection_probability: float,
    bridge_probability: float,
    seed: int = 42,
) -> list[tuple[int, int]]:
    random.seed(seed + 1000)
    edges: list[tuple[int, int]] = []

    for i, source in enumerate(agents):
        for target in agents[i + 1:]:
            same_group = source.group == target.group
            probability = connection_probability if same_group else bridge_probability

            if random.random() < probability:
                edges.append((source.agent_id, target.agent_id))
                edges.append((target.agent_id, source.agent_id))

    return edges


def degree_map(edges: list[tuple[int, int]]) -> dict[int, int]:
    degrees: dict[int, int] = {}
    for source, _target in edges:
        degrees[source] = degrees.get(source, 0) + 1
    return degrees


def choose_seed_agents(agents: list[Agent], edges: list[tuple[int, int]], strategy: str, count: int) -> list[int]:
    if strategy == "high_degree":
        degrees = degree_map(edges)
        ranked = sorted(agents, key=lambda agent: degrees.get(agent.agent_id, 0), reverse=True)
        return [agent.agent_id for agent in ranked[:count]]

    if strategy == "bridge_and_equity":
        high_barrier = [agent.agent_id for agent in agents if agent.group == "high_barrier"]
        degrees = degree_map(edges)
        ranked = sorted(agents, key=lambda agent: degrees.get(agent.agent_id, 0), reverse=True)
        seed_ids = high_barrier[: min(3, len(high_barrier))]
        for agent in ranked:
            if agent.agent_id not in seed_ids:
                seed_ids.append(agent.agent_id)
            if len(seed_ids) >= count:
                break
        return seed_ids[:count]

    random.seed(7)
    return random.sample([agent.agent_id for agent in agents], count)


def neighbor_ids(agent_id: int, edges: list[tuple[int, int]]) -> list[int]:
    return [target for source, target in edges if source == agent_id]


def neighbor_adoption_share(agent_id: int, agents_by_id: dict[int, Agent], edges: list[tuple[int, int]]) -> float:
    neighbors = neighbor_ids(agent_id, edges)
    if not neighbors:
        return 0.0
    return sum(agents_by_id[neighbor].adopted for neighbor in neighbors) / len(neighbors)


def group_adoption_summary(agents: list[Agent]) -> dict[str, float]:
    groups = sorted(set(agent.group for agent in agents))
    summary: dict[str, float] = {}

    for group in groups:
        group_agents = [agent for agent in agents if agent.group == group]
        summary[group] = sum(agent.adopted for agent in group_agents) / len(group_agents)

    return summary


def simulate(scenario: Scenario) -> tuple[list[dict[str, object]], list[Agent], list[tuple[int, int]]]:
    agents = create_agents()
    for agent in agents:
        agent.trust = min(1.0, agent.trust * scenario.trust_modifier)
        agent.cost_sensitivity = min(1.0, agent.cost_sensitivity * scenario.cost_modifier)

    edges = create_network(
        agents=agents,
        connection_probability=scenario.connection_probability,
        bridge_probability=scenario.bridge_probability,
    )

    seed_ids = choose_seed_agents(agents, edges, scenario.seed_strategy, scenario.seed_count)
    agents_by_id = {agent.agent_id: agent for agent in agents}

    for seed_id in seed_ids:
        agents_by_id[seed_id].adopted = 1

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

    for step in range(scenario.steps + 1):
        group_summary = group_adoption_summary(agents)
        adoption_values = list(group_summary.values())
        adoption_gap = max(adoption_values) - min(adoption_values)

        rows.append(
            {
                "scenario": scenario.name,
                "step": step,
                "adoption_share": round(sum(agent.adopted for agent in agents) / len(agents), 6),
                "adopter_count": sum(agent.adopted for agent in agents),
                "adoption_gap": round(adoption_gap, 6),
                "early_access_adoption": round(group_summary.get("early_access", 0), 6),
                "mainstream_adoption": round(group_summary.get("mainstream", 0), 6),
                "high_barrier_adoption": round(group_summary.get("high_barrier", 0), 6),
            }
        )

        if step == scenario.steps:
            break

        new_adopters: list[int] = []

        for agent in agents:
            if agent.adopted == 1:
                continue

            peer_share = neighbor_adoption_share(agent.agent_id, agents_by_id, edges)

            adoption_pressure = (
                scenario.benefit_weight * agent.perceived_benefit
                + scenario.social_weight * agent.trust * peer_share
                + scenario.intervention_weight
                - scenario.cost_weight * agent.cost_sensitivity
                - scenario.resistance_weight * agent.resistance
            )

            if adoption_pressure >= agent.threshold:
                new_adopters.append(agent.agent_id)

        for agent_id in new_adopters:
            agents_by_id[agent_id].adopted = 1

    return rows, agents, edges


def summarize(rows: list[dict[str, object]]) -> dict[str, object]:
    final = rows[-1]
    time_to_25 = [int(row["step"]) for row in rows if float(row["adoption_share"]) >= 0.25]
    time_to_50 = [int(row["step"]) for row in rows if float(row["adoption_share"]) >= 0.50]

    return {
        "scenario": final["scenario"],
        "final_adoption_share": final["adoption_share"],
        "final_adopter_count": final["adopter_count"],
        "maximum_adoption_gap": round(max(float(row["adoption_gap"]) for row in rows), 6),
        "final_adoption_gap": final["adoption_gap"],
        "time_to_25_percent": min(time_to_25) if time_to_25 else "not_reached",
        "time_to_50_percent": min(time_to_50) if time_to_50 else "not_reached",
    }


def main() -> None:
    scenarios = [
        Scenario(name="baseline_diffusion"),
        Scenario(name="high_social_influence", social_weight=0.75),
        Scenario(name="high_cost_barrier", cost_modifier=1.35),
        Scenario(name="targeted_seeding", seed_strategy="high_degree"),
        Scenario(name="network_fragmentation", connection_probability=0.060, bridge_probability=0.003),
        Scenario(name="trust_and_resistance", trust_modifier=0.65, cost_modifier=1.10),
    ]

    all_rows: list[dict[str, object]] = []
    summary_rows: list[dict[str, object]] = []
    scenario_rows: list[dict[str, object]] = []
    final_agent_rows: list[dict[str, object]] = []

    for scenario in scenarios:
        rows, agents, edges = simulate(scenario)
        all_rows.extend(rows)
        summary_rows.append(summarize(rows))
        scenario_rows.append(asdict(scenario))

        for agent in agents:
            agent_row = asdict(agent)
            agent_row["scenario"] = scenario.name
            final_agent_rows.append(agent_row)

    validation_rows = [
        {
            "check": "scenario_runs_created",
            "passed": len(all_rows) > 0,
            "value": len(all_rows),
        },
        {
            "check": "adoption_share_normalized",
            "passed": all(0 <= float(row["adoption_share"]) <= 1 for row in all_rows),
            "value": "all_adoption_shares_checked",
        },
        {
            "check": "adopter_count_nonnegative",
            "passed": all(int(row["adopter_count"]) >= 0 for row in all_rows),
            "value": "all_adopter_counts_checked",
        },
        {
            "check": "summary_created",
            "passed": len(summary_rows) == len(scenarios),
            "value": len(summary_rows),
        },
    ]

    write_csv(TABLES / "python_adoption_diffusion_timeseries.csv", all_rows)
    write_csv(TABLES / "python_adoption_diffusion_summary.csv", summary_rows)
    write_csv(TABLES / "python_adoption_diffusion_scenarios.csv", scenario_rows)
    write_csv(TABLES / "python_final_agent_states.csv", final_agent_rows)
    write_csv(TABLES / "python_adoption_diffusion_validation_checks.csv", validation_rows)

    print("Agent-based adoption and diffusion workflow complete.")
    print(TABLES / "python_adoption_diffusion_summary.csv")


if __name__ == "__main__":
    main()

This workflow produces a reproducible adoption-diffusion scenario set. It can be adapted for technology adoption, policy uptake, behavioral diffusion, organizational change, public health interventions, or sustainability transitions.

Back to top ↑

GitHub Repository

Back to top ↑

Common Pitfalls

Agent-based diffusion models are powerful because they represent heterogeneity and interaction. They can also mislead if the rules, network, or assumptions are poorly justified.

The central correction is disciplined interpretation. An ABM should clarify possible mechanisms, not pretend that synthetic agents are a complete representation of real adoption behavior.

Back to top ↑

Conclusion

Agent-based modeling of adoption and diffusion reveals how system-level adoption patterns emerge from heterogeneous local decisions. Adoption does not spread through an abstract average population. It spreads through agents with different thresholds, costs, benefits, trust levels, resistance, and network positions.

This case study shows why adoption curves need explanation. A smooth aggregate curve can hide clustered diffusion, unequal access, persistent non-adoption, social influence, trust barriers, targeted seeding effects, and network bottlenecks. Agent-based modeling helps make those mechanisms visible.

The strongest lesson is that diffusion strategy depends on structure. If cost barriers dominate, subsidies or support may matter most. If network fragmentation dominates, bridge-building matters. If trust is low, credible messengers and participation matter. If adoption depends on social proof, seeding strategy matters. If some groups are excluded, equity-focused diffusion design matters.

Agent-based diffusion models should not be treated as automatic forecasts. Their value lies in structured exploration: showing how assumptions, networks, heterogeneity, and interventions interact to shape adoption over time.

Back to top ↑

Related Articles

• Systems Modeling
• Agent-Based Modeling
• Network Models
• Scenario Modeling and Simulation
• Sensitivity Analysis in Systems Models
• Calibration and Validation of Models
• Uncertainty and Model Interpretation
• Participatory Modeling and Stakeholder Systems
• AI and Machine Learning in Systems Modeling
• Communicating Model Results Responsibly
• Case Study: Scenario Modeling for Public Policy
• Case Study: Resilience Modeling Under Climate Stress

Further Reading

• Railsback, S.F. and Grimm, V. Agent-Based and Individual-Based Modeling: A Practical Introduction. Available at: https://www.railsback-grimm-abm-book.com/.
• Smith, R.A. and colleagues. (2012) ‘Investigating Adopter Categories to Diffuse an Innovation’, Journal of Extension. Available at: https://pmc.ncbi.nlm.nih.gov/articles/PMC3772073/.
• Zhang, H. and Vorobeychik, Y. (2019) ‘Empirically grounded agent-based models of innovation diffusion: a critical review’, Artificial Intelligence Review. Available at: https://dl.acm.org/doi/abs/10.1007/s10462-017-9577-z.
• Kiesling, E., Günther, M., Stummer, C. and Wakolbinger, L.M. (2012) ‘Agent-based simulation of innovation diffusion: a review’, Central European Journal of Operations Research, 20, pp. 183–230. Available at: https://ideas.repec.org/a/spr/cejnor/v20y2012i2p183-230.html.
• Kotthoff, F., et al. (2022) ‘Calibrating Agent-Based Models of Innovation Diffusion with Gradients’, Journal of Artificial Societies and Social Simulation, 25(3), 4. Available at: https://www.jasss.org/25/3/4.html.
• Rogers, E.M. (2003) Diffusion of Innovations. 5th edn. New York: Free Press.
• Bass, F.M. (1969) ‘A new product growth for model consumer durables’, Management Science, 15(5), pp. 215–227.
• Valente, T.W. (1995) Network Models of the Diffusion of Innovations. Cresskill, NJ: Hampton Press.
• Granovetter, M. (1978) ‘Threshold models of collective behavior’, American Journal of Sociology, 83(6), pp. 1420–1443.
• Watts, D.J. (2002) ‘A simple model of global cascades on random networks’, Proceedings of the National Academy of Sciences, 99(9), pp. 5766–5771.
• Goldenberg, J., Libai, B. and Muller, E. (2001) ‘Talk of the network: A complex systems look at the underlying process of word-of-mouth’, Marketing Letters, 12, pp. 211–223.
• Epstein, J.M. (2006) Generative Social Science: Studies in Agent-Based Computational Modeling. Princeton, NJ: Princeton University Press.
• Wilensky, U. and Rand, W. (2015) An Introduction to Agent-Based Modeling: Modeling Natural, Social, and Engineered Complex Systems with NetLogo. Cambridge, MA: MIT Press.

Back to top ↑

References

• Bass, F.M. (1969) ‘A new product growth for model consumer durables’, Management Science, 15(5), pp. 215–227.
• Epstein, J.M. (2006) Generative Social Science: Studies in Agent-Based Computational Modeling. Princeton, NJ: Princeton University Press.
• Goldenberg, J., Libai, B. and Muller, E. (2001) ‘Talk of the network: A complex systems look at the underlying process of word-of-mouth’, Marketing Letters, 12, pp. 211–223.
• Granovetter, M. (1978) ‘Threshold models of collective behavior’, American Journal of Sociology, 83(6), pp. 1420–1443.
• Kiesling, E., Günther, M., Stummer, C. and Wakolbinger, L.M. (2012) ‘Agent-based simulation of innovation diffusion: a review’, Central European Journal of Operations Research, 20, pp. 183–230. Available at: https://ideas.repec.org/a/spr/cejnor/v20y2012i2p183-230.html.
• Kotthoff, F., et al. (2022) ‘Calibrating Agent-Based Models of Innovation Diffusion with Gradients’, Journal of Artificial Societies and Social Simulation, 25(3), 4. Available at: https://www.jasss.org/25/3/4.html.
• Railsback, S.F. and Grimm, V. Agent-Based and Individual-Based Modeling: A Practical Introduction. Available at: https://www.railsback-grimm-abm-book.com/.
• Rogers, E.M. (2003) Diffusion of Innovations. 5th edn. New York: Free Press.
• Smith, R.A. and colleagues. (2012) ‘Investigating Adopter Categories to Diffuse an Innovation’, Journal of Extension. Available at: https://pmc.ncbi.nlm.nih.gov/articles/PMC3772073/.
• Valente, T.W. (1995) Network Models of the Diffusion of Innovations. Cresskill, NJ: Hampton Press.
• Watts, D.J. (2002) ‘A simple model of global cascades on random networks’, Proceedings of the National Academy of Sciences, 99(9), pp. 5766–5771.
• Wilensky, U. and Rand, W. (2015) An Introduction to Agent-Based Modeling: Modeling Natural, Social, and Engineered Complex Systems with NetLogo. Cambridge, MA: MIT Press.
• Zhang, H. and Vorobeychik, Y. (2019) ‘Empirically grounded agent-based models of innovation diffusion: a critical review’, Artificial Intelligence Review. Available at: https://dl.acm.org/doi/abs/10.1007/s10462-017-9577-z.

Back to top ↑