@@ -158,31 +158,37 @@ def parse_design(post, project) -> dict:
                 )
         models[axis] = [found[i] for i in dict.fromkeys(ids)]
 
-    # Judges: version ids, and/or "latest:<judge id>" (always latest: unpinned,
-    # so repeating runs follow new versions).
-    raw = [v for v in dict.fromkeys(post.getlist("judge")) if v]
-    if not raw:
-        raise DesignError("Pick at least one judge.")
-    follow_ids = [v.split(":", 1)[1] for v in raw if v.startswith("latest:")]
-    pinned_ids = [v for v in raw if not v.startswith("latest:")]
-    judges = list(
-        JudgeVersion.objects.filter(pk__in=pinned_ids, judge__project=project).select_related("judge")
-    )
-    follow = list(Judge.objects.filter(pk__in=follow_ids, project=project))
-    if len(judges) != len(pinned_ids) or len(follow) != len(follow_ids):
-        raise DesignError("A selected judge is not in this workspace.")
-    for judge in follow:
-        latest = judge.versions.select_related("judge").order_by("-version").first()
-        if latest is None:
-            raise DesignError(f"Judge “{judge.name}” has no version.")
-        latest.follow_latest = True
-        judges.append(latest)
-    judges.sort(key=lambda v: (v.judge.name, is_follow(v), v.version))
-
     # When an agent is the target, its base_model IS the target model.
     if agent is not None and not models.get("target"):
         models["target"] = [agent.base_model]
 
+    all_decision = _all_decision_targets(models["target"])
+
+    # Judges: version ids, and/or "latest:<judge id>" (always latest: unpinned,
+    # so repeating runs follow new versions). All-decision designs skip this:
+    # choice_match grades in code and no judge model is called.
+    if all_decision:
+        judges = [_decision_judge_version(project)]
+    else:
+        raw = [v for v in dict.fromkeys(post.getlist("judge")) if v]
+        if not raw:
+            raise DesignError("Pick at least one judge.")
+        follow_ids = [v.split(":", 1)[1] for v in raw if v.startswith("latest:")]
+        pinned_ids = [v for v in raw if not v.startswith("latest:")]
+        judges = list(
+            JudgeVersion.objects.filter(pk__in=pinned_ids, judge__project=project).select_related("judge")
+        )
+        follow = list(Judge.objects.filter(pk__in=follow_ids, project=project))
+        if len(judges) != len(pinned_ids) or len(follow) != len(follow_ids):
+            raise DesignError("A selected judge is not in this workspace.")
+        for judge in follow:
+            latest = judge.versions.select_related("judge").order_by("-version").first()
+            if latest is None:
+                raise DesignError(f"Judge “{judge.name}” has no version.")
+            latest.follow_latest = True
+            judges.append(latest)
+        judges.sort(key=lambda v: (v.judge.name, is_follow(v), v.version))
+
     n_reps_raw = (post.get("n_repetitions") or "").strip()
     try:
         n_reps = int(n_reps_raw) if n_reps_raw else None
@@ -293,16 +299,46 @@ def run_count(design: dict) -> int:
     return n
 
 
+def _all_decision_targets(targets: list) -> bool:
+    """True when every selected target is a decision model."""
+    return bool(targets) and all(m.is_decision for m in targets)
+
+
+def _decision_judge_version(project):
+    """A Choice Match judge version for this workspace, created on first use."""
+    from judges.models import JudgeVersion
+    from judges.services import create_judge, unique_name
+
+    existing = JudgeVersion.objects.filter(
+        judge__project=project, base="choice_match"
+    ).order_by("judge__name", "version").first()
+    if existing:
+        return existing
+    name = unique_name(project, "Choice Match")
+    judge = create_judge(project=project, name=name, base="choice_match")
+    return judge.latest
+
+
 def expand(design: dict) -> list[dict]:
     """Every combination of the design's values, as run specs."""
     if run_count(design) > MAX_RUNS_PER_EXPERIMENT:
         raise DesignError(
             f"This design makes {run_count(design)} runs; the limit is {MAX_RUNS_PER_EXPERIMENT}. "
             "Fix more inputs to one value, or split it into several experiments."
         )
