Deliberative aggregation

Putting the model in the facilitator's seat

A model takes over tasks that a human facilitator, chair, or annotator would perform when a group disagrees. It drafts a candidate group statement from everyone's opinions and critiques, and revises it as participants rank the versions. It selects sets of statements that represent the full range of opinion under formal fairness guarantees. It chairs a live session by managing the speaking queue and intervening when participants are uncivil. It speaks for stakeholders who are not present. It also rates each contribution for justification, novelty, and openness, in place of the human coders who used to do this. Some of these tasks run live inside a session, and some work offline from a collected set of opinions. What the papers share is that the model takes a role in the deliberation rather than using its output afterward.

The method (highlighting differences with Deliberative aggregation)

Scroll the diagram sideways to see all of it.

Use it in codefrom aiag.procedural import Facilitator
from aiag import LM
from aiag.procedural import Facilitator

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
opinions = ["Dogs should be leashed everywhere.", "Dogs need room to run.", "Just keep them off the playground."]

# Draft candidate statements, predict who would endorse each, and elect one by ranked vote (Schulze)
out = Facilitator(lm)("Should the park allow dogs off-leash?", opinions)
print(out["statement"])  # the elected group statement
print(out["support"])    # P(endorse) for each participant and candidate

pip install aiagEvery method in aiag Library on GitHub

Concept Analysis: Theoretical Foundations

Each concept is read twice: whether the approach carries it over, and whether the approach's own sources claim it. A concept that the approach claims but does not carry over is a shortfall. A concept that it neither claims nor carries over is an omission, which marks a gap in the field rather than a failure of the work.

Deliberation, Not Tallying

PartialShortfall · partially preserved

Definition (Jürgen Habermas, Between Facts and Norms, 1992)

This concept locates legitimacy in the exchange of reasons among equals. Participants justify their views to each other, free of coercion, and remain able to change their minds. Counting votes or averaging preferences does not produce legitimacy, because the reasoning itself is what produces it.

Analysis

One mechanism in this approach does exchange reasons. In the Habermas machine, participants submit critiques of a draft and the model rewrites the draft in light of them. Participants demonstrably changed their positions, which no tally can produce. The Stanford moderator adds the speech conditions Habermas cares about, by allocating speaking time and intervening on incivility. However, every method in the approach settles the matter by counting rather than by the better argument. The winning statement is fixed by a preference ranking. The veto-core and token-level-MDP papers work entirely from per-participant preference models, so no participant reasons with anyone. The two quality graders score contributions one at a time, so a discussion in which one party dominates and nobody changes their mind can score well throughout. Reasons therefore enter as inputs to an aggregation, and it is the aggregation that decides.

General Will vs. Sum of Preferences

PartialShortfall · partially preserved

Definition (Jean-Jacques Rousseau, The Social Contract, 1762)

This distinction separates what is good for a public in common from the sum of what its members privately want. Aggregating private wants, however fairly, does not produce the former, since the two can and often do diverge.

Analysis

The approach carries over the form of the output. Most of these systems produce a single statement written in the group's voice rather than a numeric average. Tessler et al. show that the winning statements incorporate dissenting views instead of following the majority, which is the divergence Rousseau points to. The approach does not carry over the distinction itself. Every rule that picks the statement is a function of what members privately want (social welfare functions in Bakker, the proportional veto core, per-participant token rewards, and proportional slates). The Overton benchmark directly scores how much of the spread of private views one answer covers. In Bakker, the choice between summing the group's preferences and protecting its worst-off members is a parameter the researchers set. So in the one place where the question arises, the researchers settle it, rather than the public whose common good is at issue.

Veil of Ignorance

AbsentOmission

Definition (John Rawls, A Theory of Justice, 1971)

This device requires that rules be chosen without knowledge of which position the chooser will occupy under them (e.g., rich or poor, majority or minority). Not knowing generally leads the chooser to protect the worst-off position, since it may turn out to be their own.

