@@ -479,6 +479,67 @@ def _extract_evaluator_arn(evaluator, param_name: str = "custom_reward_function"
         return evaluator.arn
 
 
+def _get_lambda_arn_from_evaluator_arn(evaluator_arn: str, sagemaker_session=None) -> str:
+    """Extract the Lambda ARN from an evaluator's hub content entry.
+
+    Parses the hub name, content type, content name, and version directly from the
+    evaluator ARN, then calls describe_hub_content on the SageMaker client to retrieve
+    the stored Lambda function reference. This bypasses AIRHub (which hardcodes a
+    single hub name) so it works for evaluators stored in any hub.
+
+    Args:
+        evaluator_arn: Full evaluator ARN
+            (e.g., arn:aws:sagemaker:us-west-2:123456789012:hub-content/MyHub/JsonDoc/my-eval/0.0.1)
+        sagemaker_session: Optional SageMaker session
+
+    Returns:
+        The Lambda function ARN stored as the evaluator's reference
+
+    Raises:
+        ValueError: If the ARN cannot be parsed or the evaluator has no Lambda reference
+    """
+    # Parse: arn:aws:sagemaker:region:account:hub-content/HubName/ContentType/ContentName/Version
+    try:
+        resource_part = evaluator_arn.split(":", 5)[5]  # "hub-content/HubName/Type/Name/Version"
+        parts = resource_part.split("/")
+        # parts[0] = "hub-content", parts[1] = HubName, parts[2] = ContentType,
+        # parts[3] = ContentName, parts[4] = Version (optional)
+        hub_name = parts[1]
+        hub_content_type = parts[2]
+        hub_content_name = parts[3]
+        hub_content_version = parts[4] if len(parts) > 4 else None
+    except (IndexError, ValueError) as e:
+        raise ValueError(
+            f"Failed to parse evaluator ARN '{evaluator_arn}': {str(e)}"
+        )
+
+    sagemaker_session = TrainDefaults.get_sagemaker_session(sagemaker_session=sagemaker_session)
+    client = sagemaker_session.sagemaker_client
+
+    request = {
+        "HubName": hub_name,
+        "HubContentType": hub_content_type,
+        "HubContentName": hub_content_name,
+    }
+    if hub_content_version:
+        request["HubContentVersion"] = hub_content_version
+
+    response = client.describe_hub_content(**request)
+
+    # Parse the document: HubContentDocument -> JsonContent -> Reference
+    doc = json.loads(response["HubContentDocument"])
+    json_content = json.loads(doc.get("JsonContent", "{}"))
+    reference = json_content.get("Reference", "")
+
+    if not reference:
+        raise ValueError(
+            f"Evaluator '{hub_content_name}' in hub '{hub_name}' does not have a "
+            "Lambda ARN reference."
+        )
+
+    return reference
+
+
 def _resolve_model_name(model_package) -> str:
     """Resolve model_name from model_package if needed."""
     if model_package:
 
@@ -181,32 +181,34 @@ def verify_reward_function(
     # Determine if it's a Lambda ARN or local file
     is_lambda = bool(LAMBDA_ARN_REGEX.match(reward_function))
 
-    # Compute is required for Lambda ARNs with Nova models
-    if is_lambda and is_nova and compute is None:
-        raise ValueError(
-            "The 'compute' parameter is required for Nova models when using a Lambda ARN. "
-            "Please specify compute as a TrainingJobCompute or HyperPodCompute instance."
-        )
-
     # Validate Lambda ARN format for HyperPod compute
-    if is_nova and isinstance(compute, HyperPodCompute) and is_lambda:
-        # Extract function name from ARN: arn:aws[-*]:lambda:region:account:function:function-name
-        function_name_match = re.search(
-            r"arn:aws[a-zA-Z-]*:lambda:[^:]+:[^:]+:function:([^:]+)", reward_function
-        )
-        if function_name_match:
-            function_name = function_name_match.group(1)
-            # Check if function name contains 'SageMaker' (case-insensitive)
-            if not re.search(r"sagemaker", function_name, re.IGNORECASE):
+    if is_nova and isinstance(compute, HyperPodCompute):
+        if is_lambda:
+            # Extract function name from ARN: arn:aws[-*]:lambda:region:account:function:function-name
+            function_name_match = re.search(
+                r"arn:aws[a-zA-Z-]*:lambda:[^:]+:[^:]+:function:([^:]+)", reward_function
+            )
+            if function_name_match:
+                function_name = function_name_match.group(1)
+                # Check if function name contains 'SageMaker' (case-insensitive)
+                if not re.search(r"sagemaker", function_name, re.IGNORECASE):
+                    raise ValueError(
+                        f"Lambda ARN for HyperPod compute must contain 'SageMaker' in the function name for Nova models. "
+                        f"Current function name: '{function_name}'. "
+                        f"Expected format: 'arn:aws:lambda:*:*:function:*SageMaker*'"
+                    )
+            else:
                 raise ValueError(
-                    f"Lambda ARN for HyperPod compute must contain 'SageMaker' in the function name for Nova models. "
-                    f"Current function name: '{function_name}'. "
-                    f"Expected format: 'arn:aws:lambda:*:*:function:*SageMaker*'"
+                    f"Invalid Lambda ARN format: {reward_function}. "
+                    f"Expected format: 'arn:aws:lambda:region:account:function:function-name'"
                 )
         else:
-            raise ValueError(
-                f"Invalid Lambda ARN format: {reward_function}. "
-                f"Expected format: 'arn:aws:lambda:region:account:function:function-name'"
+            logger.warning(
+                f"Skipping Lambda function name validation because a local Python file is being used: "
+                f"'{reward_function}'. "
+                "For Nova RLVR jobs on HyperPod, ensure your reward function Lambda name "
+                "contains 'SageMaker' (case-insensitive). "
+                "Expected format: 'arn:aws:lambda:*:*:function:*SageMaker*'"
             )
 
     results = []
 
@@ -17,6 +17,7 @@
     _get_fine_tuning_options_and_model_arn,
     _validate_and_resolve_model_package_group,
     _extract_evaluator_arn,
+    _get_lambda_arn_from_evaluator_arn,
     _is_lambda_arn,
     _is_nova_model,
     _resolve_model_and_name,
@@ -104,9 +105,9 @@ class RLVRTrainer(BaseTrainer):
             ARN, or ModelPackageGroup object. Required when model is not a ModelPackage.
         custom_reward_function (Optional[Union[str, Evaluator]]):
             The custom reward function evaluator. Can be an evaluator ARN string, a Lambda
-            function ARN string, or an Evaluator object. If a Lambda ARN is provided
+            function ARN string, or an Evaluator object. If a Lambda ARN is provided for serverless training
             (e.g., "arn:aws:lambda:us-east-1:123456789012:function:my-reward"), an Evaluator
-            will be automatically created in the AI Registry and used for training.
+            will be automatically created in the AI Registry.
             Required for RLVR training to provide reward signals.
         mlflow_resource_arn (Optional[Union[str, MlflowTrackingServer]]):
             The MLflow tracking server ARN for experiment tracking.
@@ -132,6 +133,9 @@ class RLVRTrainer(BaseTrainer):
         is_multimodal (Optional[bool]):
             Whether the training dataset contains multimodal data. If None (default),
             auto-detected from the training dataset at train time.
+        skip_reward_validation (bool):
+            If True, skips the reward function verification step before submitting
+            the training job. Defaults to False.
     """
 
     _customization_technique = CustomizationTechnique.RLVR.value
@@ -156,6 +160,7 @@ def __init__(
         recipe: Optional[str] = None,
         overrides: Optional[dict] = None,
         is_multimodal: Optional[bool] = None,
+        skip_reward_validation: bool = False,
         base_model_name: Optional[str] = None,
         disable_output_compression: Optional[bool] = False,
         **kwargs,
@@ -195,6 +200,7 @@ def __init__(
         self._recipe_resolver = None
         self._resolved_recipe_cache = None
         self.is_multimodal = is_multimodal
+        self.skip_reward_validation = skip_reward_validation
 
         # Initialize fine-tuning options with beta session fallback
         self.hyperparameters, self._model_arn, is_gated_model = _get_fine_tuning_options_and_model_arn(self._model_name,
@@ -279,19 +285,13 @@ def _verify_reward_function(
                 )
         elif isinstance(reward_function, str) and not _is_lambda_arn(reward_function):
             # It's a string but not a Lambda ARN — treat as an evaluator ARN,
-            # fetch the Evaluator object and extract the Lambda ARN from it.
-            # Evaluator Lambdas always use OSS format (statusCode/body envelope)
+            # fetch the Lambda ARN directly from the hub content entry.
+            # This bypasses AIRHub so it works for any hub name in the ARN.
             try:
-                # Parse evaluator name from the ARN
-                # ARN format: arn:aws:sagemaker:region:account:hub-content/hub/type/name/version
-                evaluator_name = reward_function.split("/")[-2]
-                evaluator = Evaluator.get(evaluator_name, sagemaker_session=TrainDefaults.get_sagemaker_session(sagemaker_session=self.sagemaker_session))
-                reward_function = evaluator.reference
-                if not reward_function:
-                    raise ValueError(
-                        f"Evaluator '{evaluator_name}' does not have a Lambda ARN reference. "
-                        "Verification requires a Lambda ARN."
-                    )
+                reward_function = _get_lambda_arn_from_evaluator_arn(
+                    reward_function,
+                    sagemaker_session=self.sagemaker_session,
+                )
                 logger.info(f"Resolved evaluator ARN to Lambda ARN: {reward_function}")
             except ValueError:
                 raise
@@ -430,7 +430,21 @@ def train(self, training_dataset: Optional[Union[str, DataSet]] = None,
         )
 
         # Extract and validate evaluator ARN
-        evaluator_arn = _extract_evaluator_arn(self.custom_reward_function) if self.custom_reward_function else None
+        # If custom_reward_function is a Lambda ARN, create an Evaluator object first
+        if self.custom_reward_function and isinstance(self.custom_reward_function, str) and _is_lambda_arn(self.custom_reward_function):
+            lambda_arn = self.custom_reward_function
+            evaluator_name = _get_unique_name(f"rlvr-reward-{self._model_name}")
+            logger.info(f"Creating Evaluator from Lambda ARN: {lambda_arn}")
+            evaluator_obj = Evaluator.create(
+                name=evaluator_name,
+                type="RewardFunction",
+                source=lambda_arn,
+                sagemaker_session=sagemaker_session,
+            )
+            evaluator_arn = _extract_evaluator_arn(evaluator_obj)
+            logger.info(f"Created Evaluator with ARN: {evaluator_arn}")
+        else:
+            evaluator_arn = _extract_evaluator_arn(self.custom_reward_function) if self.custom_reward_function else None
         serverless_config = _create_serverless_config(model_arn=self._model_arn,
                                                      customization_technique=CustomizationTechnique.RLVR.value,
                                                      training_type=self.training_type,
@@ -465,7 +479,7 @@ def train(self, training_dataset: Optional[Union[str, DataSet]] = None,
         )
 
         # Verify reward function before submitting training job
-        if self.custom_reward_function:
+        if self.custom_reward_function and not self.skip_reward_validation:
             effective_dataset = training_dataset or self.training_dataset
             if effective_dataset is not None:
                 logger.info("Verifying reward function before submitting training job...")
 
@@ -26,8 +26,9 @@ def lambda_handler(event, context):
         # print(sample)
         if not "id" in sample:
             print(f"ID is None/empty for sample: {sample}")
-        else:
-            idx = sample["id"]
+            continue
+
+        idx = sample["id"]
 
         ro = RewardOutput(id=idx, aggregate_reward_score=0.0)
 
@@ -38,24 +39,24 @@ def lambda_handler(event, context):
 
         # Extract answer from ground truth dict
         if ground_truth is None:
-            print(f"No answer found in ground truth for id: {idx}")
-            # scores.append(RewardOutput(id="0", aggregate_reward_score=0.0))
+            print(f"Warning: No answer found in ground truth (reference_answer) for id: {idx}")
+            scores.append(RewardOutput(id=idx, aggregate_reward_score=0.0))
             continue
 
         # Get completion from last message (assistant message)
         last_message = sample["messages"][-1]
         # completion_text = last_message["content"]
-        
-        if last_message["role"] != "assistant":
-            print(f"Last message is not from assistant for id: {idx}")
-            # scores.append(RewardOutput(id="0", aggregate_reward_score=0.0))
-            continue
 
         if not "content" in last_message:
             print(f"Completion text is empty for id: {idx}")
             # scores.append(RewardOutput(id="0", aggregate_reward_score=0.0))
             continue
 
+        if last_message["role"] != "assistant":
+            print(f"Last message is not from assistant for id: {idx}")
+            scores.append(RewardOutput(id=idx, aggregate_reward_score=0.0))
+            continue
+
         random_score = random.uniform(0.0, 1.0)
         ro = RewardOutput(id=idx, aggregate_reward_score=random_score)
 
 
@@ -94,34 +94,3 @@ def test_extract_evaluator_arn_with_evaluator_string(sagemaker_session, evaluato
     # Should return the ARN string unchanged
     assert result == evaluator.arn
 
-
-def test_extract_evaluator_arn_with_lambda_arn_string(sagemaker_session, lambda_arn):
-    """Test _extract_evaluator_arn with a Lambda ARN string.
-
-    Verifies that passing a Lambda ARN triggers auto-creation of an Evaluator
-    in the AI Registry and returns the newly created evaluator's hub-content ARN.
-    """
-    result = _extract_evaluator_arn(lambda_arn, "custom_reward_function")
-
-    # The result should be a SageMaker hub-content ARN (not the Lambda ARN)
-    assert result != lambda_arn
-    assert result.startswith("arn:aws:sagemaker:")
-    assert "/JsonDoc/" in result
-    # The evaluator name should be derived from the Lambda function name (sanitized)
-    assert SANITIZED_LAMBDA_FUNCTION_NAME in result
-
-
-def test_extract_evaluator_arn_lambda_creates_retrievable_evaluator(sagemaker_session, lambda_arn):
-    """Test that the Evaluator auto-created from a Lambda ARN is retrievable.
-
-    Verifies that after _extract_evaluator_arn creates an Evaluator from a Lambda ARN,
-    the evaluator can be retrieved from the AI Registry by name.
-    """
-    result_arn = _extract_evaluator_arn(lambda_arn, "custom_reward_function")
-
-    # Verify the evaluator was actually created and is retrievable (use sanitized name)
-    evaluator = Evaluator.get(SANITIZED_LAMBDA_FUNCTION_NAME, sagemaker_session=sagemaker_session)
-    assert evaluator is not None
-    assert evaluator.arn == result_arn
-    assert evaluator.type == REWARD_FUNCTION
-    assert evaluator.reference == lambda_arn
@@ -414,16 +414,16 @@ def test_lambda_nova_without_format_validation(self, nova_sample_data, nova_lamb
         assert result["total_samples"] == 2
         assert result["successful_samples"] == 2
 
-    def test_lambda_nova_requires_compute(self, nova_sample_data, nova_lambda_arn):
-        """Test that Nova Lambda ARN requires compute parameter."""
-        with pytest.raises(ValueError, match="compute.*required"):
-            verify_reward_function(
-                reward_function=nova_lambda_arn,
-                sample_data=nova_sample_data,
-                validate_format=True,
-                is_nova=True,
-            )
-
+    def test_lambda_nova_serverless_compute(self, nova_sample_data, nova_lambda_arn):
+        result = verify_reward_function(
+            reward_function=nova_lambda_arn,
+            sample_data=nova_sample_data,
+            validate_format=True,
+            is_nova=True,
+        )
+        assert result["success"] is True
+        assert result["total_samples"] == 2
+        assert result["successful_samples"] == 2
 
 # ---------------------------------------------------------------------------
 # Test class: OSS Remote Lambda (is_nova=False)
@@ -533,16 +533,6 @@ def test_invalid_lambda_arn_format(self, nova_sample_data):
                 is_nova=True,
             )
 
-    def test_lambda_arn_without_compute_raises_error(self, nova_sample_data, nova_lambda_arn):
-        """Test that Lambda ARN without compute raises ValueError."""
-        with pytest.raises(ValueError, match="compute.*required"):
-            verify_reward_function(
-                reward_function=nova_lambda_arn,
-                sample_data=nova_sample_data,
-                validate_format=True,
-                compute=None,
-                is_nova=True,
-            )
 
     def test_hyperpod_compute_requires_sagemaker_in_function_name(
         self, nova_sample_data, nova_lambda_arn