Physics of Agents: Statistical Mechanics Predicts Collective Behavior of AI Agents

In plain words

Picture a small group of chatbots, each given its own persona, which vote on a question, post a short reason, read the reasons from the others they are linked to, and vote again. This paper runs many such groups, some on maths problems with a right answer and some on political statements with none, and watches how their opinions move.

Most groups do not wander at random. They settle into one of three patterns: they stay unsure, they split into two camps that each hold strong views, or they agree. The agents usually start out unsure and become more sure as they talk. On the maths problems, talking tends to bring the group closer to the right answer. On the political statements, it tends to push the group's views in one direction.

The authors describe this with a model borrowed from physics. Each agent is pulled toward agreeing with the agents it is friendly with, pushed away from the ones it opposes, and pulled toward the view it would hold on its own. A simple rule fitted to observed votes predicts how individual agents change their minds and how often each kind of group outcome occurs. The tests cover one set of tasks and a handful of models, so the claim is narrower than it sounds.

TL;DR

• Author-reported: groups of 32 language-model agents vote on binary questions over eight rounds and end up indifferent, polarized or in consensus §2 §3.2.
• A logistic update with three couplings (concordant, discordant and unsigned ties) predicts each agent's next vote §4 tab. 1.
• Held-out one-step balanced accuracy is 75-86% across four models and both question types, above all baselines. Multi-step rollouts score lower §5.1 tab. 1.
• The fitted couplings say the groups run below their critical temperature, concordant ties outweigh discordant ones, and correct neighbours pull harder §5.3 §5.4 tab. 3.
• The official code is Apache-2.0, but the saved notebook output and the message scheme for two of the four models differ from the paper. See Paper vs code.

Problem

Systems of interacting language-model agents, such as debate, ensembles and mixture-of-agents, are common, and their collective outcome can help or harm: interaction can aggregate information but also cause herding, polarization or amplify shared biases §1. The paper asks whether a compact model, fitted to observed votes, can predict an agent's next vote and the group outcome from the initial opinions, personas and communication graph alone §1 §2. Without such a model, the only way to know the outcome is to run the system.

Method

The paper has two parts: an experimental setup that produces the data §2, and a statistical model fitted to that data §4. Both are described below.

Experimental setup

1. Agents. A community has N = 32 agents, each with a fixed persona p_i §2 §2 fn.. For objective questions the persona is an expert who has been shown the worked solution to a different MATH problem. For subjective questions it is a short profile of a real individual app. Tasks.
2. Questions. Objective questions are MATH problems recast as a two-option A/B choice. The distractor was generated by claude-4.8-opus, and the correct answer is placed at A or B at random app. Tasks. Subjective questions are political statements; each agent agrees (+1) or disagrees (-1) app. Tasks. Only questions whose answers have high entropy across eight samples per agent are kept app. Tasks.
3. Communication graph. J is an N x N matrix with entries in {-1, 0, +1}, symmetric with a zero diagonal §2 app. Communication Networks. +1 is a friendly tie (messages from this sender go to an "agree" inbox), -1 is an unfriendly tie (a "disagree" inbox), and 0 means no contact §2. Four families are used: random graphs, square and triangular lattices, and low-rank graphs app. Communication Networks.
4. Round. At each round every agent writes one message from its current opinion and inbox. Each message is routed by the sign of the tie. Then each agent casts K = 5 binary votes with its new inbox. The mean vote is o_i(t) in {-1, -0.6, -0.2, 0.2, 0.6, 1}, and the state is s_i(t) = sign of that mean §2 §3.1 fn.. The paper runs T = 8 rounds §2 fn.. Updates are synchronous, and an asynchronous variant is covered in §5.5.

# One synchronous round of the community  [§2]
# Input:  personas (N), question, graph J (N, N), states (N,), inboxes
# Output: next states (N,), next inboxes

def community_round(personas, question, J, states, inboxes):
    # Each agent writes one message from its opinion and its inbox  [§2]
    messages = [
        write_message(personas[i], question, inboxes[i], states[i])
        for i in range(N)
    ]
    # Route each message by the sign of the tie: +1 agree, -1 disagree  [§2]
    # Inboxes are shuffled with a seed per (replica, step, receiver)  [§2]
    inboxes = route_by_sign(messages, J)
    # Each agent casts K binary votes with its new inbox  [§2]
    votes = [
        [cast_vote(personas[i], question, inboxes[i]) for _ in range(K)]
        for i in range(N)
    ]
    # Mean vote lies in {-1, -0.6, -0.2, 0.2, 0.6, 1}; K odd, so never 0  [§2]
    opinions = [mean(vote_list) for vote_list in votes]
    # The state is the sign of the mean opinion  [§2]
    next_states = [sign(opinion) for opinion in opinions]
    return next_states, inboxes

