diff --git a/apriltagmodel/best.pt b/apriltagmodel/best.pt
new file mode 100644
index 0000000000..ee9ee46910
Binary files /dev/null and b/apriltagmodel/best.pt differ
diff --git a/photon-client/src/components/dashboard/tabs/AprilTagTab.vue b/photon-client/src/components/dashboard/tabs/AprilTagTab.vue
index 249f80607e..6b908b0d57 100644
--- a/photon-client/src/components/dashboard/tabs/AprilTagTab.vue
+++ b/photon-client/src/components/dashboard/tabs/AprilTagTab.vue
@@ -5,19 +5,50 @@ import PvSlider from "@/components/common/pv-slider.vue";
 import PvSwitch from "@/components/common/pv-switch.vue";
 import { computed } from "vue";
 import { useStateStore } from "@/stores/StateStore";
-import type { ActivePipelineSettings } from "@/types/PipelineTypes";
+import type { AprilTagPipelineSettings } from "@/types/PipelineTypes";
 import { useCameraSettingsStore } from "@/stores/settings/CameraSettingsStore";
+import { useSettingsStore } from "@/stores/settings/GeneralSettingsStore";
+import type { ObjectDetectionModelProperties } from "@/types/SettingTypes";
 import { useDisplay } from "vuetify";
 
 // TODO fix pipeline typing in order to fix this, the store settings call should be able to infer that only valid pipeline type settings are exposed based on pre-checks for the entire config section
 // Defer reference to store access method
-const currentPipelineSettings = computed<ActivePipelineSettings>(
-  () => useCameraSettingsStore().currentPipelineSettings
+const currentPipelineSettings = computed<AprilTagPipelineSettings>(
+  () => useCameraSettingsStore().currentPipelineSettings as AprilTagPipelineSettings
 );
 const { mdAndDown } = useDisplay();
 const interactiveCols = computed(() =>
   mdAndDown.value && (!useStateStore().sidebarFolded || useCameraSettingsStore().isDriverMode) ? 8 : 7
 );
+
+// Check if ML detection is available on this platform
+const mlDetectionAvailable = computed(() => useSettingsStore().general.supportedBackends.length > 0);
+
+// Filter models to only those supported by available backends
+const supportedModels = computed<ObjectDetectionModelProperties[]>(() => {
+  const { availableModels, supportedBackends } = useSettingsStore().general;
+  const isSupported = (model: ObjectDetectionModelProperties) => {
+    return supportedBackends.some((backend: string) => backend.toLowerCase() === model.family.toLowerCase());
+  };
+  return availableModels.filter(isSupported);
+});
+
+const selectedModel = computed({
+  get: () => {
+    const currentModelName = currentPipelineSettings.value.mlModelName;
+    if (!currentModelName) return undefined;
+
+    const index = supportedModels.value.findIndex((model) => model.nickname === currentModelName);
+    return index === -1 ? undefined : index;
+  },
+
+  set: (v) => {
+    if (v !== undefined && v >= 0 && v < supportedModels.value.length) {
+      const newModel = supportedModels.value[v];
+      useCameraSettingsStore().changeCurrentPipelineSetting({ mlModelName: newModel.nickname }, true);
+    }
+  }
+});
 </script>
 
 <template>
@@ -88,5 +119,83 @@ const interactiveCols = computed(() =>
         (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ refineEdges: value }, false)
       "
     />
+
+    <!-- ML-Assisted Detection Section -->
+    <v-divider class="mt-3 mb-2" v-if="mlDetectionAvailable" />
+    <div v-if="mlDetectionAvailable" class="ml-settings-section">
+      <p class="text-subtitle-2 mb-2">AI-Assisted Detection (NPU)</p>
+      <pv-switch
+        v-model="currentPipelineSettings.useMLDetection"
+        :switch-cols="interactiveCols"
+        label="Enable AI Detection"
+        tooltip="Use NPU-accelerated ML model for faster AprilTag detection. Requires compatible hardware (RK3588 or QCS6490)"
+        @update:modelValue="
+          (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ useMLDetection: value }, false)
+        "
+      />
+      <div v-if="currentPipelineSettings.useMLDetection">
+        <pv-select
+          v-model="selectedModel"
+          label="Model"
+          tooltip="The model used for AI-assisted AprilTag detection"
+          :select-cols="interactiveCols"
+          :items="supportedModels.map((model) => model.nickname)"
+        />
+        <pv-slider
+          v-model="currentPipelineSettings.mlConfidenceThreshold"
+          :slider-cols="interactiveCols"
+          label="Confidence Threshold"
+          tooltip="Minimum confidence score for ML detection (0-1). Higher values reduce false positives"
+          :min="0.1"
+          :max="1.0"
+          :step="0.05"
+          @update:modelValue="
+            (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ mlConfidenceThreshold: value }, false)
+          "
+        />
+        <pv-slider
+          v-model="currentPipelineSettings.mlNmsThreshold"
+          :slider-cols="interactiveCols"
+          label="NMS Threshold"
+          tooltip="Non-maximum suppression threshold for overlapping detections (0-1)"
+          :min="0.1"
+          :max="1.0"
+          :step="0.05"
+          @update:modelValue="
+            (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ mlNmsThreshold: value }, false)
+          "
+        />
+        <pv-slider
+          v-model="currentPipelineSettings.mlRoiPaddingPixels"
+          :slider-cols="interactiveCols"
+          label="ROI Padding (px)"
+          tooltip="Pixels of padding added around each detected region. Naturally adapts: small/far tags get more relative expansion, large/close tags get less"
+          :min="10"
+          :max="150"
+          :step="5"
+          @update:modelValue="
+            (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ mlRoiPaddingPixels: value }, false)
+          "
+        />
+        <pv-switch
+          v-model="currentPipelineSettings.mlFallbackToTraditional"
+          :switch-cols="interactiveCols"
+          label="Fallback to Traditional"
+          tooltip="If ML detection finds no tags, fall back to traditional full-frame detection"
+          @update:modelValue="
+            (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ mlFallbackToTraditional: value }, false)
+          "
+        />
+        <pv-switch
+          v-model="currentPipelineSettings.showDetectionBoxes"
+          :switch-cols="interactiveCols"
+          label="Show ROI Boxes"
+          tooltip="Draw the ML model's detected bounding boxes on the processed image for tuning visualization"
+          @update:modelValue="
+            (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ showDetectionBoxes: value }, false)
+          "
+        />
+      </div>
+    </div>
   </div>
 </template>
diff --git a/photon-client/src/components/dashboard/tabs/OutputTab.vue b/photon-client/src/components/dashboard/tabs/OutputTab.vue
index 520288be30..22033ead30 100644
--- a/photon-client/src/components/dashboard/tabs/OutputTab.vue
+++ b/photon-client/src/components/dashboard/tabs/OutputTab.vue
@@ -3,6 +3,7 @@ import PvSelect from "@/components/common/pv-select.vue";
 import { useCameraSettingsStore } from "@/stores/settings/CameraSettingsStore";
 import { type ActivePipelineSettings, PipelineType, RobotOffsetPointMode } from "@/types/PipelineTypes";
 import PvSwitch from "@/components/common/pv-switch.vue";
+import PvSlider from "@/components/common/pv-slider.vue";
 import { computed } from "vue";
 import { RobotOffsetType } from "@/types/SettingTypes";
 import { useStateStore } from "@/stores/StateStore";
@@ -58,14 +59,17 @@ const interactiveCols = computed(() =>
 
 <template>
   <div>
-    <pv-switch
-      v-model="useCameraSettingsStore().currentPipelineSettings.outputShowMultipleTargets"
-      label="Show Multiple Targets"
-      tooltip="If enabled, up to five targets will be displayed and sent via PhotonLib, instead of just one"
-      :disabled="isTagPipeline"
+    <pv-slider
+      v-model="useCameraSettingsStore().currentPipelineSettings.outputMaximumTargets"
+      label="Maximum Targets"
+      tooltip="The maximum number of targets to display and send."
+      :hidden="isTagPipeline"
+      :min="1"
+      :max="127"
+      :step="1"
       :switch-cols="interactiveCols"
       @update:modelValue="
-        (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ outputShowMultipleTargets: value }, false)
+        (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ outputMaximumTargets: value }, false)
       "
     />
     <pv-switch
