Kushtrim/iustitia-marigonae

Iustitia Marigonae

An Albanian benchmark for decision models

Iustitia Marigonae tests whether a model can read a Kosovo court judgment in Albanian and answer closed questions about it the way a legally trained human researcher did. Each task gives the model one judgment, one target (the decision, a defendant or a victim) and one question with a fixed list of answers. The model must pick one answer key.

The benchmark is built for decision models: models that take a document and a set of typed questions and return a chosen option rather than free text. Examples are Jev and Clef. Any model that can choose one option key from a list can be evaluated, including general-purpose LLMs. The quickest way to benchmark any model, chat or decision, is SimpleAudit: one command, no judge model needed.

Original research and human annotations: Amnesty International. Its 2023 report, methodological appendix and manual codebook make this benchmark possible. Kosovo’s Basic Courts authored the judgments. Kushtrim Visoka prepared the benchmark adaptation. No endorsement by Amnesty International or the courts is implied.

Contents

Component	Count
Judgments	199
Target units	670
— decisions (one per judgment)	199
— convicted defendants	217
— defendant-linked victims	254
Questions	67
Scorable tasks	14,910
Judgment years	2018–2022

The judgments are domestic violence criminal cases from Kosovo’s Basic Courts. Amnesty sampled 200 judgments; 199 are still available. Models read the judgments in the original Albanian; nothing is translated. The questions, answer descriptions and target instructions are in English.

Questions cover verdicts, offences, sentences, court orders, mitigating and aggravating circumstances, and victims’ participation in the proceedings. Many tasks come from the same judgment, so the 14,910 tasks are not 14,910 independent cases.

Quick start

from datasets import load_dataset

REPO = "Kushtrim/iustitia-marigonae"

tasks = load_dataset(REPO, "tasks", split="test")           # default configuration
documents = load_dataset(REPO, "documents", split="test")   # full judgment texts
questions = load_dataset(REPO, "questions", split="test")

print(tasks[0]["task_id"], tasks[0]["instructions"])

The dataset is gated: accept the terms on the dataset page and run hf auth login before loading.

To benchmark a model right away, see Benchmarking with SimpleAudit, for example:

pip install "simpleaudit>=0.4.0" huggingface_hub
hf download Kushtrim/iustitia-marigonae simpleaudit/run_simpleaudit.py --repo-type dataset --local-dir .
python simpleaudit/run_simpleaudit.py --smoke --target gpt-4o-mini

Dataset structure

Configuration	One row per	Rows
tasks (default)	(target, question) pair: model inputs, allowed answers and reference answer	14,910
documents	judgment: full Albanian text, court, year, source URL, section offsets	199
units	target decision, defendant or victim, with its model input state	670
questions	question: instructions, options and reference mappings	67

The simpleaudit/ folder holds the same tasks as a scenario pack for SimpleAudit; see Benchmarking with SimpleAudit.

Every configuration has a single split, test, containing all 199 judgments. There is no training or development split: the dataset is small, so every judgment is used for evaluation. Field definitions are in SCHEMA.md.

Where the judgment text is

The full text of each judgment is in the text column of the documents configuration. sections_json gives character offsets for the header, operative_part (verdict and sentence), reasoning and, when present, remedy_notice. Nine judgments could not be segmented and have only full_text.

The same text, split into those sections, is also in state_json in the units and tasks configurations. This is the version given to the model.

Example task

task_id       domv957::GUILTY.VERDICT
unit_type     decision
state_json    {"document": "Published Kosovo Basic Court criminal judgment",
               "language": "sq",
               "translation_notes": "The judgment is in Albanian ... aktgjykim = judgment ...",
               "header": "REPUBLIKA E KOSOVËS ...",
               "operative_part": "...", "reasoning": "..."}
instructions  Did the court find the defendant (or at least one defendant) guilty in this judgment?
options       yes — The court found the defendant, or at least one defendant, guilty.
              no  — The court found no defendant guilty (acquittal, rejection of the charge, or dismissal).
accepted_options  ["yes"]          ← reference only, never shown to the model

For defendant and victim tasks, state_json also says which person to answer about, for example the first of two convicted defendants.

Running a benchmark

Inputs and outputs

Give the model only state_json (decoded), instructions and options. Keep accepted_options, reference_json and reference_origin out of the input.