Statistical model

The authors model the community as a system that lowers its social pressure. An agent's opinion s_i in {-1, +1} is coupled to its neighbours through J_ij and to its own predisposition g_i. The energy of a configuration is §4

E(s) = -\frac{1}{2}\sum_{i}\sum_{j} J_{ij}\, s_i s_j - \sum_i g_i\, s_i §4

Fixing all other agents, agent i sees a local field f_i = sum_{j != i} J_ij s_j

• g_i. The probability that it holds +1 is a logistic function of that field with inverse temperature beta app. Local Update Rule. In the main text the logit is written with the coefficients beta and g_i directly, without the factor 2 that appears in the appendix derivation §4 app. Local Update Rule:

P(s_i = +1 \mid s_{-i}) = \sigma(h_i), \quad h_i = \beta \sum_j J_{ij}\, s_j(t) + g_i §4

The three-coupling rule, which the paper finds works best, splits the social term into a concordant part, a discordant part and an unsigned part §4:

P(s_i = +1) = \sigma\Big(\beta^{+}\sum_j J^{+}_{ij} s_j(t) + \beta^{-}\sum_j J^{-}_{ij} s_j(t) + \beta_0 \sum_j |J_{ij}|\, s_j(t) + g_i\Big) §4

Here J^+ = max(J, 0) and J^- = min(J, 0), so J^- <= 0 and beta^- multiplies it with its sign. The total weight on a friendly neighbour is beta^+ + beta_0, and on an unfriendly neighbour it is beta_0 - beta^- §4. The intrinsic field is linear in a 16-dimensional feature vector, g_i = w^T phi_i app. Fitting. phi_i = [1 | p_i | q | p_i (x) q], where p_i and q are the top three principal components of the persona and question embeddings app. Fitting.

# Fitted update rule with three couplings  [§4] [app. Fitting]
# Input:  states (N,) in {-1, +1}; J (N, N); phi (N, 16)
# Output: P(next state = +1), shape (N,)

def update_probability(states, J, phi, weights, betas):
    # Intrinsic field from persona and question features  [app. Fitting]
    field = phi @ weights.field
    # Concordant, discordant and unsigned peer drives  [§4] [app. Fitting]
    drive_pos = positive_part(J) @ states
    drive_neg = negative_part(J) @ states
    drive_abs = abs(J) @ states
    # Logit: field plus the three weighted drives  [§4]
    logit = (field
             + betas.pos * drive_pos
             + betas.neg * drive_neg
             + betas.zero * drive_abs)
    # Logistic link  [§4]
    return sigmoid(logit)

Fitting. The weights are fitted by maximum likelihood on one-step transitions from the training questions, pooled over all agents, rounds and episodes app. Fitting. Feature columns are standardised, except the bias. The L2 penalty of 1e-3 applies to the persona-question field weights only, and the coupling weights start at 0.1 app. Fitting. Because the unsigned drive is a linear combination of the signed drives, the three-coupling model is fitted in two stages: beta_0 first, on the unsigned drive alone, then beta^+ and beta^- with beta_0 held fixed as an offset app. Fitting §4.

# Fit the field and couplings on one-step transitions  [app. Fitting]
# Input:  features (rows, 19), targets in {0, 1}; unparsed targets dropped
# Output: weights (19,)

def fit_couplings(features, targets):
    # Standardise every column except the bias  [app. Fitting]
    scaled = standardise(features, keep_bias_column=True)
    # Couplings start at 0.1; all other weights start at 0  [app. Fitting]
    weights = initial_weights(coupling_init=0.1)
    # Full-batch Adam, lr 0.05, betas 0.9 and 0.999, <= 1500 steps  [app. Fitting]
    for step in range(1500):
        probs = sigmoid(scaled @ weights)
        # Cross-entropy plus L2 of 1e-3 on field weights only  [app. Fitting]
        loss = bce(probs, targets) + l2_penalty(weights.field, 1e-3)
        weights = adam_step(weights, loss)
        # Stop when the loss plateaus, checked every 100 steps  [app. Fitting]
        if step % 100 == 0 and plateaued(loss):
            break
    return weights

