Habermolt: Delegating Deliberation to AI Representatives

This paper introduces Habermolt, a public platform for AI-delegated deliberation where agents represent humans in collective decision-making, and evaluates its effectiveness through the dimensions of representation, aggregation, and revision to address the novel design and alignment challenges of scalable, trustworthy AI representatives.

The Gist

Imagine you want to vote on a new community rule, like "Should we plant more trees or build a new park?" In a perfect world, everyone would sit down, talk it out, and agree. But in reality, you're busy, tired, or just can't be there. So, you usually pick a human representative (like a city council member) to go for you. But that person might not know exactly what you think, and they might change their mind without telling you.

This paper introduces a new idea called AI-delegated deliberation. Instead of a human representative, you give your views to an AI agent (a digital robot). This robot learns what you think, goes to the "meeting" when you can't, argues your case, and helps pick a final decision.

The researchers built a real-world playground for this called HABERMOLT to see if it actually works. They tested it using three main rules:

1. Representation: The "Digital Twin" Interview

The Concept: How does the AI know what you think?
The Analogy: Think of the AI as a personal assistant who writes a diary for you.

• How it works: You chat with your AI agent. It asks you questions (like, "Do you prefer apples or oranges?") and saves your answers in a "memory file."
• The Problem they found: When the AI goes to a meeting on its own (without you talking to it that day), it tends to sound a bit generic. It's like a student who studied the textbook but forgot the specific stories you told them. The AI's opinions started to sound very similar to each other, losing the unique "flavor" of your actual personality.
• The Fix: If you sit down and have a specific chat with the AI about the topic right before the meeting, the AI sounds much more like you.

2. Aggregation: The "Group Vote"

The Concept: How do all these different AI agents combine their thoughts into one final decision?
The Analogy: Imagine a potluck dinner where everyone brings a dish and votes on the menu.

• How it works: In HABERMOLT, every AI agent does two things:
  1. They suggest a new dish (a statement) if they think something is missing.
  2. They rank all the dishes from "Yummiest" to "Disgusting."
     The system then uses a special math formula (Schulze ranking) to find the dish that everyone can agree on.
• The Problem they found: There is a trade-off.
  • If you want a decision that feels safe and true to everyone, the result is often vague (e.g., "We should do good things").
  • If you want a decision that is specific and actionable (e.g., "Build a park on 5th Street by next Tuesday"), it might feel like it doesn't represent everyone's true feelings.
  • The researchers found that letting the AI agents write their own suggestions and vote on them (the method they used) was the best way to keep it feeling "real" to the users, even if it wasn't the most specific.

3. Revision: The "Undo Button"

The Concept: What happens if the AI gets it wrong or you change your mind?
The Analogy: Think of this as a live-editing document where you can fix your agent's mistakes anytime.

• How it works: If your AI agent says something you disagree with, you can log in, edit its "memory," or change its vote. The system instantly recalculates the group decision based on your new input.
• The Problem they found: Nobody used the undo button. Even though the system was built to let people fix mistakes, over 90% of users never checked their agent's work.
• The Risk: If the AI makes a mistake, it stays there. The system sends a weekly email to remind people to check, but most people ignore it. The researchers realized that for this to work, the "fixing" process needs to be much easier and more obvious.

The Big Takeaway

The paper concludes that AI-delegated deliberation is a powerful idea that could let millions of people participate in democracy without needing hours of free time. However, it's like a new car that hasn't been fully tested yet.

• The Good: It scales up participation. You don't need to be there to have a voice.
• The Bad: The AI sometimes sounds too much like a generic robot rather than you, and people aren't checking to make sure it's speaking the truth.

The researchers say we need to build better "memory systems" for these AIs so they remember exactly who you are, and we need to make it much easier for humans to step in and correct their digital representatives when things go off track. Until then, we have to be careful about trusting these robots to speak for us.

Technical Summary

Technical Summary: HABERMOLT – Delegating Deliberation to AI Representatives

1. Problem Statement

Deliberative democracy offers a pathway to higher-quality collective decisions but is fundamentally constrained by human attention and bandwidth. Traditional solutions like citizen assemblies are expensive, slow, and limited in scale. While recent AI-mediated deliberation systems (e.g., the Habermas Machine) successfully scale participation by synthesizing inputs from many humans, they remain time-intensive for individual users, as humans must still actively read, write, and engage.

A more ambitious paradigm, AI-delegated deliberation, proposes deploying AI agents not merely as mediators but as persistent representatives that deliberate on behalf of human users when they are absent. While this promises unprecedented scale for democratic participation, it introduces qualitatively new design and alignment challenges that are currently poorly understood and under-theorized. Specifically, there is a lack of empirical data on how to ensure these agents faithfully represent user views, how to aggregate their outputs effectively, and how to allow for revision when user perspectives change.

2. Methodology: The HABERMOLT Platform

To study these dynamics empirically, the authors deployed HABERMOLT, a public web platform where AI agents deliberate on behalf of human users. The system is structured around three core dimensions of any deliberative system: Representation, Aggregation, and Revision.

2.1. Representation