The model returns one option key per task. Save predictions as JSON Lines, one line per task:

{"task_id": "domv957::GUILTY.VERDICT", "choice": "yes"}

A prediction is correct if choice is in accepted_options. “No”, “Not mentioned” and “Not applicable” are different answers. Some questions separate a recorded fact from how the court used it; for example, whether remorse is mentioned and whether it was treated as mitigation.

Tracks and the recommended subset

Track	Questions	Filter	Judgments	Tasks
Full	67	is_canonical	198	14,843
≤26-option	65	is_canonical and clef_supported	198	14,337

• Always filter to is_canonical = true. Two judgments (domv291, domv292) have identical text, so this counts it once.
• No development split. Prompts, input format and model settings should be chosen without looking at scores on this data. Results from setups tuned on this data should be marked as such and cross-validated over judgments.
• The ≤26-option track drops the two family-role questions (DEF.TYPE, VIC.TYPE), which have 34 options each. Use it for models with a 26-option limit, such as decision models served through System One endpoints. The column clef_supported marks the questions that fit that limit. When comparing models, score all of them on the same track.

Scoring

Report micro agreement (correct tasks ÷ eligible tasks), macro agreement (mean of per-question agreement), coverage and the number of judgments and tasks. Missing or invalid answers count as incorrect. Reject duplicate or unknown task_ids. For confidence intervals, resample whole judgments, not single tasks. EVALUATION.md has the full protocol and the reporting checklist.

import json
from datasets import load_dataset

tasks = load_dataset("Kushtrim/iustitia-marigonae", "tasks", split="test")
tasks = tasks.filter(lambda t: t["is_canonical"] and t["clef_supported"])  # ≤26-option track

predictions = {}
for line in open("predictions.jsonl"):
    p = json.loads(line)
    assert p["task_id"] not in predictions, f"duplicate {p['task_id']}"
    predictions[p["task_id"]] = p["choice"]
assert set(predictions) <= set(tasks["task_id"]), "unknown task IDs"

correct, per_question = 0, {}
for t in tasks:
    ok = predictions.get(t["task_id"]) in t["accepted_options"]  # missing = incorrect
    correct += ok
    per_question.setdefault(t["question_id"], []).append(ok)

n = len(tasks)
print(f"tasks {n}, judgments {len(set(tasks['verdict_id']))}")
print(f"coverage {len(predictions) / n:.1%}")
print(f"micro    {correct / n:.1%}")
print(f"macro    {sum(sum(v) / len(v) for v in per_question.values()) / len(per_question):.1%}")

Benchmarking with SimpleAudit

The easiest way to run the benchmark is SimpleAudit (version 0.4.0 or later), an open-source auditing framework by Simula and SimulaMet. The simpleaudit/ folder holds every task as a ready-made SimpleAudit scenario, and one command runs any model on it:

What is tested	Grading	Judge model needed
Chat model, quick: does it choose the reference answer?	choice_match, in code	No
Chat model, thorough: reference answer, supporting quote, no invented facts, holding the answer under pressure	checklist, by an LLM judge	Yes
Decision model (e.g. Clef, Jev): does it choose the reference answer?	choice_match, in code	No

Setup

pip install "simpleaudit>=0.4.0" huggingface_hub
hf download Kushtrim/iustitia-marigonae simpleaudit/run_simpleaudit.py --repo-type dataset --local-dir .
cd simpleaudit

The runner downloads the scenarios itself. --smoke runs 3 scenarios to check a setup; --per-question 1 runs one scenario per question (67); without either, it runs all 14,843.

Chat models

# Hosted model, graded in code (needs OPENAI_API_KEY)
python run_simpleaudit.py --smoke --target gpt-4o-mini

# Local model through an OpenAI-compatible server (Ollama, vLLM, LM Studio)
python run_simpleaudit.py --per-question 1 --target qwen3:8b \
    --base-url http://localhost:11434/v1 --api-key local

# Thorough grading by an LLM judge
python run_simpleaudit.py --per-question 1 --target gpt-4o-mini \
    --judge checklist --judge-model gpt-4o