+    all_decision = _all_decision_targets(design["target"])
+    # All-decision designs have no auditor or judge model; give them a
+    # placeholder so the cartesian product isn't empty (overwritten below).
+    axes = {k: design[k] for k in DESIGN_AXES}
+    if all_decision:
+        axes["auditor"] = [None]
+        axes["judge_model"] = [None]
     specs = []
-    for combo in itertools.product(*(design[key] for key in DESIGN_AXES)):
+    for combo in itertools.product(*(axes[key] for key in DESIGN_AXES)):
         spec = dict(zip(DESIGN_AXES, combo, strict=True))
+        if all_decision:
+            spec["auditor"] = spec["judge_model"] = spec["target"]
+            spec["max_turns"] = 1
         spec["n_repetitions"] = design["n_repetitions"]
         spec["gen_config"] = design["gen_config"]
         spec["system_prompt_version"] = design.get("system_prompt_version")
@@ -360,7 +396,12 @@ def spec_label(spec: dict, factors: list[str]) -> str:
 
 def spec_warnings(spec: dict) -> list[str]:
     warnings = []
-    if spec["judge_model"].pk == spec["target"].pk:
+    if spec["target"].is_decision:
+        warnings.append(
+            "Decision targets are graded by the Choice Match judge (choice_match); "
+            "no judge model is called."
+        )
+    elif spec["judge_model"].pk == spec["target"].pk:
         warnings.append("Judge model is the target model: it grades itself.")
     for role, model in (("Target", spec["target"]), ("Auditor", spec["auditor"]), ("Judge", spec["judge_model"])):
         if not model.has_key:
 
@@ -46,6 +46,9 @@ def setUp(self):
         self.t1 = RegisteredModelFactory(connection=conn, display_name="GPT")
         self.t2 = RegisteredModelFactory(connection=conn, display_name="Claude")
         self.judge = RegisteredModelFactory(connection=conn, display_name="Qwen")
