@@ -216,6 +216,14 @@ technologies:
   - id: sr
     label: SR
     source: "Shadow Residual (q,o + MLP, r=32, cross r=32, shared KV)"
+  # A classifier slot: a linear head on the frozen base model's final hidden
+  # state at the end of the prompt, composed into the LoRA / aLoRA checkpoint,
+  # its verdict emitted as one label word. Only intrinsics with a `classifier`
+  # entry have one; it answers in one token, so it has no serving blocks.
+  - id: classifier
+    label: Classifier
+    source: "Linear head on the final hidden state (frozen base, logistic regression)"
+    serving: false
 
 # Decode throughput, the Throughput columns: per technology, granite-switch
 # against stock vLLM serving the same adapters (native-lora), measured by the
@@ -278,6 +286,12 @@ intrinsics:
     headline: accuracy
     headline_label: Accuracy
     max_new_tokens: 200
+    # Its classifier head's labels, in the head's row order, and each as the
+    # scorer reads an answer. A label must be one token of the base model's
+    # tokenizer, and "answerable" / "unanswerable" are several.
+    classifier:
+      labels: ["yes", "no"]
+      to_answer: {"yes": '"answerable"', "no": '"unanswerable"'}
   - id: query_clarification
     name: Query clarification
     scorer: query_clarification
@@ -290,6 +304,10 @@ intrinsics:
     headline: accuracy
     headline_label: Accuracy
     max_new_tokens: 24
+    # yes: the text is a risk; no: it is not. The scorer reads them as they are.
+    classifier:
+      labels: ["yes", "no"]
+      to_answer: {"yes": "yes", "no": "no"}
   - id: requirement_check
     name: Requirement check
     scorer: requirements
 
@@ -39,13 +39,23 @@
 PYPI_VERSION = re.compile(r"\d+(\.\d+)*")
 
 # Technologies composed into the same checkpoint. SR is a whole-checkpoint
-# dual-stream mode and the composer refuses to mix it with LoRA / aLoRA.
-COMPOSE_GROUPS = {"single_stream": ("lora", "alora"), "dual_stream": ("sr",)}
+# dual-stream mode and the composer refuses to mix it with LoRA / aLoRA. A
+# classifier slot (a linear head, no LoRA) rides in the LoRA / aLoRA
+# checkpoint: the composer cannot compose classifiers on their own, and its
+# marker selects the head without changing the active adapter.
+CLASSIFIER = "classifier"
+COMPOSE_GROUPS = {
+    "single_stream": ("lora", "alora", CLASSIFIER),
+    "dual_stream": ("sr",),
+}
 
 # Reference columns (``reference.py``): each technology's staged checkpoint
-# with HF + PEFT and no granite-switch, and the base model with no adapter.
+# with HF + PEFT (a classifier: its head on the HF base model) and no
+# granite-switch, and the base model with no adapter.
 BASE_COLUMN = "base"
-REFERENCE_COLUMNS = ("lora", "alora", "sr", BASE_COLUMN)
+REFERENCE_COLUMNS = ("lora", "alora", "sr", CLASSIFIER, BASE_COLUMN)
+# The skip reason of an intrinsic with no classifier head (adapters.yaml).
+NO_CLASSIFIER = "no classifier head for this task"
 # Libraries whose versions the reference run records.
 REFERENCE_LIBRARIES = ("torch", "transformers", "peft")
 
@@ -144,6 +154,25 @@ class Technology:
     id: str
     label: str
     source: str
+    # Whether the serving blocks (throughput, switching) measure it. A
+    # classifier answers in one token: there is nothing to decode or switch.
+    serving: bool = True
+
+
+@dataclass(frozen=True)
+class Classifier:
+    """An intrinsic's classifier head (``classifier`` in adapters.yaml): its
+    label words, in the head's row order, and what each means to the scorer."""
+
+    # Single-token words: the head's verdict is emitted as one of them.
+    labels: tuple[str, ...]
+    # Each label as the intrinsic's scorer reads an answer, e.g. "yes" ->
+    # '"answerable"' for answerability, whose own words are several tokens.
+    to_answer: dict
+
+    def answer(self, label: str) -> str:
+        """The scorer's form of a generated label word; any other text as is."""
+        return self.to_answer.get(label.strip(), label)
 
 
 @dataclass(frozen=True)
@@ -157,6 +186,30 @@ class Intrinsic:
     # Bumped when only this intrinsic's scoring changes: its saved answers are
     # scored again (rescore.py) instead of generated again.
     score_version: int = 1