Analysis

Nothing in the approach screens a chooser from their own position. Participants give opinions and critiques as themselves. The citizens'-assembly replication matches demographics precisely so that known positions are present. Annotators rate from their own standpoint. The Empty Chair supplies absent perspectives by naming and voicing them, without veiling anyone. The maximin outcome that the veil is meant to produce does appear. Bakker selects statements under egalitarian as well as utilitarian welfare functions, and the proportional veto core protects minorities from being overruled. However, this outcome comes from a researcher's choice of objective, which gives the conclusion without the device. No source engages the veil. Using Rawlsian vocabulary for a welfare function imports the outcome principle but not the construction procedure.

Reasonable Rejection

PartialShortfall · partially preserved

Definition (T. M. Scanlon, What We Owe to Each Other, 1998)

This test holds a principle justified only if no individual could reasonably reject it. The test is applied person by person rather than in aggregate. One sufficiently strong objection therefore outweighs many mild preferences, which is the case that averaging handles wrongly.

Analysis

The approach carries over the power to reject in a quantitative form. The proportional veto core lets a coalition block any statement in proportion to its size. Generative social choice guarantees a cohesive group of sufficient size a statement of its own. In the mediation loop, the next draft must answer a critique, or the statement loses ground. However, both parts of Scanlon's test are missing. The test is applied person by person and does not depend on how many people share the objection, and it turns on the grounds offered rather than on strength of feeling. In these systems, an objection is recorded as a preference score or a rating. A reasoned rejection and a mild dislike are therefore the same data point, and many mild approvals outweigh one strong objection. Bakker's own exclusion experiment shows this failure concretely, as a statement assembled from a subset still stands over the member who was left out.

Concept Analysis: Newly Introduced

Dissent kept inside the winning statement

Added

Deliberative theory asks that the outcome be one that everybody could accept. It does not say that the outcome should contain the objections. The embedding analysis here finds that the statements that succeed are those that incorporate dissenting voices while respecting the majority. This is a property of the resulting statement rather than of the procedure, and the tradition has no name for it.

A computable measure of deliberative quality

Added

Habermas supplies a standard for deliberation but no way of telling whether a given discussion met it, because his participants were assumed to be present to one another. These instruments make the standard computable for every post. AQuA runs adapter models for 20 deliberative indices and produces a score from pre-trained adapters alone. The Stanford model rates posts on four criteria, at a scale that, according to the paper, human annotation cannot reach because it is time-consuming and costly. Whether the number measures what the standard asks for is a separate question, but the tradition offers no number at all.

Papers

Generative Social Choice

Sara Fish et al., Sep 2023

arXiv:2309.01291MethodPartialAuthority: Affected public (open)

CodeGenerativeSocialChoice
from aiag import LM
from aiag.procedural import GenerativeSocialChoice

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
opinions = ["Bike lanes on Main Street, now.", "Shops need parking out front.", "Buses every ten minutes.",
            "Fix the potholes first.", "Car-free Main Street on weekends.", "Slower traffic near the school."]

# A slate of k statements: each round seats the one most of the still-unrepresented would endorse
slate = GenerativeSocialChoice(lm)(opinions, k=3)
for seat in slate:
    print(seat["statement"], seat["represents"])  # each statement and the people it represents

pip install aiagEvery method in aiag Library on GitHub

doi:10.1126/science.adq2852172 citationsMethodBuiltAuthority: Affected public (open)

Trains an AI mediator that takes a group's individual opinions and critiques, writes a candidate group statement, and refines it over repeated rounds. Participants (N=5,734) preferred its statements to those of human mediators. They also moved toward a shared position. The result was replicated in a demographically representative UK citizens' assembly.

CodeHabermasMachine
from aiag import LM
from aiag.procedural import HabermasMachine

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
opinions = ["Cars pollute.", "Shops need car access.", "Fix the buses first."]
critiques = ["Say when the ban would start.", "Delivery vans must still get in.", "Still vague about buses."]
critique = lambda member, statement: critiques[member]