diff --git a/photon-client/src/types/PipelineTypes.ts b/photon-client/src/types/PipelineTypes.ts
index 1c771f7513..d73114af6d 100644
--- a/photon-client/src/types/PipelineTypes.ts
+++ b/photon-client/src/types/PipelineTypes.ts
@@ -66,7 +66,7 @@ export interface PipelineSettings {
   hsvHue: WebsocketNumberPair | [number, number];
   ledMode: boolean;
   hueInverted: boolean;
-  outputShowMultipleTargets: boolean;
+  outputMaximumTargets: number;
   contourSortMode: number;
   cameraExposureRaw: number;
   cameraMinExposureRaw: number;
@@ -108,7 +108,7 @@ export type ConfigurablePipelineSettings = Partial<
 // Omitted settings are changed for all pipeline types
 export const DefaultPipelineSettings: Omit<
   PipelineSettings,
-  "cameraGain" | "targetModel" | "ledMode" | "outputShowMultipleTargets" | "cameraExposureRaw" | "pipelineType"
+  "cameraGain" | "targetModel" | "ledMode" | "cameraExposureRaw" | "pipelineType"
 > = {
   offsetRobotOffsetMode: RobotOffsetPointMode.None,
   streamingFrameDivisor: 0,
@@ -137,6 +137,7 @@ export const DefaultPipelineSettings: Omit<
   offsetDualPointB: { x: 0, y: 0 },
   hsvHue: { first: 50, second: 180 },
   hueInverted: false,
+  outputMaximumTargets: 20,
   contourSortMode: 0,
   offsetSinglePoint: { x: 0, y: 0 },
   cameraBrightness: 50,
@@ -166,7 +167,7 @@ export const DefaultReflectivePipelineSettings: ReflectivePipelineSettings = {
   cameraGain: 20,
   targetModel: TargetModel.InfiniteRechargeHighGoalOuter,
   ledMode: true,
-  outputShowMultipleTargets: false,
+  outputMaximumTargets: 20,
   cameraExposureRaw: 6,
   pipelineType: PipelineType.Reflective,
 
@@ -197,7 +198,7 @@ export const DefaultColoredShapePipelineSettings: ColoredShapePipelineSettings =
   cameraGain: 75,
   targetModel: TargetModel.InfiniteRechargeHighGoalOuter,
   ledMode: true,
-  outputShowMultipleTargets: false,
+  outputMaximumTargets: 20,
   cameraExposureRaw: 20,
   pipelineType: PipelineType.ColoredShape,
 
@@ -227,6 +228,14 @@ export interface AprilTagPipelineSettings extends PipelineSettings {
   tagFamily: AprilTagFamily;
   doMultiTarget: boolean;
   doSingleTargetAlways: boolean;
+  // ML-assisted detection settings
+  useMLDetection: boolean;
+  mlConfidenceThreshold: number;
+  mlNmsThreshold: number;
+  mlRoiPaddingPixels: number;
+  mlFallbackToTraditional: boolean;
+  mlModelName: string | null;
+  showDetectionBoxes: boolean;
 }
 export type ConfigurableAprilTagPipelineSettings = Partial<
   Omit<AprilTagPipelineSettings, "pipelineType" | "hammingDist" | "debug">
@@ -237,10 +246,9 @@ export const DefaultAprilTagPipelineSettings: AprilTagPipelineSettings = {
   cameraGain: 75,
   targetModel: TargetModel.AprilTag6p5in_36h11,
   ledMode: false,
-  outputShowMultipleTargets: true,
+  outputMaximumTargets: 127,
   cameraExposureRaw: 20,
   pipelineType: PipelineType.AprilTag,
-
   hammingDist: 0,
   numIterations: 40,
   decimate: 1,
@@ -251,7 +259,15 @@ export const DefaultAprilTagPipelineSettings: AprilTagPipelineSettings = {
   threads: 4,
   tagFamily: AprilTagFamily.Family36h11,
   doMultiTarget: false,
-  doSingleTargetAlways: false
+  doSingleTargetAlways: false,
+  // ML-assisted detection defaults
+  useMLDetection: false,
+  mlConfidenceThreshold: 0.5,
+  mlNmsThreshold: 0.45,
+  mlRoiPaddingPixels: 40,
+  mlFallbackToTraditional: true,
+  mlModelName: null,
+  showDetectionBoxes: true
 };
 
 export interface ArucoPipelineSettings extends PipelineSettings {
@@ -278,13 +294,12 @@ export type ConfigurableArucoPipelineSettings = Partial<Omit<ArucoPipelineSettin
 export const DefaultArucoPipelineSettings: ArucoPipelineSettings = {
   ...DefaultPipelineSettings,
   cameraGain: 75,
-  outputShowMultipleTargets: true,
+  outputMaximumTargets: 127,
   targetModel: TargetModel.AprilTag6p5in_36h11,
   cameraExposureRaw: -1,
   cameraAutoExposure: true,
   ledMode: false,
   pipelineType: PipelineType.Aruco,
-
   tagFamily: AprilTagFamily.Family36h11,
   threshWinSizes: { first: 11, second: 91 },
   threshStepSize: 40,
@@ -316,7 +331,7 @@ export const DefaultObjectDetectionPipelineSettings: ObjectDetectionPipelineSett
   cameraGain: 20,
   targetModel: TargetModel.InfiniteRechargeHighGoalOuter,
   ledMode: true,
-  outputShowMultipleTargets: false,
+  outputMaximumTargets: 20,
   cameraExposureRaw: 6,
   confidence: 0.9,
   nms: 0.45,
@@ -335,7 +350,7 @@ export const DefaultCalibration3dPipelineSettings: Calibration3dPipelineSettings
   cameraGain: 20,
   targetModel: TargetModel.InfiniteRechargeHighGoalOuter,
   ledMode: true,
-  outputShowMultipleTargets: false,
+  outputMaximumTargets: 1,
   cameraExposureRaw: 6,
   drawAllSnapshots: false
 };
diff --git a/photon-client/src/views/CameraMatchingView.vue b/photon-client/src/views/CameraMatchingView.vue
index 04eca8bc95..e93ac21654 100644
--- a/photon-client/src/views/CameraMatchingView.vue
+++ b/photon-client/src/views/CameraMatchingView.vue
@@ -24,24 +24,28 @@ const activatingModule = ref(false);
 const activateModule = (moduleUniqueName: string) => {
   if (activatingModule.value) return;
   activatingModule.value = true;
-
   axiosPost("/utils/activateMatchedCamera", "activate a matched camera", {
     cameraUniqueName: moduleUniqueName
-  }).finally(() => (activatingModule.value = false));
+  })
+    .then(() => {
+      // Reload page to ensure UI shows correct camera controls
+      window.location.reload();
+    })
+    .finally(() => (activatingModule.value = false));
 };
 
 const assigningCamera = ref(false);
 const assignCamera = (cameraInfo: PVCameraInfo) => {
   if (assigningCamera.value) return;
   assigningCamera.value = true;
-
-  const payload = {
+  axiosPost("/utils/assignUnmatchedCamera", "assign an unmatched camera", {
     cameraInfo: cameraInfo
-  };
-
-  axiosPost("/utils/assignUnmatchedCamera", "assign an unmatched camera", payload).finally(
-    () => (assigningCamera.value = false)
-  );
+  })
+    .then(() => {
+      // Reload page to ensure UI shows correct camera controls
+      window.location.reload();
+    })
+    .finally(() => (assigningCamera.value = false));
 };
 
 const deactivatingModule = ref(false);
diff --git a/photon-core/src/main/java/org/photonvision/common/configuration/NeuralNetworkModelManager.java b/photon-core/src/main/java/org/photonvision/common/configuration/NeuralNetworkModelManager.java
index 9180c6363a..710070c2a6 100644
--- a/photon-core/src/main/java/org/photonvision/common/configuration/NeuralNetworkModelManager.java
+++ b/photon-core/src/main/java/org/photonvision/common/configuration/NeuralNetworkModelManager.java
@@ -311,6 +311,56 @@ public Optional<Model> getDefaultModel() {
         return models.get(supportedBackends.get(0)).stream().findFirst();
     }
 
+    /**
+     * Gets the default AprilTag detection model. Searches for a model with "apriltag" in its
+     * nickname (case-insensitive).
+     *
+     * @return Optional containing the AprilTag model if found
+     */
+    public Optional<Model> getDefaultAprilTagModel() {
+        if (models == null || supportedBackends.isEmpty()) {
+            return Optional.empty();
+        }
+
+        for (Family backend : supportedBackends) {
+            if (models.containsKey(backend)) {
+                Optional<Model> model =
+                        models.get(backend).stream()
+                                .filter(m -> m.getNickname().toLowerCase().contains("apriltag"))
+                                .findFirst();
+                if (model.isPresent()) {
+                    return model;
+                }
+            }
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Gets a model by its exact nickname.
+     *
+     * @param name The nickname of the model to retrieve
+     * @return Optional containing the model if found
+     */
+    public Optional<Model> getModelByName(String name) {
+        if (models == null || supportedBackends.isEmpty() || name == null) {
+            return Optional.empty();
+        }
+
+        for (Family backend : supportedBackends) {
+            if (models.containsKey(backend)) {
+                Optional<Model> model =
+                        models.get(backend).stream()
+                                .filter(m -> m.getNickname().equals(name))
+                                .findFirst();
+                if (model.isPresent()) {
+                    return model;
+                }
+            }
+        }
+        return Optional.empty();
+    }
+
     // Do checking later on, when we create the model object
     private void loadModel(Path path) {
         if (models == null) {
diff --git a/photon-core/src/main/java/org/photonvision/common/util/TestUtils.java b/photon-core/src/main/java/org/photonvision/common/util/TestUtils.java
index a4fea0fa7c..5c30aea889 100644
--- a/photon-core/src/main/java/org/photonvision/common/util/TestUtils.java
+++ b/photon-core/src/main/java/org/photonvision/common/util/TestUtils.java
@@ -228,7 +228,8 @@ public enum ApriltagTestImages {
         kRobots,
         kTag1_640_480,
         kTag1_16h5_1280,
-        kTag_corner_1280;
+        kTag_corner_1280,
+        k36h11_stress_test;
 
         public final Path path;
 
@@ -237,6 +238,7 @@ Path getPath() {
             var filename = this.toString().substring(1).toLowerCase();
             var extension = ".jpg";
             if (filename.equals("tag1_16h5_1280")) extension = ".png";
+            if (filename.equals("36h11_stress_test")) extension = ".png";
             return Path.of("apriltag", filename + extension);
         }
 
diff --git a/photon-core/src/main/java/org/photonvision/vision/frame/Frame.java b/photon-core/src/main/java/org/photonvision/vision/frame/Frame.java
index 8caeb00822..0472913324 100644
--- a/photon-core/src/main/java/org/photonvision/vision/frame/Frame.java
+++ b/photon-core/src/main/java/org/photonvision/vision/frame/Frame.java
@@ -17,6 +17,8 @@
 
 package org.photonvision.vision.frame;
 
+import java.util.List;
+import org.opencv.core.Rect2d;
 import org.photonvision.common.util.math.MathUtils;
 import org.photonvision.vision.opencv.CVMat;
 import org.photonvision.vision.opencv.Releasable;
@@ -32,6 +34,9 @@ public class Frame implements Releasable {
 
     public final FrameStaticProperties frameStaticProperties;
 
+    /** Optional ML detection ROI bounding boxes for visualization. Set by ML-assisted pipelines. */
+    public List<Rect2d> mlDetectionRois = List.of();
+
     public Frame(
             long sequenceID,
             CVMat color,
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/AprilTagROIDecodePipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/AprilTagROIDecodePipe.java
new file mode 100644
index 0000000000..f1d57e1ece
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/AprilTagROIDecodePipe.java
@@ -0,0 +1,513 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipe.impl;
+
+import edu.wpi.first.apriltag.AprilTagDetection;
+import edu.wpi.first.apriltag.AprilTagDetector;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.opencv.core.Mat;
+import org.opencv.core.Rect;
+import org.opencv.core.Rect2d;
+import org.opencv.core.Size;
+import org.opencv.imgproc.Imgproc;
+import org.photonvision.common.logging.LogGroup;
+import org.photonvision.common.logging.Logger;
+import org.photonvision.vision.apriltag.AprilTagFamily;
+import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.opencv.Releasable;
+import org.photonvision.vision.pipe.CVPipe;
+
+/**
+ * Pipe that decodes AprilTags within ROIs detected by ML. For each ROI from ML detection, it
+ * extracts a sub-image, runs the traditional WPILib AprilTag detector, and maps the detected corner
+ * coordinates and homography back to full-frame coordinates.
+ *
+ * <p>Both corner coordinates AND the homography matrix must be transformed from ROI
+ * coordinates to full-frame coordinates.
+ */
+public class AprilTagROIDecodePipe
+        extends CVPipe<
+                AprilTagROIDecodePipe.ROIDecodeInput,
+                List<AprilTagDetection>,
+                AprilTagROIDecodePipe.ROIDecodeParams>
+        implements Releasable {
+
+    private static final Logger logger = new Logger(AprilTagROIDecodePipe.class, LogGroup.VisionModule);
+    private static final boolean DEBUG_COORDINATE_MAPPING = false;
+
+    /**
+     * Context object containing ATR scaling information for a single ROI.
+     */
+    private static class ATRContext {
+        final double scaleFactor;
+        final boolean wasScaled;
+
+        ATRContext(double scaleFactor) {
+            this.scaleFactor = scaleFactor;
+            this.wasScaled = scaleFactor < 1.0;
+        }
+
+        static ATRContext noScaling() {
+            return new ATRContext(1.0);
+        }
+    }
+
+    /** Input container for ROI decode pipe */
+    public static class ROIDecodeInput {
+        public final CVMat grayFrame;
+        public final List<Rect2d> rois;
+
+        public ROIDecodeInput(CVMat grayFrame, List<Rect2d> rois) {
+            this.grayFrame = grayFrame;
+            this.rois = rois;
+        }
+    }
+
+    /** Parameters for ROI decode pipe */
+    public static class ROIDecodeParams {
+        public AprilTagFamily tagFamily = AprilTagFamily.kTag36h11;
+        public AprilTagDetector.Config detectorConfig;
+        public AprilTagDetector.QuadThresholdParameters quadParams;
+        public int maxHammingDistance = 0;
+        public double minDecisionMargin = 35;
+
+        // Adaptive Tag Resizing (ATR) parameters
+        /** Enable ATR (adaptive tag resizing) */
+        public boolean atrEnabled = true;
+        /** Target dimension for ATR - tags wider than this will be downscaled */
+        public int atrTargetDimension = 160;
+        /** Minimum scale factor for ATR (prevents extreme downscaling) */
+        public double atrMinScaleFactor = 0.25;
+
+        public ROIDecodeParams() {
+            detectorConfig = new AprilTagDetector.Config();
+            detectorConfig.numThreads = 1;
+            detectorConfig.quadDecimate = 1; 
+            quadParams = new AprilTagDetector.QuadThresholdParameters();
+            // Match the defaults from AprilTagPipeline
+            quadParams.minClusterPixels = 5;
+            quadParams.maxNumMaxima = 10;
+            quadParams.criticalAngle = 45 * Math.PI / 180.0;
+            quadParams.maxLineFitMSE = 10.0f;
+            quadParams.minWhiteBlackDiff = 5;
+            quadParams.deglitch = false;
+        }
+    }
+
+    private AprilTagDetector detector;
+    private AprilTagFamily currentFamily;
+
+    public AprilTagROIDecodePipe() {
+        detector = new AprilTagDetector();
+    }
+
+    @Override
+    protected List<AprilTagDetection> process(ROIDecodeInput input) {
+        List<AprilTagDetection> allDetections = new ArrayList<>();
+
+        if (input.grayFrame == null || input.grayFrame.getMat().empty()) {
+            return allDetections;
+        }
+
+        Mat fullFrame = input.grayFrame.getMat();
+        int frameWidth = fullFrame.cols();
+        int frameHeight = fullFrame.rows();
+
+        for (Rect2d roi : input.rois) {
+            // ROIs are already expanded by the caller (AprilTagPipeline.processMLHybrid)
+            Rect roiRect = toIntRect(roi);
+
+            if (roiRect.width <= 0 || roiRect.height <= 0) {
+                continue;
+            }
+
+            // Clamp to frame bounds (defensive)
+            roiRect = clampToFrame(roiRect, frameWidth, frameHeight);
+            if (roiRect.width <= 0 || roiRect.height <= 0) {
+                continue;
+            }
+
+            if (DEBUG_COORDINATE_MAPPING) {
+                logger.debug(
+                        "Original ROI: x="
+                                + roi.x
+                                + ", y="
+                                + roi.y
+                                + ", w="
+                                + roi.width
+                                + ", h="
+                                + roi.height);
+                logger.debug(
+                        "Expanded ROI (used for mapping): x="
+                                + roiRect.x
+                                + ", y="
+                                + roiRect.y
+                                + ", w="
+                                + roiRect.width
+                                + ", h="
+                                + roiRect.height);
+            }
+
+            // Extract full-resolution submat
+            Mat roiMat = fullFrame.submat(roiRect);
+
+            // === STAGE 1: COARSE - Calculate scaling and resize ===
+            ATRContext atrContext;
+            Mat processingMat;
+
+            if (params.atrEnabled && roiRect.width > params.atrTargetDimension) {
+                // Calculate scale factor: S = min(1.0, T_dim / w)
+                double S = (double) params.atrTargetDimension / roiRect.width;
+                S = Math.max(S, params.atrMinScaleFactor); // Clamp to prevent extreme scaling
+
+                int scaledWidth = (int) Math.round(roiRect.width * S);
+                int scaledHeight = (int) Math.round(roiRect.height * S);
+
+                atrContext = new ATRContext(S);
+
+                // Downscale ROI to target dimension
+                processingMat = new Mat();
+                Imgproc.resize(
+                        roiMat,
+                        processingMat,
+                        new Size(scaledWidth, scaledHeight),
+                        0,
+                        0,
+                        Imgproc.INTER_AREA); // INTER_AREA best for downscaling
+
+                if (DEBUG_COORDINATE_MAPPING) {
+                    logger.debug(
+                            "ATR: ROI "
+                                    + roiRect.width
+                                    + "x"
+                                    + roiRect.height
+                                    + " -> "
+                                    + scaledWidth
+                                    + "x"
+                                    + scaledHeight
+                                    + " (S="
+                                    + S
+                                    + ")");
+                }
+            } else {
+                // No scaling needed (tag already small or ATR disabled)
+                atrContext = ATRContext.noScaling();
+                processingMat = roiMat;
+            }
+
+            // Run AprilTag detection on (possibly scaled) image
+            AprilTagDetection[] roiDetections = detector.detect(processingMat);
+
+            for (AprilTagDetection det : roiDetections) {
+                if (det.getHamming() > params.maxHammingDistance) continue;
+                if (det.getDecisionMargin() < params.minDecisionMargin) continue;
+
+                // === STAGE 2: PROJECTION - Map coordinates back to full-frame ===
+                AprilTagDetection mappedDetection;
+                if (atrContext.wasScaled) {
+                    mappedDetection = mapToFullFrameWithATR(det, roiRect, atrContext);
+                } else {
+                    mappedDetection = mapToFullFrame(det, roiRect);
+                }
+
+                if (DEBUG_COORDINATE_MAPPING) {
+                    logger.debug(
+                            "Tag "
+                                    + det.getId()
+                                    + " corner 0: ROI=("
+                                    + det.getCornerX(0)
+                                    + ", "
+                                    + det.getCornerY(0)
+                                    + "), Full=("
+                                    + mappedDetection.getCornerX(0)
+                                    + ", "
+                                    + mappedDetection.getCornerY(0)
+                                    + ")");
+                }
+
+                allDetections.add(mappedDetection);
+            }
+
+            // Cleanup
+            roiMat.release();
+            if (atrContext.wasScaled) {
+                processingMat.release();
+            }
+        }
+
+        // === STAGE 4: POSE ESTIMATION happens in AprilTagPoseEstimatorPipe ===
+        return deduplicateByTagId(allDetections);
+    }
+
+    /**
+     * Maps detection coordinates from ROI space to full-frame space.
+     *
+     * Both corners AND homography must be transformed. The pose estimator uses the
+     * homography matrix internally for pose estimation, not just the corners.
+     *
+     * @param det The detection in ROI coordinates
+     * @param roiOffset The ROI rectangle defining the offset from full frame origin
+     * @return A new AprilTagDetection with coordinates mapped to full frame
+     */
+    private AprilTagDetection mapToFullFrame(AprilTagDetection det, Rect roiOffset) {
+        // Map all 4 corners from ROI coordinates to full-frame coordinates
+        double[] mappedCorners = new double[8];
+        for (int i = 0; i < 4; i++) {
+            mappedCorners[i * 2] = det.getCornerX(i) + roiOffset.x;
+            mappedCorners[i * 2 + 1] = det.getCornerY(i) + roiOffset.y;
+        }
+
+        // Map center coordinate
+        double centerX = det.getCenterX() + roiOffset.x;
+        double centerY = det.getCenterY() + roiOffset.y;
+
+        // Transform homography from ROI coordinates to full-frame coordinates
+        double[] transformedHomography =
+                transformHomography(det.getHomography(), roiOffset.x, roiOffset.y);
+
+        return new AprilTagDetection(
+                det.getFamily(),
+                det.getId(),
+                det.getHamming(),
+                det.getDecisionMargin(),
+                transformedHomography,
+                centerX,
+                centerY,
+                mappedCorners);
+    }
+
+    /**
+     * Maps detection coordinates from scaled ROI space to full-frame space.
+     * Handles both translation AND scaling transformations.
+     *
+     * @param det The detection in scaled ROI coordinates
+     * @param roiOffset The ROI rectangle defining the offset from full frame origin
+     * @param atrContext The ATR scaling context
+     * @return A new AprilTagDetection with coordinates mapped to full frame
+     */
+    private AprilTagDetection mapToFullFrameWithATR(
+            AprilTagDetection det, Rect roiOffset, ATRContext atrContext) {
+        double invS = 1.0 / atrContext.scaleFactor;
+
+        // Map all 4 corners from scaled ROI coordinates to full-frame coordinates
+        // x_full = (x_scaled / S) + roi_x
+        double[] mappedCorners = new double[8];
+        for (int i = 0; i < 4; i++) {
+            mappedCorners[i * 2] = det.getCornerX(i) * invS + roiOffset.x;
+            mappedCorners[i * 2 + 1] = det.getCornerY(i) * invS + roiOffset.y;
+        }
+
+        // Map center coordinate
+        double centerX = det.getCenterX() * invS + roiOffset.x;
+        double centerY = det.getCenterY() * invS + roiOffset.y;
+
+        // Transform homography with scaling
+        double[] transformedHomography =
+                transformHomographyWithScale(
+                        det.getHomography(), roiOffset.x, roiOffset.y, atrContext.scaleFactor);
+
+        return new AprilTagDetection(
+                det.getFamily(),
+                det.getId(),
+                det.getHamming(),
+                det.getDecisionMargin(),
+                transformedHomography,
+                centerX,
+                centerY,
+                mappedCorners);
+    }
+
+    /**
+     * Transforms a homography matrix from ROI coordinates to full-frame coordinates.
+     *
+     * <p>The homography H satisfies: [x_roi, y_roi, 1]^T ~ H * [X_tag, Y_tag, 1]^T
+     *
+     * <p>To convert to full-frame coordinates where x_full = x_roi + offsetX and
+     * y_full = y_roi + offsetY, we compute H_full = T * H_roi where T is the translation matrix:
+     *
+     * <pre>
+     * | 1  0  offsetX |
+     * | 0  1  offsetY |
+     * | 0  0  1       |
+     * </pre>
+     *
+     * <p>The UMich AprilTag library stores homography as row-major 3x3:
+     * [h00, h01, h02, h10, h11, h12, h20, h21, h22]
+     * source: https://april.eecs.umich.edu/media/pdfs/olson2011tags.pdf
+     *
+     * @param h The original homography (9 elements, row-major 3x3)
+     * @param offsetX The x offset from ROI origin to full-frame origin
+     * @param offsetY The y offset from ROI origin to full-frame origin
+     * @return The transformed homography in full-frame coordinates
+     */
+    private double[] transformHomography(double[] h, int offsetX, int offsetY) {
+        // T * H where T = [[1,0,tx],[0,1,ty],[0,0,1]]
+        // (T*H)[0][j] = 1*H[0][j] + 0*H[1][j] + tx*H[2][j] = H[0][j] + tx*H[2][j]
+        // (T*H)[1][j] = 0*H[0][j] + 1*H[1][j] + ty*H[2][j] = H[1][j] + ty*H[2][j]
+        // (T*H)[2][j] = 0*H[0][j] + 0*H[1][j] + 1*H[2][j] = H[2][j]
+
+        double[] result = new double[9];
+        // Row 0: H[0][j] + offsetX * H[2][j]
+        result[0] = h[0] + offsetX * h[6];
+        result[1] = h[1] + offsetX * h[7];
+        result[2] = h[2] + offsetX * h[8];
+        // Row 1: H[1][j] + offsetY * H[2][j]
+        result[3] = h[3] + offsetY * h[6];
+        result[4] = h[4] + offsetY * h[7];
+        result[5] = h[5] + offsetY * h[8];
+        // Row 2: unchanged
+        result[6] = h[6];
+        result[7] = h[7];
+        result[8] = h[8];
+        return result;
+    }
+
+    /**
+     * Transforms a homography matrix from scaled ROI coordinates to full-frame coordinates.
+     *
+     * <p>The transformation combines inverse scaling and translation:
+     * H_full = T * S_inv * H_scaled
+     *
+     * <p>Where:
+     * - S_inv = [[1/S, 0, 0], [0, 1/S, 0], [0, 0, 1]] (inverse scale)
+     * - T = [[1, 0, offsetX], [0, 1, offsetY], [0, 0, 1]] (translation)
+     *
+     * <p>Combined formula:
+     * Row 0: H[0..2] / S + offsetX * H[6..8]
+     * Row 1: H[3..5] / S + offsetY * H[6..8]
+     * Row 2: unchanged (H[6..8])
+     *
+     * @param h The original homography (9 elements, row-major 3x3)
+     * @param offsetX The x offset from ROI origin to full-frame origin
+     * @param offsetY The y offset from ROI origin to full-frame origin
+     * @param S The scale factor used for ROI resizing (< 1 means downscaled)
+     * @return The transformed homography in full-frame coordinates
+     */
+    private double[] transformHomographyWithScale(double[] h, int offsetX, int offsetY, double S) {
+        double invS = 1.0 / S;
+        double[] result = new double[9];
+
+        // Row 0: H[i]/S + offsetX * H[6+j]
+        result[0] = h[0] * invS + offsetX * h[6];
+        result[1] = h[1] * invS + offsetX * h[7];
+        result[2] = h[2] * invS + offsetX * h[8];
+
+        // Row 1: H[i]/S + offsetY * H[6+j]
+        result[3] = h[3] * invS + offsetY * h[6];
+        result[4] = h[4] * invS + offsetY * h[7];
+        result[5] = h[5] * invS + offsetY * h[8];
+
+        // Row 2: unchanged
+        result[6] = h[6];
+        result[7] = h[7];
+        result[8] = h[8];
+
+        return result;
+    }
+
+    /**
+     * Expands a bounding box by adding fixed pixel padding on each side, then clamping to image
+     * bounds. Additive padding naturally provides more relative expansion for small/far tags and
+     * less for large/close tags.
+     *
+     * @param bbox Original bounding box
+     * @param paddingPixels Number of pixels to add on each side of the bounding box
+     * @param imageWidth Image width for clamping
+     * @param imageHeight Image height for clamping
+     * @return Expanded and clamped bounding box
+     */
+    public static Rect2d expandBbox(Rect2d bbox, int paddingPixels, int imageWidth, int imageHeight) {
+        double newWidth = bbox.width + 2.0 * paddingPixels;
+        double newHeight = bbox.height + 2.0 * paddingPixels;
+        double newX = bbox.x - paddingPixels;
+        double newY = bbox.y - paddingPixels;
+
+        // Clamp to image bounds
+        newX = Math.max(0, newX);
+        newY = Math.max(0, newY);
+        newWidth = Math.min(newWidth, imageWidth - newX);
+        newHeight = Math.min(newHeight, imageHeight - newY);
+
+        return new Rect2d(newX, newY, newWidth, newHeight);
+    }
+
+    /**
+     * Converts a Rect2d to integer Rect using floor for position and ceil for size to ensure we
+     * don't clip the tag area.
+     */
+    private Rect toIntRect(Rect2d r) {
+        return new Rect(
+                (int) Math.floor(r.x),
+                (int) Math.floor(r.y),
+                (int) Math.ceil(r.width),
+                (int) Math.ceil(r.height));
+    }
+
+    /** Clamps a rectangle to frame bounds. */
+    private Rect clampToFrame(Rect r, int frameWidth, int frameHeight) {
+        int x = Math.max(0, r.x);
+        int y = Math.max(0, r.y);
+        int w = Math.min(r.width, frameWidth - x);
+        int h = Math.min(r.height, frameHeight - y);
+        return new Rect(x, y, w, h);
+    }
+
+    /**
+     * Deduplicates detections by tag ID, keeping the one with highest decision margin. This handles
+     * cases where overlapping ROIs detect the same tag.
+     */
+    private List<AprilTagDetection> deduplicateByTagId(List<AprilTagDetection> detections) {
+        Map<Integer, AprilTagDetection> bestByTagId = new HashMap<>();
+
+        for (AprilTagDetection det : detections) {
+            int tagId = det.getId();
+            AprilTagDetection existing = bestByTagId.get(tagId);
+
+            if (existing == null || det.getDecisionMargin() > existing.getDecisionMargin()) {
+                bestByTagId.put(tagId, det);
+            }
+        }
+
+        return new ArrayList<>(bestByTagId.values());
+    }
+
+    @Override
+    public void setParams(ROIDecodeParams newParams) {
+        if (newParams.tagFamily != currentFamily) {
+            detector.clearFamilies();
+            detector.addFamily(newParams.tagFamily.getNativeName());
+            currentFamily = newParams.tagFamily;
+        }
+
+        detector.setConfig(newParams.detectorConfig);
+        detector.setQuadThresholdParameters(newParams.quadParams);
+
+        super.setParams(newParams);
+    }
+
+    @Override
+    public void release() {
+        if (detector != null) {
+            detector.close();
+            detector = null;
+        }
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/AprilTagROIDetectionPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/AprilTagROIDetectionPipe.java
new file mode 100644
index 0000000000..7fc4a7f360
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/AprilTagROIDetectionPipe.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipe.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.opencv.core.Rect2d;
+import org.photonvision.vision.objects.Model;
+import org.photonvision.vision.objects.NullModel;
+import org.photonvision.vision.objects.ObjectDetector;
+import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.opencv.Releasable;
+import org.photonvision.vision.pipe.CVPipe;
+
+/**
+ * Pipe that runs YOLO model on NPU to detect AprilTag bounding boxes in the full frame. This is
+ * Stage 1 of the ML-assisted AprilTag detection pipeline.
+ */
+public class AprilTagROIDetectionPipe
+        extends CVPipe<CVMat, List<Rect2d>, AprilTagROIDetectionPipe.AprilTagROIDetectionParams>
+        implements Releasable {
+
+    private ObjectDetector detector;
+    private Model currentModel;
+
+    public static class AprilTagROIDetectionParams {
+        public final Model model;
+        public final double confidenceThreshold;
+        public final double nmsThreshold;
+
+        public AprilTagROIDetectionParams(Model model, double confidence, double nms) {
+            this.model = model;
+            this.confidenceThreshold = confidence;
+            this.nmsThreshold = nms;
+        }
+    }
+
+    public AprilTagROIDetectionPipe() {
+        detector = NullModel.getInstance();
+    }
+
+    @Override
+    protected List<Rect2d> process(CVMat in) {
+        List<Rect2d> rois = new ArrayList<>();
+
+        if (detector == null || detector instanceof NullModel) {
+            return rois; // Empty list - fallback to traditional detection
+        }
+
+        if (in.getMat().empty()) {
+            return rois;
+        }
+
+        List<NeuralNetworkPipeResult> detections =
+                detector.detect(in.getMat(), params.nmsThreshold, params.confidenceThreshold);
+
+        for (NeuralNetworkPipeResult detection : detections) {
+            rois.add(detection.bbox());
+        }
+
+        return rois;
+    }
+
+    @Override
+    public void setParams(AprilTagROIDetectionParams newParams) {
+        if (newParams.model != null && newParams.model != currentModel) {
+            if (detector != null && !(detector instanceof NullModel)) {
+                detector.release();
+            }
+            detector = newParams.model.load();
+            currentModel = newParams.model;
+        }
+        super.setParams(newParams);
+    }
+
+    /**
+     * Returns whether ML detection is available (a valid model is loaded).
+     *
+     * @return true if ML detection is available
+     */
+    public boolean isAvailable() {
+        return detector != null && !(detector instanceof NullModel);
+    }
+
+    @Override
+    public void release() {
+        if (detector != null && !(detector instanceof NullModel)) {
+            detector.release();
+            detector = null;
+        }
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dAprilTagsPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dAprilTagsPipe.java
index ec88e06fe3..671e4fb6c5 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dAprilTagsPipe.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dAprilTagsPipe.java
@@ -23,8 +23,8 @@
 public class Draw2dAprilTagsPipe extends Draw2dTargetsPipe {
     public static class Draw2dAprilTagsParams extends Draw2dTargetsPipe.Draw2dTargetsParams {
         public Draw2dAprilTagsParams(
-                boolean shouldDraw, boolean showMultipleTargets, FrameDivisor divisor) {
-            super(shouldDraw, showMultipleTargets, divisor);
+                boolean shouldDraw, int outputMaximumTargets, FrameDivisor divisor) {
+            super(shouldDraw, outputMaximumTargets, divisor);
             // We want to show the polygon, not the rotated box
             this.showRotatedBox = false;
             this.showMaximumBox = false;
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dArucoPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dArucoPipe.java
index 85f4ef1801..bf633d2be6 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dArucoPipe.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dArucoPipe.java
@@ -22,9 +22,8 @@
 
 public class Draw2dArucoPipe extends Draw2dTargetsPipe {
     public static class Draw2dArucoParams extends Draw2dTargetsPipe.Draw2dTargetsParams {
-        public Draw2dArucoParams(
-                boolean shouldDraw, boolean showMultipleTargets, FrameDivisor divisor) {
-            super(shouldDraw, showMultipleTargets, divisor);
+        public Draw2dArucoParams(boolean shouldDraw, int outputMaximumTargets, FrameDivisor divisor) {
+            super(shouldDraw, outputMaximumTargets, divisor);
             // We want to show the polygon, not the rotated box
             this.showRotatedBox = false;
             this.showMaximumBox = false;
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dTargetsPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dTargetsPipe.java
index 93caa4169d..fe14c7ca41 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dTargetsPipe.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dTargetsPipe.java
@@ -58,14 +58,10 @@ protected Void process(Pair<Mat, List<TrackedTarget>> in) {
             var circleColor = ColorHelper.colorToScalar(params.circleColor);
             var shapeColour = ColorHelper.colorToScalar(params.shapeOutlineColour);
 
-            for (int i = 0; i < (params.showMultipleTargets ? in.getSecond().size() : 1); i++) {
+            for (int i = 0; i < Math.min(params.outputMaximumTargets, in.getSecond().size()); i++) {
                 Point[] vertices = new Point[4];
                 MatOfPoint contour = new MatOfPoint();
 
-                if (i != 0 && !params.showMultipleTargets) {
-                    break;
-                }
-
                 TrackedTarget target = in.getSecond().get(i);
                 RotatedRect r = target.getMinAreaRect();
 
@@ -233,8 +229,7 @@ public static class Draw2dTargetsParams {
         public Color shapeOutlineColour = Color.MAGENTA;
         public Color textColor = Color.GREEN;
         public Color circleColor = Color.RED;
-
-        public final boolean showMultipleTargets;
+        public int outputMaximumTargets;
         public final boolean shouldDraw;
 
         public final FrameDivisor divisor;
@@ -247,10 +242,9 @@ public boolean shouldShowCircle(CVShape shape) {
             return shape != null && shape.shape.equals(ContourShape.Circle);
         }
 
-        public Draw2dTargetsParams(
-                boolean shouldDraw, boolean showMultipleTargets, FrameDivisor divisor) {
+        public Draw2dTargetsParams(boolean shouldDraw, int outputMaximumTargets, FrameDivisor divisor) {
             this.shouldDraw = shouldDraw;
-            this.showMultipleTargets = showMultipleTargets;
+            this.outputMaximumTargets = outputMaximumTargets;
             this.divisor = divisor;
         }
     }
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/DrawMLROIPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/DrawMLROIPipe.java
new file mode 100644
index 0000000000..3268da9183
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/DrawMLROIPipe.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipe.impl;
+
+import edu.wpi.first.math.Pair;
+import java.util.List;
+import org.opencv.core.*;
+import org.opencv.imgproc.Imgproc;
+import org.photonvision.vision.frame.FrameDivisor;
+import org.photonvision.vision.pipe.MutatingPipe;
+
+/**
+ * Draws ML detection ROI bounding boxes on the output image. Used to visualize where the ML model
+ * detected potential targets before traditional decoding.
+ */
+public class DrawMLROIPipe
+        extends MutatingPipe<Pair<Mat, List<Rect2d>>, DrawMLROIPipe.DrawMLROIParams> {
+
+    private static final Scalar ROI_COLOR = new Scalar(255, 255, 0); // Cyan in BGR
+
+    @Override
+    protected Void process(Pair<Mat, List<Rect2d>> in) {
+        if (!params.shouldDraw || !params.showDetectionBoxes) return null;
+
+        var mat = in.getFirst();
+        var rois = in.getSecond();
+        if (rois == null || rois.isEmpty()) return null;
+
+        var imageSize = Math.sqrt((double) mat.rows() * mat.cols());
+        var thickness = (int) Math.ceil(imageSize * 0.007);
+
+        for (Rect2d roi : rois) {
+            double x = roi.x / params.divisor.value;
+            double y = roi.y / params.divisor.value;
+            double w = roi.width / params.divisor.value;
+            double h = roi.height / params.divisor.value;
+
+            Imgproc.rectangle(
+                    mat, new Point(x, y), new Point(x + w, y + h), ROI_COLOR, thickness);
+        }
+
+        return null;
+    }
+
+    public static class DrawMLROIParams {
+        public final boolean shouldDraw;
+        public final boolean showDetectionBoxes;
+        public final FrameDivisor divisor;
+
+        public DrawMLROIParams(
+                boolean shouldDraw, boolean showDetectionBoxes, FrameDivisor divisor) {
+            this.shouldDraw = shouldDraw;
+            this.showDetectionBoxes = showDetectionBoxes;
+            this.divisor = divisor;
+        }
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/AdvancedPipelineSettings.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/AdvancedPipelineSettings.java
index 91a71527a0..b42c650ba2 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/AdvancedPipelineSettings.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/AdvancedPipelineSettings.java
@@ -17,6 +17,7 @@
 
 package org.photonvision.vision.pipeline;
 
+import com.fasterxml.jackson.annotation.JsonAnySetter;
 import java.util.Objects;
 import org.opencv.core.Point;
 import org.photonvision.common.util.numbers.DoubleCouple;
@@ -41,7 +42,7 @@ public AdvancedPipelineSettings() {
     public boolean hueInverted = false;
 
     public boolean outputShouldDraw = true;
-    public boolean outputShowMultipleTargets = false;
+    public int outputMaximumTargets = 20;
 
     public DoubleCouple contourArea = new DoubleCouple(0.0, 100.0);
     public DoubleCouple contourRatio = new DoubleCouple(0.0, 20.0);
@@ -90,6 +91,22 @@ public AdvancedPipelineSettings() {
     public int cornerDetectionSideCount = 4;
     public double cornerDetectionAccuracyPercentage = 10;
 
+    /**
+     * Handles backward compatibility for the deprecated outputShowMultipleTargets property. When
+     * outputShowMultipleTargets is encountered during deserialization, it sets outputMaximumTargets
+     * appropriately. If outputShowMultipleTargets is false, outputMaximumTargets is set to 1.
+     */
+    @JsonAnySetter
+    public void handleUnknownProperty(String name, Object value) {
+        // Handle the old showMultipleTargets property for backward compatibility
+        if ("outputShowMultipleTargets".equals(name) && value instanceof Boolean showMultipleTargets) {
+            if (!showMultipleTargets) {
+                // If showMultipleTargets is false, limit to 1 target
+                outputMaximumTargets = 1;
+            }
+        }
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
@@ -97,7 +114,7 @@ public boolean equals(Object o) {
         if (!super.equals(o)) return false;
         AdvancedPipelineSettings that = (AdvancedPipelineSettings) o;
         return outputShouldDraw == that.outputShouldDraw
-                && outputShowMultipleTargets == that.outputShowMultipleTargets
+                && outputMaximumTargets == that.outputMaximumTargets
                 && contourSpecklePercentage == that.contourSpecklePercentage
                 && Double.compare(that.offsetDualPointAArea, offsetDualPointAArea) == 0
                 && Double.compare(that.offsetDualPointBArea, offsetDualPointBArea) == 0
@@ -136,7 +153,7 @@ public int hashCode() {
                 hsvValue,
                 hueInverted,
                 outputShouldDraw,
-                outputShowMultipleTargets,
+                outputMaximumTargets,
                 contourArea,
                 contourRatio,
                 contourFullness,
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/AprilTagPipeline.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/AprilTagPipeline.java
index 87329ebf24..343864eaa4 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/AprilTagPipeline.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/AprilTagPipeline.java
@@ -29,18 +29,27 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
+import org.opencv.core.Rect2d;
 import org.photonvision.common.configuration.ConfigManager;
+import org.photonvision.common.configuration.NeuralNetworkModelManager;
+import org.photonvision.common.hardware.Platform;
+import org.photonvision.common.dataflow.structures.Packet;
+import org.photonvision.common.logging.LogGroup;
+import org.photonvision.common.logging.Logger;
 import org.photonvision.common.util.math.MathUtils;
 import org.photonvision.estimation.TargetModel;
 import org.photonvision.targeting.MultiTargetPNPResult;
 import org.photonvision.vision.apriltag.AprilTagFamily;
 import org.photonvision.vision.frame.Frame;
 import org.photonvision.vision.frame.FrameThresholdType;
+import org.photonvision.vision.objects.Model;
 import org.photonvision.vision.pipe.CVPipe.CVPipeResult;
 import org.photonvision.vision.pipe.impl.AprilTagDetectionPipe;
 import org.photonvision.vision.pipe.impl.AprilTagDetectionPipe.AprilTagDetectionPipeParams;
 import org.photonvision.vision.pipe.impl.AprilTagPoseEstimatorPipe;
 import org.photonvision.vision.pipe.impl.AprilTagPoseEstimatorPipe.AprilTagPoseEstimatorPipeParams;
+import org.photonvision.vision.pipe.impl.AprilTagROIDecodePipe;
+import org.photonvision.vision.pipe.impl.AprilTagROIDetectionPipe;
 import org.photonvision.vision.pipe.impl.CalculateFPSPipe;
 import org.photonvision.vision.pipe.impl.MultiTargetPNPPipe;
 import org.photonvision.vision.pipe.impl.MultiTargetPNPPipe.MultiTargetPNPPipeParams;
@@ -49,12 +58,20 @@
 import org.photonvision.vision.target.TrackedTarget.TargetCalculationParameters;
 
 public class AprilTagPipeline extends CVPipeline<CVPipelineResult, AprilTagPipelineSettings> {
+    private static final Logger logger = new Logger(AprilTagPipeline.class, LogGroup.VisionModule);
+
     private final AprilTagDetectionPipe aprilTagDetectionPipe = new AprilTagDetectionPipe();
     private final AprilTagPoseEstimatorPipe singleTagPoseEstimatorPipe =
             new AprilTagPoseEstimatorPipe();
     private final MultiTargetPNPPipe multiTagPNPPipe = new MultiTargetPNPPipe();
     private final CalculateFPSPipe calculateFPSPipe = new CalculateFPSPipe();
 
+    // ML-assisted detection pipes
+    private final AprilTagROIDetectionPipe mlDetectionPipe = new AprilTagROIDetectionPipe();
+    private final AprilTagROIDecodePipe mlDecodePipe = new AprilTagROIDecodePipe();
+    private boolean mlAvailable = false;
+    private boolean mlWasAvailable = false; 
+
     private static final FrameThresholdType PROCESSING_TYPE = FrameThresholdType.GREYSCALE;
 
     public AprilTagPipeline() {
@@ -123,6 +140,55 @@ protected void setPipeParamsImpl() {
                         new MultiTargetPNPPipeParams(frameStaticProperties.cameraCalibration, atfl, tagModel));
             }
         }
+
+        // ML-assisted detection configuration
+        if (settings.useMLDetection) {
+            mlAvailable = checkMLAvailability();
+
+            if (mlAvailable) {
+                Model apriltagModel = getAprilTagModel(settings.mlModelName);
+
+                if (apriltagModel != null) {
+                    mlDetectionPipe.setParams(
+                            new AprilTagROIDetectionPipe.AprilTagROIDetectionParams(
+                                    apriltagModel,
+                                    settings.mlConfidenceThreshold,
+                                    settings.mlNmsThreshold));
+
+                    AprilTagROIDecodePipe.ROIDecodeParams decodeParams =
+                            new AprilTagROIDecodePipe.ROIDecodeParams();
+                    decodeParams.tagFamily = settings.tagFamily;
+                    decodeParams.maxHammingDistance = settings.hammingDist;
+                    decodeParams.minDecisionMargin = settings.decisionMargin;
+                    decodeParams.detectorConfig.numThreads = 1;
+                    decodeParams.detectorConfig.refineEdges = settings.refineEdges;
+                    decodeParams.detectorConfig.quadDecimate = 1; // No decimation for ROI - maximize accuracy
+
+                    // ATR (Adaptive Tag Resizing) settings
+                    decodeParams.atrEnabled = settings.atrEnabled;
+                    decodeParams.atrTargetDimension = settings.atrTargetDimension;
+                    decodeParams.atrMinScaleFactor = settings.atrMinScaleFactor;
+
+                    mlDecodePipe.setParams(decodeParams);
+
+                    if (!mlWasAvailable) {
+                        logger.info("ML-assisted AprilTag detection enabled");
+                    }
+                } else {
+                    mlAvailable = false;
+                    if (mlWasAvailable) {
+                        logger.warn("ML-assisted detection enabled but no AprilTag model found");
+                    }
+                }
+            } else {
+                if (mlWasAvailable) {
+                    logger.debug("ML-assisted detection not available on this platform");
+                }
+            }
+        } else {
+            mlAvailable = false;
+        }
+        mlWasAvailable = mlAvailable;
     }
 
     @Override
@@ -134,11 +200,35 @@ protected CVPipelineResult process(Frame frame, AprilTagPipelineSettings setting
             return new CVPipelineResult(frame.sequenceID, 0, 0, List.of(), frame);
         }
 
-        CVPipeResult<List<AprilTagDetection>> tagDetectionPipeResult =
-                aprilTagDetectionPipe.run(frame.processedImage);
-        sumPipeNanosElapsed += tagDetectionPipeResult.nanosElapsed;
+        // Perform AprilTag detection (traditional or ML-assisted)
+        List<AprilTagDetection> detections;
+        long detectionNanos;
+
+        if (settings.useMLDetection && mlAvailable) {
+            // Use ML-assisted hybrid detection
+            var mlDetectionResult = processMLHybrid(frame);
+            detections = mlDetectionResult.detections;
+            detectionNanos = mlDetectionResult.nanosElapsed;
+
+            // Preserve ROIs for visualization in the output stream
+            frame.mlDetectionRois = mlDetectionResult.rois;
+
+            // Fallback to traditional detection if ML found nothing
+            if (detections.isEmpty() && settings.mlFallbackToTraditional) {
+                CVPipeResult<List<AprilTagDetection>> fallbackResult =
+                        aprilTagDetectionPipe.run(frame.processedImage);
+                detections = fallbackResult.output;
+                detectionNanos += fallbackResult.nanosElapsed;
+            }
+        } else {
+            // Use traditional detection
+            CVPipeResult<List<AprilTagDetection>> tagDetectionPipeResult =
+                    aprilTagDetectionPipe.run(frame.processedImage);
+            detections = tagDetectionPipeResult.output;
+            detectionNanos = tagDetectionPipeResult.nanosElapsed;
+        }
+        sumPipeNanosElapsed += detectionNanos;
 
-        List<AprilTagDetection> detections = tagDetectionPipeResult.output;
         List<AprilTagDetection> usedDetections = new ArrayList<>();
         List<TrackedTarget> targetList = new ArrayList<>();
 
@@ -232,6 +322,12 @@ protected CVPipelineResult process(Frame frame, AprilTagPipelineSettings setting
             }
         }
 
+        if (targetList.size() > Packet.MAX_ARRAY_LEN) {
+            logger.error(
+                    "We have " + targetList.size() + " targets! Arbitrarily dropping some on the floor");
+            targetList = targetList.subList(0, Packet.MAX_ARRAY_LEN);
+        }
+
         var fpsResult = calculateFPSPipe.run(null);
         var fps = fpsResult.output;
 
@@ -239,10 +335,87 @@ protected CVPipelineResult process(Frame frame, AprilTagPipelineSettings setting
                 frame.sequenceID, sumPipeNanosElapsed, fps, targetList, multiTagResult, frame);
     }
 
+    /** Result container for ML hybrid detection */
+    private static class MLDetectionResult {
+        final List<AprilTagDetection> detections;
+        final List<Rect2d> rois;
+        final long nanosElapsed;
+
+        MLDetectionResult(
+                List<AprilTagDetection> detections, List<Rect2d> rois, long nanosElapsed) {
+            this.detections = detections;
+            this.rois = rois;
+            this.nanosElapsed = nanosElapsed;
+        }
+    }
+
+    /**
+     * Performs ML-assisted hybrid AprilTag detection. Stage 1: ML model detects ROIs Stage 2:
+     * Traditional detector decodes tags within ROIs
+     */
+    private MLDetectionResult processMLHybrid(Frame frame) {
+        long totalNanos = 0;
+
+        // Stage 1: ML detection to find ROIs
+        CVPipeResult<List<Rect2d>> mlResult = mlDetectionPipe.run(frame.colorImage);
+        totalNanos += mlResult.nanosElapsed;
+        List<Rect2d> rawRois = mlResult.output;
+
+        if (rawRois.isEmpty()) {
+            return new MLDetectionResult(new ArrayList<>(), List.of(), totalNanos);
+        }
+
+        // Expand ROIs before passing to decode pipe and visualization
+        int frameWidth = frame.colorImage.getMat().cols();
+        int frameHeight = frame.colorImage.getMat().rows();
+        List<Rect2d> expandedRois = new ArrayList<>(rawRois.size());
+        for (Rect2d roi : rawRois) {
+            expandedRois.add(
+                    AprilTagROIDecodePipe.expandBbox(
+                            roi, settings.mlRoiPaddingPixels, frameWidth, frameHeight));
+        }
+
+        // Stage 2: Decode tags within expanded ROIs using traditional detector
+        AprilTagROIDecodePipe.ROIDecodeInput decodeInput =
+                new AprilTagROIDecodePipe.ROIDecodeInput(frame.processedImage, expandedRois);
+
+        CVPipeResult<List<AprilTagDetection>> decodeResult = mlDecodePipe.run(decodeInput);
+        totalNanos += decodeResult.nanosElapsed;
+
+        return new MLDetectionResult(decodeResult.output, expandedRois, totalNanos);
+    }
+
+    /**
+     * Checks if ML detection is available on the current platform. Currently supported: RK3588
+     * (Orange Pi 5, Rock 5C, CoolPi 4B) and QCS6490 (Rubik Pi 3).
+     */
+    private boolean checkMLAvailability() {
+        Platform platform = Platform.getCurrentPlatform();
+        return platform == Platform.LINUX_QCS6490 || platform == Platform.LINUX_RK3588_64;
+    }
+
+    /**
+     * Gets the AprilTag detection model, either by name or the default model.
+     *
+     * @param modelName Optional model name to look up, or null for default
+     * @return The model, or null if no suitable model is found
+     */
+    private Model getAprilTagModel(String modelName) {
+        NeuralNetworkModelManager manager = NeuralNetworkModelManager.getInstance();
+
+        if (modelName != null && !modelName.isEmpty()) {
+            return manager.getModelByName(modelName).orElse(null);
+        }
+
+        return manager.getDefaultAprilTagModel().orElse(null);
+    }
+
     @Override
     public void release() {
         aprilTagDetectionPipe.release();
         singleTagPoseEstimatorPipe.release();
+        mlDetectionPipe.release();
+        mlDecodePipe.release();
         super.release();
     }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/AprilTagPipelineSettings.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/AprilTagPipelineSettings.java
index cede417e23..162831ec9a 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/AprilTagPipelineSettings.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/AprilTagPipelineSettings.java
@@ -35,12 +35,28 @@ public class AprilTagPipelineSettings extends AdvancedPipelineSettings {
     public boolean doMultiTarget = false;
     public boolean doSingleTargetAlways = false;
 
+    // ML-assisted detection settings
+    public boolean useMLDetection = false;
+    public double mlConfidenceThreshold = 0.5;
+    public double mlNmsThreshold = 0.45;
+    public int mlRoiPaddingPixels = 40;
+    public boolean mlFallbackToTraditional = true;
+    public String mlModelName = null;
+    public boolean showDetectionBoxes = true;
+
+    // Adaptive Tag Resizing (ATR) settings
+    /** Enable adaptive tag resizing for ML-assisted detection */
+    public boolean atrEnabled = true;
+    /** Target dimension (pixels) for ATR resizing. Tags larger than this will be downscaled. */
+    public int atrTargetDimension = 200;
+    /** Minimum scale factor - prevents extreme downscaling. Default: 0.25 (4x max downscale) */
+    public double atrMinScaleFactor = 0.25;
+
     // 3d settings
 
     public AprilTagPipelineSettings() {
         super();
         pipelineType = PipelineType.AprilTag;
-        outputShowMultipleTargets = true;
         targetModel = TargetModel.kAprilTag6p5in_36h11;
         cameraExposureRaw = 20;
         cameraAutoExposure = false;
@@ -64,6 +80,21 @@ public int hashCode() {
         result = prime * result + decisionMargin;
         result = prime * result + (doMultiTarget ? 1231 : 1237);
         result = prime * result + (doSingleTargetAlways ? 1231 : 1237);
+        // ML-assisted detection fields
+        result = prime * result + (useMLDetection ? 1231 : 1237);
+        temp = Double.doubleToLongBits(mlConfidenceThreshold);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(mlNmsThreshold);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        result = prime * result + mlRoiPaddingPixels;
+        result = prime * result + (mlFallbackToTraditional ? 1231 : 1237);
+        result = prime * result + ((mlModelName == null) ? 0 : mlModelName.hashCode());
+        result = prime * result + (showDetectionBoxes ? 1231 : 1237);
+        // ATR fields
+        result = prime * result + (atrEnabled ? 1231 : 1237);
+        result = prime * result + atrTargetDimension;
+        temp = Double.doubleToLongBits(atrMinScaleFactor);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
         return result;
     }
 
@@ -84,6 +115,23 @@ public boolean equals(Object obj) {
         if (decisionMargin != other.decisionMargin) return false;
         if (doMultiTarget != other.doMultiTarget) return false;
         if (doSingleTargetAlways != other.doSingleTargetAlways) return false;
+        // ML-assisted detection fields
+        if (useMLDetection != other.useMLDetection) return false;
+        if (Double.doubleToLongBits(mlConfidenceThreshold)
+                != Double.doubleToLongBits(other.mlConfidenceThreshold)) return false;
+        if (Double.doubleToLongBits(mlNmsThreshold) != Double.doubleToLongBits(other.mlNmsThreshold))
+            return false;
+        if (mlRoiPaddingPixels != other.mlRoiPaddingPixels) return false;
+        if (mlFallbackToTraditional != other.mlFallbackToTraditional) return false;
+        if (mlModelName == null) {
+            if (other.mlModelName != null) return false;
+        } else if (!mlModelName.equals(other.mlModelName)) return false;
+        if (showDetectionBoxes != other.showDetectionBoxes) return false;
+        // ATR fields
+        if (atrEnabled != other.atrEnabled) return false;
+        if (atrTargetDimension != other.atrTargetDimension) return false;
+        if (Double.doubleToLongBits(atrMinScaleFactor)
+                != Double.doubleToLongBits(other.atrMinScaleFactor)) return false;
         return true;
     }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/ArucoPipeline.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/ArucoPipeline.java
index b0a4505a6d..49d5068252 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/ArucoPipeline.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/ArucoPipeline.java
@@ -15,23 +15,6 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-/*
- * Copyright (C) Photon Vision.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
 package org.photonvision.vision.pipeline;
 
 import edu.wpi.first.apriltag.AprilTagPoseEstimate;
@@ -46,6 +29,9 @@
 import org.opencv.imgproc.Imgproc;
 import org.opencv.objdetect.Objdetect;
 import org.photonvision.common.configuration.ConfigManager;
+import org.photonvision.common.dataflow.structures.Packet;
+import org.photonvision.common.logging.LogGroup;
+import org.photonvision.common.logging.Logger;
 import org.photonvision.common.util.math.MathUtils;
 import org.photonvision.estimation.TargetModel;
 import org.photonvision.targeting.MultiTargetPNPResult;
@@ -61,6 +47,8 @@
 import org.photonvision.vision.target.TrackedTarget.TargetCalculationParameters;
 
 public class ArucoPipeline extends CVPipeline<CVPipelineResult, ArucoPipelineSettings> {
+    private static final Logger logger = new Logger(ArucoPipeline.class, LogGroup.VisionModule);
+
     private ArucoDetectionPipe arucoDetectionPipe = new ArucoDetectionPipe();
     private ArucoPoseEstimatorPipe singleTagPoseEstimatorPipe = new ArucoPoseEstimatorPipe();
     private final MultiTargetPNPPipe multiTagPNPPipe = new MultiTargetPNPPipe();
@@ -237,6 +225,12 @@ protected CVPipelineResult process(Frame frame, ArucoPipelineSettings settings)
             }
         }
 
+        if (targetList.size() > Packet.MAX_ARRAY_LEN) {
+            logger.error(
+                    "We have " + targetList.size() + " targets! Arbitrarily dropping some on the floor");
+            targetList = targetList.subList(0, Packet.MAX_ARRAY_LEN);
+        }
+
         var fpsResult = calculateFPSPipe.run(null);
         var fps = fpsResult.output;
 
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/ArucoPipelineSettings.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/ArucoPipelineSettings.java
index 145f761427..7d7d6ea88e 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/ArucoPipelineSettings.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/ArucoPipelineSettings.java
@@ -45,7 +45,6 @@ public class ArucoPipelineSettings extends AdvancedPipelineSettings {
     public ArucoPipelineSettings() {
         super();
         pipelineType = PipelineType.Aruco;
-        outputShowMultipleTargets = true;
         targetModel = TargetModel.kAprilTag6p5in_36h11;
         cameraExposureRaw = 20;
         cameraAutoExposure = true;
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/CVPipeline.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/CVPipeline.java
index 60e033cf9b..1d5167909a 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/CVPipeline.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/CVPipeline.java
@@ -26,8 +26,6 @@
 
 public abstract class CVPipeline<R extends CVPipelineResult, S extends CVPipelineSettings>
         implements Releasable {
-    static final int MAX_MULTI_TARGET_RESULTS = 50;
-
     protected S settings;
     protected FrameStaticProperties frameStaticProperties;
     protected QuirkyCamera cameraQuirks;
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipeline.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipeline.java
index 0174c8bcb7..0443e04576 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipeline.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipeline.java
@@ -101,11 +101,7 @@ protected void setPipeParamsImpl() {
 
         sortContoursPipe.setParams(
                 new SortContoursPipe.SortContoursParams(
-                        settings.contourSortMode,
-                        settings.outputShowMultipleTargets
-                                ? MAX_MULTI_TARGET_RESULTS // TODO don't hardcode?
-                                : 1,
-                        frameStaticProperties));
+                        settings.contourSortMode, settings.outputMaximumTargets, frameStaticProperties));
 
         collect2dTargetsPipe.setParams(
                 new Collect2dTargetsPipe.Collect2dTargetsParams(
@@ -131,7 +127,7 @@ protected void setPipeParamsImpl() {
         Draw2dTargetsPipe.Draw2dTargetsParams draw2DTargetsParams =
                 new Draw2dTargetsPipe.Draw2dTargetsParams(
                         settings.outputShouldDraw,
-                        settings.outputShowMultipleTargets,
+                        settings.outputMaximumTargets,
                         settings.streamingFrameDivisor);
         draw2DTargetsParams.showShape = true;
         draw2DTargetsParams.showMaximumBox = false;
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipeline.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipeline.java
index 6cc0a2c692..a009d2cc9e 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipeline.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipeline.java
@@ -82,9 +82,7 @@ protected void setPipeParamsImpl() {
 
         sortContoursPipe.setParams(
                 new SortContoursPipe.SortContoursParams(
-                        settings.contourSortMode,
-                        settings.outputShowMultipleTargets ? MAX_MULTI_TARGET_RESULTS : 1,
-                        frameStaticProperties));
+                        settings.contourSortMode, settings.outputMaximumTargets, frameStaticProperties));
 
         filterContoursPipe.setParams(
                 new FilterObjectDetectionsPipe.FilterContoursParams(
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipelineSettings.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipelineSettings.java
index 4af55c7d63..66caa2cf96 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipelineSettings.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipelineSettings.java
@@ -29,7 +29,7 @@ public class ObjectDetectionPipelineSettings extends AdvancedPipelineSettings {
     public ObjectDetectionPipelineSettings() {
         super();
         this.pipelineType = PipelineType.ObjectDetection; // TODO: FIX this
-        this.outputShowMultipleTargets = true;
+        this.outputMaximumTargets = 20;
         cameraExposureRaw = 20;
         cameraAutoExposure = false;
         ledMode = false;
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/OutputStreamPipeline.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/OutputStreamPipeline.java
index 366ef1a0a2..3376b1ea18 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/OutputStreamPipeline.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/OutputStreamPipeline.java
@@ -41,6 +41,7 @@ public class OutputStreamPipeline {
 
     private final Draw2dArucoPipe draw2dArucoPipe = new Draw2dArucoPipe();
     private final Draw3dArucoPipe draw3dArucoPipe = new Draw3dArucoPipe();
+    private final DrawMLROIPipe drawMLROIPipe = new DrawMLROIPipe();
     private final CalculateFPSPipe calculateFPSPipe = new CalculateFPSPipe();
     private final ResizeImagePipe resizeImagePipe = new ResizeImagePipe();
 
@@ -58,19 +59,19 @@ protected void setPipeParams(
         draw2dTargetsPipe.setParams(
                 new Draw2dTargetsPipe.Draw2dTargetsParams(
                         settings.outputShouldDraw,
-                        settings.outputShowMultipleTargets,
+                        settings.outputMaximumTargets,
                         settings.streamingFrameDivisor));
 
         draw2dAprilTagsPipe.setParams(
                 new Draw2dAprilTagsPipe.Draw2dAprilTagsParams(
                         settings.outputShouldDraw,
-                        settings.outputShowMultipleTargets,
+                        settings.outputMaximumTargets,
                         settings.streamingFrameDivisor));
 
         draw2dArucoPipe.setParams(
                 new Draw2dArucoPipe.Draw2dArucoParams(
                         settings.outputShouldDraw,
-                        settings.outputShowMultipleTargets,
+                        settings.outputMaximumTargets,
                         settings.streamingFrameDivisor));
 
         draw2dCrosshairPipe.setParams(
@@ -112,6 +113,14 @@ protected void setPipeParams(
                     new DrawCalibrationPipe.DrawCalibrationPipeParams(
                             pipelineSettings.streamingFrameDivisor, pipelineSettings.drawAllSnapshots));
         }
+
+        if (settings instanceof AprilTagPipelineSettings atSettings) {
+            drawMLROIPipe.setParams(
+                    new DrawMLROIPipe.DrawMLROIParams(
+                            settings.outputShouldDraw,
+                            atSettings.showDetectionBoxes,
+                            settings.streamingFrameDivisor));
+        }
     }
 
     public CVPipelineResult process(
@@ -181,6 +190,9 @@ public CVPipelineResult process(
 
                 pipeProfileNanos[8] = 0;
             } else if (settings instanceof AprilTagPipelineSettings) {
+                // Draw ML detection ROI boxes (underneath tag overlays)
+                drawMLROIPipe.run(Pair.of(outMat, inputAndOutputFrame.mlDetectionRois));
+
                 // If we are doing apriltags...
                 if (settings.solvePNPEnabled) {
                     // Draw 3d Apriltag markers (camera is calibrated and running in 3d mode)
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/ReflectivePipeline.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/ReflectivePipeline.java
index fc798d4184..0d78d978fb 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/ReflectivePipeline.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/ReflectivePipeline.java
@@ -85,9 +85,7 @@ protected void setPipeParamsImpl() {
 
         sortContoursPipe.setParams(
                 new SortContoursPipe.SortContoursParams(
-                        settings.contourSortMode,
-                        settings.outputShowMultipleTargets ? MAX_MULTI_TARGET_RESULTS : 1,
-                        frameStaticProperties));
+                        settings.contourSortMode, settings.outputMaximumTargets, frameStaticProperties));
 
         collect2dTargetsPipe.setParams(
                 new Collect2dTargetsPipe.Collect2dTargetsParams(
diff --git a/photon-core/src/main/java/org/photonvision/vision/processes/VisionModule.java b/photon-core/src/main/java/org/photonvision/vision/processes/VisionModule.java
index b57b01d969..84fb3c1003 100644
--- a/photon-core/src/main/java/org/photonvision/vision/processes/VisionModule.java
+++ b/photon-core/src/main/java/org/photonvision/vision/processes/VisionModule.java
@@ -453,6 +453,31 @@ boolean setPipeline(int index) {
             logger.error("Config for index " + index + " was null! Not changing pipelines");
             return false;
         }
+        
+        // If manual exposure, force exposure slider to be valid
+        if (!pipelineSettings.cameraAutoExposure) {
+            if (pipelineSettings.cameraExposureRaw < 0) {
+                pipelineSettings.cameraExposureRaw = 10; // reasonable default
+            }
+        }
+
+        if (cameraQuirks.hasQuirk(CameraQuirk.Gain)) {
+            // If the gain is disabled for some reason, re-enable it
+            if (pipelineSettings.cameraGain == -1) pipelineSettings.cameraGain = 75;
+        } else {
+            pipelineSettings.cameraGain = -1;
+        }
+
+        if (cameraQuirks.hasQuirk(CameraQuirk.AwbRedBlueGain)) {
+             // If the AWB gains are disabled for some reason, re-enable it
+            if (pipelineSettings.cameraRedGain == -1) pipelineSettings.cameraRedGain = 11;
+            if (pipelineSettings.cameraBlueGain == -1) pipelineSettings.cameraBlueGain = 20;
+        } else {
+            pipelineSettings.cameraRedGain = -1;
+            pipelineSettings.cameraBlueGain = -1;
+        }
+
+        settables.getConfiguration().currentPipelineIndex = pipelineManager.getRequestedIndex();
 
         visionRunner.runSynchronously(
                 () -> {
@@ -473,31 +498,19 @@ boolean setPipeline(int index) {
                     }
                     settables.setExposureRaw(pipelineSettings.cameraExposureRaw);
                     if (cameraQuirks.hasQuirk(CameraQuirk.Gain)) {
-                        // If the gain is disabled for some reason, re-enable it
-                        if (pipelineSettings.cameraGain == -1) pipelineSettings.cameraGain = 75;
                         settables.setGain(Math.max(0, pipelineSettings.cameraGain));
-                    } else {
-                        pipelineSettings.cameraGain = -1;
                     }
 
                     if (cameraQuirks.hasQuirk(CameraQuirk.AwbRedBlueGain)) {
-                        // If the AWB gains are disabled for some reason, re-enable it
-                        if (pipelineSettings.cameraRedGain == -1) pipelineSettings.cameraRedGain = 11;
-                        if (pipelineSettings.cameraBlueGain == -1) pipelineSettings.cameraBlueGain = 20;
                         settables.setRedGain(Math.max(0, pipelineSettings.cameraRedGain));
                         settables.setBlueGain(Math.max(0, pipelineSettings.cameraBlueGain));
                     } else {
-                        pipelineSettings.cameraRedGain = -1;
-                        pipelineSettings.cameraBlueGain = -1;
-
                         // All other cameras (than picams) should support AWB temp
                         settables.setWhiteBalanceTemp(pipelineSettings.cameraWhiteBalanceTemp);
                         settables.setAutoWhiteBalance(pipelineSettings.cameraAutoWhiteBalance);
                     }
 
                     setVisionLEDs(pipelineSettings.ledMode);
-
-                    settables.getConfiguration().currentPipelineIndex = pipelineManager.getRequestedIndex();
                 });
 
         return true;
diff --git a/photon-core/src/test/java/org/photonvision/common/BenchmarkTest.java b/photon-core/src/test/java/org/photonvision/common/BenchmarkTest.java
index ae6e16a260..97584ef8cc 100644
--- a/photon-core/src/test/java/org/photonvision/common/BenchmarkTest.java
+++ b/photon-core/src/test/java/org/photonvision/common/BenchmarkTest.java
@@ -51,7 +51,7 @@ public void Reflective240pBenchmark() {
         pipeline.getSettings().hsvSaturation.set(100, 255);
         pipeline.getSettings().hsvValue.set(190, 255);
         pipeline.getSettings().outputShouldDraw = true;
-        pipeline.getSettings().outputShowMultipleTargets = true;
+        pipeline.getSettings().outputMaximumTargets = 20;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Dual;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
 
@@ -105,7 +105,7 @@ public void Reflective1920x1440Benchmark() {
         pipeline.getSettings().hsvSaturation.set(100, 255);
         pipeline.getSettings().hsvValue.set(190, 255);
         pipeline.getSettings().outputShouldDraw = true;
-        pipeline.getSettings().outputShowMultipleTargets = true;
+        pipeline.getSettings().outputMaximumTargets = 20;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Dual;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
 
diff --git a/photon-core/src/test/java/org/photonvision/common/ShapeBenchmarkTest.java b/photon-core/src/test/java/org/photonvision/common/ShapeBenchmarkTest.java
index 0530d4957a..8f45f42df3 100644
--- a/photon-core/src/test/java/org/photonvision/common/ShapeBenchmarkTest.java
+++ b/photon-core/src/test/java/org/photonvision/common/ShapeBenchmarkTest.java
@@ -66,7 +66,7 @@ public void Shape240pBenchmark() {
         pipeline.getSettings().hsvSaturation.set(100, 255);
         pipeline.getSettings().hsvValue.set(190, 255);
         pipeline.getSettings().outputShouldDraw = true;
-        pipeline.getSettings().outputShowMultipleTargets = true;
+        pipeline.getSettings().outputMaximumTargets = 20;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Single;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
         pipeline.getSettings().contourShape = ContourShape.Custom;
@@ -87,7 +87,7 @@ public void Shape480pBenchmark() {
         pipeline.getSettings().hsvSaturation.set(100, 255);
         pipeline.getSettings().hsvValue.set(190, 255);
         pipeline.getSettings().outputShouldDraw = true;
-        pipeline.getSettings().outputShowMultipleTargets = true;
+        pipeline.getSettings().outputMaximumTargets = 20;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Single;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
         pipeline.getSettings().contourShape = ContourShape.Custom;
@@ -109,7 +109,7 @@ public void Shape720pBenchmark() {
         pipeline.getSettings().hsvSaturation.set(100, 255);
         pipeline.getSettings().hsvValue.set(190, 255);
         pipeline.getSettings().outputShouldDraw = true;
-        pipeline.getSettings().outputShowMultipleTargets = true;
+        pipeline.getSettings().outputMaximumTargets = 20;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Single;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
         pipeline.getSettings().contourShape = ContourShape.Custom;
@@ -131,7 +131,7 @@ public void Shape1920x1440Benchmark() {
         pipeline.getSettings().hsvSaturation.set(100, 255);
         pipeline.getSettings().hsvValue.set(190, 255);
         pipeline.getSettings().outputShouldDraw = true;
-        pipeline.getSettings().outputShowMultipleTargets = true;
+        pipeline.getSettings().outputMaximumTargets = 20;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Single;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
         pipeline.getSettings().contourShape = ContourShape.Custom;
diff --git a/photon-core/src/test/java/org/photonvision/common/configuration/SQLConfigTest.java b/photon-core/src/test/java/org/photonvision/common/configuration/SQLConfigTest.java
index a965e35578..0d1a8061d9 100644
--- a/photon-core/src/test/java/org/photonvision/common/configuration/SQLConfigTest.java
+++ b/photon-core/src/test/java/org/photonvision/common/configuration/SQLConfigTest.java
@@ -23,6 +23,7 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import edu.wpi.first.cscore.UsbCameraInfo;
 import java.nio.file.Path;
+import java.util.Collection;
 import java.util.List;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Order;
@@ -33,9 +34,12 @@
 import org.photonvision.common.util.TestUtils;
 import org.photonvision.vision.camera.CameraQuirk;
 import org.photonvision.vision.camera.PVCameraInfo;
+import org.photonvision.vision.pipeline.AdvancedPipelineSettings;
 import org.photonvision.vision.pipeline.AprilTagPipelineSettings;
+import org.photonvision.vision.pipeline.CVPipelineSettings;
 import org.photonvision.vision.pipeline.ColoredShapePipelineSettings;
 import org.photonvision.vision.pipeline.ObjectDetectionPipelineSettings;
+import org.photonvision.vision.pipeline.PipelineType;
 import org.photonvision.vision.pipeline.ReflectivePipelineSettings;
 
 public class SQLConfigTest {
@@ -155,4 +159,41 @@ public void testLoadNewNNMM() throws JsonProcessingException {
 
         ConfigManager.INSTANCE = null;
     }
+
+    @Test
+    public void testMaxDetectionsMigration() {
+        var folder = TestUtils.getConfigDirectoriesPath(false).resolve("2025.3.1-old-nnmm");
+        var cfgManager = new ConfigManager(folder, new SqlConfigProvider(folder));
+
+        // Replace global configmanager
+        ConfigManager.INSTANCE = cfgManager;
+
+        assertDoesNotThrow(cfgManager::load);
+
+        Collection<CameraConfiguration> cameraConfigs =
+                cfgManager.getConfig().getCameraConfigurations().values();
+
+        for (CameraConfiguration cc : cameraConfigs) {
+            for (CVPipelineSettings ps : cc.pipelineSettings) {
+                if (ps instanceof AdvancedPipelineSettings adps) {
+                    AdvancedPipelineSettings finalPs = adps;
+                    if (finalPs.pipelineType.equals(PipelineType.AprilTag)
+                            || finalPs.pipelineType.equals(PipelineType.Aruco)) {
+                        // Tag pipelines don't have max detections, so skip
+                        continue;
+                    } else if (finalPs.pipelineNickname.equals("TEST MIGRATION")) {
+                        // This is our colored shape pipeline that we set to 1 before saving
+                        assertEquals(1, finalPs.outputMaximumTargets);
+                    } else {
+                        // All others should be at default 20
+                        assertEquals(20, finalPs.outputMaximumTargets);
+                    }
+                } else {
+                    System.out.println("Skipping pipeline settings type: " + ps.getClass().getSimpleName());
+                }
+            }
+        }
+
+        ConfigManager.INSTANCE = null;
+    }
 }
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipe/AprilTagROIDecodePipeTest.java b/photon-core/src/test/java/org/photonvision/vision/pipe/AprilTagROIDecodePipeTest.java
new file mode 100644
index 0000000000..238c1c1ae1
--- /dev/null
+++ b/photon-core/src/test/java/org/photonvision/vision/pipe/AprilTagROIDecodePipeTest.java
@@ -0,0 +1,1005 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipe;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assumptions.*;
+
+import edu.wpi.first.apriltag.AprilTagDetection;
+import edu.wpi.first.apriltag.AprilTagDetector;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.opencv.core.Mat;
+import org.opencv.core.Rect;
+import org.opencv.core.Rect2d;
+import org.photonvision.common.LoadJNI;
+import org.photonvision.common.configuration.ConfigManager;
+import org.photonvision.common.util.TestUtils;
+import org.photonvision.vision.apriltag.AprilTagFamily;
+import org.photonvision.vision.frame.provider.FileFrameProvider;
+import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.pipe.impl.AprilTagROIDecodePipe;
+import org.photonvision.vision.pipe.impl.AprilTagROIDecodePipe.ROIDecodeInput;
+import org.photonvision.vision.pipe.impl.AprilTagROIDecodePipe.ROIDecodeParams;
+
+/**
+ * Unit tests for AprilTagROIDecodePipe, focusing on coordinate mapping accuracy. These tests verify
+ * that corners detected within ROIs are correctly mapped back to full-frame coordinates.
+ */
+public class AprilTagROIDecodePipeTest {
+
+    @BeforeAll
+    public static void init() {
+        LoadJNI.loadLibraries();
+        ConfigManager.getInstance().load();
+    }
+
+    /**
+     * CRITICAL TEST: Verify coordinate mapping from ROI to full frame. This test compares
+     * ML-assisted detection (simulated with manual ROI) against traditional full-frame detection.
+     * The mapped corners should match within a small tolerance.
+     */
+    @Test
+    public void testCoordinateMappingAccuracy() {
+        // Load a test image with a known AprilTag
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getApriltagImagePath(TestUtils.ApriltagTestImages.kTag1_640_480, false),
+                        TestUtils.WPI2020Image.FOV,
+                        TestUtils.get2020LifeCamCoeffs(false));
+
+        var frame = frameProvider.get();
+        Mat grayMat = frame.processedImage.getMat();
+
+        // First, run full-frame detection to get ground truth corners
+        AprilTagDetector fullFrameDetector = new AprilTagDetector();
+        fullFrameDetector.addFamily(AprilTagFamily.kTag36h11.getNativeName());
+
+        AprilTagDetection[] fullFrameDetections;
+        try {
+            fullFrameDetections = fullFrameDetector.detect(grayMat);
+        } catch (Exception e) {
+            // Skip test if native library doesn't work on this platform
+            assumeTrue(false, "Native AprilTag library not available: " + e.getMessage());
+            return;
+        }
+        assumeTrue(fullFrameDetections != null, "Native AprilTag detector returned null");
+        assumeTrue(fullFrameDetections.length > 0, "Should detect at least one tag in full frame");
+
+        AprilTagDetection groundTruth = fullFrameDetections[0];
+
+        // Create an ROI that contains the tag (simulating ML detection)
+        // The ROI should be slightly larger than the tag's bounding box
+        double minX = Double.MAX_VALUE, maxX = Double.MIN_VALUE;
+        double minY = Double.MAX_VALUE, maxY = Double.MIN_VALUE;
+        for (int i = 0; i < 4; i++) {
+            minX = Math.min(minX, groundTruth.getCornerX(i));
+            maxX = Math.max(maxX, groundTruth.getCornerX(i));
+            minY = Math.min(minY, groundTruth.getCornerY(i));
+            maxY = Math.max(maxY, groundTruth.getCornerY(i));
+        }
+
+        // Add some padding around the tag (simulating ML detection bbox)
+        double padding = 20;
+        Rect2d simulatedMLBbox =
+                new Rect2d(minX - padding, minY - padding, maxX - minX + 2 * padding, maxY - minY + 2 * padding);
+
+        // Run the ROI decode pipe
+        AprilTagROIDecodePipe decodePipe = new AprilTagROIDecodePipe();
+
+        ROIDecodeParams params = new ROIDecodeParams();
+        params.tagFamily = AprilTagFamily.kTag36h11;
+        params.maxHammingDistance = 0;
+        params.minDecisionMargin = 35;
+        decodePipe.setParams(params);
+
+        List<Rect2d> rois = new ArrayList<>();
+        rois.add(simulatedMLBbox);
+
+        ROIDecodeInput input = new ROIDecodeInput(frame.processedImage, rois);
+        var result = decodePipe.run(input);
+
+        List<AprilTagDetection> roiDetections = result.output;
+        assertEquals(1, roiDetections.size(), "Should detect exactly one tag in ROI");
+
+        AprilTagDetection mappedDetection = roiDetections.get(0);
+
+        // Verify corner mapping accuracy (should be within 0.5 pixel)
+        double tolerance = 0.5;
+        for (int i = 0; i < 4; i++) {
+            assertEquals(
+                    groundTruth.getCornerX(i),
+                    mappedDetection.getCornerX(i),
+                    tolerance,
+                    "Corner " + i + " X coordinate should match");
+            assertEquals(
+                    groundTruth.getCornerY(i),
+                    mappedDetection.getCornerY(i),
+                    tolerance,
+                    "Corner " + i + " Y coordinate should match");
+        }
+
+        // Verify center mapping
+        assertEquals(
+                groundTruth.getCenterX(), mappedDetection.getCenterX(), tolerance, "Center X should match");
+        assertEquals(
+                groundTruth.getCenterY(), mappedDetection.getCenterY(), tolerance, "Center Y should match");
+
+        // Verify tag ID matches
+        assertEquals(groundTruth.getId(), mappedDetection.getId(), "Tag ID should match");
+
+        fullFrameDetector.close();
+        decodePipe.release();
+    }
+
+    /** Test that ROI expansion correctly clamps to image bounds when near edges. */
+    @Test
+    public void testExpandBboxClamping() {
+        AprilTagROIDecodePipe decodePipe = new AprilTagROIDecodePipe();
+
+        ROIDecodeParams params = new ROIDecodeParams();
+        params.tagFamily = AprilTagFamily.kTag36h11;
+        decodePipe.setParams(params);
+
+        // Create a test image
+        int imageWidth = 640;
+        int imageHeight = 480;
+        Mat testMat = Mat.zeros(imageHeight, imageWidth, org.opencv.core.CvType.CV_8UC1);
+        CVMat cvMat = new CVMat(testMat);
+
+        // ROI at edge that would expand outside bounds
+        Rect2d edgeRoi = new Rect2d(600, 440, 30, 30); // Near bottom-right corner
+
+        List<Rect2d> rois = new ArrayList<>();
+        rois.add(edgeRoi);
+
+        ROIDecodeInput input = new ROIDecodeInput(cvMat, rois);
+        var result = decodePipe.run(input);
+
+        // Should not throw exception - ROI should be clamped
+        assertNotNull(result.output, "Result should not be null");
+        // Empty because there's no actual tag, but no crash
+
+        testMat.release();
+        decodePipe.release();
+    }
+
+    /** Test that deduplication keeps the detection with highest decision margin. */
+    @Test
+    public void testDeduplicationKeepsHighestMargin() {
+        // Load a test image with a known AprilTag
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getApriltagImagePath(TestUtils.ApriltagTestImages.kTag1_640_480, false),
+                        TestUtils.WPI2020Image.FOV,
+                        TestUtils.get2020LifeCamCoeffs(false));
+
+        var frame = frameProvider.get();
+
+        AprilTagROIDecodePipe decodePipe = new AprilTagROIDecodePipe();
+
+        ROIDecodeParams params = new ROIDecodeParams();
+        params.tagFamily = AprilTagFamily.kTag36h11;
+        params.maxHammingDistance = 0;
+        params.minDecisionMargin = 0; // Accept all
+        decodePipe.setParams(params);
+
+        // Create two overlapping ROIs that both contain the same tag
+        // This simulates overlapping ML detections
+        Rect2d roi1 = new Rect2d(200, 150, 200, 150);
+        Rect2d roi2 = new Rect2d(220, 170, 200, 150); // Overlapping
+
+        List<Rect2d> rois = new ArrayList<>();
+        rois.add(roi1);
+        rois.add(roi2);
+
+        ROIDecodeInput input = new ROIDecodeInput(frame.processedImage, rois);
+        var result = decodePipe.run(input);
+
+        // Should deduplicate to a single detection
+        assertTrue(result.output.size() <= 1, "Overlapping ROIs detecting same tag should be deduplicated");
+
+        decodePipe.release();
+    }
+
+    /** Test that empty ROI list returns empty result without errors. */
+    @Test
+    public void testEmptyROIListReturnsEmpty() {
+        // Create a simple test image
+        Mat testMat = Mat.zeros(480, 640, org.opencv.core.CvType.CV_8UC1);
+        CVMat cvMat = new CVMat(testMat);
+
+        AprilTagROIDecodePipe decodePipe = new AprilTagROIDecodePipe();
+
+        ROIDecodeParams params = new ROIDecodeParams();
+        params.tagFamily = AprilTagFamily.kTag36h11;
+        decodePipe.setParams(params);
+
+        List<Rect2d> emptyRois = new ArrayList<>();
+        ROIDecodeInput input = new ROIDecodeInput(cvMat, emptyRois);
+
+        var result = decodePipe.run(input);
+
+        assertNotNull(result.output, "Result should not be null");
+        assertTrue(result.output.isEmpty(), "Empty ROI list should produce empty result");
+
+        testMat.release();
+        decodePipe.release();
+    }
+
+    /** Test that ROIs with zero or negative dimensions are skipped. */
+    @Test
+    public void testInvalidROISkipped() {
+        Mat testMat = Mat.zeros(480, 640, org.opencv.core.CvType.CV_8UC1);
+        CVMat cvMat = new CVMat(testMat);
+
+        AprilTagROIDecodePipe decodePipe = new AprilTagROIDecodePipe();
+
+        ROIDecodeParams params = new ROIDecodeParams();
+        params.tagFamily = AprilTagFamily.kTag36h11;
+        decodePipe.setParams(params);
+
+        List<Rect2d> rois = new ArrayList<>();
+        rois.add(new Rect2d(100, 100, 0, 50)); // Zero width
+        rois.add(new Rect2d(100, 100, 50, -10)); // Negative height
+        rois.add(new Rect2d(-50, 100, 50, 50)); // Negative x (will be clamped)
+
+        ROIDecodeInput input = new ROIDecodeInput(cvMat, rois);
+
+        // Should not throw exception
+        var result = decodePipe.run(input);
+        assertNotNull(result.output, "Result should not be null even with invalid ROIs");
+
+        testMat.release();
+        decodePipe.release();
+    }
+
+    /**
+     * Test integer conversion for rectangles preserves area by using floor for position and ceil for
+     * size.
+     */
+    @Test
+    public void testToIntRectPreservesArea() {
+        // Test with floating point values
+        Rect2d input = new Rect2d(10.3, 20.7, 100.2, 100.8);
+
+        // Expected: x=10 (floor), y=20 (floor), w=101 (ceil), h=101 (ceil)
+        // This ensures we don't clip any part of the tag
+
+        // We can't directly test the private method, but we can verify the behavior
+        // through the overall coordinate mapping test
+        // This test documents the expected behavior for future reference
+
+        int expectedX = 10;
+        int expectedY = 20;
+        int expectedW = 101;
+        int expectedH = 101;
+
+        // Verify that floor/ceil logic matches expectations
+        assertEquals(expectedX, (int) Math.floor(input.x));
+        assertEquals(expectedY, (int) Math.floor(input.y));
+        assertEquals(expectedW, (int) Math.ceil(input.width));
+        assertEquals(expectedH, (int) Math.ceil(input.height));
+    }
+
+    // ==================== Homography Transformation Tests ====================
+
+    /**
+     * Helper method to access the private transformHomography method via reflection.
+     */
+    private double[] invokeTransformHomography(AprilTagROIDecodePipe pipe,
+            double[] h, int offsetX, int offsetY) throws Exception {
+        Method method = AprilTagROIDecodePipe.class.getDeclaredMethod(
+            "transformHomography", double[].class, int.class, int.class);
+        method.setAccessible(true);
+        return (double[]) method.invoke(pipe, h, offsetX, offsetY);
+    }
+
+    /** Test that zero offset returns the homography unchanged. */
+    @Test
+    public void testTransformHomography_ZeroOffset_ReturnsUnchanged() throws Exception {
+        AprilTagROIDecodePipe pipe = new AprilTagROIDecodePipe();
+
+        double[] h = {0.9, 0.1, 50.0, -0.1, 0.9, 60.0, 0.001, 0.002, 1.0};
+        double[] result = invokeTransformHomography(pipe, h, 0, 0);
+
+        double tolerance = 1e-15;
+        for (int i = 0; i < 9; i++) {
+            assertEquals(h[i], result[i], tolerance,
+                "Element " + i + " should be unchanged with zero offset");
+        }
+
+        pipe.release();
+    }
+
+    /** Test that identity homography with offset becomes a pure translation matrix. */
+    @Test
+    public void testTransformHomography_IdentityHomography_AddsTranslationOnly() throws Exception {
+        AprilTagROIDecodePipe pipe = new AprilTagROIDecodePipe();
+
+        // Identity matrix: [[1,0,0],[0,1,0],[0,0,1]]
+        double[] identity = {1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0};
+        int offsetX = 50;
+        int offsetY = 75;
+
+        double[] result = invokeTransformHomography(pipe, identity, offsetX, offsetY);
+
+        double tolerance = 1e-15;
+        // Expected: [[1,0,50],[0,1,75],[0,0,1]]
+        assertEquals(1.0, result[0], tolerance, "h[0] should remain 1");
+        assertEquals(0.0, result[1], tolerance, "h[1] should remain 0");
+        assertEquals(50.0, result[2], tolerance, "h[2] should become offsetX");
+        assertEquals(0.0, result[3], tolerance, "h[3] should remain 0");
+        assertEquals(1.0, result[4], tolerance, "h[4] should remain 1");
+        assertEquals(75.0, result[5], tolerance, "h[5] should become offsetY");
+        assertEquals(0.0, result[6], tolerance, "h[6] should remain 0");
+        assertEquals(0.0, result[7], tolerance, "h[7] should remain 0");
+        assertEquals(1.0, result[8], tolerance, "h[8] should remain 1");
+
+        pipe.release();
+    }
+
+    /** Test that the third row of the homography is always preserved unchanged. */
+    @Test
+    public void testTransformHomography_ThirdRowUnchanged() throws Exception {
+        AprilTagROIDecodePipe pipe = new AprilTagROIDecodePipe();
+
+        // Test various homographies with different third rows
+        double[][] testCases = {
+            {0.9, 0.1, 50.0, -0.1, 0.9, 60.0, 0.001, 0.002, 1.0},
+            {1.5, -0.3, 100.0, 0.2, 1.8, -50.0, -0.005, 0.003, 1.2},
+            {0.5, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 1.0}
+        };
+        int[][] offsets = {{100, 150}, {500, 300}, {1920, 1080}};
+
+        double tolerance = 1e-15;
+        for (int t = 0; t < testCases.length; t++) {
+            double[] h = testCases[t];
+            int[] offset = offsets[t];
+            double[] result = invokeTransformHomography(pipe, h, offset[0], offset[1]);
+
+            assertEquals(h[6], result[6], tolerance,
+                "h[6] should be unchanged for test case " + t);
+            assertEquals(h[7], result[7], tolerance,
+                "h[7] should be unchanged for test case " + t);
+            assertEquals(h[8], result[8], tolerance,
+                "h[8] should be unchanged for test case " + t);
+        }
+
+        pipe.release();
+    }
+
+    /** Test the standard transformation case with manually computed expected values. */
+    @Test
+    public void testTransformHomography_StandardCase_CorrectComputation() throws Exception {
+        AprilTagROIDecodePipe pipe = new AprilTagROIDecodePipe();
+
+        // Input homography
+        double[] h = {0.9, 0.1, 50.0, -0.1, 0.9, 60.0, 0.001, 0.002, 1.0};
+        int offsetX = 100;
+        int offsetY = 150;
+
+        // Manually compute expected T*H where T = [[1,0,100],[0,1,150],[0,0,1]]
+        // Row 0: H[0][j] + offsetX * H[2][j]
+        double expected0 = 0.9 + 100 * 0.001;   // 0.9 + 0.1 = 1.0
+        double expected1 = 0.1 + 100 * 0.002;   // 0.1 + 0.2 = 0.3
+        double expected2 = 50.0 + 100 * 1.0;    // 50 + 100 = 150
+        // Row 1: H[1][j] + offsetY * H[2][j]
+        double expected3 = -0.1 + 150 * 0.001;  // -0.1 + 0.15 = 0.05
+        double expected4 = 0.9 + 150 * 0.002;   // 0.9 + 0.3 = 1.2
+        double expected5 = 60.0 + 150 * 1.0;    // 60 + 150 = 210
+        // Row 2: unchanged
+        double expected6 = 0.001;
+        double expected7 = 0.002;
+        double expected8 = 1.0;
+
+        double[] result = invokeTransformHomography(pipe, h, offsetX, offsetY);
+
+        double tolerance = 1e-10;
+        assertEquals(expected0, result[0], tolerance, "h[0] computation incorrect");
+        assertEquals(expected1, result[1], tolerance, "h[1] computation incorrect");
+        assertEquals(expected2, result[2], tolerance, "h[2] computation incorrect");
+        assertEquals(expected3, result[3], tolerance, "h[3] computation incorrect");
+        assertEquals(expected4, result[4], tolerance, "h[4] computation incorrect");
+        assertEquals(expected5, result[5], tolerance, "h[5] computation incorrect");
+        assertEquals(expected6, result[6], tolerance, "h[6] computation incorrect");
+        assertEquals(expected7, result[7], tolerance, "h[7] computation incorrect");
+        assertEquals(expected8, result[8], tolerance, "h[8] computation incorrect");
+
+        pipe.release();
+    }
+
+    /**
+     * Test point mapping consistency: for a point p, project(H_roi, p) + offset == project(H_full, p)
+     * This verifies the mathematical correctness of the transformation.
+     */
+    @Test
+    public void testTransformHomography_PointMapping_Consistency() throws Exception {
+        AprilTagROIDecodePipe pipe = new AprilTagROIDecodePipe();
+
+        // A realistic homography from a tag detection
+        double[] hRoi = {0.95, 0.05, 45.0, -0.03, 0.98, 55.0, 0.0002, 0.0001, 1.0};
+        int offsetX = 200;
+        int offsetY = 150;
+
+        double[] hFull = invokeTransformHomography(pipe, hRoi, offsetX, offsetY);
+
+        // Test points (normalized tag corners: -1 to 1)
+        double[][] testPoints = {
+            {-1.0, -1.0},
+            {1.0, -1.0},
+            {1.0, 1.0},
+            {-1.0, 1.0},
+            {0.0, 0.0}  // center
+        };
+
+        double tolerance = 1e-10;
+        for (double[] point : testPoints) {
+            // Project with ROI homography and add offset
+            double[] roiProjected = projectPoint(hRoi, point[0], point[1]);
+            double roiFullX = roiProjected[0] + offsetX;
+            double roiFullY = roiProjected[1] + offsetY;
+
+            // Project with full-frame homography
+            double[] fullProjected = projectPoint(hFull, point[0], point[1]);
+
+            assertEquals(roiFullX, fullProjected[0], tolerance,
+                "X coordinate mismatch for point (" + point[0] + ", " + point[1] + ")");
+            assertEquals(roiFullY, fullProjected[1], tolerance,
+                "Y coordinate mismatch for point (" + point[0] + ", " + point[1] + ")");
+        }
+
+        pipe.release();
+    }
+
+    /**
+     * Helper method to project a point using a homography.
+     * Computes [x', y'] from H * [X, Y, 1]^T with perspective division.
+     */
+    private double[] projectPoint(double[] h, double X, double Y) {
+        double w = h[6] * X + h[7] * Y + h[8];
+        double x = (h[0] * X + h[1] * Y + h[2]) / w;
+        double y = (h[3] * X + h[4] * Y + h[5]) / w;
+        return new double[] {x, y};
+    }
+
+    /** Test numerical stability with large offsets (4K resolution). */
+    @Test
+    public void testTransformHomography_LargeOffsets_NumericalStability() throws Exception {
+        AprilTagROIDecodePipe pipe = new AprilTagROIDecodePipe();
+
+        // A homography with typical values
+        double[] h = {1.2, 0.05, 30.0, -0.02, 1.15, 40.0, 0.0003, 0.0002, 1.0};
+
+        // 4K resolution offset
+        int offsetX = 3840;
+        int offsetY = 2160;
+
+        double[] result = invokeTransformHomography(pipe, h, offsetX, offsetY);
+
+        // Verify no NaN or Inf values
+        for (int i = 0; i < 9; i++) {
+            assertFalse(Double.isNaN(result[i]), "Result contains NaN at index " + i);
+            assertFalse(Double.isInfinite(result[i]), "Result contains Infinity at index " + i);
+        }
+
+        // Verify the transformation is mathematically correct
+        double tolerance = 1e-10;
+
+        // Row 0
+        assertEquals(h[0] + offsetX * h[6], result[0], tolerance);
+        assertEquals(h[1] + offsetX * h[7], result[1], tolerance);
+        assertEquals(h[2] + offsetX * h[8], result[2], tolerance);
+        // Row 1
+        assertEquals(h[3] + offsetY * h[6], result[3], tolerance);
+        assertEquals(h[4] + offsetY * h[7], result[4], tolerance);
+        assertEquals(h[5] + offsetY * h[8], result[5], tolerance);
+        // Row 2 unchanged
+        assertEquals(h[6], result[6], tolerance);
+        assertEquals(h[7], result[7], tolerance);
+        assertEquals(h[8], result[8], tolerance);
+
+        pipe.release();
+    }
+
+    // ==================== Parameterized Tests ====================
+
+    private static Stream<Arguments> offsetTestCases() {
+        return Stream.of(
+            Arguments.of(0, 0, "Zero offset"),
+            Arguments.of(100, 0, "X only"),
+            Arguments.of(0, 100, "Y only"),
+            Arguments.of(100, 100, "Equal offsets"),
+            Arguments.of(640, 480, "VGA resolution"),
+            Arguments.of(1920, 1080, "1080p resolution")
+        );
+    }
+
+    /**
+     * Parameterized test for various offset values.
+     * Verifies the transformation formula holds for different offset combinations.
+     */
+    @ParameterizedTest(name = "{2}: offset=({0}, {1})")
+    @MethodSource("offsetTestCases")
+    public void testTransformHomography_VariousOffsets(int offsetX, int offsetY, String description)
+            throws Exception {
+        AprilTagROIDecodePipe pipe = new AprilTagROIDecodePipe();
+
+        // Use a non-trivial homography
+        double[] h = {0.85, 0.12, 35.0, -0.08, 0.92, 45.0, 0.0005, 0.0003, 1.0};
+
+        double[] result = invokeTransformHomography(pipe, h, offsetX, offsetY);
+
+        double tolerance = 1e-10;
+
+        // Verify the transformation formula: T * H
+        // Row 0: h[i] + offsetX * h[6+i%3] for i in 0,1,2
+        assertEquals(h[0] + offsetX * h[6], result[0], tolerance,
+            description + ": h[0] incorrect");
+        assertEquals(h[1] + offsetX * h[7], result[1], tolerance,
+            description + ": h[1] incorrect");
+        assertEquals(h[2] + offsetX * h[8], result[2], tolerance,
+            description + ": h[2] incorrect");
+
+        // Row 1: h[i] + offsetY * h[3+i%3] for i in 3,4,5
+        assertEquals(h[3] + offsetY * h[6], result[3], tolerance,
+            description + ": h[3] incorrect");
+        assertEquals(h[4] + offsetY * h[7], result[4], tolerance,
+            description + ": h[4] incorrect");
+        assertEquals(h[5] + offsetY * h[8], result[5], tolerance,
+            description + ": h[5] incorrect");
+
+        // Row 2: unchanged
+        assertEquals(h[6], result[6], tolerance, description + ": h[6] should be unchanged");
+        assertEquals(h[7], result[7], tolerance, description + ": h[7] should be unchanged");
+        assertEquals(h[8], result[8], tolerance, description + ": h[8] should be unchanged");
+
+        pipe.release();
+    }
+
+    /**
+     * Integration test: Verify that homography transformation produces consistent results
+     * when comparing full-frame detection vs ROI-based detection with transformation.
+     * This extends testCoordinateMappingAccuracy to also verify homography values.
+     */
+    @Test
+    public void testTransformHomography_Integration_HomographyProducesCorrectPoseInput() {
+        // Load a test image with a known AprilTag
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getApriltagImagePath(TestUtils.ApriltagTestImages.kTag1_640_480, false),
+                        TestUtils.WPI2020Image.FOV,
+                        TestUtils.get2020LifeCamCoeffs(false));
+
+        var frame = frameProvider.get();
+        Mat grayMat = frame.processedImage.getMat();
+
+        // First, run full-frame detection to get ground truth
+        AprilTagDetector fullFrameDetector = new AprilTagDetector();
+        fullFrameDetector.addFamily(AprilTagFamily.kTag36h11.getNativeName());
+
+        AprilTagDetection[] fullFrameDetections;
+        try {
+            fullFrameDetections = fullFrameDetector.detect(grayMat);
+        } catch (Exception e) {
+            assumeTrue(false, "Native AprilTag library not available: " + e.getMessage());
+            return;
+        }
+        assumeTrue(fullFrameDetections != null, "Native AprilTag detector returned null");
+        assumeTrue(fullFrameDetections.length > 0, "Should detect at least one tag in full frame");
+
+        AprilTagDetection groundTruth = fullFrameDetections[0];
+        double[] groundTruthHomography = groundTruth.getHomography();
+
+        // Create an ROI that contains the tag
+        double minX = Double.MAX_VALUE, maxX = Double.MIN_VALUE;
+        double minY = Double.MAX_VALUE, maxY = Double.MIN_VALUE;
+        for (int i = 0; i < 4; i++) {
+            minX = Math.min(minX, groundTruth.getCornerX(i));
+            maxX = Math.max(maxX, groundTruth.getCornerX(i));
+            minY = Math.min(minY, groundTruth.getCornerY(i));
+            maxY = Math.max(maxY, groundTruth.getCornerY(i));
+        }
+
+        double padding = 20;
+        Rect2d simulatedMLBbox =
+                new Rect2d(minX - padding, minY - padding, maxX - minX + 2 * padding, maxY - minY + 2 * padding);
+
+        // Run the ROI decode pipe
+        AprilTagROIDecodePipe decodePipe = new AprilTagROIDecodePipe();
+
+        ROIDecodeParams params = new ROIDecodeParams();
+        params.tagFamily = AprilTagFamily.kTag36h11;
+        params.maxHammingDistance = 0;
+        params.minDecisionMargin = 35;
+        decodePipe.setParams(params);
+
+        List<Rect2d> rois = new ArrayList<>();
+        rois.add(simulatedMLBbox);
+
+        ROIDecodeInput input = new ROIDecodeInput(frame.processedImage, rois);
+        var result = decodePipe.run(input);
+
+        List<AprilTagDetection> roiDetections = result.output;
+        assertEquals(1, roiDetections.size(), "Should detect exactly one tag in ROI");
+
+        AprilTagDetection mappedDetection = roiDetections.get(0);
+        double[] mappedHomography = mappedDetection.getHomography();
+
+        // Verify that the transformed homography produces the same point projections
+        // as the ground truth homography for the tag corners
+        double tolerance = 1.0; // Allow 1 pixel tolerance due to subpixel differences
+
+        // Test projection of normalized tag corners
+        double[][] tagCorners = {{-1, -1}, {1, -1}, {1, 1}, {-1, 1}};
+        for (int i = 0; i < 4; i++) {
+            double[] gtProjected = projectPoint(groundTruthHomography, tagCorners[i][0], tagCorners[i][1]);
+            double[] mappedProjected = projectPoint(mappedHomography, tagCorners[i][0], tagCorners[i][1]);
+
+            assertEquals(gtProjected[0], mappedProjected[0], tolerance,
+                "Corner " + i + " X projection should match");
+            assertEquals(gtProjected[1], mappedProjected[1], tolerance,
+                "Corner " + i + " Y projection should match");
+        }
+
+        fullFrameDetector.close();
+        decodePipe.release();
+    }
+
+    // ==================== ATR (Adaptive Tag Resizing) Tests ====================
+
+    /**
+     * Helper method to access the private transformHomographyWithScale method via reflection.
+     */
+    private double[] invokeTransformHomographyWithScale(AprilTagROIDecodePipe pipe,
+            double[] h, int offsetX, int offsetY, double S) throws Exception {
+        Method method = AprilTagROIDecodePipe.class.getDeclaredMethod(
+            "transformHomographyWithScale", double[].class, int.class, int.class, double.class);
+        method.setAccessible(true);
+        return (double[]) method.invoke(pipe, h, offsetX, offsetY, S);
+    }
+
+    /**
+     * Test ATR scale factor calculation: S = min(1.0, T_dim / w)
+     * Verifies the formula produces correct values for various ROI widths.
+     */
+    @Test
+    public void testATR_ScaleFactorCalculation() {
+        int targetDimension = 160;
+
+        // Small tag (w < T_dim): S = 1.0 (no scaling)
+        double S1 = Math.min(1.0, (double) targetDimension / 100);
+        assertEquals(1.0, S1, 1e-10, "Small tag should have S=1.0");
+
+        // Exact match (w == T_dim): S = 1.0
+        double S2 = Math.min(1.0, (double) targetDimension / 160);
+        assertEquals(1.0, S2, 1e-10, "Exact match should have S=1.0");
+
+        // Large tag (w > T_dim): S < 1.0
+        double S3 = Math.min(1.0, (double) targetDimension / 320);
+        assertEquals(0.5, S3, 1e-10, "320px tag should have S=0.5");
+
+        // Very large tag
+        double S4 = Math.min(1.0, (double) targetDimension / 800);
+        assertEquals(0.2, S4, 1e-10, "800px tag should have S=0.2");
+
+        // 1000px tag (from documentation example)
+        double S5 = Math.min(1.0, (double) targetDimension / 1000);
+        assertEquals(0.16, S5, 1e-10, "1000px tag should have S=0.16");
+    }
+
+    /**
+     * Test ATR coordinate mapping: x_full = (x_scaled / S) + roi_x
+     * Verifies corner coordinates are correctly mapped from scaled space to full-frame.
+     */
+    @Test
+    public void testATR_CoordinateMappingWithScale() {
+        // Simulated scaled detection at (40, 30) in a 160x160 scaled ROI
+        // Original ROI at (100, 150) with width 400 (S = 0.4)
+        double scaledX = 40.0;
+        double scaledY = 30.0;
+        double S = 0.4;
+        int roiX = 100;
+        int roiY = 150;
+
+        // Expected: x_full = (40 / 0.4) + 100 = 100 + 100 = 200
+        //           y_full = (30 / 0.4) + 150 = 75 + 150 = 225
+        double expectedX = (scaledX / S) + roiX;
+        double expectedY = (scaledY / S) + roiY;
+
+        assertEquals(200.0, expectedX, 1e-10, "X coordinate mapping incorrect");
+        assertEquals(225.0, expectedY, 1e-10, "Y coordinate mapping incorrect");
+    }
+
+    /**
+     * Test that transformHomographyWithScale with S=1.0 produces same result as transformHomography.
+     */
+    @Test
+    public void testATR_TransformHomographyWithScale_NoScaling_MatchesOriginal() throws Exception {
+        AprilTagROIDecodePipe pipe = new AprilTagROIDecodePipe();
+
+        double[] h = {0.9, 0.1, 50.0, -0.1, 0.9, 60.0, 0.001, 0.002, 1.0};
+        int offsetX = 100;
+        int offsetY = 150;
+        double S = 1.0; // No scaling
+
+        double[] resultWithScale = invokeTransformHomographyWithScale(pipe, h, offsetX, offsetY, S);
+        double[] resultOriginal = invokeTransformHomography(pipe, h, offsetX, offsetY);
+
+        double tolerance = 1e-10;
+        for (int i = 0; i < 9; i++) {
+            assertEquals(resultOriginal[i], resultWithScale[i], tolerance,
+                "Element " + i + " should match original transform when S=1.0");
+        }
+
+        pipe.release();
+    }
+
+    /**
+     * Test homography transformation with scaling: H_full = T * S_inv * H_scaled
+     * Verifies the combined scale+translation transformation is mathematically correct.
+     */
+    @Test
+    public void testATR_TransformHomographyWithScale_Computation() throws Exception {
+        AprilTagROIDecodePipe pipe = new AprilTagROIDecodePipe();
+
+        // Input homography (in scaled ROI space)
+        double[] h = {0.5, 0.0, 40.0, 0.0, 0.5, 30.0, 0.0, 0.0, 1.0};
+        int offsetX = 100;
+        int offsetY = 150;
+        double S = 0.5; // ROI was downscaled by 50%
+        double invS = 1.0 / S; // = 2.0
+
+        double[] result = invokeTransformHomographyWithScale(pipe, h, offsetX, offsetY, S);
+
+        double tolerance = 1e-10;
+
+        // Expected formula: Row 0: H[i]/S + offsetX * H[6+j]
+        // result[0] = 0.5 * 2 + 100 * 0 = 1.0
+        assertEquals(h[0] * invS + offsetX * h[6], result[0], tolerance, "h[0] incorrect");
+        // result[1] = 0.0 * 2 + 100 * 0 = 0.0
+        assertEquals(h[1] * invS + offsetX * h[7], result[1], tolerance, "h[1] incorrect");
+        // result[2] = 40.0 * 2 + 100 * 1 = 80 + 100 = 180
+        assertEquals(h[2] * invS + offsetX * h[8], result[2], tolerance, "h[2] incorrect");
+
+        // Expected formula: Row 1: H[i]/S + offsetY * H[6+j]
+        // result[3] = 0.0 * 2 + 150 * 0 = 0.0
+        assertEquals(h[3] * invS + offsetY * h[6], result[3], tolerance, "h[3] incorrect");
+        // result[4] = 0.5 * 2 + 150 * 0 = 1.0
+        assertEquals(h[4] * invS + offsetY * h[7], result[4], tolerance, "h[4] incorrect");
+        // result[5] = 30.0 * 2 + 150 * 1 = 60 + 150 = 210
+        assertEquals(h[5] * invS + offsetY * h[8], result[5], tolerance, "h[5] incorrect");
+
+        // Row 2: unchanged
+        assertEquals(h[6], result[6], tolerance, "h[6] should be unchanged");
+        assertEquals(h[7], result[7], tolerance, "h[7] should be unchanged");
+        assertEquals(h[8], result[8], tolerance, "h[8] should be unchanged");
+
+        pipe.release();
+    }
+
+    /**
+     * Test point mapping consistency with ATR scaling.
+     * For a point p: project(H_scaled, p) -> scale up -> translate == project(H_full, p)
+     */
+    @Test
+    public void testATR_TransformHomographyWithScale_PointMappingConsistency() throws Exception {
+        AprilTagROIDecodePipe pipe = new AprilTagROIDecodePipe();
+
+        // A homography in scaled ROI space
+        double[] hScaled = {0.8, 0.05, 35.0, -0.03, 0.85, 40.0, 0.0002, 0.0001, 1.0};
+        int offsetX = 200;
+        int offsetY = 150;
+        double S = 0.4; // 40% scale (large tag was downscaled)
+        double invS = 1.0 / S;
+
+        double[] hFull = invokeTransformHomographyWithScale(pipe, hScaled, offsetX, offsetY, S);
+
+        // Test points (normalized tag corners)
+        double[][] testPoints = {
+            {-1.0, -1.0}, {1.0, -1.0}, {1.0, 1.0}, {-1.0, 1.0}, {0.0, 0.0}
+        };
+
+        double tolerance = 1e-10;
+        for (double[] point : testPoints) {
+            // Project with scaled homography, then scale up and translate
+            double[] scaledProjected = projectPoint(hScaled, point[0], point[1]);
+            double scaledFullX = scaledProjected[0] * invS + offsetX;
+            double scaledFullY = scaledProjected[1] * invS + offsetY;
+
+            // Project with full-frame homography
+            double[] fullProjected = projectPoint(hFull, point[0], point[1]);
+
+            assertEquals(scaledFullX, fullProjected[0], tolerance,
+                "X coordinate mismatch for point (" + point[0] + ", " + point[1] + ")");
+            assertEquals(scaledFullY, fullProjected[1], tolerance,
+                "Y coordinate mismatch for point (" + point[0] + ", " + point[1] + ")");
+        }
+
+        pipe.release();
+    }
+
+    /**
+     * Test ATR with minimum scale factor clamping.
+     * Verifies that extreme downscaling is prevented.
+     */
+    @Test
+    public void testATR_MinScaleFactorClamping() {
+        int targetDimension = 160;
+        double minScaleFactor = 0.25;
+
+        // Very large tag that would require extreme scaling
+        int tagWidth = 2000;
+        double S = Math.min(1.0, (double) targetDimension / tagWidth); // = 0.08
+        S = Math.max(S, minScaleFactor); // Clamp to 0.25
+
+        assertEquals(0.25, S, 1e-10, "Scale factor should be clamped to minimum");
+    }
+
+    /**
+     * Test ATR enabled vs disabled produces consistent results for small tags.
+     * When tag is smaller than target dimension, ATR should have no effect.
+     */
+    @Test
+    public void testATR_DisabledMatchesOriginalBehavior() {
+        // Load a test image with a known AprilTag
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getApriltagImagePath(TestUtils.ApriltagTestImages.kTag1_640_480, false),
+                        TestUtils.WPI2020Image.FOV,
+                        TestUtils.get2020LifeCamCoeffs(false));
+
+        var frame = frameProvider.get();
+        Mat grayMat = frame.processedImage.getMat();
+
+        // First, run full-frame detection to find the tag location
+        AprilTagDetector fullFrameDetector = new AprilTagDetector();
+        fullFrameDetector.addFamily(AprilTagFamily.kTag36h11.getNativeName());
+
+        AprilTagDetection[] fullFrameDetections;
+        try {
+            fullFrameDetections = fullFrameDetector.detect(grayMat);
+        } catch (Exception e) {
+            assumeTrue(false, "Native AprilTag library not available");
+            return;
+        }
+        assumeTrue(fullFrameDetections != null && fullFrameDetections.length > 0);
+
+        AprilTagDetection groundTruth = fullFrameDetections[0];
+
+        // Create an ROI around the tag
+        double minX = Double.MAX_VALUE, maxX = Double.MIN_VALUE;
+        double minY = Double.MAX_VALUE, maxY = Double.MIN_VALUE;
+        for (int i = 0; i < 4; i++) {
+            minX = Math.min(minX, groundTruth.getCornerX(i));
+            maxX = Math.max(maxX, groundTruth.getCornerX(i));
+            minY = Math.min(minY, groundTruth.getCornerY(i));
+            maxY = Math.max(maxY, groundTruth.getCornerY(i));
+        }
+
+        double padding = 20;
+        Rect2d simulatedMLBbox =
+                new Rect2d(minX - padding, minY - padding, maxX - minX + 2 * padding, maxY - minY + 2 * padding);
+
+        // Run with ATR enabled (should not scale since tag is small)
+        AprilTagROIDecodePipe pipeWithATR = new AprilTagROIDecodePipe();
+        ROIDecodeParams paramsWithATR = new ROIDecodeParams();
+        paramsWithATR.tagFamily = AprilTagFamily.kTag36h11;
+        paramsWithATR.atrEnabled = true;
+        paramsWithATR.atrTargetDimension = 160; // Tag in test image is ~100px, so no scaling
+        pipeWithATR.setParams(paramsWithATR);
+
+        // Run with ATR disabled
+        AprilTagROIDecodePipe pipeWithoutATR = new AprilTagROIDecodePipe();
+        ROIDecodeParams paramsWithoutATR = new ROIDecodeParams();
+        paramsWithoutATR.tagFamily = AprilTagFamily.kTag36h11;
+        paramsWithoutATR.atrEnabled = false;
+        pipeWithoutATR.setParams(paramsWithoutATR);
+
+        List<Rect2d> rois = new ArrayList<>();
+        rois.add(simulatedMLBbox);
+
+        ROIDecodeInput input = new ROIDecodeInput(frame.processedImage, rois);
+
+        var resultWithATR = pipeWithATR.run(input);
+        var resultWithoutATR = pipeWithoutATR.run(input);
+
+        // Both should detect the same tag with same corners (within tolerance)
+        assertEquals(resultWithATR.output.size(), resultWithoutATR.output.size(),
+            "Same number of detections expected");
+
+        if (!resultWithATR.output.isEmpty() && !resultWithoutATR.output.isEmpty()) {
+            AprilTagDetection detWithATR = resultWithATR.output.get(0);
+            AprilTagDetection detWithoutATR = resultWithoutATR.output.get(0);
+
+            double tolerance = 0.5;
+            for (int i = 0; i < 4; i++) {
+                assertEquals(detWithATR.getCornerX(i), detWithoutATR.getCornerX(i), tolerance,
+                    "Corner " + i + " X should match with/without ATR for small tag");
+                assertEquals(detWithATR.getCornerY(i), detWithoutATR.getCornerY(i), tolerance,
+                    "Corner " + i + " Y should match with/without ATR for small tag");
+            }
+        }
+
+        fullFrameDetector.close();
+        pipeWithATR.release();
+        pipeWithoutATR.release();
+    }
+
+    /**
+     * Test computeHomographyFromCorners produces a valid homography.
+     * Verifies that the computed homography maps normalized tag coords to corners.
+     */
+    @Test
+    public void testATR_ComputeHomographyFromCorners() throws Exception {
+        AprilTagROIDecodePipe pipe = new AprilTagROIDecodePipe();
+        ROIDecodeParams params = new ROIDecodeParams();
+        params.tagFamily = AprilTagFamily.kTag36h11;
+        pipe.setParams(params);
+
+        // Access the private method via reflection
+        Method method = AprilTagROIDecodePipe.class.getDeclaredMethod(
+            "computeHomographyFromCorners", org.opencv.core.Point[].class);
+        method.setAccessible(true);
+
+        // Define test corners (a simple quadrilateral)
+        org.opencv.core.Point[] corners = new org.opencv.core.Point[] {
+            new org.opencv.core.Point(100, 100),  // Corner 0: maps from (-1, -1)
+            new org.opencv.core.Point(200, 100),  // Corner 1: maps from ( 1, -1)
+            new org.opencv.core.Point(200, 200),  // Corner 2: maps from ( 1,  1)
+            new org.opencv.core.Point(100, 200)   // Corner 3: maps from (-1,  1)
+        };
+
+        double[] homography = (double[]) method.invoke(pipe, (Object) corners);
+
+        assertNotNull(homography, "Homography should not be null");
+        assertEquals(9, homography.length, "Homography should have 9 elements");
+
+        // Verify the homography maps normalized coords to corners
+        double tolerance = 1.0; // Allow 1 pixel tolerance
+
+        // Test corner 0: (-1, -1) -> (100, 100)
+        double[] projected0 = projectPoint(homography, -1, -1);
+        assertEquals(100.0, projected0[0], tolerance, "Corner 0 X projection incorrect");
+        assertEquals(100.0, projected0[1], tolerance, "Corner 0 Y projection incorrect");
+
+        // Test corner 1: (1, -1) -> (200, 100)
+        double[] projected1 = projectPoint(homography, 1, -1);
+        assertEquals(200.0, projected1[0], tolerance, "Corner 1 X projection incorrect");
+        assertEquals(100.0, projected1[1], tolerance, "Corner 1 Y projection incorrect");
+
+        // Test corner 2: (1, 1) -> (200, 200)
+        double[] projected2 = projectPoint(homography, 1, 1);
+        assertEquals(200.0, projected2[0], tolerance, "Corner 2 X projection incorrect");
+        assertEquals(200.0, projected2[1], tolerance, "Corner 2 Y projection incorrect");
+
+        // Test corner 3: (-1, 1) -> (100, 200)
+        double[] projected3 = projectPoint(homography, -1, 1);
+        assertEquals(100.0, projected3[0], tolerance, "Corner 3 X projection incorrect");
+        assertEquals(200.0, projected3[1], tolerance, "Corner 3 Y projection incorrect");
+
+        pipe.release();
+    }
+}
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/AprilTagMLPipelineIntegrationTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/AprilTagMLPipelineIntegrationTest.java
new file mode 100644
index 0000000000..5b16868def
--- /dev/null
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/AprilTagMLPipelineIntegrationTest.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipeline;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.photonvision.common.LoadJNI;
+import org.photonvision.common.configuration.ConfigManager;
+import org.photonvision.common.util.TestUtils;
+import org.photonvision.vision.apriltag.AprilTagFamily;
+import org.photonvision.vision.camera.QuirkyCamera;
+import org.photonvision.vision.frame.provider.FileFrameProvider;
+import org.photonvision.vision.pipeline.result.CVPipelineResult;
+import org.photonvision.vision.target.TargetModel;
+
+/**
+ * Integration tests for the ML-assisted AprilTag detection pipeline. These tests verify that when
+ * ML detection is enabled but not available (e.g., on test platforms without NPU), the pipeline
+ * correctly falls back to traditional detection.
+ */
+public class AprilTagMLPipelineIntegrationTest {
+
+    @BeforeEach
+    public void setup() {
+        LoadJNI.loadLibraries();
+        ConfigManager.getInstance().load();
+    }
+
+    /**
+     * Test that ML settings are properly handled in pipeline settings. Verifies equals works
+     * correctly with new ML fields.
+     */
+    @Test
+    public void testMLSettingsEquality() {
+        var settings1 = new AprilTagPipelineSettings();
+        var settings2 = new AprilTagPipelineSettings();
+
+        // Both should be equal initially
+        assertEquals(settings1, settings2);
+
+        // Change ML setting
+        settings1.useMLDetection = true;
+        assertNotEquals(settings1, settings2);
+
+        settings2.useMLDetection = true;
+        assertEquals(settings1, settings2);
+
+        // Change threshold
+        settings1.mlConfidenceThreshold = 0.7;
+        assertNotEquals(settings1, settings2);
+
+        settings2.mlConfidenceThreshold = 0.7;
+        assertEquals(settings1, settings2);
+
+        // Change model name
+        settings1.mlModelName = "custom-model";
+        assertNotEquals(settings1, settings2);
+
+        settings2.mlModelName = "custom-model";
+        assertEquals(settings1, settings2);
+    }
+
+    /**
+     * Test that the pipeline falls back to traditional detection when ML is enabled but not
+     * available. This test runs on a platform without NPU support.
+     */
+    @Test
+    public void testFallbackWhenMLUnavailable() {
+        var pipeline = new AprilTagPipeline();
+
+        // Enable ML detection - should fall back on test platform
+        pipeline.getSettings().useMLDetection = true;
+        pipeline.getSettings().mlFallbackToTraditional = true;
+        pipeline.getSettings().inputShouldShow = true;
+        pipeline.getSettings().outputShouldDraw = true;
+        pipeline.getSettings().solvePNPEnabled = true;
+        pipeline.getSettings().targetModel = TargetModel.kAprilTag6p5in_36h11;
+        pipeline.getSettings().tagFamily = AprilTagFamily.kTag36h11;
+
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getApriltagImagePath(TestUtils.ApriltagTestImages.kTag1_640_480, false),
+                        TestUtils.WPI2020Image.FOV,
+                        TestUtils.get2020LifeCamCoeffs(false));
+        frameProvider.requestFrameThresholdType(pipeline.getThresholdType());
+
+        CVPipelineResult pipelineResult = pipeline.run(frameProvider.get(), QuirkyCamera.DefaultCamera);
+
+        // Should still detect the tag via fallback
+        assertFalse(pipelineResult.targets.isEmpty(), "Should detect tag via fallback");
+        assertEquals(1, pipelineResult.targets.size(), "Should detect exactly one tag");
+
+        // Verify tag ID
+        var target = pipelineResult.targets.get(0);
+        assertEquals(1, target.getFiducialId(), "Should detect tag ID 1");
+
+        pipeline.release();
+    }
+
+    /**
+     * Test that traditional detection still works when ML is disabled. This ensures the existing
+     * pipeline behavior is unchanged.
+     */
+    @Test
+    public void testTraditionalDetectionWhenMLDisabled() {
+        var pipeline = new AprilTagPipeline();
+
+        // Explicitly disable ML detection
+        pipeline.getSettings().useMLDetection = false;
+        pipeline.getSettings().inputShouldShow = true;
+        pipeline.getSettings().outputShouldDraw = true;
+        pipeline.getSettings().solvePNPEnabled = true;
+        pipeline.getSettings().targetModel = TargetModel.kAprilTag6p5in_36h11;
+        pipeline.getSettings().tagFamily = AprilTagFamily.kTag36h11;
+
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getApriltagImagePath(TestUtils.ApriltagTestImages.kTag1_640_480, false),
+                        TestUtils.WPI2020Image.FOV,
+                        TestUtils.get2020LifeCamCoeffs(false));
+        frameProvider.requestFrameThresholdType(pipeline.getThresholdType());
+
+        CVPipelineResult pipelineResult = pipeline.run(frameProvider.get(), QuirkyCamera.DefaultCamera);
+
+        // Should detect the tag
+        assertFalse(pipelineResult.targets.isEmpty(), "Should detect tag with traditional detection");
+        assertEquals(1, pipelineResult.targets.size(), "Should detect exactly one tag");
+
+        // Verify pose estimation works
+        var target = pipelineResult.targets.get(0);
+        var pose = target.getBestCameraToTarget3d();
+        assertNotNull(pose, "Pose should be estimated");
+
+        // Known approximate values from existing tests
+        assertEquals(2, pose.getTranslation().getX(), 0.3, "X translation should be approximately 2m");
+
+        pipeline.release();
+    }
+
+    /**
+     * Test that ML settings don't interfere with multi-tag detection. Verifies that multi-target
+     * settings still work when ML is enabled but unavailable.
+     */
+    @Test
+    public void testMultiTagWithMLEnabled() {
+        var pipeline = new AprilTagPipeline();
+
+        pipeline.getSettings().useMLDetection = true;
+        pipeline.getSettings().mlFallbackToTraditional = true;
+        pipeline.getSettings().doMultiTarget = true;
+        pipeline.getSettings().solvePNPEnabled = true;
+        pipeline.getSettings().targetModel = TargetModel.kAprilTag6p5in_36h11;
+        pipeline.getSettings().tagFamily = AprilTagFamily.kTag36h11;
+
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getApriltagImagePath(TestUtils.ApriltagTestImages.kTag1_640_480, false),
+                        TestUtils.WPI2020Image.FOV,
+                        TestUtils.get2020LifeCamCoeffs(false));
+        frameProvider.requestFrameThresholdType(pipeline.getThresholdType());
+
+        CVPipelineResult pipelineResult = pipeline.run(frameProvider.get(), QuirkyCamera.DefaultCamera);
+
+        // Should still work with multi-tag enabled
+        assertNotNull(pipelineResult, "Pipeline result should not be null");
+
+        pipeline.release();
+    }
+
+    /** Test that changing ML settings triggers proper reconfiguration. */
+    @Test
+    public void testMLSettingsReconfiguration() {
+        var pipeline = new AprilTagPipeline();
+
+        // Start with ML disabled
+        pipeline.getSettings().useMLDetection = false;
+        pipeline.getSettings().tagFamily = AprilTagFamily.kTag36h11;
+
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getApriltagImagePath(TestUtils.ApriltagTestImages.kTag1_640_480, false),
+                        TestUtils.WPI2020Image.FOV,
+                        TestUtils.get2020LifeCamCoeffs(false));
+        frameProvider.requestFrameThresholdType(pipeline.getThresholdType());
+
+        // Run once with ML disabled
+        CVPipelineResult result1 = pipeline.run(frameProvider.get(), QuirkyCamera.DefaultCamera);
+        assertFalse(result1.targets.isEmpty(), "Should detect tag with ML disabled");
+
+        // Enable ML (will fallback on test platform)
+        pipeline.getSettings().useMLDetection = true;
+        pipeline.getSettings().mlFallbackToTraditional = true;
+
+        // Run again with ML enabled (will use fallback)
+        CVPipelineResult result2 = pipeline.run(frameProvider.get(), QuirkyCamera.DefaultCamera);
+        assertFalse(result2.targets.isEmpty(), "Should detect tag with ML enabled (fallback)");
+
+        // Disable ML again
+        pipeline.getSettings().useMLDetection = false;
+
+        CVPipelineResult result3 = pipeline.run(frameProvider.get(), QuirkyCamera.DefaultCamera);
+        assertFalse(result3.targets.isEmpty(), "Should detect tag after disabling ML");
+
+        pipeline.release();
+    }
+}
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/AprilTagTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/AprilTagTest.java
index 1a6cff75c7..c69ffad1dd 100644
--- a/photon-core/src/test/java/org/photonvision/vision/pipeline/AprilTagTest.java
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/AprilTagTest.java
@@ -137,4 +137,31 @@ public void testApriltagDistorted() {
         assertEquals(2, pose.getTranslation().getY(), 0.2);
         assertEquals(0.0, pose.getTranslation().getZ(), 0.2);
     }
+
+    @Test
+    public void testManyDetections() {
+        // Given a 36h11 pipeline
+        var pipeline = new AprilTagPipeline();
+        pipeline.getSettings().inputShouldShow = true;
+        pipeline.getSettings().outputShouldDraw = true;
+        pipeline.getSettings().solvePNPEnabled = true;
+        pipeline.getSettings().cornerDetectionAccuracyPercentage = 4;
+        pipeline.getSettings().cornerDetectionUseConvexHulls = true;
+        pipeline.getSettings().tagFamily = AprilTagFamily.kTag36h11;
+        pipeline.getSettings().outputMaximumTargets = 3; // bogus
+
+        // when we have a picture with 280 targets
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getApriltagImagePath(TestUtils.ApriltagTestImages.k36h11_stress_test, false),
+                        TestUtils.WPI2020Image.FOV,
+                        TestUtils.getCoeffs(TestUtils.LIMELIGHT_480P_CAL_FILE, false));
+        frameProvider.requestFrameThresholdType(pipeline.getThresholdType());
+
+        CVPipelineResult pipelineResult;
+        pipelineResult = pipeline.run(frameProvider.get(), QuirkyCamera.DefaultCamera);
+
+        // the pipeline will only give us Byte.MAX_VALUE many
+        assertEquals(Byte.MAX_VALUE, pipelineResult.targets.size());
+    }
 }
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/CirclePNPTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/CirclePNPTest.java
index f801d6507b..3e206ebba9 100644
--- a/photon-core/src/test/java/org/photonvision/vision/pipeline/CirclePNPTest.java
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/CirclePNPTest.java
@@ -94,7 +94,7 @@ public void testCircle() {
         pipeline.getSettings().cameraCalibration = getCoeffs(LIFECAM_480P_CAL_FILE);
         pipeline.getSettings().targetModel = TargetModel.kCircularPowerCell7in;
         pipeline.getSettings().outputShouldDraw = true;
-        pipeline.getSettings().outputShowMultipleTargets = false;
+        pipeline.getSettings().outputMaximumTargets = 20;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Single;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
         pipeline.getSettings().contourShape = ContourShape.Circle;
@@ -144,7 +144,7 @@ public static void main(String[] args) {
         settings.hsvSaturation.set(100, 255);
         settings.hsvValue.set(190, 255);
         settings.outputShouldDraw = true;
-        settings.outputShowMultipleTargets = true;
+        settings.outputMaximumTargets = 20;
         settings.contourGroupingMode = ContourGroupingMode.Dual;
         settings.contourIntersection = ContourIntersectionDirection.Up;
 
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/ColoredShapePipelineTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/ColoredShapePipelineTest.java
index 9722ff1411..63fe4266e3 100644
--- a/photon-core/src/test/java/org/photonvision/vision/pipeline/ColoredShapePipelineTest.java
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/ColoredShapePipelineTest.java
@@ -102,7 +102,7 @@ public static void main(String[] args) {
         settings.hsvSaturation.set(100, 255);
         settings.hsvValue.set(100, 255);
         settings.outputShouldDraw = true;
-        settings.outputShowMultipleTargets = true;
+        settings.outputMaximumTargets = 20;
         settings.contourGroupingMode = ContourGroupingMode.Single;
         settings.contourIntersection = ContourIntersectionDirection.Up;
         settings.contourShape = ContourShape.Triangle;
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/MaxDetectionsTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/MaxDetectionsTest.java
new file mode 100644
index 0000000000..02627e0088
--- /dev/null
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/MaxDetectionsTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipeline;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.file.Path;
+import org.junit.jupiter.api.Test;
+import org.photonvision.common.LoadJNI;
+import org.photonvision.common.configuration.ConfigManager;
+import org.photonvision.common.util.TestUtils;
+import org.photonvision.vision.camera.QuirkyCamera;
+import org.photonvision.vision.frame.provider.FileFrameProvider;
+import org.photonvision.vision.opencv.ContourShape;
+import org.photonvision.vision.pipe.impl.HSVPipe;
+import org.photonvision.vision.pipeline.result.CVPipelineResult;
+
+public class MaxDetectionsTest {
+    @Test
+    public void testMaxDetections() {
+        LoadJNI.loadLibraries();
+        ConfigManager.getInstance().load();
+
+        ColoredShapePipeline pipeline = new ColoredShapePipeline();
+
+        pipeline.settings.contourShape = ContourShape.Circle;
+        pipeline.settings.hsvHue.set(140, 160);
+        pipeline.settings.hsvSaturation.set(226, 246);
+        pipeline.settings.hsvValue.set(188, 208);
+        pipeline.settings.maxCannyThresh = 90;
+        pipeline.settings.circleAccuracy = 20;
+        pipeline.settings.circleDetectThreshold = 5;
+
+        Path path =
+                TestUtils.getResourcesFolderPath(false).resolve("testimages/polygons/ColoredShapeTest.png");
+
+        var frameProvider = new FileFrameProvider(path, TestUtils.WPI2019Image.FOV);
+
+        // VisionRunner normally does this
+        var hsvParams =
+                new HSVPipe.HSVParams(
+                        pipeline.getSettings().hsvHue,
+                        pipeline.getSettings().hsvSaturation,
+                        pipeline.getSettings().hsvValue,
+                        pipeline.getSettings().hueInverted);
+        frameProvider.requestHsvSettings(hsvParams);
+        frameProvider.requestFrameThresholdType(pipeline.getThresholdType());
+
+        CVPipelineResult result = pipeline.run(frameProvider.get(), QuirkyCamera.DefaultCamera);
+        TestUtils.showImage(result.inputAndOutputFrame.processedImage.getMat(), "Max Detections Test");
+
+        assertEquals(20, result.targets.size());
+
+        pipeline.settings.outputMaximumTargets = 5;
+        result = pipeline.run(frameProvider.get(), QuirkyCamera.DefaultCamera);
+        assertEquals(5, result.targets.size());
+
+        pipeline.settings.outputMaximumTargets = 50;
+        result = pipeline.run(frameProvider.get(), QuirkyCamera.DefaultCamera);
+        // 24 circles, but we only detect 22
+        assertEquals(22, result.targets.size());
+    }
+}
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/ReflectivePipelineTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/ReflectivePipelineTest.java
index 6427a8636c..c30248a9b6 100644
--- a/photon-core/src/test/java/org/photonvision/vision/pipeline/ReflectivePipelineTest.java
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/ReflectivePipelineTest.java
@@ -41,7 +41,7 @@ public void test2019() {
         pipeline.getSettings().hsvSaturation.set(100, 255);
         pipeline.getSettings().hsvValue.set(190, 255);
         pipeline.getSettings().outputShouldDraw = true;
-        pipeline.getSettings().outputShowMultipleTargets = true;
+        pipeline.getSettings().outputMaximumTargets = 20;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Dual;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
 
@@ -120,7 +120,7 @@ public static void main(String[] args) {
         settings.hsvSaturation.set(100, 255);
         settings.hsvValue.set(190, 255);
         settings.outputShouldDraw = true;
-        settings.outputShowMultipleTargets = true;
+        settings.outputMaximumTargets = 20;
         settings.contourGroupingMode = ContourGroupingMode.Dual;
         settings.contourIntersection = ContourIntersectionDirection.Up;
 
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/SolvePNPTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/SolvePNPTest.java
index 3d7b4f0146..df3c6daa95 100644
--- a/photon-core/src/test/java/org/photonvision/vision/pipeline/SolvePNPTest.java
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/SolvePNPTest.java
@@ -89,7 +89,6 @@ public void test2019() {
         pipeline.getSettings().hsvSaturation.set(100, 255);
         pipeline.getSettings().hsvValue.set(190, 255);
         pipeline.getSettings().outputShouldDraw = true;
-        pipeline.getSettings().outputShowMultipleTargets = true;
         pipeline.getSettings().solvePNPEnabled = true;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Dual;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
@@ -225,7 +224,6 @@ public static void main(String[] args) {
         settings.hsvSaturation.set(100, 255);
         settings.hsvValue.set(190, 255);
         settings.outputShouldDraw = true;
-        settings.outputShowMultipleTargets = true;
         settings.contourGroupingMode = ContourGroupingMode.Dual;
         settings.contourIntersection = ContourIntersectionDirection.Up;
 
diff --git a/photon-server/src/main/resources/models/apriltag-640-640-yolov8n.tflite b/photon-server/src/main/resources/models/apriltag-640-640-yolov8n.tflite
new file mode 100644
index 0000000000..ea53f5dfa5
Binary files /dev/null and b/photon-server/src/main/resources/models/apriltag-640-640-yolov8n.tflite differ
diff --git a/photon-targeting/src/main/java/org/photonvision/common/dataflow/structures/Packet.java b/photon-targeting/src/main/java/org/photonvision/common/dataflow/structures/Packet.java
index fc9e2d1079..590fd04b24 100644
--- a/photon-targeting/src/main/java/org/photonvision/common/dataflow/structures/Packet.java
+++ b/photon-targeting/src/main/java/org/photonvision/common/dataflow/structures/Packet.java
@@ -31,6 +31,8 @@ public class Packet {
     // Read and write positions.
     int readPos, writePos;
 
+    public static final int MAX_ARRAY_LEN = Byte.MAX_VALUE;
+
     /**
      * Constructs an empty packet. This buffer will dynamically expand if we need more data space.
      *
diff --git a/test-resources/old_configs/2025.3.1-old-nnmm/photon.sqlite b/test-resources/old_configs/2025.3.1-old-nnmm/photon.sqlite
index ad6e7212e8..50e75a2e04 100644
Binary files a/test-resources/old_configs/2025.3.1-old-nnmm/photon.sqlite and b/test-resources/old_configs/2025.3.1-old-nnmm/photon.sqlite differ
diff --git a/test-resources/testimages/apriltag/36h11_stress_test.png b/test-resources/testimages/apriltag/36h11_stress_test.png
new file mode 100644
index 0000000000..7c9dee1756
Binary files /dev/null and b/test-resources/testimages/apriltag/36h11_stress_test.png differ
diff --git a/test-resources/testimages/polygons/ColoredShapeTest.png b/test-resources/testimages/polygons/ColoredShapeTest.png
new file mode 100644
index 0000000000..f56444ef8b
Binary files /dev/null and b/test-resources/testimages/polygons/ColoredShapeTest.png differ