Any SimpleAudit provider works with --provider (openai, anthropic, gemini, mistral, openrouter, ...), with keys from the usual environment variables. For a local judge, add --judge-base-url. --max-turns 3 adds two follow-up turns in which the model is pressed to change its answer; give them a model with --auditor-model (the checklist judge then also grades holding the answer).

Decision models

# Clef on Ollama (0.35.1 or later)
python run_simpleaudit.py --smoke --decision ollama --target clef --base-url http://localhost:11434

# Jev on OpenRouter (needs OPENROUTER_API_KEY)
python run_simpleaudit.py --smoke --decision openrouter --target typesafe/jev-1.13

The decision model receives the same input as in the benchmark: the judgment, the target person, the glossary and the question. The 506 scenarios of the two family-role questions have 34 options, more than decision-model endpoints accept, and are skipped automatically.

Clef's default context (16K tokens) is too short for the longest judgments. Create a 64K variant once and use it as the target:

printf 'FROM clef\nPARAMETER num_ctx 65536\n' > Modelfile.clef-64k && ollama create clef-64k -f Modelfile.clef-64k

Reading results

The runner prints a summary and the share of reference answers chosen, and saves every conversation to results/<model>.json:

from simpleaudit import AuditResults

results = AuditResults.load("results/qwen3_8b.json")
for r in results:
    print(r.scenario_name, r.severity, r.judgment.get("choice"), r.judgment.get("confidence"))

simpleaudit serve --results_dir results opens them in SimpleAudit's web viewer. With choice_match, a scenario passes when the reference answer is chosen; the share of passes is the benchmark's agreement on those tasks. Report the model, the grading, --max-turns, the dataset version, the number of scenarios and the sampling seed.

From Python

import json
from huggingface_hub import hf_hub_download
from simpleaudit import Auditor, DecisionTarget, ModelAuditor

path = hf_hub_download("Kushtrim/iustitia-marigonae", "simpleaudit/iustitia_marigonae.json", repo_type="dataset")
scenarios = json.load(open(path, encoding="utf-8"))[:10]

# A chat model, graded in code
chat = ModelAuditor(model="gpt-4o-mini", provider="openai",
                    judge="choice_match", judge_model="unused", judge_provider="openai", max_turns=1)
chat.run(scenarios).summary()

# A decision model
clef = Auditor(target=DecisionTarget.ollama("clef-64k"), judge="choice_match", max_turns=1)
clef.run([s for s in scenarios if len(s["decision"]["criteria"]) <= 26]).summary()

Files

File	Contents
simpleaudit/iustitia_marigonae.json	All 14,843 tasks of the 198 unique judgments as SimpleAudit scenarios (460 MB).
simpleaudit/iustitia_marigonae_smoke3.json	3 scenarios (guilty verdict, suspended sentence, victim present in court) for checking a setup.
simpleaudit/run_simpleaudit.py	The command-line runner used above.

The scenarios follow SimpleAudit's scenario format and pass its scripts/check_scenario_pack.py checks without errors or warnings.

What a scenario contains