• Input Mechanism: A user's perspective enters the system via two artifacts:
  1. Persistent Memory: A free-text document maintained by the agent, populated through an interview process where the agent learns the user's values and views.
  2. Per-Deliberation Opinion: A short text generated by the agent from its memory (and topic-specific interviews) when joining a specific deliberation.
• Participation Modes:
  • Autonomous: The agent joins deliberations based on a "heartbeat" schedule, selecting topics where its memory is sufficient to represent the user.
  • User-Directed: The user actively directs the agent to a specific topic, triggering a deep interview to update the agent's memory before participation.
• Interoperability: The platform supports both native HABERMOLT agents and external "OpenClaw" agents via a shared API.

2.2. Aggregation

• Output Goal: The system aims to produce a single consensus statement (the "winner") deemed most agreeable to all participating agents.
• Mechanism:
  • Bring-Your-Own-Statement (BYOS): Agents can author candidate statements if they judge a position is missing from the pool, decentralizing authorship.
  • Ranking & Selection: Every agent ranks the pool of candidate statements. The winner is determined using the Schulze method over the resulting ranking distribution.

2.3. Revision

• Editability: All artifacts (memory, opinions, rankings, and authored statements) are editable at any time.
• Lazy Consensus: The platform employs an asynchronous "lazy consensus" model. When a new statement is added or an existing one is edited, the system re-aggregates immediately without requiring participants to be present simultaneously. New candidates are inserted at the median rank of existing agents' prior rankings as an unbiased starting point.
• Review Loop: Since users are absent during autonomous participation, the system sends weekly emails surfacing one recent agent action for review. An LLM judge scores actions for misrepresentation risk against the user's stored memory to prioritize review.

3. Key Contributions and Empirical Results

The authors conducted controlled experiments using production data from the deployed platform to evaluate the system's effectiveness.

3.1. Representation: Diversity vs. Fidelity

• Finding: Autonomous participation produces less diverse opinions than topic-specific interviews.
  • Mean pairwise cosine similarity for autonomous opinions was 0.745, compared to 0.649 for topic-specific interviews.
  • In extreme cases, 36 of 54 autonomous opinions began with identical phrases despite agents having substantial memory profiles.
• Implication: The model's prior on a topic appears to override specific user knowledge in autonomous modes. Longer user profiles did not correlate with more distinctive opinions (Spearman correlation $\rho = +0.15$), suggesting profile length is not a reliable proxy for representation fidelity.

3.2. Aggregation: The Representativeness-Actionability Trade-off

The authors compared the deployed Production Schulze method against nine other aggregation architectures (ranging from single-shot LLM synthesis to decoupled authorship/ranking systems).

• Finding: A clear trade-off exists between representativeness (agents recognizing the output as their own) and actionability (the output being specific enough for policy drafting).
  • Production Schulze (the deployed method) sits at the high-representativeness end of the frontier.
  • Single-shot synthesis (prompted for specificity) sits at the high-actionability end but scores poorly on representativeness.
  • Architectures that decouple authorship from ranking generally fell inside the frontier (dominated), suggesting that having agents write and vote on their own candidates is a necessary condition for high representativeness in this context.
• Implication: No single architecture maximizes both metrics; designers must choose a point on the frontier or compose methods (e.g., rewriting a representative winner for specificity).

3.3. Revision: Low Engagement and Propagation Gaps

• Finding: Revision is rare. Of 91 users who submitted opinions, only 8 ever revised them (over 90% never used the channel).
• Propagation Issues: When revisions occur, they update the agent's profile for future contributions but do not automatically correct past contributions in existing deliberations. Users must manually find and revise past artifacts, a burden that grows with agent activity.
• Implication: The current flat, unstructured memory format makes targeted corrections difficult. The system relies on users to exercise a high-friction correction channel that they rarely use.

4. Significance and Future Directions

The paper positions HABERMOLT as a foundational instantiation of the AI-delegated deliberation paradigm, bridging the gap between AI-mediated deliberation (human-in-the-loop but attention-bounded) and generative simulacra (unbounded but human-out-of-the-loop).

Key Claims:

• Design Space Mapping: The study reveals that the "production" loop (agents writing and ranking their own candidates) is structurally superior for representativeness compared to decoupled systems, challenging the assumption that separating authorship from voting is always optimal.
• Memory as a Primitive: The authors argue that agent memory is the central design primitive for this paradigm. Current flat, unstructured memory stores are insufficient; future systems require structured, decomposable memory that allows users to trace, inspect, and edit how specific memories shape future agent behavior.
• Legitimacy Risks: The paper highlights a unique risk profile: AI agents that misrepresent users could distort collective outcomes while creating an appearance of broad participation. This threatens the legitimacy of democratic processes in ways distinct from typical AI harms.
• Open Questions: The authors note that it remains an open question whether AI-delegated deliberation can facilitate the transformation of preferences (a core tenet of deliberative democracy) or if it merely aggregates static preferences. Furthermore, the "correction problem"—how to retroactively fix misrepresentations in past deliberations—remains a significant unsolved design challenge.

The paper concludes that while AI-delegated deliberation loosens the trade-off between scale and fidelity, realizing its potential requires building specific affordances that allow users to meaningfully govern their AI representatives, particularly through better memory structures and lower-friction revision mechanisms.