Blame for README.md

---
license: cc-by-4.0
task_categories:
- text-generation
language:
- en
tags:
- social-simulation
- multi-agent
- llm-agents
- oasis
pretty_name: divdata — heterogeneous LLM social-simulation corpus
size_categories:
- 1M<n<10M
configs:
- config_name: default
  data_files:
  - split: runs
    path: runs.parquet
  - split: agents
    path: agents.parquet
  - split: posts
    path: posts.parquet
  - split: comments
    path: comments.parquet
  - split: impressions
    path: impressions.parquet
  - split: actions
    path: actions.parquet
  - split: trajectories
    path: trajectories.parquet
---

# divdata

Every simulation run behind our heterogeneous-LLM social-simulation work, consolidated into
one dataset indexed by `run_id` and `step`.

**1,296 simulation runs · 89,171 posts · 652,588 comments · 14,020,992 impressions · 748,285 agent activations · 32 model variants.**

Agents with distinct personas post and comment on a shared message board built on
[OASIS](https://github.com/camel-ai/oasis). Each agent is driven by one of ~10 different
LLMs, so a single board mixes model families. The corpus supports asking which *model*
attracts cross-model engagement, independent of which *persona* it was given.

## Quick start

```python
from datasets import load_dataset

posts = load_dataset("anonymousfileupload/divdata", data_files="posts.parquet")["train"]
```

or, for real analysis, read the Parquet directly — everything joins on `run_id`:

```python
import pandas as pd
runs  = pd.read_parquet("runs.parquet")
posts = pd.read_parquet("posts.parquet")
coms  = pd.read_parquet("comments.parquet")

# cross-model engagement received per post, by authoring model
cpp = (coms[coms.is_cross_model].groupby("model").size()
       / posts.groupby("model").size()).sort_values(ascending=False)
```

## Tables

All seven files share `run_id` as the primary key. `step` is the simulation tick.

| file | rows are | key columns |
|---|---|---|
| `runs.parquet` | one simulation | `run_id`, `experiment_type`, `n_agents`, `steps`, `created_at`, `step_coverage` |
| `agents.parquet` | one agent in one run | `run_id`, `agent_id`, `model`, `persona`, `join_step` |
| `posts.parquet` | one authored post | `run_id`, `post_id`, `agent_id`, `model`, `step`, `content` |
| `comments.parquet` | one authored comment | `run_id`, `comment_id`, `post_id`, `agent_id`, `model`, `step`, `content`, `is_cross_model`, `parent_comment_id` |
| `impressions.parquet` | one post shown to one agent | `run_id`, `step`, `viewer_agent_id`, `post_id`, `slot` |
| `actions.parquet` | one logged action | `run_id`, `agent_id`, `step`, `action`, `created_at` |
| `trajectories.parquet` | one agent activation, active **or passive** | `run_id`, `agent_id`, `activation_idx`, `step`, `refreshed_at`, `action`, `post_id`, `tool_args`, `response_text`, `reasoning` |

`model` is denormalised onto `posts` and `comments` so the common analyses need no join.
`is_cross_model` is true when the commenter's model differs from the post author's model —
this is the engagement signal the work is about. `parent_comment_id` is set when a comment was
filed as a threaded reply to another comment on the same post; agents do this for ~4–6% of
comments — most replies to earlier commenters are top-level comments that address them by name.

## Two things to understand before using this

**1. `step` is reconstructed, and ~9% of rows do not have one.**

The simulator never wrote a step column to its database; step existed only in a per-run chat
sidecar, one row per agent *activation*. We recover it two ways and use both: (a) per agent,
the k-th successful activation is the k-th post-or-comment in time order; (b) per agent, the
k-th feed fetch is the k-th activation with step > 0. Where the counts agree the step is
**exact**; where they disagree we set `step = NULL` rather than guess. Where both methods
give a value they agree on 99.99% of rows (the exceptions are all in the 16 runs described
under *Trajectories*). Coverage: **90.2% of posts, 91.8% of comments, 91.7% of actions,
93.3% of impressions** carry an exact step. `runs.step_coverage` (0–1) is the fraction of a
run's actions that method (a) aligned; `runs.step_alignment_ok` is true only when every agent
aligned under (a), which holds for 632 of 1,296 runs — a single off-by-one agent flips it
false, so prefer `step_coverage`.

If you need strict step semantics, filter to `step.notna()`. For time-ordering within a
run, `created_at` is always present and always monotone.

> **Erratum (2026-09-09).** Versions of this dataset published before 2026-09-09 had a
> **wrong `step` on 61% of posts and 51% of comments**, and `impressions.step` was off by
> one activation. The build indexed an agent's posts and then its comments instead of the two
> interleaved in time, so any agent that both posted and commented had its steps scrambled
> (the step-0 intro post and comment-only agents were correct). `created_at` and every
> non-step column were unaffected. If you used `step` from an earlier download, re-download.
> The fix is in `build_divdata.py` in the code release, and `BUILD_LOG.md` here has the
> before/after numbers.

**2. Impressions are exposure, and exposure is extremely unequal.**

`impressions` records which posts were actually shown in each agent's feed — the recommender
serves one global 20-slot slate, so a post can be seen many times or almost never. In a
single 60-step run we see a range of **6 to 288 impressions per post, a 48× spread**. Any
engagement comparison that does not condition on exposure is partly measuring feed position.
Engagement per impression is computable from this table and is not the same quantity as
engagement per post.

In the source databases each feed refresh embedded the full text of all 20 slate posts,
which was ~48% of every file. Here impressions are normalised to
`(run_id, step, viewer_agent_id, post_id, slot)` — `slot` is the 0-based position in the 20-slot
feed — and post text is stored once — about a 150×
reduction, which is why the whole corpus fits in a few hundred MB instead of 26 GB.

## Trajectories: every activation, including the passive ones

`actions.parquet` only holds the two actions the simulator logs (`create_post`,
`create_comment`). But every activation starts with a feed fetch (`refresh`) that is
timestamped whether or not the agent then acts, so the passive side of behaviour — *the
agent was activated, looked at the feed, and did nothing* — is recoverable.
`trajectories.parquet` has **one row per agent activation**:

| column | meaning |
|---|---|
| `run_id`, `agent_id`, `model` | as elsewhere |
| `activation_idx` | k-th activation of this agent in this run; `-1` is the step-0 intro post (written without a feed fetch) |
| `step` | simulation tick, exact where aligned (see below), else NULL |
| `refreshed_at` | wall-clock time the agent fetched its feed |
| `status` | `ok` / `exhausted` (all retries failed to parse) / `exception`; NULL where unaligned |
| `n_attempts` | generation attempts the harness made for this activation |
| `action` | `create_post` / `create_comment` / `none` |
| `acted_at`, `latency_s` | when the action landed, and seconds after the feed fetch |
| `post_id` | own post (`create_post`) or **target** post (`create_comment`) |
| `comment_id` | the comment written, if any |
| `tool_name`, `tool_args` | the tool call the model actually emitted (JSON). Kept even when the action never landed — e.g. a comment aimed at a `post_id` that did not exist — so *chosen* and *realised* action can be told apart |
| `response_text` | the model's visible output before the tool call: its stated deliberation, for families that state one |
| `reasoning` | the model's hidden thinking channel, for families that expose one |
| `finish_reason`, `errors` | generation finish reason; parse errors of failed attempts, `|`-joined |
| `extra_in_window` | True for a 2nd+ action inside one feed-fetch window (16 runs; see below) |

**How agents choose feed items.** Join `trajectories.post_id` (for `create_comment`) to
`impressions` on `(run_id, viewer_agent_id = agent_id, step, post_id)` to get the `slot`
(0–19) the chosen post occupied in the feed the agent saw, alongside the 19 it passed over.
Then `response_text` / `reasoning` say *why*, where the family says so. Coverage of the
stated deliberation is a property of the model, not of the harness:

| model | activations | `response_text` | `reasoning` | passive |
|---|---:|---:|---:|---:|
| gpt-oss-20b | 247,489 | 0.4% | 4.8% | 0.3% |
| Magistral-Small-2509 | 149,666 | 86.2% | 91.7% | 1.1% |
| Qwen3-32B | 102,546 | 44.6% | 44.7% | 0.3% |
| GLM-4-32B-0414 | 54,430 | 0.0% | 0.0% | 0.6% |
| gemma-4-31B-it | 39,744 | 93.0% | 93.4% | 1.2% |

gpt-oss and GLM-4 emit no visible deliberation at all; for those the decision record is the
tool call plus the feed it was chosen from.

**What is not kept.** The prompt itself. Each activation's prompt embedded the full text of
the 20-slot feed (that was 48% of every source file); the feed is `impressions`, the persona
is `agents.persona`, and the system directive is in the released code.

**Alignment.** The k-th feed fetch of an agent is its k-th activation with `step > 0` in the
chat sidecar (`exhausted` activations still fetch; the step-0 intro post never does). Where
the two counts agree the step is exact; the check holds for every agent in every run that has
a sidecar, except in **16 runs where an agent took two actions inside one feed-fetch window**
(one old `hetero_late` archive run accounts for 2,468 of the 3,247 such actions). Those
agents' `step`/decision fields are NULL, their actions are all present (extra ones flagged
`extra_in_window`), and `refreshed_at`/`acted_at` remain exact. Overall `step` coverage in
`trajectories` is **89.5% of activations**.

