MTACIFBench

Multi-Turn Agentic Coding Instruction Following benchmark.

Coding benchmarks usually ask whether an agent produced working software. MTACIFBench asks something different: while building the software, did the agent obey the constraints it was told to obey — and did it keep obeying them as the conversation went on?

An agent works through several rounds of feature requests in one workspace and one conversation. Each round carries its own checklist of constraints — some about the reply ("every reply must begin with 喵～", "answer in Chinese"), some about the code it writes ("every code file's first line must be -*- coding: utf-8 -*-", "indent with exactly 2 spaces", "no console.log"), some about the process ("plan with TodoWrite before editing", "prefer Read/Write /Edit over bash"). The round is scored only if every constraint holds.

The hard part is not any single constraint. It is that constraints accumulate, sometimes contradict earlier ones, and must survive ten rounds of a growing codebase without being forgotten.

At a glance

Tasks	20
Rounds	141 (5–10 per task, median 7)
Constraints	1,853 (9–19 per round, median 13)
With a deterministic checker	892 (48%)
Scored by an LLM judge	961 (52%)
Functional checks	288 (across all 20 tasks)
Language	Chinese instructions and constraints; code is language-agnostic

Why constraints get replaced, not just added

Each round's checklist is self-contained and is never merged with another round's. That is deliberate — a later round may forbid what an earlier round required. In verified_1:

• round 0 — "run ESLint over your code and fix every error it reports"
• round 1 — "do not run any ESLint check"
• round 2 — "you must run ESLint again and resolve all errors"

An agent that treats round 0's instruction as permanent fails round 1. One that forgets it fails round 2. Score each round against its own checklist only.

Data fields

One JSON object per line in questions.jsonl.

Field	Type	Meaning
task_id	str	Unique id, also used as the result filename
docker	str	Container image the agent works in
judge_docker	str	Container image the LLM judge runs in
workspace_dir	str	Working directory inside the container (/workspace)
system_prompt	str	Constraints injected as a system prompt for the whole task
description	str	Optional task summary; empty for every task in this release
task_category	str	Broad task family (Data Analysis, …)
rounds	list[Round]	The rounds, in the order they must be run
function_checklist	list[FunctionCheck]	User-visible functional requirements, scored per task

Round

Field	Type	Meaning
round_id	int	Round identifier (0-based, contiguous)
prompt	str	The feature request for this round
instruction_following_checklist	list[Constraint]	Constraints scored for this round only

Constraint

Field	Type	Meaning
constraint	str	The requirement, in natural language
validation_code	str	Python checker, or "" when the constraint is judged by an LLM
tags	list[str]	Category labels (内容 content, 环境 environment, 风格 style, 工作流 workflow, 人设 persona, 语言 language, …)
main_id, type_id	int | null	Provenance ids from constraint authoring; not used in scoring

FunctionCheck

Whether the software works, as opposed to whether the agent obeyed its constraints. Settling one of these means rendering the page and interacting with it — "hover a status light, check a tooltip appears" — so they are scored once per task against the built and served application, not per round.

Field	Type	Meaning
checklist_id	int | str	Identifier, unique within the task
description	str	What to verify, from a user's point of view
weight	float	Relative weight; 1.0 for every item in this release

288 items across the 20 tasks. Evaluating them is optional and off by default in the reference harness: an unrun check must score no verdict, never 0, or switching the pass off looks like the product regressed.

Metrics

Metric	Definition
IFCSR	Instruction-Following Constraint Success Rate — constraints satisfied / total constraints
IFISR	Instruction-Following Instruction Success Rate — rounds where every constraint held / total rounds
IFSSR	Instruction-Following Session Success Rate — tasks where every round passed / total tasks
ISR	Tasks where every functional check passed / tasks functionally evaluated
CSR	Functional checks passed / functional checks that produced a verdict
BSR	Successful builds / tasks functionally evaluated

The three are deliberately nested and increasingly strict. With ~13 constraints per round, IFISR is hypersensitive: an 85% per-constraint rate implies roughly a 12% chance of a clean round if failures were independent. IFSSR — a flawless 5-to-10-round session — is currently 0 for every model measured.

Count only tasks that produced a verdict. Infrastructure failures (container died, API quota exhausted) belong in coverage, not in the score.

Baseline

glm-5.3 driving Claude Code 2.1.199, judged by deepseek-v4-pro:

Metric	Score
IFCSR	86.89
IFISR	21.37
IFSSR	0.00

19 of 20 tasks valid (one hit an API quota limit mid-inference). Split by verdict source: deterministic checkers 84.0%, LLM judge 89.4%. CLI budget 32k output / 16k thinking tokens, reasoning effort max.

Take it as a reference point, not a leaderboard: 20 tasks is small, and both the agent scaffold and the judge model affect the number.

How to run it

Evaluation is implemented in AgentProbe, a sandbox-native framework for evaluating coding agents. Every round and every judge call executes in an isolated container.

git clone https://github.com/abelperry/AgentProbe && cd AgentProbe
uv sync

# starts the sandbox server and fetches the offline agent package
./scripts/init.sh
source .agentprobe-env

# pull this dataset into benchmarks/mtacifbench/data/
python scripts/pull_benchmarks.py --org AbelNexux mtacifbench

export ZHIPU_API_KEY=... GATEWAY_API_KEY=...
uv run agentprobe -c examples/exp-mtacifbench.yaml -l info

init.sh is not optional here: this benchmark starts one judge container per round, so the judge config installs the CLI from a local tarball rather than running npm i -g inside each one — at that rate an online install hits ECONNRESET, and the judge image has no npm to fall back on either.

See benchmarks/mtacifbench/README.md in that repository for the scoring pipeline, the artifacts each run leaves behind, and the environment variables to set.

If you are implementing your own harness

The pieces that matter, in the order they bite:

1. One conversation for the whole task. Constraints span rounds ("keep the naming you used last round"), so a fresh session per round changes what the benchmark measures. With Claude Code that means --resume, not a new --session-id.
2. Inject system_prompt out of band (--append-system-prompt), not by writing into the workspace — the workspace is the artifact under evaluation.
3. Snapshot the workspace after every round. Constraints are scored against the state that round left behind, not the final state.
4. Give the judge only the current round. Slice the round's own operation flow out of the shared transcript, replace tool-result payloads with a placeholder, and never include the user instruction itself.
5. validation_code is a Python snippet, not a callable. Exec it, then resolve the entry point (check, verify, check_requirement, … — see benchmarks/mtacifbench/validation.py for the exact order and the three helpers it injects), call it with the round's reply and an absolute path to the snapshot, and fall back to the judge on timeout, exception or a non-bool return. A relative path silently fails every checker guarded by os.path.exists(workspace_path).
6. Parse judge output fail-closed. An unparseable verdict means "no verdict" — retry, then flag it. Never a pass. Require the judge to reproduce each requirement verbatim and compare against the trusted checklist, so a requirement forged inside the model's own output cannot be scored.

Citation

@misc{mtacifbench2026,
  title  = {MTACIFBench: Multi-Turn Agentic Coding Instruction Following},
  year   = {2026},
  url    = {https://huggingface.co/datasets/AbelNexux/mtacifbench}
}