DeepMind Pluralistic Agents: Code and Data for Scaling Public Input on AI Policy

Google DeepMind has quietly published a new research repository, google-deepmind/pluralistic_agents, that gives outsiders the code and a large dataset behind a 2026 paper on gathering public input about AI policy with LLM agents. It appeared on GitHub's weekly trending list for week 45 with zero stars, so almost nobody has looked at it yet.

This post covers what the repository contains, how to run it, and what it leaves out. We could not find the paper's full text or an arXiv page, so everything below comes from the repository itself and the README. We state no result figures from the paper because we have not read them.

TL;DR: the repo at a glance

What is a pluralistic agent, and why use it for public input?

Asking the public what rules AI should follow is hard to do at scale. Surveys give shallow answers, and live deliberation costs money and time. The idea behind pluralistic agents is to build many LLM agents, each given a persona, and let them answer questions or debate the way a varied public might.

Earlier work explored this direction. A 2023 paper, Democratic Policy Development using Collective Dialogues and AI, used AI-run collective dialogues with more than 1,500 US participants and reported broad support for the policy guidelines it produced. The Plurals library, presented at NeurIPS 2024, simulates deliberating LLM agents with personas inside customizable structures. The new DeepMind repo belongs to the same line, with a human study alongside the simulated agents so the two can be compared.

What is in the repository?

The folder list shows a compact research package: figures, results, scripts, run_analysis.py, run_experiments.py, download_data.py, data_manifest.json and pa_template.json. The repo had five commits when we looked.

Analysis script

run_analysis.py runs every statistical model and test in the paper. It writes unrounded outputs to results/results.json and generates twelve figure PDFs. It pulls four data files, about 18 MB in total, from a public Google Cloud Storage bucket on the first run. Two diagram figures render through Chrome or Chromium, and you can point CHROME_BIN at a custom install.

Agent experiments

run_experiments.py runs or verifies three experiments:

• persona_bank. Builds and checks banks of LLM personas. The README shows a --self-test flag.
• conjoint. A conjoint experiment, where agents choose between policy packages that vary on several attributes. The README shows options such as --check-draws, --analyze-only, --groups and --workers, and an example that compares several model families by name.
• open_ended. Open-ended deliberations among agent groups, with a --judge step and a --classify-themes step.

Gemini and Gemma models handle the within-family work. Anthropic, OpenAI, Mistral and Together keys, or OpenRouter as a fallback, serve the cross-family conjoint run. You can pass a comma-separated list of Gemini keys for rotation.

Speech bubbles converging around a single green pebble, showing pluralistic agents reaching a deliberation outcome

Data

About 0.9 GB of data sits in a public bucket. download_data.py checks each file's size and SHA-256 digest against data_manifest.json. The files include persona banks, conjoint and open-ended deliberation records, and open-ended judgments. The README is direct about their origin: all of these are generated by language models, and none come from human participants.

What is not released

The human study is the part you cannot rerun. Data from 746 participants is withheld to protect their privacy. The study ran on the Deliberate Lab platform, and pa_template.json holds the configuration, so another group could in principle run a similar study. The aggregate results are kept in results/results.json and the human-study figures, and run_analysis.py leaves those untouched.

This split matters for how you read the work. Anyone can check the statistics on the simulated side. Nobody outside the team can check the comparison between simulated and real people from raw records.

What we could not verify

• The paper itself. The README gives a citation with a BibTeX entry but no link. We searched for the title and authors and found no listing, so we cannot report the paper's findings.
• Whether simulated agents track real opinion. That is the central question of the work, and the repository alone cannot answer it.
• Which models perform best. The README names several model families in an example command, but a command line is not a result.
• Adoption. The repo had zero stars, zero forks and no releases when we checked.

If you want to check the claims yourself, run python3 run_analysis.py, open results/results.json, and compare each model and test against the figures. Then read the paper once it is posted.