+        self.decision = RegisteredModelFactory(
+            connection=conn, display_name="Jev", capabilities={"decision": True}
+        )
         for target in (
             mock.patch("audits.services.resolve_engine_provenance", return_value=_PROVENANCE),
             mock.patch("audits.services.submit_audit_run"),
@@ -69,6 +72,19 @@ def _design(self, **extra):
         data.update(extra)
         return data
 
+    def _decision(self, **extra):
+        """A design POST for a decision-only target: no judge or auditor fields."""
+        data = {
+            "scenario_set": [self.set_a.id],
+            "target_model": [self.decision.id],
+            "max_turns": "3",
+            "language": "",
+            "n_repetitions": "1",
+            "gen_config_json": "",
+        }
+        data.update(extra)
+        return data
+
     def _review_to_launch_payload(self, review, include=None, **overrides):
         data = {
             "action": "launch",
@@ -116,6 +132,12 @@ def test_design_page_renders_multi_pickers(self):
         self.assertNotContains(page, f'name="judge_model" value="{agent_model.id}"')
         self.assertContains(page, 'name="scenario_version"')
 
+    def test_decision_target_design_page_still_shows_all_pickers(self):
+        # GET design page: JS hides columns client-side; server renders all.
+        page = self.client.get("/experiments/new/")
+        self.assertContains(page, 'name="auditor_model"')
+        self.assertContains(page, 'name="judge_model"')
+
     def test_single_combination_becomes_a_singleton_experiment(self):
         # Anything launched from New Experiment is an Experiment, even one run.
         resp = self.client.post("/experiments/new/", self._design(target_model=[self.t1.id], max_turns="3"))
@@ -127,6 +149,20 @@ def test_single_combination_becomes_a_singleton_experiment(self):
         self.assertEqual(run.experiment, exp)
         self.assertEqual(run.generation_parameters_snapshot["max_turns"], 3)
 
+    def test_decision_target_launches_without_judge_and_forces_max_turns_one(self):
+        resp = self.client.post("/experiments/new/", self._decision())
+        exp = Experiment.objects.get()
+        run = AuditRun.objects.get()
+        self.assertRedirects(resp, f"/experiments/{exp.id}/", fetch_redirect_response=False)
+        # max_turns forced to 1 regardless of the submitted value.
+        self.assertEqual(run.generation_parameters_snapshot["max_turns"], 1)
+        # The target model stands in for both auditor and judge_model FKs.
+        self.assertEqual(run.auditor_model_id, self.decision.id)
+        self.assertEqual(run.judge_model_id, self.decision.id)
+        # The judge version is choice_match, not the workspace default.
+        snap = run.judge_config_snapshot
+        self.assertEqual(snap["judge"]["base"], "choice_match")
+
     def test_singleton_experiment_page_renders(self):
         self.client.post("/experiments/new/", self._design(target_model=[self.t1.id], max_turns="3"))
         exp = Experiment.objects.get()
@@ -149,6 +185,23 @@ def test_multi_design_shows_review_without_launching(self):
         self.assertContains(resp, "Launch")
         self.assertFalse(AuditRun.objects.exists())
 
+    def test_decision_target_review_forces_max_turns_and_hides_judge_model_column(self):
+        # Two scenario sets × one decision target → multi-run review screen.
+        review = self.client.post(
+            "/experiments/new/",
+            self._decision(scenario_set=[self.set_a.id, self.set_b.id]),
+        )
+        self.assertTemplateUsed(review, "experiment_review.html")
+        rows = review.context["rows"]
+        self.assertEqual(len(rows), 2)
+        # max_turns forced to 1 on every row.
+        self.assertTrue(all(r["max_turns"] == 1 for r in rows))
+        # No judge_model column; choice_match note shown once at top.
+        self.assertNotIn("judge_model", [k for k, _ in review.context["columns"]])
+        self.assertIn(
+            "All runs: Decision targets are graded by the Choice Match judge (choice_match); no judge model is called.",
+            review.context["design_warnings"],
+        )
 
     def test_launch_creates_experiment_with_selected_runs(self):
         review = self.client.post("/experiments/new/", self._design())
@@ -185,12 +238,44 @@ def test_back_to_design_keeps_choices(self):
         self.assertEqual(set(page.context["sel"]["target"]), {str(self.t1.id), str(self.t2.id)})
         self.assertEqual(page.context["clone"]["max_turns"], "3, 5")
 
+    def test_decision_target_back_to_design_keeps_all_pickers(self):
+        # Going back from review to design re-renders the full form; JS
+        # hides columns client-side based on the selected targets.
+        review = self.client.post(
+            "/experiments/new/",
+            self._decision(scenario_set=[self.set_a.id, self.set_b.id]),
+        )
+        back = {"action": "edit"}
+        for key, value in review.context["design_post"]:
+            back.setdefault(f"design__{key}", []).append(value)
+        page = self.client.post("/experiments/new/", back)
+        self.assertTemplateUsed(page, "experiment_new.html")
+        # All pickers are rendered; JS handles visibility.
+        self.assertContains(page, 'name="auditor_model"')
+        self.assertContains(page, 'name="judge_model"')
+
     def test_design_errors_are_explained(self):
         resp = self.client.post("/experiments/new/", self._design(judge=[]))
         self.assertContains(resp, "Pick at least one judge.")
         resp = self.client.post("/experiments/new/", self._design(max_turns="3, lots"))
         self.assertContains(resp, "Max turns")
 
+    def test_mixed_decision_and_chat_targets_show_choice_match_warning(self):
+        # Mixed targets: both rows get the same auditor/judge; only the
+        # decision row gets the choice_match warning.
+        review = self.client.post(
+            "/experiments/new/",
+            self._design(target_model=[self.t1.id, self.decision.id], max_turns=""),
+        )
+        self.assertTemplateUsed(review, "experiment_review.html")
+        rows = review.context["rows"]
+        decision_row = next(r for r in rows if json.loads(r["spec"])["t"] == self.decision.id)
+        chat_row = next(r for r in rows if json.loads(r["spec"])["t"] == self.t1.id)
+        # Decision row: choice_match warning present.
+        self.assertTrue(any("Choice Match judge" in w for w in decision_row["warnings"]))
+        # Chat row: no choice_match warning.
+        self.assertFalse(any("Choice Match judge" in w for w in chat_row["warnings"]))
+
     def test_run_cap(self):
         from audits.experiments import MAX_RUNS_PER_EXPERIMENT
 
@@ -335,6 +420,18 @@ def test_row_specific_warning_stays_on_its_row(self):
         rows = review.context["rows"]
         self.assertEqual(sum("grades itself" in " ".join(r["warnings"]) for r in rows), 1)
 
+    def test_decision_target_warning_shown_once_for_all_rows(self):
+        # Two scenario sets × one decision target → 2 runs; note is shared.
+        review = self.client.post(
+            "/experiments/new/",
+            self._decision(scenario_set=[self.set_a.id, self.set_b.id]),
+        )
+        self.assertIn(
+            "All runs: Decision targets are graded by the Choice Match judge (choice_match); no judge model is called.",
+            review.context["design_warnings"],
+        )
+        self.assertTrue(all(not r["warnings"] for r in review.context["rows"]))
+
 
 class ScenarioVersionPickTests(_ExperimentBase):
     def setUp(self):
 
@@ -1719,15 +1719,17 @@ def lookup(found, pk, model):
             if spec.get("jf"):
                 judge = copy.copy(judge)   # the flag is per row
                 judge.follow_latest = True
+            target_model = lookup(models, spec["t"], RegisteredModel)
+            is_dec = target_model.is_decision
             objs = {
                 "version": version,
-                "target": lookup(models, spec["t"], RegisteredModel),
+                "target": target_model,
                 "auditor": lookup(models, spec["a"], RegisteredModel),
                 "judge_model": lookup(models, spec["jm"], RegisteredModel),
                 "judge": judge,
             }
             name = (post.get(f"run-{i}-name") or "").strip() or f"Run {i + 1}"
-            mt = (post.get(f"run-{i}-max_turns") or "").strip()
+            mt = "1" if is_dec else (post.get(f"run-{i}-max_turns") or "").strip()
             lang = (post.get(f"run-{i}-language") or "").strip()
             reps = (post.get(f"run-{i}-n_repetitions") or "").strip()
             system_prompt = (post.get(f"run-{i}-system_prompt") or "").strip()
 
@@ -174,7 +174,10 @@ <h3 class="text-sm font-semibold text-gray-300 mb-1">Schedule</h3>
   const summary = document.getElementById('design-summary');
   const canLaunch = {{ can_launch|yesno:"true,false" }};
   const MAX_RUNS = {{ max_runs }};
-  const AXES = [['scenario_version', 'scenario set'], ['target_model', 'target'], ['auditor_model', 'auditor'], ['judge_model', 'judge model'], ['judge', 'judge']];
+  const ALL_DECISION = {{ all_decision|yesno:"true,false" }};
+  const AXES = ALL_DECISION
+    ? [['scenario_version', 'scenario set'], ['target_model', 'target'], ['judge', 'judge']]
+    : [['scenario_version', 'scenario set'], ['target_model', 'target'], ['auditor_model', 'auditor'], ['judge_model', 'judge model'], ['judge', 'judge']];
 
   function listCount(name) {
     const el = form.querySelector(`[name="${name}"]`);