+    # Its classifier head, when it has one; None skips its classifier cell.
+    classifier: Classifier | None = None
+
+
+def make_intrinsic(raw: dict) -> Intrinsic:
+    """An ``intrinsics`` entry, its ``classifier`` checked: two or more labels,
+    each mapped to the scorer's answer."""
+    raw = dict(raw)
+    head = raw.pop("classifier", None)
+    if head is not None:
+        labels = tuple(str(label) for label in head.get("labels") or ())
+        to_answer = {str(k): str(v) for k, v in (head.get("to_answer") or {}).items()}
+        if (
+            set(head) - {"labels", "to_answer"}
+            or len(labels) < 2
+            or len(set(labels)) != len(labels)
+            or set(to_answer) != set(labels)
+        ):
+            raise ValueError(
+                f"intrinsic {raw.get('id')}: a classifier needs two or more "
+                "distinct labels, each with its answer in to_answer"
+            )
+        head = Classifier(labels=labels, to_answer=to_answer)
+    return Intrinsic(**raw, classifier=head)
 
 
 @dataclass(frozen=True)
@@ -281,6 +334,11 @@ def public_models(self) -> tuple[Model, ...]:
         """The models the results page shows."""
         return tuple(m for m in self.models if not m.private)
 
+    @property
+    def serving_technologies(self) -> tuple[Technology, ...]:
+        """The technologies the serving blocks (throughput, switching) measure."""
+        return tuple(t for t in self.technologies if t.serving)
+
     def source(self, tech_id: str) -> str:
         """How the model's adapters of a technology were trained, for the page."""
         own = self.model.technologies.get(tech_id, {}).get("source")
@@ -397,7 +455,7 @@ def load_spec(path: Path = SPEC_PATH, model: str | None = None) -> Spec:
         reference_version=int(raw["reference_version"]),
         models=models,
         technologies=tuple(Technology(**t) for t in raw["technologies"]),
-        intrinsics=tuple(Intrinsic(**i) for i in raw["intrinsics"]),
+        intrinsics=tuple(make_intrinsic(i) for i in raw["intrinsics"]),
         model_id=ids[0],
         throughput=Throughput(**raw.get("throughput", {})),
         switching=Switching(**raw.get("switching", {})),
 
@@ -29,6 +29,12 @@
 ``adapter_name``, in the job's document style and chat-template options
 (``prompts.py``). An unknown name silently renders the base-model prompt, so
 every prompt is checked to contain the adapter's control token.