# Opinion round: sixteen drafts, predicted rankings, Schulze winner; then a critique round redrafts it
out = HabermasMachine(lm)("Should our town ban cars downtown?", opinions, critique=critique)
print(out["statement"])             # the winner of the opinion round
print(out["revised"]["statement"])  # the winner after the critique round
  • HabermasMachineProcedureaiag/procedural/deliberative_aggregation.py:419 Habermas Machine: sixteen candidate group statements, a personalized reward model predicting each member's ranking from their opinion, the Schulze winner returned, then a critique round that redrafts it from everyone's critiques and elects again (Tessler et al., 2024).

pip install aiagEvery method in aiag Library on GitHub

arXiv:2603.16751MethodBuiltAuthority: Affected public (open)

Gives a formal account, based on the proportional veto core, of finding common ground when the number of candidate statements is effectively infinite. It supplies a sampling algorithm that returns an alternative in the approximate core with high probability, together with matching lower bounds.

CodeVetoCore
from aiag import LM
from aiag.procedural import VetoCore

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
vc = VetoCore(lm)  # twenty alternatives, each written from a random member's perspective
opinions = ["Students need late hours.", "Staff deserve to get home.", "Only stay open late during exams."]

# Members, drawn at random, veto the alternative they like least until one is left
out = vc("Should the library stay open until midnight?", opinions)
winner = out["candidates"].index(out["statement"])
eps = vc.critical_epsilon(out["support"], winner)  # how far the winner is from the proportional veto core
  • VetoCoreProcedureaiag/procedural/deliberative_aggregation.py:443 Common ground in a sea of alternatives: draw statements from the generator, then until one is left a random participant vetoes the one they like least, which lands in the approximate proportional veto core with high probability (Chooi et al., 2026).

pip install aiagEvery method in aiag Library on GitHub

arXiv:2510.14106MethodBuiltAuthority: Affected public (open)

Models consensus-statement generation as a token-level Markov decision process with one objective per participant. Each participant's token rewards come from their own personalized model, so fairness guarantees apply to the generation itself.

CodeTokenLevelConsensus
from aiag import LM
from aiag.procedural import TokenLevelConsensus

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
q, opinions = "Should our school ban phones in class?", ["Phones distract everyone.", "Parents need to reach their kids."]
tlc = TokenLevelConsensus(lm)

# Beam search on the worst-off participant's likelihood, under a model prompted with their own opinion
out = tlc(q, opinions)
print(out["statement"])
lottery = tlc.lottery(q, opinions, out["candidates"])  # a Nash-welfare lottery over the finished statements
  • TokenLevelConsensusProcedureaiag/procedural/deliberative_aggregation.py:509 Consensus generation as a token-level MDP: each participant's token reward is beta times its log-probability under an LM prompted with their opinion; beam search maximizes the worst-off participant's total, and a Nash-welfare lottery over finished statements gives an ex-ante core policy (Blair & Larson, 2025).

pip install aiagEvery method in aiag Library on GitHub

Generative Social Choice: The Next Generation

Niclas Boehmer et al., May 2025

arXiv:2505.22939MethodBuiltAuthority: Affected public (open)

Extends generative social choice to produce a slate of statements that proportionally represents the full range of opinion. Its theoretical guarantees hold under the queries that an LLM can actually answer.

CodePROSE
from aiag import LM
from aiag.procedural import PROSE

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
opinions = ["Bike lanes on Main Street, now.", "Shops need parking out front.", "Buses every ten minutes."]

