sarvam/indic_writing_bench_v1

Indic WritingBench v1

An Indic-language generative-writing benchmark built in the spirit of WritingBench: A Comprehensive Benchmark for Generative Writing, but constructed from scratch for Indian languages with a fully LLM-driven pipeline (no human-in-the-loop). Each item is a realistic writing request paired with real reference material and a per-sample, query-specific rubric used for LLM-as-a-judge scoring.

Structure

• One config/subset per language (e.g. Hindi). Load a language with the name argument.
• Single test split per subset (this is an evaluation benchmark).
• Prompts appear in three renderings: native (native script), code_mixed (everyday English words mixed into the sentence, Roman script), and romanized (the same language transliterated to Roman script). The evaluation rubric is language- and script-independent, so the same rubric applies across all three.

from datasets import load_dataset

ds = load_dataset("sarvam/indic_writing_bench_v1", "Hindi", split="test")
print(ds[0]["query"])      # the prompt + reference material, as sent to the model
print(ds[0]["checklist"])  # the 5-criterion rubric used to score responses

Fields

Field	Type	Description
index	int	Stable index within the subset (used by the scorer to join responses to rubrics).
id	string	Unique record id.
domain	string	Top-level domain (10 total).
subdomain	string	Specific writing task type.
language	string	Language of the subset (e.g. Hindi).
variant	string	Rendering: native | code_mixed | romanized.
is_code_mixed / is_romanized	bool	Flags for the rendering.
prompt	string	The writing request only (no reference material).
query	string	The prompt with its reference material combined — this is what the model under test and the judge receive.
reference	struct	{ title, url, source_language, content } — the grounding material (full text).
checklist	list	The per-sample rubric: 5 criteria, each with name, criteria_description, and a 10-point rubric split into five bands (1-2, 3-4, 5-6, 7-8, 9-10).

Evaluation

Evaluation follows the original WritingBench LLM-as-a-judge protocol, with GPT-5.4 as the judge. There is no single gold answer; instead, each response is scored against the item's own checklist, then averaged.

Step A — Generate responses

Run the model under test on each item's query and save one record per item:

{"index": 0, "response": "..."}

Suggested generation params (from the original benchmark): temperature=0.7, top_p=0.8, top_k=20, max_tokens=16000. For reasoning models, strip the chain-of-thought before scoring — discard everything up to and including the </think>\n\n marker.

Step B — Score each criterion separately (GPT-5.4 judge)

The judge is not asked to score the whole response at once. For each item it is called once per criterion (5 calls), each time given the query, the response, and that one criterion's rubric, returning strict JSON {"score": 1-10, "reason": "..."}.

Judge system prompt

You are an expert evaluator with extensive experience in evaluating response of given query.

Judge scoring prompt (the criterion is injected twice — before and after the query/response — so it stays in attention over long inputs):

Evaluate the Response based on the Query and Criteria provided following the Scoring Rules.

** Scoring Rules **

"1-2": "Low score description: Critical deficiencies and major issues that prevent adequate functionality.",
"3-4": "Below average score description: Lacking with noticeable shortcomings that impact overall effectiveness and require improvement.",
"5-6": "Average score description: Adequate but not exemplary, Baseline performance that meets essential requirements. Most models may achieve this score.",
"7-8": "Above average score description: Strong performance characterized by competent execution, though minor refinements are needed to achieve excellence.",
"9-10": "High score description: Exceptional performance with all aspects optimally addressed, demonstrating superior effectiveness and quality without any flaws."

-Provide reasons for each score by indicating specific strengths or deficiencies within the Response. Reference exact text passages to justify the score, ensuring that each reason is concrete and aligns with the criteria requirements while highlighting key gaps from the ideal answer.

-Be very STRICT and do not be misled by format or length; ensure that the Response is thoroughly evaluated beyond superficial appearances.

-Carefully discern whether the content of the Response is an illusion, appearing substantial but actually entirely fabricated.

-Sometimes the model may only provide an introduction or an overview without truly completing the query, which should be considered a failed response. Carefully discern this.

-Scoring Range: Assign an integer score between 1 to 10

** Output format **
(Remove symbols that interfere with JSON parsing, don't use " inside reason)
Return the results in the following JSON format, Only output the following JSON format and nothing else:
```json
{
    "score": an integer score between 1 to 10,
    "reason": "Specific and detailed justification for the score using text elements."
}

** Criteria **
```{criteria}```

** Query **
```{query}```

** Response **
```{response}```

Provide your evaluation based on the criteria restated below:

```{criteria}```

** Output format **
(Remove symbols that interfere with JSON parsing, don't use " inside reason)
Return the results in the following JSON format, Only output the following JSON format and nothing else:
```json
{
    "score": an integer score between 1 to 10,
    "reason": "Specific and detailed justification for the score using text elements."
}
```

Here {criteria} is the JSON of a single checklist entry (its name, criteria_description, and the five bands), {query} is the item's query, and {response} is the (CoT-stripped) model output.

GPT-5.4 judge configuration. GPT-5.x is a reasoning model served via Azure OpenAI: send max_completion_tokens (e.g. 8000) and do not send temperature/top_p/top_k. Validate the JSON and retry (up to 3×) if score is not an integer 1–10 or a field is missing.

from openai import AzureOpenAI

client = AzureOpenAI(
    azure_endpoint="https://<resource>.cognitiveservices.azure.com/",
    api_key="<AZURE_SUBSCRIPTION_KEY>",
    api_version="2024-12-01-preview",
)

def judge(query, response, criterion):
    prompt = SCORING_PROMPT.format(
        criteria=json.dumps(criterion, ensure_ascii=False),
        query=query,
        response=response,
    )
    out = client.chat.completions.create(
        model="gpt-5.4",  # Azure deployment name
        messages=[
            {"role": "system", "content": "You are an expert evaluator with extensive experience in evaluating response of given query."},
            {"role": "user", "content": prompt},
        ],
        max_completion_tokens=8000,
    )
    return json.loads(out.choices[0].message.content.strip("json|`"))

Step C — Aggregate

• Per item: mean of its 5 criterion scores (e.g. 8,7,7,8,7 → 7.4/10).
• Overall: mean of per-item scores across the subset.
• Breakdowns: by domain, by subdomain, and — specific to this dataset — by variant (native / code_mixed / romanized), which measures robustness to script/register while holding the (script-independent) rubric fixed.

Provenance

Fully LLM-generated: prompts and their diversification, web-grounded reference collection, prompt–reference pairing and curation, prompt naturalization, code-mix/romanize rendering, and per-sample rubric generation. Rubrics were generated with the original WritingBench Criteria Generation Prompt (Appendix C.5), extended with a language/script-independence instruction so the same rubric scores native, code-mixed, and romanized responses equally.

Work in progress. Additional languages will be added as subsets.