Continuous-time variant. Agents can instead revise at independent random times. A per-round update rate eps in (0, 1) gives a discretised mean-field rule app. Continuous Extension:

m_i(t{+}1) = (1-\varepsilon)\, m_i(t) + \varepsilon \tanh\big(\beta (Jm(t))_i + g_i\big) app. Continuous Extension

For fitting, the probability of +1 is (1 + m_i) / 2, with m_i = (1 - eps) s_i(t) + eps tanh(w^T x) and eps a learned parameter [app. Fitting]. This variant is evaluated on asynchronous data §5.5.

Baselines app. Baselines:

• Majority class: always predicts the majority label of the training data. Reported only under raw accuracy.
• Persistence: copies the current opinion; in rollouts it predicts s_i(0) at every step.
• Interaction-free: P = sigma(g_i). It uses the persona-question field and no peer term.
• Mean-field: P = sigma(g_i + beta * s_bar(t)), where s_bar is the population mean. It has no graph structure. It is implemented as the field plus the mean opinion as one extra feature app. Fitting [code: res/4_prediction.ipynb, cell 82cd974d].

Scoring. The metric is flip-and-class balanced accuracy. Transitions are grouped by whether the state flips or stays, and by the next value (+1 or -1). The score is the unweighted mean of the four group accuracies [app. Balanced Accuracy]:

\mathrm{BA} = \tfrac{1}{4}\big(\mathrm{acc}[\text{flip},{+}1] + \mathrm{acc}[\text{flip},{-}1] + \mathrm{acc}[\text{stay},{+}1] + \mathrm{acc}[\text{stay},{-}1]\big) app. Balanced Accuracy

A rule that always copies the current state, or always predicts the majority label, scores 50 by design app. Balanced Accuracy.

One-step and rollout prediction. One-step prediction uses the observed state at t as input. A rollout feeds the model's own predictions back in §5.1 app. Rollouts. Rollout predictions are deterministic: the sign of the logit app. Rollouts. For the distribution analysis, the rollouts are stochastic: each agent's next state is +1 with probability sigma(h_i(t)) §5.2 [app. Rollouts]. The temperature sweep scales the logit by 1/T §5.3 [app. Temperature Sweep].

Analysis quantities.

• Individual archetype, from the number of sign flips F_i over the rounds: Frozen (F = 0), Switcher (F = 1), Intermittent (F = 2), Oscillator (F > 2) §3.1.
• Group archetype, from the net opinion n(t) = (1/N) sum_i o_i(t) and a split band of half-width delta = 0.2 §3.1 fn.. The five classes are Persistent Split, Convergence, Divergence, Majority Switch and Persistent Majority §3.1.
• Conviction c(t) = (1/N) sum_i o_i(t)^2 §3.2. Regimes are indifference, polarization and consensus, with thresholds chosen per model and question type §3.2 app. Thresholds for Characteristic Regimes.
• Critical temperature T_c is the temperature at which chi peaks, with chi = N Var_t(|n(t)|) §5.3.
• Truth-seeking split: each signed channel is split by whether the neighbour's current state equals the ground truth y. With kappa_j = 1 when s_j = y, the logit is §5.4

h = \sum_j \big[\beta^{+}_T \kappa_j + \beta^{+}_F(1-\kappa_j)\big] J^{+}_{ij} s_j + \sum_j \big[\beta^{-}_T \kappa_j + \beta^{-}_F(1-\kappa_j)\big] J^{-}_{ij} s_j + \beta_0 \sum_j |J_{ij}|\, s_j + g_i §5.4

Hyperparameters

Values are from the paper unless marked "code", and "not stated" means the paper gives no value. Appendix subsections have no numbers, so they are cited by title. The paper's equations and algorithms are unnumbered, so equations are cited by section.

Regime thresholds from the appendix [app. Thresholds for Characteristic Regimes]. Conviction threshold c* is the 1/3 quantile of conviction; net-opinion threshold n* is the median of |n(t)| among committed communities:

Results

Author-reported. Setup: 9,600 simulated groups in the main analysis §3 fn., on four models, two question types, four graph families and four episodes each §3 fn.

Prediction and generalization §5.1

Balanced accuracy on held-out test questions. Each cell is one-step (rollout) in percent. In-d. graphs were seen in training; Out-d. graphs were held out. The test set is 320 pairs for subjective and 640 for objective questions tab. 1.

Subjective questions tab. 1

