@@ -91,9 +91,9 @@ def scenario_1_balanced_three_class() -> None:
         ("reschedule", "book"),
     ]
     spec = PrecisionAggregatorSpec(
-        classes=["book", "cancel", "reschedule"], averaging="macro"
+        averaging="macro"
     )
-    evaluator = build_dataset_evaluator(spec, source_evaluator="intent_match")
+    evaluator = build_dataset_evaluator(spec, classes=["book","cancel","reschedule"], source_evaluator="intent_match")
     report(
         "Scenario 1 — Balanced 3-class (intent recognition)\n"
         "  Each class: 2 TP, 1 FP, 1 FN. Symmetric setup → macro = micro = 2/3.",
@@ -114,11 +114,13 @@ def scenario_2_imbalanced_two_class() -> None:
     classes = ["positive", "negative"]
 
     macro = build_dataset_evaluator(
-        PrecisionAggregatorSpec(classes=classes, averaging="macro"),
+        PrecisionAggregatorSpec(averaging="macro"),
+        classes=classes,
         source_evaluator="positive_match",
     )
     micro = build_dataset_evaluator(
-        PrecisionAggregatorSpec(classes=classes, averaging="micro"),
+        PrecisionAggregatorSpec(averaging="micro"),
+        classes=classes,
         source_evaluator="positive_match",
     )
     report(
@@ -150,19 +152,23 @@ def scenario_3_precision_vs_recall_vs_f() -> None:
 
     evaluators = {
         "Scenario 3a — Precision on a recall-favourable dataset": build_dataset_evaluator(
-            PrecisionAggregatorSpec(classes=classes, averaging="macro"),
+            PrecisionAggregatorSpec(averaging="macro"),
+            classes=classes,
             source_evaluator="yes_match",
         ),
         "Scenario 3b — Recall (same data — note 'yes' recall is 1.0)": build_dataset_evaluator(
-            RecallAggregatorSpec(classes=classes, averaging="macro"),
+            RecallAggregatorSpec(averaging="macro"),
+            classes=classes,
             source_evaluator="yes_match",
         ),
         "Scenario 3c — F1 (harmonic mean of P and R)": build_dataset_evaluator(
-            FScoreAggregatorSpec(classes=classes, averaging="macro", f_value=1.0),
+            FScoreAggregatorSpec(averaging="macro", f_value=1.0),
+            classes=classes,
             source_evaluator="yes_match",
         ),
         "Scenario 3d — F2 (β=2 weighs recall higher — score moves toward recall)": build_dataset_evaluator(
-            FScoreAggregatorSpec(classes=classes, averaging="macro", f_value=2.0),
+            FScoreAggregatorSpec(averaging="macro", f_value=2.0),
+            classes=classes,
             source_evaluator="yes_match",
         ),
     }
@@ -181,7 +187,8 @@ def scenario_4_skipped_datapoints() -> None:
         EvaluationResultDto(score=0.0, details={"unrelated": "shape"}),
     ]
     evaluator = build_dataset_evaluator(
-        PrecisionAggregatorSpec(classes=["cat", "dog"], averaging="macro"),
+        PrecisionAggregatorSpec(averaging="macro"),
+        classes=["cat", "dog"],
         source_evaluator="any_match",
     )
     report(
@@ -211,7 +218,8 @@ def scenario_5_realistic_intent_classifier() -> None:
     results = materialize_pairs(pairs)
     classes = ["book", "cancel", "reschedule", "modify"]
     macro_f1 = build_dataset_evaluator(
-        FScoreAggregatorSpec(classes=classes, averaging="macro", f_value=1.0),
+        FScoreAggregatorSpec(averaging="macro", f_value=1.0),
+        classes=classes,
         source_evaluator="intent_match",
     )
     report(
 
@@ -1,7 +1,7 @@
 {
   "version": "1.0",
   "id": "BinarySpamPrecision",
-  "description": "Precision on the 'spam' positive class, plus run-level aggregators",
+  "description": "Precision on the 'spam' positive class",
   "evaluatorTypeId": "uipath-binary-classification",
   "evaluatorConfig": {
     "name": "BinarySpamPrecision",
@@ -11,24 +11,6 @@
     "fValue": 1.0,
     "defaultEvaluationCriteria": {
       "expectedClass": "ham"
-    },
-    "aggregators": [
-      {
-        "type": "precision",
-        "classes": ["spam", "ham"],
-        "averaging": "macro"
-      },
-      {
-        "type": "recall",
-        "classes": ["spam", "ham"],
-        "averaging": "macro"
-      },
-      {
-        "type": "fscore",
-        "classes": ["spam", "ham"],
-        "averaging": "macro",
-        "fValue": 1.0
-      }
-    ]
+    }
   }
 }
@@ -1,7 +1,7 @@
 {
   "version": "1.0",
   "id": "EmailMulticlassFScore",
-  "description": "Macro-averaged F1 across payments / support / spam, plus run-level aggregators",
+  "description": "Macro-averaged F1 across payments / support / spam",
   "evaluatorTypeId": "uipath-multiclass-classification",
   "evaluatorConfig": {
     "name": "EmailMulticlassFScore",
@@ -12,24 +12,6 @@
     "fValue": 1.0,
     "defaultEvaluationCriteria": {
       "expectedClass": "support"
-    },
-    "aggregators": [
-      {
-        "type": "precision",
-        "classes": ["payments", "support", "spam"],
-        "averaging": "macro"
-      },
-      {
-        "type": "recall",
-        "classes": ["payments", "support", "spam"],
-        "averaging": "macro"
-      },
-      {
-        "type": "fscore",
-        "classes": ["payments", "support", "spam"],
-        "averaging": "macro",
-        "fValue": 1.0
-      }
-    ]
+    }
   }
 }
@@ -1,11 +1,10 @@
 """Aggregator specs embedded in per-datapoint classification evaluator configs.
 
-Each aggregator is a self-contained run-level metric (precision / recall /
-f-score) attached to a classification evaluator. Specs do not share any
-properties — each variant declares its own ``classes``, ``averaging``, and
-(for fscore) ``f_value`` independently. This keeps each aggregator's contract
-explicit at the JSON level: nothing is hoisted up to the evaluator and silently
-applied to siblings.
+Each aggregator is a run-level metric (precision / recall / f-score) attached
+to a classification evaluator. Classes are declared once on the parent evaluator
+config — every aggregator on the same evaluator operates on the same class
+vocabulary, so the field is not repeated per spec. Only the metric-shape fields
+(``averaging`` and, for fscore, ``f_value``) live on the spec itself.
 """
 
 from __future__ import annotations
@@ -26,23 +25,20 @@ class PrecisionAggregatorSpec(_AggregatorSpecBase):
     """Run-level precision aggregator (multiclass, micro or macro averaged)."""
 
     type: Literal["precision"] = "precision"
-    classes: list[str] = Field(..., min_length=1)
     averaging: Literal["macro", "micro"]
 
 
 class RecallAggregatorSpec(_AggregatorSpecBase):
     """Run-level recall aggregator (multiclass, micro or macro averaged)."""
 
     type: Literal["recall"] = "recall"
-    classes: list[str] = Field(..., min_length=1)
     averaging: Literal["macro", "micro"]
 
 
 class FScoreAggregatorSpec(_AggregatorSpecBase):
     """Run-level F-beta aggregator (multiclass, micro or macro averaged)."""
 
     type: Literal["fscore"] = "fscore"
-    classes: list[str] = Field(..., min_length=1)
     averaging: Literal["macro", "micro"]
     f_value: float = Field(default=1.0, gt=0)
 
 
@@ -31,20 +31,23 @@
 class BaseDatasetEvaluator(ABC, Generic[SpecT]):
     """Abstract base for dataset-level evaluators.
 
-    Constructed from an :class:`AggregatorSpec` and the name of the source
-    per-datapoint evaluator whose results this aggregator consumes. The
-    dataset evaluator's "name" used for result keying is derived from
-    ``"{source_evaluator}.{spec.type}"`` so two aggregators on the same source
-    don't collide.
+    Constructed from an :class:`AggregatorSpec`, the class vocabulary of the
+    parent per-datapoint evaluator, and the source evaluator's name. Classes
+    live on the evaluator config (not the spec) — every aggregator on the same
+    evaluator operates on the same vocabulary. The dataset evaluator's "name"
+    used for result keying is derived from ``"{source_evaluator}.{spec.type}"``
+    so two aggregators on the same source don't collide.
     """
 
     spec: SpecT
     source_evaluator: str
+    classes: list[str]
 
-    def __init__(self, spec: SpecT, source_evaluator: str) -> None:
-        """Store the aggregator spec and the source evaluator name."""
+    def __init__(self, spec: SpecT, source_evaluator: str, classes: list[str]) -> None:
+        """Store the aggregator spec, source evaluator name, and shared classes."""
         self.spec = spec
         self.source_evaluator = source_evaluator
+        self.classes = classes
 
     @property
     def name(self) -> str:
 
@@ -8,8 +8,6 @@
 
 from typing import Literal
 
-from pydantic import model_validator
-
 from ..models import (
     EvaluationResult,
     EvaluatorType,
@@ -21,22 +19,12 @@
     UiPathEvaluationError,
     UiPathEvaluationErrorCategory,
 )
-from ._aggregator_specs import AggregatorSpec, FScoreAggregatorSpec
 from .base_evaluator import BaseEvaluationCriteria, BaseEvaluatorJustification
 from .output_evaluator import (
     BaseOutputEvaluator,
     OutputEvaluatorConfig,
 )
 
-# Maps the evaluator-level ``metric_type`` strings to the corresponding
-# aggregator-spec ``type`` values. The two spellings differ historically:
-# the evaluator uses "f-score" (hyphen), the aggregator uses "fscore".
-_METRIC_TYPE_TO_AGGREGATOR_TYPE = {
-    "precision": "precision",
-    "recall": "recall",
-    "f-score": "fscore",
-}
-
 
 class BinaryClassificationEvaluationCriteria(BaseEvaluationCriteria):
     """Per-datapoint criteria: which class this sample should belong to."""
@@ -53,58 +41,6 @@ class BinaryClassificationEvaluatorConfig(
     positive_class: str
     metric_type: Literal["precision", "recall", "f-score"] = "precision"
     f_value: float = 1.0
-    # Optional run-level aggregators (precision / recall / fscore). Each is a
-    # self-contained spec carrying its own ``classes``, ``averaging``, and
-    # (for fscore) ``f_value``. The dataset-evaluator runtime walks this list
-    # after all per-datapoint evaluators complete and emits one structured
-    # result per aggregator keyed by ``{evaluator_name}.{aggregator.type}``.
-    aggregators: list[AggregatorSpec] | None = None
-
-    @model_validator(mode="after")
-    def _validate_aggregators_against_evaluator_config(
-        self,
-    ) -> "BinaryClassificationEvaluatorConfig":
-        """Reject aggregators that are inconsistent with the evaluator's own config.
-
-        Two checks:
-          * ``positive_class`` must appear in every aggregator's ``classes``
-            list (case-insensitive). Otherwise the per-datapoint headline
-            and the aggregator's confusion matrix score completely
-            disjoint label spaces.
-          * For each aggregator whose ``type`` matches the evaluator-level
-            ``metric_type`` (mapped via :data:`_METRIC_TYPE_TO_AGGREGATOR_TYPE`),
-            the aggregator's ``f_value`` must match the evaluator's
-            ``f_value``. Otherwise the per-evaluator headline produced via
-            ``reduce_scores`` and the dataset evaluator's per-aggregator
-            score diverge silently.
-        """
-        if not self.aggregators:
-            return self
-        positive_lower = self.positive_class.lower() if self.positive_class else ""
-        evaluator_aggregator_type = _METRIC_TYPE_TO_AGGREGATOR_TYPE.get(
-            self.metric_type
-        )
-        for spec in self.aggregators:
-            if positive_lower and positive_lower not in {
-                c.lower() for c in spec.classes
-            }:
-                raise ValueError(
-                    f"Aggregator '{spec.type}' on evaluator '{self.name}' "
-                    f"declares classes={spec.classes!r} but positive_class="
-                    f"{self.positive_class!r} is not in that list. Add the "
-                    "positive class to the aggregator's classes or remove it."
-                )
-            if spec.type == evaluator_aggregator_type and isinstance(
-                spec, FScoreAggregatorSpec
-            ):
-                if spec.f_value != self.f_value:
-                    raise ValueError(
-                        f"Aggregator 'fscore' on evaluator '{self.name}' has "
-                        f"f_value={spec.f_value} but the evaluator's f_value="
-                        f"{self.f_value}. The per-evaluator headline and the "
-                        "aggregator would compute different F-beta scores."
-                    )
-        return self
 
 
 class BinaryClassificationEvaluator(
@@ -162,8 +98,14 @@ def reduce_scores(self, results: list[EvaluationResultDto]) -> float:
         tp = fp = fn = 0
 
         for r in results:
-            details = BaseEvaluatorJustification.try_from(r.details)
-            if details is None:
+            if isinstance(r.details, BaseEvaluatorJustification):
+                details = r.details
+            elif isinstance(r.details, dict):
+                try:
+                    details = BaseEvaluatorJustification.model_validate(r.details)
+                except Exception:
+                    continue
+            else:
                 continue
             pred = details.actual
             exp = details.expected
 
@@ -130,7 +130,7 @@ class ClassificationDatasetEvaluator(BaseDatasetEvaluator[AggregatorSpec]):
 
     def evaluate(self, results: list[EvaluationResultDto]) -> EvaluationResult:
         """Compute the configured metric report and return the headline as score."""
-        confusion = _build_confusion(results, self.spec.classes)
+        confusion = _build_confusion(results, self.classes)
         beta_sq = (
             self.spec.f_value * self.spec.f_value
             if isinstance(self.spec, FScoreAggregatorSpec)
 
@@ -16,12 +16,16 @@
 def build_dataset_evaluator(
     spec: AggregatorSpec,
     source_evaluator: str,
+    classes: list[str],
 ) -> ClassificationDatasetEvaluator:
     """Build a dataset evaluator instance from an aggregator spec.
 
     Args:
         spec: A validated :class:`AggregatorSpec` (precision / recall / fscore).
         source_evaluator: Name of the per-datapoint evaluator whose results
             this aggregator consumes.
+        classes: The class vocabulary from the parent evaluator's config. Shared
+            across all aggregators attached to that evaluator — a spec no longer
+            carries classes of its own.
     """
-    return ClassificationDatasetEvaluator(spec, source_evaluator)
+    return ClassificationDatasetEvaluator(spec, source_evaluator, classes)
@@ -1,11 +1,14 @@
 """Exact match evaluator for workload outputs."""
 
+from pydantic import model_validator
+
 from ..models import (
     EvaluationResult,
     EvaluatorType,
     NumericEvaluationResult,
     WorkloadExecution,
 )
+from ._aggregator_specs import AggregatorSpec
 from .base_evaluator import BaseEvaluatorJustification
 from .output_evaluator import (
     OutputEvaluationCriteria,
@@ -20,6 +23,24 @@ class ExactMatchEvaluatorConfig(OutputEvaluatorConfig[OutputEvaluationCriteria])
     name: str = "ExactMatchEvaluator"
     case_sensitive: bool = False
     negated: bool = False
+    # Optional dataset-level aggregators (Precision / Recall / F-score) computed
+    # over the per-datapoint match outcomes. When set, ``classes`` must declare
+    # the label vocabulary the aggregators will bucket predictions and expected
+    # outputs into — the same vocabulary is shared across every aggregator on
+    # this evaluator.
+    classes: list[str] | None = None
+    aggregators: list[AggregatorSpec] | None = None
+
+    @model_validator(mode="after")
+    def _validate_aggregators_have_classes(self) -> "ExactMatchEvaluatorConfig":
+        """Aggregators need a class vocabulary to build a confusion matrix from."""
+        if self.aggregators and not self.classes:
+            raise ValueError(
+                f"ExactMatch evaluator '{self.name}' declares aggregators but no "
+                "``classes`` list. Set ``classes`` to the label vocabulary the "
+                "aggregators should compute Precision/Recall/F-score over."
+            )
+        return self
 
 
 class ExactMatchEvaluator(