diff --git a/changelog.d/20250115_125619_sekachev.bs_updated_mil.md b/changelog.d/20250115_125619_sekachev.bs_updated_mil.md
new file mode 100644
index 000000000000..533a158df252
--- /dev/null
+++ b/changelog.d/20250115_125619_sekachev.bs_updated_mil.md
@@ -0,0 +1,4 @@
+### Changed
+
+- Enhanced MIL tracker. Optimized memory usage. Now it is runnable on many frames, and applicable to drawn rectangles.
+  (<https://github.com/cvat-ai/cvat/pull/8942>)
diff --git a/cvat-core/src/frames.ts b/cvat-core/src/frames.ts
index b772aca4ca4a..c611bd5cec0a 100644
--- a/cvat-core/src/frames.ts
+++ b/cvat-core/src/frames.ts
@@ -1,5 +1,5 @@
 // Copyright (C) 2021-2022 Intel Corporation
-// Copyright (C) 2022-2024 CVAT.ai Corporation
+// Copyright (C) 2022-2025 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -300,7 +300,11 @@ export class FrameData {
         );
     }
 
-    async data(onServerRequest = () => {}): Promise<ImageBitmap | Blob> {
+    async data(onServerRequest = () => {}): Promise<{
+        renderWidth: number;
+        renderHeight: number;
+        imageData: ImageBitmap | Blob;
+    }> {
         const result = await PluginRegistry.apiWrapper.call(this, FrameData.prototype.data, onServerRequest);
         return result;
     }
@@ -372,7 +376,7 @@ Object.defineProperty(FrameData.prototype.data, 'implementation', {
             renderWidth: number;
             renderHeight: number;
             imageData: ImageBitmap | Blob;
-        } | Blob>((resolve, reject) => {
+        }>((resolve, reject) => {
             const requestId = +_.uniqueId();
             const requestedDataFrameNumber = meta.getDataFrameNumber(this.number - jobStartFrame);
             const chunkIndex = meta.getFrameChunkIndex(requestedDataFrameNumber);
diff --git a/cvat-ui/src/components/annotation-page/annotations-actions/annotations-actions-modal.tsx b/cvat-ui/src/components/annotation-page/annotations-actions/annotations-actions-modal.tsx
index 509dd42b9b35..05723e21e4e1 100644
--- a/cvat-ui/src/components/annotation-page/annotations-actions/annotations-actions-modal.tsx
+++ b/cvat-ui/src/components/annotation-page/annotations-actions/annotations-actions-modal.tsx
@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2024 CVAT.ai Corporation
+// Copyright (C) 2023-2025 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -37,7 +37,6 @@ const core = getCore();
 interface State {
     actions: BaseAction[];
     activeAction: BaseAction | null;
-    initialized: boolean;
     fetching: boolean;
     progress: number | null;
     progressMessage: string | null;
@@ -50,7 +49,6 @@ interface State {
 }
 
 enum ReducerActionType {
-    SET_INITIALIZED = 'SET_INITIALIZED',
     SET_ANNOTATIONS_ACTIONS = 'SET_ANNOTATIONS_ACTIONS',
     SET_ACTIVE_ANNOTATIONS_ACTION = 'SET_ACTIVE_ANNOTATIONS_ACTION',
     UPDATE_PROGRESS = 'UPDATE_PROGRESS',
@@ -65,9 +63,6 @@ enum ReducerActionType {
 }
 
 export const reducerActions = {
-    setInitialized: (initialized: boolean) => (
-        createAction(ReducerActionType.SET_INITIALIZED, { initialized })
-    ),
     setAnnotationsActions: (actions: BaseAction[]) => (
         createAction(ReducerActionType.SET_ANNOTATIONS_ACTIONS, { actions })
     ),
@@ -105,7 +100,6 @@ export const reducerActions = {
 
 const defaultState = {
     actions: [],
-    initialized: false,
     fetching: false,
     activeAction: null,
     progress: null,
@@ -119,23 +113,13 @@ const defaultState = {
 };
 
 const reducer = (state: State = { ...defaultState }, action: ActionUnion<typeof reducerActions>): State => {
-    if (action.type === ReducerActionType.SET_INITIALIZED) {
-        return {
-            ...state,
-            initialized: action.payload.initialized,
-        };
-    }
-
     if (action.type === ReducerActionType.SET_ANNOTATIONS_ACTIONS) {
         const { actions } = action.payload;
-        const { targetObjectState } = state;
 
-        const filteredActions = targetObjectState ? actions
-            .filter((_action) => _action.isApplicableForObject(targetObjectState)) : actions;
         return {
             ...state,
             actions,
-            activeAction: filteredActions[0] ?? null,
+            activeAction: state.activeAction ?? actions[0] ?? null,
         };
     }
 
@@ -246,7 +230,6 @@ type ActionParameterProps = NonNullable<BaseAction['parameters']>[keyof BaseActi
 
 const componentStorage = createStore(reducer, {
     actions: [],
-    initialized: false,
     fetching: false,
     activeAction: null,
     progress: null,
@@ -319,15 +302,16 @@ function ActionParameterComponent(props: ActionParameterProps & { onChange: (val
 interface Props {
     onClose: () => void;
     targetObjectState?: ObjectState;
+    defaultAnnotationAction?: string;
 }
 
 function AnnotationsActionsModalContent(props: Props): JSX.Element {
-    const { onClose, targetObjectState: defaultTargetObjectState } = props;
+    const { onClose, targetObjectState: defaultTargetObjectState, defaultAnnotationAction } = props;
     const dispatch = useDispatch();
     const storage = getCVATStore();
     const cancellationRef = useRef<boolean>(false);
     const {
-        initialized, actions, activeAction, fetching, targetObjectState, cancelled,
+        actions, activeAction, fetching, targetObjectState, cancelled,
         progress, progressMessage, frameFrom, frameTo, actionParameters, modalVisible,
     } = useSelector((state: State) => ({ ...state }), shallowEqual);
 
@@ -337,20 +321,25 @@ function AnnotationsActionsModalContent(props: Props): JSX.Element {
     const currentFrameAction = activeAction instanceof BaseCollectionAction || targetObjectState !== null;
 
     useEffect(() => {
-        dispatch(reducerActions.setVisible(true));
-        dispatch(reducerActions.updateFrameFrom(jobInstance.startFrame));
-        dispatch(reducerActions.updateFrameTo(jobInstance.stopFrame));
-        dispatch(reducerActions.updateTargetObjectState(defaultTargetObjectState ?? null));
-    }, []);
+        core.actions.list().then((list: BaseAction[]) => {
+            dispatch(reducerActions.setAnnotationsActions(list));
+
+            if (defaultAnnotationAction) {
+                const defaultAction = list.find((action) => action.name === defaultAnnotationAction);
+                if (
+                    defaultAction &&
+                    (!defaultTargetObjectState || defaultAction.isApplicableForObject(defaultTargetObjectState))
+                ) {
+                    dispatch(reducerActions.setActiveAnnotationsAction(defaultAction));
+                }
+            }
 
-    useEffect(() => {
-        if (!initialized) {
-            core.actions.list().then((list: BaseAction[]) => {
-                dispatch(reducerActions.setAnnotationsActions(list));
-                dispatch(reducerActions.setInitialized(true));
-            });
-        }
-    }, [initialized]);
+            dispatch(reducerActions.setVisible(true));
+            dispatch(reducerActions.updateFrameFrom(jobInstance.startFrame));
+            dispatch(reducerActions.updateFrameTo(jobInstance.stopFrame));
+            dispatch(reducerActions.updateTargetObjectState(defaultTargetObjectState ?? null));
+        });
+    }, []);
 
     return (
         <Modal
@@ -643,14 +632,23 @@ function AnnotationsActionsModalContent(props: Props): JSX.Element {
 
 const MemoizedAnnotationsActionsModalContent = React.memo(AnnotationsActionsModalContent);
 
-export function openAnnotationsActionModal(objectState?: ObjectState): void {
+export function openAnnotationsActionModal({
+    defaultObjectState,
+    defaultAnnotationAction,
+}: {
+    defaultObjectState?: ObjectState,
+    defaultAnnotationAction?: string,
+} = {}): void {
+    window.document.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+
     const div = window.document.createElement('div');
     window.document.body.append(div);
     const root = createRoot(div);
     root.render(
         <Provider store={componentStorage}>
             <MemoizedAnnotationsActionsModalContent
-                targetObjectState={objectState}
+                targetObjectState={defaultObjectState}
+                defaultAnnotationAction={defaultAnnotationAction}
                 onClose={() => {
                     root.unmount();
                     div.remove();
diff --git a/cvat-ui/src/components/annotation-page/standard-workspace/controls-side-bar/opencv-control.tsx b/cvat-ui/src/components/annotation-page/standard-workspace/controls-side-bar/opencv-control.tsx
index 6a8f3b5fc968..98f7cc5e3ede 100644
--- a/cvat-ui/src/components/annotation-page/standard-workspace/controls-side-bar/opencv-control.tsx
+++ b/cvat-ui/src/components/annotation-page/standard-workspace/controls-side-bar/opencv-control.tsx
@@ -1,5 +1,5 @@
 // Copyright (C) 2021-2022 Intel Corporation
-// Copyright (C) 2023-2024 CVAT.ai Corporation
+// Copyright (C) 2023-2025 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -14,12 +14,13 @@ import Button from 'antd/lib/button';
 import Progress from 'antd/lib/progress';
 import Select from 'antd/lib/select';
 import notification from 'antd/lib/notification';
-import message from 'antd/lib/message';
+import Alert from 'antd/lib/alert';
+
 import { throttle } from 'lodash';
 
 import { OpenCVIcon } from 'icons';
 import { Canvas, convertShapesForInteractor } from 'cvat-canvas-wrapper';
-import { getCore, ObjectState } from 'cvat-core-wrapper';
+import { getCore, Job, ObjectState } from 'cvat-core-wrapper';
 import openCVWrapper from 'utils/opencv-wrapper/opencv-wrapper';
 import { IntelligentScissors } from 'utils/opencv-wrapper/intelligent-scissors';
 import {
@@ -27,27 +28,25 @@ import {
 } from 'reducers';
 import {
     interactWithCanvas,
-    fetchAnnotationsAsync,
     createAnnotationsAsync,
-    switchNavigationBlocked as switchNavigationBlockedAction,
 } from 'actions/annotation-actions';
 import LabelSelector from 'components/label-selector/label-selector';
 import CVATTooltip from 'components/common/cvat-tooltip';
 import ApproximationAccuracy, {
     thresholdFromAccuracy,
 } from 'components/annotation-page/standard-workspace/controls-side-bar/approximation-accuracy';
-import { OpenCVTracker, TrackerModel } from 'utils/opencv-wrapper/opencv-interfaces';
-import { enableImageFilter as enableImageFilterAction, disableImageFilter as disableImageFilterAction, switchToolsBlockerState } from 'actions/settings-actions';
+import { OpenCVTracker } from 'utils/opencv-wrapper/opencv-interfaces';
+import { enableImageFilter as enableImageFilterAction, disableImageFilter as disableImageFilterAction } from 'actions/settings-actions';
 import { ImageFilter, ImageFilterAlias, hasFilter } from 'utils/image-processing';
+import { openAnnotationsActionModal } from 'components/annotation-page/annotations-actions/annotations-actions-modal';
 import withVisibilityHandling from './handle-popover-visibility';
 
 interface Props {
     labels: any[];
     canvasInstance: Canvas;
     canvasReady: boolean;
-    jobInstance: any;
+    jobInstance: Job;
     isActivated: boolean;
-    states: any[];
     frame: number;
     curZOrder: number;
     defaultApproxPolyAccuracy: number;
@@ -59,31 +58,19 @@ interface Props {
 
 interface DispatchToProps {
     createAnnotations: (states: ObjectState[]) => Promise<void>;
-    fetchAnnotations: () => Promise<void>;
     onInteractionStart: typeof interactWithCanvas;
-    onSwitchToolsBlockerState: typeof switchToolsBlockerState;
-    switchNavigationBlocked: typeof switchNavigationBlockedAction;
     enableImageFilter: typeof enableImageFilterAction;
     disableImageFilter: typeof disableImageFilterAction;
 }
 
-interface TrackedShape {
-    clientID: number;
-    shapePoints: number[];
-    trackerModel: TrackerModel;
-}
-
 interface State {
     libraryInitialized: boolean;
     initializationError: boolean;
     initializationProgress: number;
     activeLabelID: number;
     approxPolyAccuracy: number;
-    mode: 'interaction' | 'tracking';
-    trackedShapes: TrackedShape[];
     activeTracker: OpenCVTracker | null;
     trackers: OpenCVTracker[];
-    lastTrackedFrame: number | null;
 }
 
 const core = getCore();
@@ -93,7 +80,6 @@ function mapStateToProps(state: CombinedState): Props {
     const {
         annotation: {
             annotations: {
-                states,
                 zLayer: { cur: curZOrder },
             },
             job: { instance: jobInstance, labels },
@@ -114,10 +100,9 @@ function mapStateToProps(state: CombinedState): Props {
         canvasInstance: canvasInstance as Canvas,
         canvasReady,
         defaultApproxPolyAccuracy,
-        jobInstance,
+        jobInstance: jobInstance as Job,
         curZOrder,
         labels,
-        states,
         frame,
         frameData,
         toolsBlockerState,
@@ -127,10 +112,7 @@ function mapStateToProps(state: CombinedState): Props {
 
 const mapDispatchToProps = {
     onInteractionStart: interactWithCanvas,
-    fetchAnnotations: fetchAnnotationsAsync,
     createAnnotations: createAnnotationsAsync,
-    onSwitchToolsBlockerState: switchToolsBlockerState,
-    switchNavigationBlocked: switchNavigationBlockedAction,
     enableImageFilter: enableImageFilterAction,
     disableImageFilter: disableImageFilterAction,
 };
@@ -151,11 +133,8 @@ class OpenCVControlComponent extends React.PureComponent<Props & DispatchToProps
             initializationProgress: -1,
             approxPolyAccuracy: defaultApproxPolyAccuracy,
             activeLabelID: labels.length ? labels[0].id : null,
-            mode: 'interaction',
-            trackedShapes: [],
             trackers: openCVWrapper.isInitialized ? Object.values(openCVWrapper.tracking) : [],
             activeTracker: openCVWrapper.isInitialized ? Object.values(openCVWrapper.tracking)[0] : null,
-            lastTrackedFrame: null,
         };
     }
 
@@ -168,7 +147,7 @@ class OpenCVControlComponent extends React.PureComponent<Props & DispatchToProps
         const { approxPolyAccuracy } = this.state;
         const {
             isActivated, defaultApproxPolyAccuracy,
-            canvasInstance, canvasReady, toolsBlockerState,
+            canvasInstance, toolsBlockerState,
         } = this.props;
 
         if (!prevProps.isActivated && isActivated) {
@@ -217,29 +196,17 @@ class OpenCVControlComponent extends React.PureComponent<Props & DispatchToProps
             !!this.activeTool?.switchBlockMode) {
             this.activeTool.switchBlockMode(toolsBlockerState.algorithmsLocked);
         }
-
-        if (canvasReady) this.checkTrackedStates();
     }
 
     public componentWillUnmount(): void {
         const { canvasInstance } = this.props;
-        const { trackedShapes } = this.state;
 
         canvasInstance.html().removeEventListener('canvas.interacted', this.interactionListener);
         openCVWrapper.removeProgressCallback();
-        trackedShapes.forEach((shape: TrackedShape) => shape.trackerModel.delete());
     }
 
     private interactionListener = async (e: Event): Promise<void> => {
-        const { mode } = this.state;
-
-        if (mode === 'interaction') {
-            await this.onInteraction(e);
-        }
-
-        if (mode === 'tracking') {
-            await this.onTracking(e);
-        }
+        await this.onInteraction(e);
     };
 
     private onInteraction = async (e: Event): Promise<void> => {
@@ -314,106 +281,6 @@ class OpenCVControlComponent extends React.PureComponent<Props & DispatchToProps
         }
     };
 
-    private onTracking = async (e: Event): Promise<void> => {
-        const {
-            isActivated, jobInstance, frame, curZOrder, fetchAnnotations,
-        } = this.props;
-
-        if (!isActivated) {
-            return;
-        }
-
-        const { activeLabelID, trackedShapes, activeTracker } = this.state;
-        const [label] = jobInstance.labels.filter((_label: any): boolean => _label.id === activeLabelID);
-
-        const { isDone, shapesUpdated } = (e as CustomEvent).detail;
-        if (!isDone || !shapesUpdated || !activeTracker) {
-            return;
-        }
-
-        try {
-            const { points } = (e as CustomEvent).detail.shapes[0];
-            const imageData = this.getCanvasImageData();
-            const trackerModel = activeTracker.model();
-            trackerModel.init(imageData, points);
-            const state = new core.classes.ObjectState({
-                shapeType: ShapeType.RECTANGLE,
-                objectType: ObjectType.TRACK,
-                source: core.enums.Source.SEMI_AUTO,
-                zOrder: curZOrder,
-                label,
-                points,
-                frame,
-                occluded: false,
-                attributes: {},
-                descriptions: [`Trackable (${activeTracker.name})`],
-            });
-            const [clientID] = await jobInstance.annotations.put([state]);
-            this.setState({
-                trackedShapes: [
-                    ...trackedShapes,
-                    {
-                        clientID,
-                        trackerModel,
-                        shapePoints: points,
-                    },
-                ],
-            });
-
-            // update annotations on a canvas
-            fetchAnnotations();
-        } catch (error: any) {
-            notification.error({
-                description: error.toString(),
-                message: 'Tracking error occurred',
-            });
-        }
-    };
-
-    private getCanvasImageData = ():ImageData => {
-        const canvas: HTMLCanvasElement | null = window.document.getElementById('cvat_canvas_background') as
-        | HTMLCanvasElement
-        | null;
-        if (!canvas) {
-            throw new Error('Element #cvat_canvas_background was not found');
-        }
-        const { width, height } = canvas;
-        const context = canvas.getContext('2d');
-        if (!context) {
-            throw new Error('Canvas context is empty');
-        }
-        return context.getImageData(0, 0, width, height);
-    };
-
-    private applyTracking = (imageData: ImageData, shape: TrackedShape,
-        objectState: any): Promise<void> => new Promise((resolve, reject) => {
-        setTimeout(() => {
-            try {
-                const stateIsRelevant =
-                    objectState.points.length === shape.shapePoints.length &&
-                    objectState.points.every(
-                        (coord: number, index: number) => coord === shape.shapePoints[index],
-                    );
-                if (!stateIsRelevant) {
-                    shape.trackerModel.reinit(objectState.points);
-                    shape.shapePoints = objectState.points;
-                }
-                const { updated, points } = shape.trackerModel.update(imageData);
-                if (updated) {
-                    objectState.points = points;
-                    objectState.save().then(() => {
-                        shape.shapePoints = points;
-                    }).catch((error: any) => {
-                        reject(error);
-                    });
-                }
-                resolve();
-            } catch (error) {
-                reject(error);
-            }
-        });
-    });
-
     private setActiveTracker = (value: string): void => {
         const { trackers } = this.state;
         this.setState({
@@ -421,86 +288,6 @@ class OpenCVControlComponent extends React.PureComponent<Props & DispatchToProps
         });
     };
 
-    private checkTrackedStates(): void {
-        const {
-            frame,
-            states: objectStates,
-            fetchAnnotations,
-            switchNavigationBlocked,
-        } = this.props;
-        const { trackedShapes, lastTrackedFrame } = this.state;
-        if (lastTrackedFrame !== frame && trackedShapes.length) {
-            this.setState({
-                lastTrackedFrame: frame,
-            });
-
-            type AccumulatorType = {
-                [index: string]: TrackedShape[];
-            };
-            const trackingData = trackedShapes.reduce<AccumulatorType>(
-                (acc: AccumulatorType, trackedShape: TrackedShape): AccumulatorType => {
-                    const [clientState] = objectStates.filter(
-                        (_state: any): boolean => _state.clientID === trackedShape.clientID,
-                    );
-                    if (
-                        !clientState ||
-                        clientState.keyframes.prev !== frame - 1 ||
-                        clientState.keyframes.last >= frame
-                    ) {
-                        return acc;
-                    }
-
-                    const { name: trackerName } = trackedShape.trackerModel;
-                    if (!acc[trackerName]) {
-                        acc[trackerName] = [];
-                    }
-                    acc[trackerName].push(trackedShape);
-                    return acc;
-                }, {},
-            );
-
-            if (Object.keys(trackingData).length === 0) {
-                return;
-            }
-
-            try {
-                switchNavigationBlocked(true);
-                for (const trackerID of Object.keys(trackingData)) {
-                    const numOfObjects = trackingData[trackerID].length;
-                    const hideMessage = message.loading({
-                        content: `${trackerID}: ${numOfObjects} ${
-                            numOfObjects > 1 ? 'objects are' : 'object is'
-                        } being tracked..`,
-                        duration: 0,
-                        className: 'cvat-tracking-notice',
-                    });
-                    const imageData = this.getCanvasImageData();
-                    for (const shape of trackingData[trackerID]) {
-                        const [objectState] = objectStates.filter(
-                            (_state: any): boolean => _state.clientID === shape.clientID,
-                        );
-
-                        this.applyTracking(imageData, shape, objectState)
-                            .catch((error) => {
-                                notification.error({
-                                    message: 'Tracking error',
-                                    description: error.toString(),
-                                });
-                            });
-                    }
-                    setTimeout(() => {
-                        if (hideMessage) hideMessage();
-                    });
-                }
-            } finally {
-                setTimeout(() => {
-                    fetchAnnotations();
-                    switchNavigationBlocked(false);
-                });
-            }
-        }
-    }
-
     private async runCVAlgorithm(pressedPoints: number[]): Promise<number[]> {
         if (!this.activeTool || pressedPoints.length === 0) {
             return [];
@@ -558,7 +345,6 @@ class OpenCVControlComponent extends React.PureComponent<Props & DispatchToProps
                             <Button
                                 className='cvat-opencv-scissors-tool-button'
                                 onClick={() => {
-                                    this.setState({ mode: 'interaction' });
                                     this.activeTool = openCVWrapper.segmentation.intelligentScissorsFactory();
 
                                     canvasInstance.cancel();
@@ -612,10 +398,8 @@ class OpenCVControlComponent extends React.PureComponent<Props & DispatchToProps
     }
 
     private renderTrackingContent(): JSX.Element {
-        const { activeLabelID, trackers, activeTracker } = this.state;
-        const {
-            labels, canvasInstance, onInteractionStart, frame, jobInstance,
-        } = this.props;
+        const { trackers, activeTracker } = this.state;
+        const { canvasInstance, frame, jobInstance } = this.props;
         if (!trackers.length) {
             return (
                 <Row justify='center' align='middle' className='cvat-opencv-tracker-content'>
@@ -630,18 +414,8 @@ class OpenCVControlComponent extends React.PureComponent<Props & DispatchToProps
         return (
             <>
                 <Row justify='start'>
-                    <Col>
-                        <Text className='cvat-text-color'>Label</Text>
-                    </Col>
-                </Row>
-                <Row justify='center'>
-                    <Col span={24}>
-                        <LabelSelector
-                            className='cvat-opencv-tracking-label-select'
-                            labels={labels}
-                            value={activeLabelID}
-                            onChange={(value: any) => this.setState({ activeLabelID: value.id })}
-                        />
+                    <Col className='cvat-opencv-tracker-help-message'>
+                        <Alert type='info' message='The tracker will be applied to drawn rectangles' />
                     </Col>
                 </Row>
                 <Row justify='start'>
@@ -670,21 +444,12 @@ class OpenCVControlComponent extends React.PureComponent<Props & DispatchToProps
                     <Col>
                         <Button
                             type='primary'
-                            className='cvat-tools-track-button'
+                            className='cvat-tools-opencv-track-button'
                             disabled={!activeTracker || frame === jobInstance.stopFrame}
                             onClick={() => {
-                                this.setState({ mode: 'tracking' });
-
                                 if (activeTracker) {
                                     canvasInstance.cancel();
-                                    canvasInstance.interact({
-                                        shapeType: 'rectangle',
-                                        enabled: true,
-                                    });
-
-                                    onInteractionStart(activeTracker as OpenCVTracker, activeLabelID, {});
-                                    const { onSwitchToolsBlockerState } = this.props;
-                                    onSwitchToolsBlockerState({ buttonVisible: false });
+                                    openAnnotationsActionModal({ defaultAnnotationAction: activeTracker.name });
                                 }
                             }}
                         >
@@ -764,7 +529,7 @@ class OpenCVControlComponent extends React.PureComponent<Props & DispatchToProps
         const {
             isActivated, canvasInstance, labels, frameData,
         } = this.props;
-        const { libraryInitialized, approxPolyAccuracy, mode } = this.state;
+        const { libraryInitialized, approxPolyAccuracy } = this.state;
         const dynamicPopoverProps = isActivated ?
             {
                 overlayStyle: {
@@ -810,7 +575,7 @@ class OpenCVControlComponent extends React.PureComponent<Props & DispatchToProps
                 >
                     <Icon {...dynamicIconProps} component={OpenCVIcon} />
                 </CustomPopover>
-                {isActivated && mode !== 'tracking' ? (
+                {isActivated ? (
                     <ApproximationAccuracy
                         approxPolyAccuracy={approxPolyAccuracy}
                         onChange={(value: number) => {
diff --git a/cvat-ui/src/components/annotation-page/standard-workspace/styles.scss b/cvat-ui/src/components/annotation-page/standard-workspace/styles.scss
index c6a34379df44..7889dab6e77a 100644
--- a/cvat-ui/src/components/annotation-page/standard-workspace/styles.scss
+++ b/cvat-ui/src/components/annotation-page/standard-workspace/styles.scss
@@ -1,5 +1,5 @@
 // Copyright (C) 2020-2022 Intel Corporation
-// Copyright (C) 2022-2024 CVAT.ai Corporation
+// Copyright (C) 2022-2025 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -250,10 +250,11 @@
 }
 
 .cvat-opencv-tracker-select {
+    margin-bottom: $grid-unit-size * 2;
     width: 100%;
 }
 
-.cvat-opencv-tracking-label-select {
+.cvat-opencv-tracker-help-message {
     @extend .cvat-opencv-tracker-select;
 }
 
diff --git a/cvat-ui/src/containers/annotation-page/standard-workspace/objects-side-bar/object-item.tsx b/cvat-ui/src/containers/annotation-page/standard-workspace/objects-side-bar/object-item.tsx
index 362455a29fbf..908fa0b4b9be 100644
--- a/cvat-ui/src/containers/annotation-page/standard-workspace/objects-side-bar/object-item.tsx
+++ b/cvat-ui/src/containers/annotation-page/standard-workspace/objects-side-bar/object-item.tsx
@@ -1,5 +1,5 @@
 // Copyright (C) 2021-2022 Intel Corporation
-// Copyright (C) 2022-2024 CVAT.ai Corporation
+// Copyright (C) 2022-2025 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -379,7 +379,7 @@ class ObjectItemContainer extends React.PureComponent<Props, State> {
 
     private runAnnotationAction = (): void => {
         const { objectState } = this.props;
-        openAnnotationsActionModal(objectState);
+        openAnnotationsActionModal({ defaultObjectState: objectState });
     };
 
     private commit(): void {
diff --git a/cvat-ui/src/containers/annotation-page/standard-workspace/objects-side-bar/objects-list.tsx b/cvat-ui/src/containers/annotation-page/standard-workspace/objects-side-bar/objects-list.tsx
index 5df7b556ff34..e3ddcf91c90b 100644
--- a/cvat-ui/src/containers/annotation-page/standard-workspace/objects-side-bar/objects-list.tsx
+++ b/cvat-ui/src/containers/annotation-page/standard-workspace/objects-side-bar/objects-list.tsx
@@ -1,5 +1,5 @@
 // Copyright (C) 2020-2022 Intel Corporation
-// Copyright (C) 2022-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2025 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -599,7 +599,7 @@ class ObjectsListContainer extends React.PureComponent<Props, State> {
                 const state = activatedState(true);
                 if (!readonly) {
                     if (state) {
-                        openAnnotationsActionModal(state);
+                        openAnnotationsActionModal({ defaultObjectState: state });
                     } else {
                         openAnnotationsActionModal();
                     }
diff --git a/cvat-ui/src/utils/opencv-wrapper/annotations-actions/tracker-mil.ts b/cvat-ui/src/utils/opencv-wrapper/annotations-actions/tracker-mil.ts
new file mode 100644
index 000000000000..3099c3a8a143
--- /dev/null
+++ b/cvat-ui/src/utils/opencv-wrapper/annotations-actions/tracker-mil.ts
@@ -0,0 +1,308 @@
+// Copyright (C) 2025 CVAT.ai Corporation
+//
+// SPDX-License-Identifier: MIT
+
+import { range, cloneDeep } from 'lodash';
+
+import {
+    Job, Task, ActionParameterType, BaseCollectionAction,
+    ObjectType, ObjectState, Source, ShapeType,
+} from 'cvat-core-wrapper';
+
+type Collection = Parameters<BaseCollectionAction['run']>[0]['collection'];
+type Track = Collection['tracks'][0];
+type Shape = Collection['shapes'][0];
+
+function imageBitmapToImageData(imageBitmap: ImageBitmap): ImageData {
+    const canvas = new OffscreenCanvas(imageBitmap.width, imageBitmap.height);
+    const ctx = canvas.getContext('2d') as OffscreenCanvasRenderingContext2D;
+    ctx.drawImage(imageBitmap, 0, 0);
+    return ctx.getImageData(0, 0, canvas.width, canvas.height);
+}
+
+export default class OpenCVTrackerMIL extends BaseCollectionAction {
+    #instance: Job | Task | null;
+    #targetFrame: number;
+    #convertRectangleShapesToTracks: boolean;
+    readonly #openCVWrapper: any;
+    readonly #name: string;
+
+    public constructor(openCVWrapper: any) {
+        super();
+        this.#convertRectangleShapesToTracks = false;
+        this.#targetFrame = 0;
+        this.#instance = null;
+        this.#name = openCVWrapper.tracking.trackerMIL.name;
+        this.#openCVWrapper = openCVWrapper;
+    }
+
+    public async init(instance: Job | Task, parameters: Record<string, string>): Promise<void> {
+        this.#instance = instance;
+        this.#targetFrame = +parameters['Target frame'];
+        this.#convertRectangleShapesToTracks = parameters['Convert rectangle shapes to tracks'] === 'true';
+    }
+
+    public async destroy(): Promise<void> {
+        // nothing to destroy
+    }
+
+    public async run(
+        {
+            collection,
+            frameData: { number },
+            onProgress,
+            cancelled,
+        }: Parameters<BaseCollectionAction['run']>[0],
+    ): ReturnType<BaseCollectionAction['run']> {
+        const noChanges = {
+            created: { shapes: [], tags: [], tracks: [] },
+            deleted: { shapes: [], tags: [], tracks: [] },
+        };
+
+        if (this.#instance === null || number === this.#targetFrame) {
+            return noChanges;
+        }
+
+        if (number >= this.#targetFrame) {
+            throw new Error('OpenCV tracking backward is not supported');
+        }
+
+        const frameNumbers = this.#instance instanceof Job ?
+            await this.#instance.frames.frameNumbers() : range(0, this.#instance.size);
+        const targetFrameNumbers = frameNumbers.filter(
+            (frameNumber: number) => frameNumber >= Math.min(number, this.#targetFrame) &&
+                frameNumber <= Math.max(number, this.#targetFrame) &&
+                frameNumber !== number,
+        );
+
+        if (targetFrameNumbers.length === 0) {
+            return noChanges;
+        }
+
+        const objectStates = await this.#instance.annotations.get(number, false, []);
+        const tracks = [...collection.tracks]; // shallow copy value as it may have added new values
+        const { shapes } = collection;
+
+        const [
+            initialShapes,
+            targetObjects,
+            targetObjectStates,
+        ] = ([] as (Shape | Track)[]).concat(shapes, tracks).reduce((acc, object) => {
+            if (!Number.isInteger(object.clientID)) {
+                return acc;
+            }
+
+            const objectState = objectStates.find((_objectState) => _objectState.clientID === object.clientID);
+            if (!objectState) {
+                return acc;
+            }
+
+            acc[0].push([...objectState.points as number[]]);
+
+            if (this.#convertRectangleShapesToTracks && objectState.objectType === ObjectType.SHAPE) {
+                const castedObject = object as Required<Shape>;
+                const convertedTrack = {
+                    source: Source.AUTO,
+                    attributes: [],
+                    elements: [],
+                    frame: castedObject.frame,
+                    group: castedObject.group,
+                    label_id: castedObject.label_id,
+                    shapes: [{
+                        frame: castedObject.frame,
+                        attributes: [],
+                        occluded: castedObject.occluded,
+                        outside: false,
+                        points: [...castedObject.points],
+                        rotation: castedObject.rotation,
+                        z_order: castedObject.z_order,
+                        type: castedObject.type,
+                    }],
+                };
+
+                tracks.push(convertedTrack);
+                acc[1].push(convertedTrack);
+                acc[2].push(new Proxy(objectState, {
+                    get(_objectState, p, receiver) {
+                        if (p === 'objectType') {
+                            return ObjectType.TRACK;
+                        }
+
+                        return Reflect.get(_objectState, p, receiver);
+                    },
+                }));
+            } else {
+                acc[1].push(object);
+                acc[2].push(objectState);
+            }
+
+            return acc;
+        }, [[], [], []] as [number[][], (Shape | Track)[], ObjectState[]]);
+
+        if (!this.#openCVWrapper.isInitialized) {
+            onProgress('OpenCV library initialization', 0);
+            await this.#openCVWrapper.initialize(() => {});
+            if (cancelled()) {
+                return noChanges;
+            }
+        }
+
+        onProgress('Action is running', 0);
+        if (cancelled()) {
+            return noChanges;
+        }
+
+        let currentProgress = 0;
+        const progressPieces = targetFrameNumbers.length * initialShapes.length;
+        const trackedShapes: Shape[] = [];
+
+        for (let i = 0; i < initialShapes.length; i++) {
+            const initialShape = initialShapes[i];
+            const targetObject = targetObjects[i];
+            const targetObjectState = targetObjectStates[i];
+            const tracker = this.#openCVWrapper.tracking.trackerMIL.model();
+
+            try {
+                let frameData = await this.#instance.frames.get(number);
+                let image = await frameData.data();
+                const imageData = imageBitmapToImageData(image.imageData as ImageBitmap);
+
+                tracker.init(imageData, initialShape);
+                for (let j = 0; j < targetFrameNumbers.length; j++) {
+                    currentProgress = i * targetFrameNumbers.length + j;
+
+                    onProgress('Action is running', Math.ceil((currentProgress / progressPieces) * 100));
+                    await new Promise((resolve) => {
+                        setTimeout(resolve);
+                    });
+
+                    if (cancelled()) {
+                        return noChanges;
+                    }
+
+                    const frame = targetFrameNumbers[j];
+                    frameData = await this.#instance.frames.get(frame);
+                    if (frameData.deleted) {
+                        continue;
+                    }
+
+                    image = await frameData.data();
+                    const { updated, points } = tracker.update(imageBitmapToImageData(image.imageData as ImageBitmap));
+                    if (updated) {
+                        if (targetObjectState.objectType === ObjectType.TRACK) {
+                            const castedObject = targetObject as Track;
+                            const existingShape = castedObject.shapes.find((_shape) => _shape.frame === frame) ?? null;
+
+                            if (existingShape) {
+                                existingShape.points = points;
+                            } else {
+                                castedObject.shapes.push({
+                                    frame,
+                                    attributes: [],
+                                    occluded: targetObjectState.occluded,
+                                    outside: false,
+                                    points,
+                                    rotation: 0,
+                                    z_order: targetObjectState.zOrder,
+                                    type: targetObjectState.shapeType,
+                                });
+                            }
+                        } else {
+                            const castedObject = targetObject as Shape;
+                            trackedShapes.push({
+                                elements: [],
+                                group: castedObject.group,
+                                frame,
+                                source: Source.AUTO,
+                                attributes: cloneDeep(castedObject.attributes),
+                                occluded: castedObject.occluded,
+                                outside: false,
+                                points,
+                                rotation: 0,
+                                z_order: castedObject.z_order,
+                                label_id: castedObject.label_id,
+                                type: castedObject.type,
+                            });
+                        }
+                    }
+                }
+            } finally {
+                tracker.delete();
+            }
+        }
+
+        return {
+            created: { shapes: trackedShapes, tags: [], tracks },
+            deleted: {
+                // remove shapes converted to tracks
+                shapes: this.#convertRectangleShapesToTracks ?
+                    shapes.filter((shape) => shape.type === ShapeType.RECTANGLE) : [],
+                // remove existing tracks as they were modified and will be rewritten
+                tracks: collection.tracks,
+                tags: [],
+            },
+        };
+    }
+
+    public applyFilter(
+        input: Parameters<BaseCollectionAction['applyFilter']>[0],
+    ): ReturnType<BaseCollectionAction['applyFilter']> {
+        const { collection, frameData } = input;
+
+        return {
+            shapes: collection.shapes
+                .filter((shape) => shape.frame === frameData.number && ShapeType.RECTANGLE === shape.type),
+            tags: [],
+            tracks: collection.tracks.filter((track) => {
+                if (track.shapes[0].type !== ShapeType.RECTANGLE) {
+                    return false;
+                }
+
+                // must be any shapes before current frame
+                const shapesBefore = track.shapes.filter(
+                    (shape) => shape.frame <= frameData.number).sort((a, b) => a.frame - b.frame,
+                );
+
+                if (shapesBefore.length === 0) {
+                    return false;
+                }
+
+                // last shape must not be outside
+                return !shapesBefore[shapesBefore.length - 1].outside;
+            }),
+        };
+    }
+
+    public isApplicableForObject(objectState: ObjectState): boolean {
+        return objectState.shapeType === ShapeType.RECTANGLE;
+    }
+
+    public get name(): BaseCollectionAction['name'] {
+        return this.#name;
+    }
+
+    public get parameters(): BaseCollectionAction['parameters'] {
+        return {
+            'Convert rectangle shapes to tracks': {
+                type: ActionParameterType.CHECKBOX,
+                values: ['true', 'false'],
+                defaultValue: String(this.#convertRectangleShapesToTracks),
+            },
+            'Target frame': {
+                type: ActionParameterType.NUMBER,
+                values: ({ instance }) => {
+                    if (instance instanceof Job) {
+                        return [instance.startFrame, instance.stopFrame, 1].map((val) => val.toString());
+                    }
+                    return [0, instance.size - 1, 1].map((val) => val.toString());
+                },
+                defaultValue: ({ instance }) => {
+                    if (instance instanceof Job) {
+                        return instance.stopFrame.toString();
+                    }
+                    return (instance.size - 1).toString();
+                },
+            },
+        };
+    }
+}
diff --git a/cvat-ui/src/utils/opencv-wrapper/histogram-equalization.ts b/cvat-ui/src/utils/opencv-wrapper/histogram-equalization.ts
index 72fa1c39a120..bdeaf0ab1bda 100644
--- a/cvat-ui/src/utils/opencv-wrapper/histogram-equalization.ts
+++ b/cvat-ui/src/utils/opencv-wrapper/histogram-equalization.ts
@@ -1,5 +1,5 @@
 // Copyright (C) 2021-2022 Intel Corporation
-// Copyright (C) 2023 CVAT.ai Corporation
+// Copyright (C) 2023-2025 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -10,14 +10,14 @@ export interface HistogramEqualization extends ImageProcessing {
 }
 
 export default class HistogramEqualizationImplementation extends BaseImageFilter {
-    private cv:any;
+    private cv: any;
 
     constructor(cv:any) {
         super();
         this.cv = cv;
     }
 
-    public processImage(src:ImageData, frameNumber: number) : ImageData {
+    public processImage(src: ImageData, frameNumber: number) : ImageData {
         const { cv } = this;
         let matImage = null;
         const RGBImage = new cv.Mat();
@@ -48,11 +48,17 @@ export default class HistogramEqualizationImplementation extends BaseImageFilter
             const arr = new Uint8ClampedArray(RGBADist.data, RGBADist.cols, RGBADist.rows);
             const imgData = new ImageData(arr, src.width, src.height);
             return imgData;
-        } catch (e) {
-            throw new Error(e.toString());
+        } catch (e: unknown) {
+            throw e instanceof Error ? e : new Error('Unknown error');
         } finally {
-            if (matImage) matImage.delete();
-            if (channels) channels.delete();
+            if (matImage) {
+                matImage.delete();
+            }
+
+            if (channels) {
+                channels.delete();
+            }
+
             RGBImage.delete();
             YUVImage.delete();
             RGBDist.delete();
diff --git a/cvat-ui/src/utils/opencv-wrapper/opencv-wrapper.ts b/cvat-ui/src/utils/opencv-wrapper/opencv-wrapper.ts
index cc74252a824f..e0e7a8caa2dc 100644
--- a/cvat-ui/src/utils/opencv-wrapper/opencv-wrapper.ts
+++ b/cvat-ui/src/utils/opencv-wrapper/opencv-wrapper.ts
@@ -1,5 +1,5 @@
 // Copyright (C) 2020-2022 Intel Corporation
-// Copyright (C) 2023-2024 CVAT.ai Corporation
+// Copyright (C) 2023-2025 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -10,6 +10,7 @@ import HistogramEqualizationImplementation, { HistogramEqualization } from './hi
 import TrackerMImplementation from './tracker-mil';
 import IntelligentScissorsImplementation, { IntelligentScissors } from './intelligent-scissors';
 import { OpenCVTracker } from './opencv-interfaces';
+import TrackerMILAction from './annotations-actions/tracker-mil';
 
 const core = getCore();
 
@@ -139,10 +140,10 @@ export class OpenCVWrapper {
     }
 
     public get mat(): MatSpace {
-        this.checkInitialization();
         const { cv } = this;
         return {
             fromData: (width: number, height: number, type: MatType, data: number[]) => {
+                this.checkInitialization();
                 const typeToCVType = {
                     [MatType.CV_8UC1]: cv.CV_8UC1,
                     [MatType.CV_8UC3]: cv.CV_8UC3,
@@ -156,18 +157,21 @@ export class OpenCVWrapper {
     }
 
     public get matVector(): MatVectorSpace {
-        this.checkInitialization();
         const { cv } = this;
         return {
-            empty: () => new cv.MatVector(),
+            empty: () => {
+                this.checkInitialization();
+                return new cv.MatVector();
+            },
         };
     }
 
     public get contours(): Contours {
-        this.checkInitialization();
         const { cv } = this;
         return {
             convexHull: (contours: number[][]): number[] => {
+                this.checkInitialization();
+
                 const points = contours.flat();
                 const input = cv.matFromArray(points.length / 2, 1, cv.CV_32SC2, points);
                 const output = new cv.Mat();
@@ -180,6 +184,8 @@ export class OpenCVWrapper {
                 }
             },
             findContours: (src: any, findLongest: boolean): number[][] => {
+                this.checkInitialization();
+
                 const contours = this.matVector.empty();
                 const hierarchy = new cv.Mat();
                 const expanded = new cv.Mat();
@@ -219,6 +225,8 @@ export class OpenCVWrapper {
                 return jsContours;
             },
             approxPoly: (points: number[] | number[][], threshold: number, closed = true): number[][] => {
+                this.checkInitialization();
+
                 const isArrayOfArrays = Array.isArray(points[0]);
                 if (points.length < 3) {
                     // one pair of coordinates [x, y], approximation not possible
@@ -289,30 +297,38 @@ export class OpenCVWrapper {
     };
 
     public get segmentation(): Segmentation {
-        this.checkInitialization();
         return {
-            intelligentScissorsFactory: () => new IntelligentScissorsImplementation(this.cv),
+            intelligentScissorsFactory: () => {
+                this.checkInitialization();
+                return new IntelligentScissorsImplementation(this.cv);
+            },
         };
     }
 
     public get imgproc(): ImgProc {
-        this.checkInitialization();
         return {
-            hist: () => new HistogramEqualizationImplementation(this.cv),
+            hist: () => {
+                this.checkInitialization();
+                return new HistogramEqualizationImplementation(this.cv);
+            },
         };
     }
 
     public get tracking(): Tracking {
-        this.checkInitialization();
         return {
             trackerMIL: {
-                model: () => new TrackerMImplementation(this.cv),
+                model: () => {
+                    this.checkInitialization();
+                    return new TrackerMImplementation(this.cv);
+                },
                 name: 'TrackerMIL',
-                description: 'Light client-side model useful to track simple objects',
+                description: 'Lightweight client-side algorithm, useful to track simple objects',
                 kind: 'opencv_tracker_mil',
             },
         };
     }
 }
 
-export default new OpenCVWrapper();
+const openCVWrapper = new OpenCVWrapper();
+await core.actions.register(new TrackerMILAction(openCVWrapper));
+export default openCVWrapper;
diff --git a/cvat-ui/src/utils/opencv-wrapper/tracker-mil.ts b/cvat-ui/src/utils/opencv-wrapper/tracker-mil.ts
index e4a5ad39fc17..da6ce3671593 100644
--- a/cvat-ui/src/utils/opencv-wrapper/tracker-mil.ts
+++ b/cvat-ui/src/utils/opencv-wrapper/tracker-mil.ts
@@ -1,4 +1,5 @@
 // Copyright (C) 2022 Intel Corporation
+// Copyright (C) 2025 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -12,38 +13,87 @@ export default class TrackerMILImplementation implements TrackerMIL {
     private imageData: ImageData | null;
     private cv: any;
     private trackerMIL: any;
+    private maxSize: number;
+    private imageScale: number;
 
     constructor(cv: any) {
         this.cv = cv;
         this.trackerMIL = new cv.TrackerMIL();
         this.imageData = null;
-        this.name = 'TrackerMil';
+        this.maxSize = 2560;
+        this.imageScale = 1;
+        this.name = 'TrackerMIL';
     }
 
-    public init(src: ImageData, points: number[]): void {
-        if (points.length !== 4) {
-            throw Error(`TrackerMIL must be initialized with rectangle, but got ${points.length % 2} points.`);
+    private optResize(width: number, height: number, matImage: any): {
+        scale: number;
+        width: number;
+        height: number;
+        resized: any;
+    } {
+        if (height > this.maxSize || width > this.maxSize) {
+            const resized = new this.cv.Mat();
+            const scaleFactor = Math.min(this.maxSize / height, this.maxSize / width);
+            const targetWidth = Math.round(width * scaleFactor);
+            const targetHeight = Math.round(height * scaleFactor);
+            this.cv.resize(
+                matImage,
+                resized,
+                new this.cv.Size(targetWidth, targetHeight),
+            );
+
+            return {
+                scale: scaleFactor,
+                width: targetWidth,
+                height: targetHeight,
+                resized,
+            };
         }
-        this.imageData = src;
 
-        // cut bounding box if its out of image bounds
-        const x1 = clamp(points[0], 0, src.width);
-        const y1 = clamp(points[1], 0, src.height);
-        const x2 = clamp(points[2], 0, src.width);
-        const y2 = clamp(points[3], 0, src.height);
+        return {
+            scale: 1,
+            width,
+            height,
+            resized: matImage,
+        };
+    }
 
-        const [width, height] = [x2 - x1, y2 - y1];
-        if (width === 0 || height === 0) {
-            throw Error('TrackerMIL got rectangle out of image bounds');
+    public init(src: ImageData, points: number[]): void {
+        if (points.length !== 4) {
+            throw Error(`TrackerMIL must be initialized with rectangle, but got ${points.length % 2} points.`);
         }
 
+        this.imageData = src;
         let matImage = null;
         try {
             matImage = this.cv.matFromImageData(src);
-            const rect = new this.cv.Rect(x1, y1, width, height);
+            const {
+                width: resizedWidth, height: resizedHeight, scale, resized,
+            } = this.optResize(src.width, src.height, matImage);
+            this.imageScale = scale;
+
+            if (resized !== matImage) {
+                matImage.delete();
+                matImage = resized;
+            }
+
+            // cut bounding box if its out of image bounds
+            const x1 = clamp(points[0] * scale, 0, resizedWidth);
+            const y1 = clamp(points[1] * scale, 0, resizedHeight);
+            const x2 = clamp(points[2] * scale, 0, resizedWidth);
+            const y2 = clamp(points[3] * scale, 0, resizedHeight);
+
+            const [boxWidth, boxHeight] = [x2 - x1, y2 - y1];
+            if (boxWidth === 0 || boxHeight === 0) {
+                throw Error('TrackerMIL got rectangle out of image bounds');
+            }
+
+            const rect = new this.cv.Rect(x1, y1, boxWidth, boxHeight);
             this.trackerMIL.init(matImage, rect);
         } finally {
-            if (matImage) matImage.delete();
+            if (matImage) {
+                matImage.delete();
+            }
         }
     }
 
@@ -51,20 +101,47 @@ export default class TrackerMILImplementation implements TrackerMIL {
         if (!this.imageData) {
             throw Error('TrackerMIL needs to be initialized before re-initialization');
         }
+
         this.trackerMIL.delete();
         this.trackerMIL = new this.cv.TrackerMIL();
         this.init(this.imageData, points);
     }
 
     public update(src: ImageData): TrackingResult {
+        if (!this.imageData) {
+            throw Error('TrackerMIL needs to be initialized before updating');
+        }
+
+        const prevRes = `${this.imageData.width}x${this.imageData.height}`;
+        const curRes = `${src.width}x${src.height}`;
+        if (prevRes !== curRes) {
+            throw new Error(`Images have different resolution (previous is ${prevRes}, current one is ${curRes})`);
+        }
+
         this.imageData = src;
         let matImage = null;
         try {
             matImage = this.cv.matFromImageData(src);
+            const { resized } = this.optResize(src.width, src.height, matImage);
+            if (resized !== matImage) {
+                matImage.delete();
+                matImage = resized;
+            }
+
             const [updated, rect] = this.trackerMIL.update(matImage);
-            return { updated, points: [rect.x, rect.y, rect.x + rect.width, rect.y + rect.height] };
+            return {
+                updated,
+                points: [
+                    rect.x / this.imageScale,
+                    rect.y / this.imageScale,
+                    (rect.x + rect.width) / this.imageScale,
+                    (rect.y + rect.height) / this.imageScale,
+                ],
+            };
         } finally {
-            if (matImage) matImage.delete();
+            if (matImage) {
+                matImage.delete();
+            }
         }
     }
 
diff --git a/tests/cypress/e2e/actions_tasks2/case_101_opencv_basic_actions.js b/tests/cypress/e2e/actions_tasks2/case_101_opencv_basic_actions.js
index a62a3b13699a..ebfbd9ff62ae 100644
--- a/tests/cypress/e2e/actions_tasks2/case_101_opencv_basic_actions.js
+++ b/tests/cypress/e2e/actions_tasks2/case_101_opencv_basic_actions.js
@@ -1,5 +1,5 @@
 // Copyright (C) 2021-2022 Intel Corporation
-// Copyright (C) 2023-2024 CVAT.ai Corporation
+// Copyright (C) 2023-2025 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -32,13 +32,15 @@ context('OpenCV. Intelligent scissors. Histogram Equalization. TrackerMIL.', ()
         ],
         finishWithButton: true,
     };
-    const createOpencvTrackerShape = {
+
+    const createRectangleTrack2Points = {
+        points: 'By 2 Points',
+        type: 'Track',
+        firstX: 430,
+        firstY: 40,
+        secondX: 640,
+        secondY: 145,
         labelName,
-        tracker: 'TrackerMIL',
-        pointsMap: [
-            { x: 430, y: 40 },
-            { x: 640, y: 145 },
-        ],
     };
 
     const keyCodeN = 78;
@@ -209,27 +211,25 @@ context('OpenCV. Intelligent scissors. Histogram Equalization. TrackerMIL.', ()
         });
 
         it('Create a shape with "TrackerMIL". Track it for several frames.', () => {
+            cy.createRectangle(createRectangleTrack2Points);
             // We will start testing tracking from 2-d frame because it's a bit unstable on inintialization
-            cy.createOpenCVTrack(createOpencvTrackerShape);
-            cy.goToNextFrame(1);
-            cy.get('.cvat-tracking-notice').should('not.exist');
-            cy.get('#cvat_canvas_shape_3')
+            cy.useOpenCVTracker({ tracker: 'TrackerMIL', targetFrame: 4 });
+            cy.get('#cvat_canvas_shape_4')
                 .then((shape) => {
                     const x = Math.round(shape.attr('x'));
                     const y = Math.round(shape.attr('y'));
-                    for (let i = 2; i < imagesCount; i++) {
+                    for (let i = 1; i < imagesCount; i++) {
                         cy.goToNextFrame(i);
-                        cy.get('.cvat-tracking-notice').should('not.exist');
                         // In the beginning of this test we created images with text
                         // On each frame text is moved by 5px on x and y axis,
                         // so we expect shape to be close to real text positions
-                        cy.get('#cvat_canvas_shape_3').invoke('attr', 'x').then((xVal) => {
-                            expect(parseFloat(xVal)).to.be.closeTo(x + (i - 1) * 5, 3.0);
+                        cy.get('#cvat_canvas_shape_4').invoke('attr', 'x').then((xVal) => {
+                            expect(parseFloat(xVal)).to.be.closeTo(x + i * 5, 3.0);
                         });
-                        cy.get('#cvat_canvas_shape_3').invoke('attr', 'y').then((yVal) => {
-                            expect(parseFloat(yVal)).to.be.closeTo(y + (i - 1) * 5, 3.0);
+                        cy.get('#cvat_canvas_shape_4').invoke('attr', 'y').then((yVal) => {
+                            expect(parseFloat(yVal)).to.be.closeTo(y + i * 5, 3.0);
                         });
-                        cy.get('#cvat-objects-sidebar-state-item-3')
+                        cy.get('#cvat-objects-sidebar-state-item-4')
                             .should('contain', 'RECTANGLE TRACK')
                             .within(() => {
                                 cy.get('.cvat-object-item-button-keyframe-enabled').should('exist');
diff --git a/tests/cypress/support/commands_opencv.js b/tests/cypress/support/commands_opencv.js
index 1fef6d9fa88e..333b2d3a5778 100644
--- a/tests/cypress/support/commands_opencv.js
+++ b/tests/cypress/support/commands_opencv.js
@@ -1,5 +1,5 @@
 // Copyright (C) 2022 Intel Corporation
-// Copyright (C) 2023-2024 CVAT.ai Corporation
+// Copyright (C) 2023-2025 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -69,21 +69,22 @@ Cypress.Commands.add('opencvOpenTab', (tabName) => {
         .should('have.class', 'ant-tabs-tab-active');
 });
 
-Cypress.Commands.add('createOpenCVTrack', (trackParams) => {
+Cypress.Commands.add('useOpenCVTracker', (trackParams) => {
     cy.opencvOpenTab('Tracking');
-    cy.get('.cvat-opencv-tracking-label-select').find('.ant-select-selection-item').click();
-    cy.get('.ant-select-dropdown')
-        .not('.ant-select-dropdown-hidden')
-        .find(`.ant-select-item-option[title="${trackParams.labelName}"]`)
-        .click();
     cy.get('.cvat-opencv-tracker-select').find('.ant-select-selection-item').click();
     cy.get('.ant-select-dropdown')
         .not('.ant-select-dropdown-hidden')
         .find('.ant-select-item-option-content')
         .contains(trackParams.tracker)
         .click();
-    cy.get('.cvat-tools-track-button').click();
-    trackParams.pointsMap.forEach((point) => {
-        cy.get('.cvat-canvas-container').click(point.x, point.y);
+    cy.get('.cvat-tools-opencv-track-button').click();
+    cy.get('.cvat-action-runner-content').should('exist').and('be.visible');
+    cy.get('.cvat-action-runner-list .ant-select-selection-item').should('contain', trackParams.tracker);
+    cy.get('.cvat-action-runner-action-parameters').within(() => {
+        cy.get('.ant-input-number-input').clear();
+        cy.get('.ant-input-number-input').type(trackParams.targetFrame);
     });
+    cy.runAnnotationsAction();
+    cy.waitAnnotationsAction();
+    cy.closeAnnotationsActionsModal();
 });