Objective questions tab. 1

The authors report that the three-coupling rule is best in every column, and that the one-coupling rule drops to near chance in some cells, for example 53.9 for Llama-3.1-8B on subjective questions §5.1.

Generalization to unseen graph families (GPT-4o-mini) tab. 2. Each cell is one-step / rollout, in percent.

The authors state that the three-coupling rule is best in 15 of 16 columns, and that its one-step accuracy stays between 85.0 and 97.8 §5.1.

Larger mixed-model group (64 agents: 32 GPT-5.6-sol, 32 DeepSeek-V4-Flash, one graph, one sample per agent per round) [app. Experiments with Frontier Models and Larger Mixed Groups]. Balanced accuracy, one-step (rollout) in percent.

Fitted couplings tab. 3

Fitted coefficients of the three- and five-coupling rules tab. 3. The five-coupling rule is defined for objective questions only.

The authors report that beta^+ > beta^- in every model, that the effective concordant weight beta^+ + beta_0 lies between 0.99 and 3.03, and that the effective discordant weight beta_0 - beta^- is at most 0.73, with negative values in two cases §5.4. They also report that beta^+_T > beta^+_F and beta^-_F > beta^-_T in all four models, so correct neighbours pull harder and incorrect neighbours push harder §5.4.

Asynchronous updates §5.5 app. Asynchronous-update experiment

Rollout accuracy (raw, not balanced), GPT-4o-mini only. M = Majority Class, P = Persistence, IF = Interaction-Free, MF = Mean-Field.

Observed collective behaviour §3

• Frozen agents dominate most settings, followed by oscillators; switchers and intermittent agents are rarer §3.1 fig. 2.
• Divergence and Majority Switch, where the initial majority weakens or is overturned, reach 11-12% for GPT-4o-mini and Qwen3.5-9B §3.1 fig. 3.
• Conviction rises over the rounds in every setting, and indifference falls while consensus rises §3.2 fig. 4.
• On objective questions, switches from incorrect to correct majority are more common than the reverse for all models §3.3 fig. 5.
• On subjective questions, the majority is more likely to move from left to right than the other way §3.3. The authors report rightward drift in three of four models §7.

Distributions and critical temperature §5.2 §5.3

• Stochastic rollouts from the real initial states reproduce the group archetype distribution. Mean absolute deviation is about 3 points on objective and 5 on subjective questions. The largest gap is about 10 points (Qwen3.5-9B, subjective, Persistent Majority) §5.2 fig. 6.
• The fitted operating point, T = 1, lies below the critical temperature T_c in every dataset and model cell §5.3 fig. 7.

Paper vs code

Checked at commit 62bf0e7 of batu-el/physics-of-agents, Apache-2.0 [code: LICENSE]. The paper's footnote links this repository, and its owner is the first author, so no search was needed. The code is not the same as the paper in the places listed below.

Matches the paper.

