MDGov-Bench

A benchmark for master data governance reasoning.

Enterprises are pointing language models at their own operational data and asking them to make governance decisions: is this a duplicate supplier, does this record breach the data contract, what breaks if we retire this reference value, can this change be auto-approved. These decisions are expensive when they are wrong, and they are not covered by any existing public benchmark.

MDGov-Bench is 250 items across five task categories, fully synthetic, with gold answers derived from executable rules rather than human annotation.

The tasks are deliberately built so that the obvious surface signal is often the wrong one. A parent and its subsidiary share an address. A missing safety datasheet is not a violation if the hazardous flag is false. A downstream system with a nightly cache is still impacted by a schema change. Roughly half the items are designed around a specific known failure mode of this kind.

Task categories

Category	n	Answer	What it tests
match_adjudication	50	one of 3 labels	Entity resolution where name and address similarity conflict with identifier evidence
rule_violation	50	set of rule ids	Applying a data contract, including conditional rules and exemption clauses
hierarchy_reasoning	50	label or integer	Traversal and aggregation over an effective-dated hierarchy
change_impact	50	set of consumer ids	Tracing a schema or reference-data change through a dependency graph
steward_escalation	50	one of 3 labels	Routing a change request under a precedence-ordered governance policy

Difficulty is labelled per item: 50 easy, 83 medium, 117 hard. hard means the dominant surface signal points at the wrong answer.

Example item

A change_impact item presents a proposal to retire the reference value unclassified from spend_category, alongside a registry of downstream consumers. The registry contains a consumer that reads the field but filters the retired value out (not impacted), one that reads it through a nightly cache (impacted, just later), one fed by an impacted consumer rather than reading the field itself (impacted transitively), and one that never reads the field but holds a hardcoded mapping of the retired value (impacted).

Answering "every system that reads the field" scores zero on exact match. That is the point.

How gold answers are produced

Every label is computed, not annotated. rule_violation gold comes from an executable evaluator of the twelve-rule contract. change_impact gold comes from a dependency propagation function. steward_escalation gold comes from a policy evaluator that applies clauses in precedence order. match_adjudication and hierarchy_reasoning items are constructed from templates that determine the label by construction.

This means the answer key is reproducible and auditable. It also means an error in the key is a bug with a fix, rather than a disagreement between annotators.

The generator is seeded and deterministic: the same seed produces a byte-identical file.

python generate.py --seed 11 --per-category 50 --out data/mdgov_bench_v0.1.jsonl

Running the benchmark

The harness uses the Python standard library only. Nothing to install.

# reference baselines, no API key needed
python evaluate.py --baseline majority
python evaluate.py --baseline random --seed 7

# a model
export ANTHROPIC_API_KEY=...
python evaluate.py --model <model-name> --save results/run.json

# any OpenAI-compatible endpoint
export OPENAI_API_KEY=...
python evaluate.py --provider openai --base-url https://api.openai.com/v1 --model <model-name>

Useful flags: --category rule_violation to scope a run, --limit 25 for a smoke test, --concurrency to control request rate.

Scoring

Primary metric is exact match. Set-valued categories also report partial credit as Jaccard overlap, which is diagnostic rather than headline: a model that flags every plausible consumer scores well on partial credit and badly on exact match, and that gap is itself informative.

The parser looks for a final ANSWER: line and falls back to lenient extraction. Unparseable replies are counted and reported rather than silently scored zero, so that a formatting failure is never mistaken for a reasoning failure.

Baselines

Reference baselines, computed over all 250 items:

Run	Exact match	Partial credit
Random	21.2%	24.7%
Majority class per category	27.2%	35.0%
Frontier models	not yet run	not yet run

Model results are deliberately absent rather than estimated. They will be added once run, with the full results/*.json output committed so that every scored item can be inspected. Contributions of runs against other models are welcome.

What this is not

Honest limitations, because a benchmark that oversells itself is worse than none:

• 250 items is small. Differences of a couple of points between models are not meaningful. Per-category and per-difficulty breakdowns are more informative than the headline number.
• Template-derived. There are 15 to 16 templates per category, parameterised with generated entities. This gives controlled difficulty and clean gold labels, but it does not have the long tail of genuinely messy real data. A model could in principle overfit to the template shapes.
• Single-turn and context-complete. Every item supplies all the evidence needed. Real governance work involves going and finding the evidence, and knowing when it does not exist. Only insufficient_evidence in match_adjudication gestures at this.
• English only, one industry archetype. Manufacturing supply chain, Latin script names. Real master data is multilingual, and transliteration is one of the hardest parts of entity resolution in practice.
• No cost or latency dimension. Governance decisions in production run under throughput constraints this does not model.

Data statement

All data is synthetic. Meridian Industrial Group and every supplier, site, material and system named in this benchmark are invented. No proprietary, customer, or employer data was used, and no vendor's schema is reproduced. The structures are archetypal to the master data management domain and are drawn from publicly documented governance concepts.

The generator is included, so the synthetic provenance of every item can be verified rather than taken on trust.

Files

generate.py        seeded generator with validation
evaluate.py        evaluation harness, stdlib only
world.py           synthetic entity model
tasks_core.py      match, rule violation, hierarchy generators
tasks_impact.py    change impact and escalation generators
data/              the benchmark file

Citation

@misc{mdgovbench2026,
  title  = {MDGov-Bench: A Benchmark for Master Data Governance Reasoning},
  author = {Babita},
  year   = {2026},
  url    = {https://huggingface.co/datasets/Babita11/mdgov-bench}
}

License

CC BY 4.0. Use it, extend it, run it against your own models.