# A 40-word slate of statements up to 20 words long, seated from the highest approval level down;
# a statement needs approval from a share of the unrepresented in proportion to its length
slate = PROSE(lm)(opinions, budget=40, costs=(20,))
for seat in slate:
    print(seat["statement"], seat["represents"])  # each statement and the people it represents
  • PROSEProcedureaiag/procedural/deliberative_aggregation.py:320 PROSE: a slate under a total word budget, built from the highest approval level down and from long statements to short, seating any generated statement that at least length*n/budget of the unrepresented approve at that level and setting aside its most satisfied supporters (Boehmer et al., 2025).

pip install aiagEvery method in aiag Library on GitHub

arXiv:2211.15006MethodBuiltAuthority: Affected public (open)

Fine-tunes a 70-billion-parameter model to write statements that maximize a group's expected approval. It ranks the candidates with a reward model trained to predict individual preferences, and defines the group's appeal according to different social welfare functions. Its statements were preferred to those of prompted models more than 70% of the time, and to the best human-written opinions more than 65%. When a consensus was built silently from only a subset of the group, the excluded members were more likely to dissent.

CodeWelfareConsensus
from aiag import LM
from aiag.procedural import WelfareConsensus

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
q = "Should the town tax sugary drinks?"
opinions = ["Kids drink far too much soda.", "Taxes like this hit poor families hardest."]
drafts = ["Tax them.", "Leave them alone."]
wc = WelfareConsensus(lm, alpha=1.0)  # isoelastic welfare: 0 utilitarian, 1 Nash, float("inf") Rawlsian

# Train the reward model to predict each member's 1-7 rating of a statement from their own opinion
wc.fit_reward([(q, opinions[0], drafts, [6, 2]), (q, opinions[1], drafts, [2, 6])])
out = wc(q, opinions)
print(out["statement"])  # of sixteen new drafts, the one with the highest welfare
  • WelfareConsensusProcedureaiag/procedural/deliberative_aggregation.py:373 Consensus fine-tuning: a fine-tuned model drafts sixteen statements, a reward model predicts each member's agreement from their own opinion, and the statement maximizing an isoelastic social welfare function of those predictions wins (Bakker et al., 2022).

pip install aiagEvery method in aiag Library on GitHub

Deployed, not devised

Existing techniques applied in one real setting. They report what happened there, so they are evidence about the approach, not new methods for it.

arXiv:2503.1381210 citationsApplicationBuilt

Transcribes a live deliberation and uses LLM personas to inject, in real time, the contributions relevant but absent stakeholders would have made. It was deployed in a 19-person student deliberation.

CodeEmptyChair
from aiag import LM
from aiag.procedural import EmptyChair

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
theme = "turning the riverside parking lot into a park"
transcript = "Ana: We need more green space.\nRaj: Parking is already hard to find.\nLi: A park would bring families back."
chair = EmptyChair(lm)

absent = chair.stakeholders(theme, transcript)  # who is affected but not in the room
voice = chair(theme, transcript, "a wheelchair user who parks there for the clinic")
print(voice["missing"])  # what this absent stakeholder thinks the discussion leaves out
  • EmptyChairProcedureaiag/procedural/deliberative_aggregation.py:557 The Empty Chair: from a live deliberation's transcript the model names stakeholders who are absent and, for the one chosen, voices what they would agree with, disagree with and find missing, or a question they would put to an expert (Fulay et al., 2025).

pip install aiagEvery method in aiag Library on GitHub

Measured, not built

Instruments that measure the approach instead of implementing it. The grid counts methods only, so these are listed here but not counted.

Benchmarking Overton Pluralism in LLMs

Elinor Poole-Dayan et al., Dec 2025

arXiv:2512.013519 citationsBenchmarkBuilt

Formalizes Overton pluralism as set coverage (how much of the range of defensible views a single answer contains). It validates the metric against 1,208 US-representative human judgments. It finds that current models cover only about a third to two-fifths of this range.