• Balanced accuracy matches the four-group definition utils.py.
• Fitting uses full-batch Adam with lr 0.05, betas 0.9 and 0.999, at most 1500 steps, and the 1e-3 L2 penalty on field weights only utils.py.
• Couplings start at 0.1, and the two-stage fit uses beta_0 first [code: res/utils.py#L195-L205].
• The drives are J^+ s, J^- s and |J| s = J^+ s - J^- s utils.py.
• Deterministic rollouts use the sign of the logit, and the feature set is [1, p, q, p (x) q] utils.py.
• Individual and group archetype definitions match, including the five group classes and the strict split band utils.py.
• The interaction-free and mean-field baselines match the appendix description 4_prediction.ipynb, cell 82cd974d.

Differs from the paper.

• Message scheme. The paper says each agent writes one message per round §2. A note in the code says the older GPT-4o-mini and Gemma-3n-E4B data were generated with a separate message for each recipient, while the Qwen, Llama and asynchronous data use one message per sender [code: lib/datagen/dynamics.py#L107]. Table 1 covers all four models, so two of the four were generated under the legacy scheme.
• Notebook output versus Table 1. The saved output of res/4_prediction.ipynb matches the paper's table in most cells but differs in others. Examples: GPT-4o-mini subjective discrete update reads 77.7 (69.4) in the notebook and 77.6 (69.0) in the paper; Llama-3.1-8B subjective three-coupling out-of-distribution reads 80.8 (68.3) in the notebook and 80.8 (69.5) in the paper. The notebook also labels the Llama model "Llama-3-8B" [code: res/4_prediction.ipynb, cell 14dfde1e]. The paper's values are cited in this card.
• Coupling values. The notebook's coupling table matches the paper's Table 3 to two decimals except GPT-4o-mini subjective beta^+: 2.38 in the notebook, 2.39 in the paper 4_prediction.ipynb, cell c2b2ba1d.
• Sampling settings. The paper does not state the LM sampling temperature. The code default is 0.7 utils.py and the code notes say it was fixed at 0.7 for all experiments implementation_details.md §2.1.
• Edge budget. The paper does not state the number of edges. The code uses 112 non-zero entries for N = 32 (56 undirected ties, average degree 3.5), and 224 entries for the 64-agent run implementation_details.md §2.3 [code: implementation_details.md §2.7].
• Frontier run. The paper says the frontier run uses one sample per agent per round. The code confirms k = 1, and its CLI defaults reasoning to off so the models give direct judgements implementation_details.md §2.7.

Not verified in code. The continuous-time fit, the temperature sweep and the asynchronous pipeline were checked only through the code notes [code: implementation_details.md §2.6 and §4.2], not line by line.

Pitfalls

• Logit scale. The appendix derives sigma(2 beta f_i), but the fitted coefficients in Table 3 are the logit coefficients §4 [app. Local Update Rule]. Do not multiply or divide any coupling by 2. The code applies the coefficients directly to the logit utils.py.
• Identifiability of the three couplings. The unsigned drive is a linear combination of the signed drives, so the three couplings are not jointly identified. The paper fits beta_0 first and then fixes it. Only beta^+ + beta_0, beta_0 - beta^- and the truth gaps are identifiable tab. 3 app. Fitting. Reported beta^+ and beta^- depend on this order.
• Ties. The paper says the rule thresholds at sign(h). The code treats a logit of exactly 0 as -1 utils.py. Exact zeros are rare with continuous logits, but an implementation should choose one convention.
• Parsing. Subjective responses are parsed permissively: DISAGREE is checked before AGREE, so a response containing both words becomes -1 [code: lib/datagen/samplers.py#L29-L38]. The paper describes a one-word answer. Objective responses must contain exactly one standalone A or B [code: lib/datagen/samplers.py#L39-L49].
• Failed calls. After two retries, a failed call becomes spin 0. The code does not use these in fitting or scoring, which is why transitions with 0 are excluded dynamics.py utils.py. The paper does not state this. Failures are rare: 0.0377% of raw samples implementation_details.md §2.2.
• Inbox order. Messages in each inbox are shuffled with a seed derived from the replica, round and receiver dynamics.py. The paper does not state the order, and it can affect individual outcomes.
• Rollouts and one-step. One-step scores use the observed previous state. Rollout scores use the model's own predictions. The rollout columns in the tables are deterministic, and the stochastic rollouts are used only for the distribution analysis app. Rollouts. Do not mix the two.
• Two different temperatures. The temperature in the sweep scales the fitted logit, not the LM sampling temperature app. Temperature Sweep. The LM sampling temperature is a separate setting, and the paper does not state it.
• K differs by experiment. The main runs use K = 5. The temperature sweep and the frontier run use K = 1 §5.3 fn. [app. Experiments with Frontier Models and Larger Mixed Groups]. Compare like with like.
• Generated inputs. The question distractors were generated with claude-4.8-opus, and the subjective profiles were generated with gpt-4o-mini app. Tasks. Reproduction depends on the released question banks and personas implementation_details.md §3.2.
• Small test sets. The test sets have 20 objective and 10 subjective questions app. Tasks, so per-question variance is large. The paper reports a replica-predictability ceiling showing that episodes often disagree on the group archetype §5.2.
• Simulated personas, not people. The authors caution against treating the results as a model of human opinion dynamics §7.
• Author-reported. All numbers come from the authors' runs, with four models and one graph family per row of Table 2.

Lineage

• Builds on: the Ising model and Glauber dynamics §1 [app. Continuous Extension], the Curie-Weiss mean-field approximation for the mean-field baseline 4_prediction.ipynb, cell 82cd974d, and the logistic regression fitting in the appendix app. Fitting.
• Relates to: Mixture-of-Agents, multi-agent debate, self-consistency and critique, each seen as a special case of the graph J and the depth T §2.
• Compared against: Persistence, Interaction-Free, Mean-Field and Majority Class app. Baselines.
• Superseded by: not known from content already in this wiki.