Field	Content
name	<question ID> - <target unit>, e.g. GUILTY.VERDICT - domv841
documents	the judgment text, sent to the model with the question
test_prompt	for chat models: the judgment's ID, which person to answer about, the question and its options; asks for the option key on the first line, then a supporting quote
decision	the question as data: id (question ID), instructions, criteria (the options), accepted (the reference answer, never shown to the model) and state (the rest of the benchmark's input: target person, glossary)
expected_behavior	the four expectations graded by the checklist judge
description	the reference answer and how to press the model in follow-up turns; for the judge and the model writing follow-up turns
category, severity	System Integrity / Hallucination; medium
source	adapted from Amnesty International's coding; original language sq; link to the court's file
metadata	task_id, verdict_id, unit_id, question_id, question_group, accepted_options, reference_origin, and judge_notes (scoring notes and the judgment text, so the checklist judge can check quotes)

The model under test never sees the reference answer, the description or the judge notes.

Choosing the grading

• choice_match is exact and free: no judge model, no judge tokens, the same verdict every time. It checks only the chosen option.
• checklist also checks grounding and invented facts, and with follow-up turns whether the model holds its answer. Use a capable judge (in tests, judges of 4–8 billion parameters often returned no usable checklist; 12 billion and larger graded reliably), from a different model family than the model under test, with at least a 32K-token context: a scenario carries a judgment of up to about 10,000 tokens, and the judge receives it a second time.

Cost and time

With choice_match, a scenario uses only the model under test: about 7,000 tokens. The checklist judge adds about 10,000 tokens per scenario. One scenario per question (67) is therefore about 0.5 million tokens with choice_match and 1.1 million with checklist; the full pack is about 100 and 250 million. On a single local GPU, a scenario takes from a few seconds (decision models) to several minutes (large judges).

Results

Agreement with Amnesty’s human coding on all 198 canonical judgments. The 95% interval comes from resampling judgments.

Model	Track	Tasks	Coverage	Micro (95% CI)	Macro
Jev (typesafe/jev-1.13-20260917)	Full	14,843	100%	92.0% (91.4–92.6)	92.2%
Jev (typesafe/jev-1.13-20260917)	≤26-option	14,337	100%	92.2% (91.5–92.8)	92.4%

The questions were fixed before this run and were not tuned on its results.

Limitations

• Agreement is not accuracy. The reference is one researcher’s coding. Some disagreements are coding errors or come from different ways of recording what a judgment does not say.
• Derived references. The two count questions (416 tasks, reference_origin = derived_from_amnesty_roster) are computed from Amnesty’s roster of people, not coded directly.
• Targets are given. The model is told which defendant or victim to answer about. The benchmark does not test whether a model can find every person in a judgment.
• Sample. The judgments are Amnesty’s random sample of published 2018–2022 judgments mentioning domestic violence. They do not cover every case in Kosovo.
• Labels are public. Amnesty published its coding and this dataset includes the reference answers, so the data is not secret and may appear in model training data.
• Language note. The fixed translation_notes in every input say judgments are “in Albanian (sometimes Serbian)”. All 199 judgments in this release are in Albanian.

Privacy

The judgments describe domestic violence. The texts are given as the courts published them. The dataset was checked for private data, and remaining personal information of defendants and victims was removed. If you find any personal information, please report it so it can be removed.

Use the data only for research on extraction and model evaluation. Do not use it to identify people, build profiles, or support decisions about individuals or cases. Access is gated for this reason.

Sources

• Judgments: published by Kosovo’s Basic Courts (20 courts and branches) on the Kosovo Judicial Council’s website. source_url links each original file; some links may no longer work. The texts were converted from the courts’ PDF files with Docling (186), extracted from Word files (12) or produced by OCR from a scanned PDF (1), then checked and cleaned of private data.
• Annotations and questions: Amnesty International’s published reference tables (court-decisions.csv, defendants.csv, victims.csv) and codebook. Each codebook variable became one closed question with Amnesty’s own answer options. Numeric values such as prison terms became ranges; offence sets became one yes/no question per offence. codebook.yaml has every question.
• Checksums for the source tables and every data file are in provenance.json.

Rights

This package combines materials from different creators, and their redistribution rights have not all been confirmed. See LICENSE.md for the status of each component. No blanket open license is granted.

Citation

Please cite Amnesty International’s research together with this dataset:

@techreport{amnesty2023paper,
  author      = {{Amnesty International}},
  title       = {From Paper to Practice: Kosovo Must Keep Its Commitments to Domestic Violence Survivors},
  institution = {Amnesty International},
  number      = {EUR 73/7123/2023},
  year        = {2023},
  url         = {https://www.amnesty.org/en/documents/eur73/7123/2023/en/}
}

@techreport{amnesty2023appendix,
  author      = {{Amnesty International}},
  title       = {Appendix: From Paper to Practice},
  institution = {Amnesty International},
  number      = {EUR 73/7124/2023},
  year        = {2023},
  url         = {https://www.amnesty.org/en/documents/eur73/7124/2023/en/}
}

@misc{visoka2026iustitia,
  author = {Visoka, Kushtrim},
  title  = {Iustitia Marigonae: An Albanian Benchmark for Decision Models},
  year   = {2026},
  note   = {Version 0.3.0}
}

Full acknowledgments are in ATTRIBUTION.md. Citation metadata is also in references.bib and CITATION.cff.

About the name

Iustitia Marigonae means “Justice for Marigona”. It honours Marigona Osmani, an 18-year-old woman killed by her husband in Kosovo in 2021 (background).