ygoldi/edumirror-repro-code

Reproducing EduMirror (ICML 2026)

An independent reproduction of EduMirror: Modeling Educational Social Dynamics with Value-driven Multi-agent Simulation (arXiv:2606.07948, ICML 2026, OpenReview 9CPlmQzUtF).

Part of the Hugging Face / AlphaXiv ICML 2026 reproduction 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

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
• Results: ygoldi/edumirror-repro-results