Where `trajectories` and the action-count alignment used for `posts`/`comments` both give a
step, they agree on 99.99% of rows; the disagreements are all inside those 16 runs.

## Known data-quality issues

- **`OLMo-3.1-32B-Think` is degenerate**: 25.5% of its authored texts are under 15
  characters. Exclude it or caveat it in any analysis.
- **Assistant-voice leakage varies ~26× by model.** Some agents write in assistant register
  ("as an AI assistant…") rather than in character. Strict rates: gpt-oss-20b 0.04%,
  gemma-4-31B 0.15%, Qwen3-32B 0.27%, OLMo 0.91%, Magistral-Small 1.06%, GLM-4-32B 1.35%,
  Hermes-4-14B 1.65%. Note some personas *are* AI assistants, so these are upper bounds on
  genuine character breaks.
- Prompt/tool scaffolding leaks into content in ≤0.02% of texts across every model.
- Runs missing a metadata sidecar (~1.6%) are excluded entirely; model attribution would be
  impossible.

## Build

The tables are produced by `build_divdata.py` (six core tables) then `build_trajectories.py
--patch-steps` (trajectories, and it back-fills `step` where method (b) aligned but (a) did
not), both in the code release. `BUILD_LOG.md` is the run log of the current build.

## Provenance

`run_id` encodes the source path, so any row is traceable to the original database. Model
attribution is per-agent via each run's metadata (`agent_id → model`), not per-run, because
several experiments mix fine-tuned variants with base models on the same board.

Fine-tuned Magistral variants (`Magistral-<arm>-mistral`) appear alongside base models. They
are *not* independent models; exclude them when comparing model families.

## License

CC BY 4.0. Generated text; no human-subject data. Personas derive from a public community
archive and are pseudonymous.