+
+A classifier job (``"classifier": true``) names its head the same way: the
+template drops the generation prompt and appends the head's marker as the
+last token, where the head reads. Its prompts must end in that marker; the
+verdict is the first generated token, the label word. (granite-switch PR #134
+also took ``classifier_name`` up to 861b917; ``adapter_name`` works in both.)
 """
 
 from __future__ import annotations
@@ -62,6 +68,10 @@ def render(tok, row: dict, job: dict, control_token_id: int | None) -> list[int]
     ids = list(tok(text, add_special_tokens=False).input_ids)
     if control_token_id is not None and control_token_id not in ids:
         raise ControlTokenMissing(f"control token id for {adapter_name} not in prompt")
+    if job.get("classifier") and (
+        control_token_id is None or ids[-1] != control_token_id
+    ):
+        raise ControlTokenMissing(f"classifier marker for {adapter_name} is not last")
     return ids
 
 
@@ -189,7 +199,10 @@ def run(spec: dict) -> dict:
                 completion = out.outputs[0]
                 row["generated_content"] = completion.text
                 row["prompt_tokens"] = len(prompt["prompt_token_ids"])
-                truncated += completion.finish_reason == "length"
+                # A classifier's one-token answer always stops at its length.
+                truncated += completion.finish_reason == "length" and not job.get(
+                    "classifier"
+                )
             write_jsonl(Path(job["out_path"]), kept)
             status["jobs"][key].update(
                 n_generated=len(kept),
 
@@ -25,6 +25,11 @@
   pod at a pinned commit) with the checkpoint loaded by PEFT, as that repo's
   own generation does. The checkpoint's invocation tokens were dropped first
   (``staged.peft_sr_copy``).
+* ``classifier``: the base model and the staged head, no generation. Each
+  prompt is the conversation without a generation prompt, then the base's
+  role-open marker (``prompts.classifier_ids``), where a composed model's
+  classifier marker is embedded; the head reads the final hidden state there
+  and its best-scoring label is the answer.
 
 Prompts are rendered by the base tokenizer's chat template, with the same
 documents, tools, document style and chat-template options as the
@@ -59,8 +64,15 @@
 import traceback
 from pathlib import Path
 
-from .prompts import chat_text
-from .staged import CONFIG_FILE, WEIGHTS_FILE, read_jsonl, write_jsonl
+from .prompts import chat_text, classifier_ids
+from .staged import (
+    CONFIG_FILE,
+    HEAD_FILE,
+    WEIGHTS_FILE,
+    classifier_meta,
+    read_jsonl,
+    write_jsonl,
+)
 
 
 class CellFailed(Exception):
@@ -250,11 +262,81 @@ def generate_rows(model, tok, prompts: list[list[int]], budgets: list[int], job:
     return outputs, truncated
 
 
+def classify_rows(model, head: dict, prompts: list[list[int]], job: dict) -> list[int]:
+    """Each prompt's best-scoring head row: the head (``weight [labels, hidden]``,
+    ``bias``) on the base model's final hidden state at the prompt's last
+    token. One prompt per forward pass: no padding to change the numbers."""
+    import torch
+
+    weight = head["weight"].to("cuda", torch.float32)
+    bias = head["bias"].to("cuda", torch.float32)
+    picks = []
+    for k, ids in enumerate(prompts):
+        with torch.no_grad():
+            hidden = model.model(torch.tensor([ids], device="cuda")).last_hidden_state
+        scores = weight @ hidden[0, -1].float() + bias
+        picks.append(int(scores.argmax()))
+        if (k + 1) % 500 == 0:
+            print(f"[hf_generate] {job['key']}: {k + 1} / {len(prompts)}", flush=True)
+    return picks
+
+
+def run_classifier(job: dict) -> dict:
+    """A classifier reference cell: the staged head on the HF base model."""
+    import torch
+    from safetensors.torch import load_file
+    from transformers import AutoTokenizer
+
+    key = job["key"]
+    head_dir = Path(job["adapter_dir"])
+    labels = classifier_meta(head_dir)["labels"]
+    head = load_file(str(head_dir / HEAD_FILE))
+    tok = AutoTokenizer.from_pretrained(job["base_model"])
+    rows = read_jsonl(Path(job["eval_path"]), job.get("limit"))
+    kept, prompts, too_long = [], [], 0
+    for row in rows:
+        ids = classifier_ids(
+            tok,
+            row,
+            job.get("documents", "native"),
+            job.get("chat_template_kwargs", {}),
+        )
+        if len(ids) > int(job["max_model_len"]):
+            too_long += 1
+            continue
+        kept.append(row)
+        prompts.append(ids)
+    if not kept:
+        raise CellFailed("no rows left to classify")
+    t0 = time.time()
+    with load_lock(job.get("load_lock")):
+        model = load_model({**job, "column": "base"})
+    print(f"[hf_generate] {key}: model loaded in {time.time() - t0:.0f}s", flush=True)
+    t0 = time.time()
+    for row, ids, pick in zip(kept, prompts, classify_rows(model, head, prompts, job)):
+        row["generated_content"] = labels[pick]
+        row["prompt_tokens"] = len(ids)
+    write_jsonl(Path(job["out_path"]), kept)
+    seconds = round(time.time() - t0, 1)
+    print(f"[hf_generate] {key}: {len(kept)} rows in {seconds:.0f}s", flush=True)
+    return {
+        "ok": True,
+        "n_rows": len(rows),
+        "too_long": too_long,
+        "n_generated": len(kept),
+        "truncated": 0,
+        "seconds": seconds,
+        "gpu": torch.cuda.get_device_name(0),
+    }
+
+
 def run(job: dict) -> dict:
     import torch
     from safetensors.torch import load_file
     from transformers import AutoTokenizer
 
+    if job["column"] == "classifier":
+        return run_classifier(job)
     key = job["key"]
     max_model_len = int(job["max_model_len"])
     tok = AutoTokenizer.from_pretrained(job["base_model"])
 
@@ -148,9 +148,11 @@ def chat_text(
     documents: str,
     template_kwargs: dict,
     instruction: dict | None = None,
+    generation_prompt: bool = True,
     **extra,
 ) -> str:
-    """A row's prompt, ending in the generation prompt.
+    """A row's prompt, ending in the generation prompt (unless
+    ``generation_prompt`` is False: a classifier head's prompt).
 
     ``documents`` is the row's document style, ``template_kwargs`` its model's
     chat-template options, ``instruction`` a base-model instruction
@@ -173,8 +175,30 @@ def chat_text(
         messages,
         tools=row.get("tools"),
         documents=documents_arg,
-        add_generation_prompt=True,
+        add_generation_prompt=generation_prompt,
         tokenize=False,
         **template_kwargs,
         **extra,
     )
+
+
+# The token a granite-switch classifier marker is embedded as: the base
+# template's role-open marker, the first token of its generation prompt. The
+# composed model's template drops the generation prompt and appends the
+# marker last, so a head reads the hidden state at this token.
+ROLE_OPEN = ("<|start_of_role|>", "<|im_start|>")
+
+
+def classifier_ids(
+    tokenizer, row: dict, documents: str, template_kwargs: dict
+) -> list[int]:
+    """A row's prompt as a classifier head reads it on the base model: the
+    conversation without a generation prompt, then the role-open marker."""
+    text = chat_text(
+        tokenizer, row, documents, template_kwargs, generation_prompt=False
+    )
+    vocab = tokenizer.get_vocab()
+    marker = next((m for m in ROLE_OPEN if m in vocab), None)
+    if marker is None:
+        raise ValueError("the tokenizer has no role-open marker")
+    return [*tokenizer(text, add_special_tokens=False).input_ids, vocab[marker]]