CodeOvertonScore
from aiag import LM
from aiag.procedural import OvertonScore

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
opinions = ["Zoos protect endangered species.", "Zoos teach kids to care.", "Animals belong in the wild.", "Zoos are prisons."]
votes = [[1, 1, -1, -1], [1, 1, -1, -1], [-1, -1, 1, 1], [-1, -1, 1, 1]]  # each person's votes on the statements
answer = "Zoos fund conservation, though critics argue captivity harms animals."
overton = OvertonScore(lm)

# Share of viewpoints whose members, on average, rate the answer at least 4 of 5 for representing them
score = overton("Are zoos ethical?", answer, opinions, votes)                         # from predicted ratings
human = overton("Are zoos ethical?", answer, opinions, votes, ratings=[5, 4, 2, 3])  # -> 0.5 from people's own

pip install aiagEvery method in aiag Library on GitHub

Precedent from outside AI

Work from law, political theory, or another discipline that supplies the tradition this approach is read against.

Achieving parity with human moderators

Lodewijk Gelauff et al., Jun 2023

doi:10.4324/9781003215929-156 citationsPrecedentBuilt

Describes the Stanford Online Deliberation Platform. Its automated moderator manages the speaking queue, allocates speaking time, moves the agenda along, and intervenes on incivility. The paper reports that it reaches parity with human moderators across real Deliberative Polling sessions.

Background

Work this approach builds on that falls outside the inclusion criteria (e.g., a single-objective baseline). It is listed for reference and not counted anywhere.

Can AI mediation improve democratic deliberation?

Michael Henry Tessler et al., Jan 2026

arXiv:2601.05904ProposalGap

A discussion paper that takes the LLM mediation system of Tessler, Bakker, and colleagues and asks how it relates to Fishkin's trilemma between broad participation, meaningful deliberation, and political equality. It sets out where scalability, fair mediation, and the surfacing of trustworthy information might help, and where challenges remain.

arXiv:2404.02761PrecedentBuilt

AQuA gives each post in a political online discussion a single deliberative quality score. The score adds up the outputs of adapter models for 20 deliberative indices. Each index is weighted by the correlation between experts' annotations of it and non-experts' perceived deliberativeness.

CodeAQuA
from aiag import LM
from aiag.procedural import AQuA

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
posts = ["Widen the bike lane: two cyclists were hit there this year.", "Anyone who drives downtown is an idiot.",
         "What if we tried a car-free Sunday first?", "Fine."]
expert = [[1, 1, 0], [0, 0, 0], [0, 1, 1], [0, 0, 0]]  # experts' codes for each post on each index
lay = [4.5, 1.0, 4.0, 2.0]                             # non-experts' ratings of how deliberative each post is

# A predictor per index, weighted by how closely the experts' codes track the lay ratings
aqua = AQuA(lm, ["justification", "respect", "a proposed solution"]).fit(posts, expert, lay)
scores = aqua(["Free buses brought riders back in Tallinn, so let's try it here."])  # deliberative quality
  • AQuAMeasureaiag/procedural/deliberative_aggregation.py:601 AQuA: one deliberative-quality score per post, the sum of per-index predictions for the deliberative indices, each weighted by how strongly experts' codes for that index correlate with non-experts' ratings of deliberativeness (Behrendt et al., 2024).

pip install aiagEvery method in aiag Library on GitHub

arXiv:2408.11936PrecedentBuilt

A large language model rates each contribution in a video deliberation from 1 to 5 on justification, novelty, expansion of the conversation, and potential for further expansion. The model does the work that human annotators had been doing.

CodeContributionQuality
from aiag import LM
from aiag.procedural import ContributionQuality

lm = LM("Qwen/Qwen2.5-1.5B-Instruct")
contributions = ["Free buses brought riders back in Tallinn, and our routes are half empty.", "Buses are bad."]

# Rated 1-5 on justification, novelty, expansion of the conversation and potential for further expansion
ratings = ContributionQuality(lm)(contributions, topic="making city buses free")  # one row per contribution

pip install aiagEvery method in aiag Library on GitHub