README.md

# Reproducing EduMirror (ICML 2026)

An independent reproduction of **EduMirror: Modeling Educational Social Dynamics with Value-driven Multi-agent Simulation** ([arXiv:2606.07948](https://arxiv.org/abs/2606.07948), ICML 2026, OpenReview `9CPlmQzUtF`).

Part of the [Hugging Face / AlphaXiv ICML 2026 reproduction challenge](https://huggingface.co/datasets/ICML-2026-agent-repro/challenge).

## Status: no official code exists

The paper releases no implementation. Its only GitHub link (`Jordine/jag-concordia`) is a citation for the **JAG-Concordia baseline**, not for EduMirror. Everything here is reimplemented from the paper text (Sec 3.1-3.4, 4.1-4.4, Appendices B, D, E, F).

This shapes what a reproduction can mean. We can test whether the described **mechanism and ordering** hold when independently implemented. We cannot verify the authors' absolute numbers, because those depend on unreleased code, unreleased scenario definitions, and a proprietary backbone.

## What is verified, and how strongly

| Claim | What we test | Strength |
|---|---|---|
| 1. Concordia base + 5-category/13-sub-dimension Need System | Need System reimplemented and pinned by 28 tests | **Structural: strong.** The Concordia half is *not* verifiable (no artifact). |
| 2. Kindergarten scalability, EduMirror top at 5/15/30 agents | Full 5-method comparison, 4 LLM-judged metrics | **Ordering, at reduced scale.** Absolute values not comparable (different judge). |
| 3. Dual measurement (LLM Rater + LLM Surveyor) | Protocol implemented; RSES construct validity checked | Mechanism + construct validity |
| 4. Win-rate heatmap across scenarios | Pairwise judging, order-randomized | Ordering, on reconstructed scenarios |
| 5. Three interventions mitigate extreme competition | Variance/range of malicious competition per arm | Direction + dispersion |

## Backbone substitution

The paper uses **GPT-4o** as evaluator and frontier models as agent backbones. We serve open Qwen2.5 models with vLLM (72B-AWQ for the judged claims, after a validity probe rejected 32B).

Per the challenge guide, this is a documented backend swap, not a `toy` reduction: the backbone is not the paper's contribution — the value-driven architecture layered on it is. But it has a real consequence, stated plainly: **absolute scores are not comparable to the paper's**, and for Claims 2/4 the open judge turned out to be too blunt to adjudicate them at all (see the judge-validity page).

### Cost, measured

| | |
|---|---|
| Volume | ~20.4k calls, 18.4M input / 3.3M output tokens |
| Self-hosted (this repro) | **$30.32**, 6.7 GPU-hours, 13 HF Jobs |
| Same volume at GPT-4o list pricing | ~$79 (~$56 with 50% cached input) |
| Saving from self-hosting | **~1.8-2.6x** — real, but not an order of magnitude |

An H200 at $5/hour is not cheap, and this workload is ~4 sequential LLM rounds per step, which leaves the GPU underutilised. The stronger arguments for self-hosting here are **reproducibility** (anyone can rerun the exact job) and the fact that the backbone is not the contribution — not raw cost.

## Design rules that protect the result

These are the things that would silently invalidate the comparison if we got them wrong:

- **Identical everything but architecture.** All five methods share one backbone, one persona text (`Persona.block()`), one scenario object, one output contract (`ACTION_CONTRACT`), one observation window. Pinned by tests.
- **The Rater never sees internal state.** If the judge could read EduMirror's need values, Claim 2 would be circular — it would score bookkeeping, not behaviour. `test_behaviour_text_excludes_internal_state` asserts the negative.
- **Pairwise order is randomized.** LLM judges have position bias; always showing EduMirror first would manufacture the paper's predicted result. `test_pairwise_compare_randomizes_order_and_maps_back` proves a purely position-biased judge lands at ~50%.
- **D2A is a real baseline, not a strawman.** The paper calls it "the closest value-based baseline", so the EduMirror-vs-D2A margin is the sharpest test of the paper's specific contribution. D2A gets a genuine 5-desire system.
- **Simultaneous action selection.** Sequential turn-taking would give later agents more information, and turn order interacts with agent count — confounding the 5/15/30 axis.

Known asymmetry we do *not* hide: EduMirror spends 3 LLM calls/step (generate → evaluate → update) vs ReAct's 1. That is the paper's architecture, but it means the comparison is **per-step, not per-unit-compute**.

## Discrepancies found in the paper

1. **Appendix E.1 prose implies 14 sub-dimensions; Table 9 gives 13.** Only Table 9's reading matches the claimed 13. We follow Table 9.
2. **Category names differ between Sec 3.3 and Appendix E.1** ("Mental Health"/"Self-Esteem" vs "Psychological Health Needs"/"Esteem"). Same membership → still 5.
3. **RSES reverse-coding in Appendix F.5 appears to be a typo.** It lists items 1,2,4,6,7 as positive, which would score agreement with *"At times I think I am no good at all"* as **high** self-esteem. It contradicts the paper's own "scoring follows standard protocols". We use standard RSES coding (reverse 2,5,6,8,9).
4. **Table 1 reports 4 baselines but Sec 4.1 names 5** (JAG-Concordia is omitted from the table).

## Layout

```
edumirror/
  needs.py       # Psychological Need System: 5 categories, 13 sub-dimensions (Claim 1)
  svo.py         # Social Value System, Eq. (2) orientation signal
  agents.py      # EduMirror value-driven planner + ReAct/BabyAGI/LLMob/D2A
  gm.py          # LLM Game Master + episode loop
  measure.py     # LLM Rater + LLM Surveyor (RSES, SVO slider), pairwise judge
  scenarios.py   # kindergarten / bullying / election / representative scenarios
  llm.py         # backend seam: MockLLM (offline tests) | vLLM (real runs)
experiments/
  run_experiments.py   # one entrypoint, all stages
  make_figures.py      # figures + tables
  job_entrypoint.sh    # HF GPU Job: serve vLLM, run, upload
tests/                 # 77 tests, no network
```

## Run it

```bash
uv venv .venv && uv pip install -e ".[dev]" --python .venv
.venv/bin/python -m pytest tests/ -q          # 77 tests, offline

# Local smoke against the deterministic mock backend (no GPU, seconds):
.venv/bin/python experiments/run_experiments.py --stage smoke --out outputs

# Real run on a GPU (serves Qwen2.5-32B with vLLM, runs every claim):
hf jobs run --flavor h200 --secrets HF_TOKEN \
  -e EDUMIRROR_MODEL=Qwen/Qwen2.5-32B-Instruct -e STAGE=all \
  --timeout 6h -d vllm/vllm-openai:latest \
  bash -c "curl -sfL https://huggingface.co/datasets/ygoldi/edumirror-repro-code/resolve/main/experiments/job_entrypoint.sh -o /tmp/e.sh && bash /tmp/e.sh"
```

The mock backend returns structurally valid but **semantically empty** responses. It exists to test plumbing, never quality — no claim is evaluated against it.

## Artifacts

- Code: [`ygoldi/edumirror-repro-code`](https://huggingface.co/datasets/ygoldi/edumirror-repro-code)
- Results: [`ygoldi/edumirror-repro-results`](https://huggingface.co/datasets/ygoldi/edumirror-repro-results)