What will people ask next?

Is this a Google product? No. The README says it is not an official Google product. It is a research release under the google-deepmind organization, and the license is permissive: Apache 2.0 for code and CC-BY 4.0 for other materials. You can reuse the code in your own work, and you should credit the data under the Creative Commons terms.

Why does the repo name several outside providers? A fair test of simulated opinion needs more than one model family. A conjoint run that uses only one lab's models would tell you how that family behaves, not how language models in general behave. The README example names models from several makers for the cross-family run, which suggests the authors compared families. We have not seen their numbers.

Why test with a conjoint design? A conjoint experiment shows respondents pairs of packages that differ on several features and asks which they prefer. It is a standard survey tool because it forces trade-offs. Applying it to agents lets researchers ask a simulated panel the same question they ask humans, then compare the patterns. That is our reading of the method from the file names and options, not a statement from the paper.

Where does the open-ended step fit? Open-ended deliberation lets groups of agents talk before a judge model rates the result, and a theme classifier groups what came up. This mirrors the way human deliberation platforms collect free text. Because the judge and classifier are also models, any bias in them carries into the findings, which is a good reason to read the released judgments closely.

What would make me trust it? Three things: the paper text, the human-study aggregates matching the released script outputs, and an independent group repeating the agent runs with different seeds and models. The first is missing today, the second can be checked in results/results.json, and the third is now possible because the code and the generated data are public.

How to try it

1. Clone the repository and create a Python 3.12 environment.
2. Run pip install -r requirements.txt.
3. Run python3 run_analysis.py to download the 18 MB analysis data and regenerate the figures.
4. For agent runs, export the keys you need, then try python3 run_experiments.py persona_bank --self-test before anything larger.
5. Start small with --groups and --workers, because large conjoint runs make many API calls.

Budget for the cost of agent runs before you start. The README does not give a cost estimate, so we cannot either.

Why this fits the larger policy picture

Public input on AI is turning into a political fight. On November 4 OpenAI's policy chief urged candidates to take a "third path" in the 2028 election, as we covered in our Lehane essay post. Voters in 14 Ohio municipalities passed data center limits on November 3, per our Ohio results post. Candidates such as Abdul El-Sayed want a pause and an FDA-style agency, which we explained in the El-Sayed proposal post.

In that climate, tools that claim to measure what the public wants are valuable and risky. A lab that can say "we asked thousands of simulated citizens" has a cheap talking point. A reader should ask whether those citizens match real ones. That is why the withheld human data matters, and why the release of the generated data and code is useful: others can test the method.

DeepMind is also under scrutiny on how it treats people. See our report on its non-disparagement clause. A transparent research release helps the lab's case, but it is a separate matter from that report.

Thumb-shaped bubbles pointing up and down, representing public opinion on AI policy

What builders and researchers can take away

• Simulated panels are a tool, not a poll. Use persona agents to draft questions and find blind spots, then validate with real people.
• Check the provenance of every dataset. The README labels the data as model-generated. Keep that label in your own reports.
• Reproducibility has limits. You can rerun the simulation side. You cannot rerun the human comparison.
• Watch for the paper. Once it is public, compare its claims with results/results.json.

For teams that run agents on live data, a security layer matters as much as a good method. AgentBeam is the agent security platform from the explainx.ai team that stops AI agents before they take dangerous actions, and it fits any workflow that gives agents API keys, like the multi-provider setup this repo needs.

Related reading

• OpenAI's 2028 election essay
• Ohio voters pass data center bans
• Abdul El-Sayed's AI pause proposal
• Anthropic's 2028 presidential engagement program
• White House super intelligence task force
• Hinton's Chornobyl warning and an FDA for AI
• DeepMind's non-disparagement clause report
• Primary source: google-deepmind/pluralistic_agents on GitHub

Repository details are accurate as of November 4, 2026 and may change as DeepMind updates the repo or publishes the paper.