diff --git a/.github/ISSUE_TEMPLATE/bug.yaml b/.github/ISSUE_TEMPLATE/bug.yaml
index 75e5eab63a13..45ba18777610 100644
--- a/.github/ISSUE_TEMPLATE/bug.yaml
+++ b/.github/ISSUE_TEMPLATE/bug.yaml
@@ -8,7 +8,7 @@ body:
     options:
     - label: I searched the existing issues and did not find anything similar.
       required: true
-    - label: I read/searched [the docs](https://github.com/cvat-ai/cvat/tree/master#documentation)
+    - label: I read/searched [the docs](https://opencv.github.io/cvat/docs/)
       required: true
 
 - type: textarea
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yaml b/.github/ISSUE_TEMPLATE/feature_request.yaml
index 1e0827936bc5..ab7222ad3123 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.yaml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yaml
@@ -8,7 +8,7 @@ body:
     options:
     - label: I searched the existing issues and did not find anything similar.
       required: true
-    - label: I read/searched [the docs](https://github.com/cvat-ai/cvat/tree/master#documentation)
+    - label: I read/searched [the docs](https://opencv.github.io/cvat/docs/)
       required: true
 - type: textarea
   attributes:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5967fc679be8..5872e8e68ac8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- scriv-insert-here -->
 
+<a id='changelog-2.11.1'></a>
+## \[2.11.1\] - 2024-03-05
+
+### Added
+
+- Single shape annotation mode allowing to easily annotate scenarious where a user
+only needs to draw one object on one image (<https://github.com/opencv/cvat/pull/7486>)
+
+### Fixed
+
+- Fixed a problem with Korean/Chinese characters in attribute annotation mode
+  (<https://github.com/opencv/cvat/pull/7380>)
+
+- Fixed incorrect working time calculation in the case where an event
+  occurred during another event
+  (<https://github.com/opencv/cvat/pull/7511>)
+
+- Fixed working time not being calculated for the first event in each batch
+  sent from the UI
+  (<https://github.com/opencv/cvat/pull/7511>)
+
+- Submit button is enabled while creating a ground truth job
+  (<https://github.com/opencv/cvat/pull/7540>)
+
 <a id='changelog-2.11.0'></a>
 ## \[2.11.0\] - 2024-02-23
 
diff --git a/cvat-canvas/package.json b/cvat-canvas/package.json
index f66d9ea9d74a..97302daace22 100644
--- a/cvat-canvas/package.json
+++ b/cvat-canvas/package.json
@@ -1,6 +1,6 @@
 {
   "name": "cvat-canvas",
-  "version": "2.19.1",
+  "version": "2.20.0",
   "type": "module",
   "description": "Part of Computer Vision Annotation Tool which presents its canvas library",
   "main": "src/canvas.ts",
diff --git a/cvat-canvas/src/typescript/canvasController.ts b/cvat-canvas/src/typescript/canvasController.ts
index 510145a64c4d..9acf58e95fc2 100644
--- a/cvat-canvas/src/typescript/canvasController.ts
+++ b/cvat-canvas/src/typescript/canvasController.ts
@@ -1,5 +1,5 @@
 // Copyright (C) 2019-2022 Intel Corporation
-// Copyright (C) 2022-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -45,13 +45,6 @@ export interface CanvasController {
     zoom(x: number, y: number, direction: number): void;
     draw(drawData: DrawData): void;
     edit(editData: MasksEditData): void;
-    interact(interactionData: InteractionData): void;
-    merge(mergeData: MergeData): void;
-    split(splitData: SplitData): void;
-    group(groupData: GroupData): void;
-    join(joinData: JoinData): void;
-    slice(sliceData: SliceData): void;
-    selectRegion(enabled: boolean): void;
     enableDrag(x: number, y: number): void;
     drag(x: number, y: number): void;
     disableDrag(): void;
@@ -107,34 +100,6 @@ export class CanvasControllerImpl implements CanvasController {
         this.model.edit(editData);
     }
 
-    public interact(interactionData: InteractionData): void {
-        this.model.interact(interactionData);
-    }
-
-    public merge(mergeData: MergeData): void {
-        this.model.merge(mergeData);
-    }
-
-    public split(splitData: SplitData): void {
-        this.model.split(splitData);
-    }
-
-    public group(groupData: GroupData): void {
-        this.model.group(groupData);
-    }
-
-    public join(joinData: JoinData): void {
-        this.model.join(joinData);
-    }
-
-    public slice(sliceData: SliceData): void {
-        this.model.slice(sliceData);
-    }
-
-    public selectRegion(enable: boolean): void {
-        this.model.selectRegion(enable);
-    }
-
     public get geometry(): Geometry {
         return this.model.geometry;
     }
diff --git a/cvat-canvas/src/typescript/canvasView.ts b/cvat-canvas/src/typescript/canvasView.ts
index 4582d87a84f7..d4ab384b69a5 100644
--- a/cvat-canvas/src/typescript/canvasView.ts
+++ b/cvat-canvas/src/typescript/canvasView.ts
@@ -1,5 +1,5 @@
 // Copyright (C) 2019-2022 Intel Corporation
-// Copyright (C) 2022-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -232,6 +232,16 @@ export class CanvasViewImpl implements CanvasView, Listener {
         }
     }
 
+    private dispatchCanceledEvent(): void {
+        this.mode = Mode.IDLE;
+        const event: CustomEvent = new CustomEvent('canvas.canceled', {
+            bubbles: false,
+            cancelable: true,
+        });
+
+        this.canvas.dispatchEvent(event);
+    }
+
     private onInteraction = (
         shapes: InteractionResult[] | null,
         shapesUpdated = true,
@@ -256,16 +266,7 @@ export class CanvasViewImpl implements CanvasView, Listener {
         }
 
         if (shapes === null || isDone) {
-            const event: CustomEvent = new CustomEvent('canvas.canceled', {
-                bubbles: false,
-                cancelable: true,
-            });
-
-            this.canvas.dispatchEvent(event);
-            this.mode = Mode.IDLE;
-            this.controller.interact({
-                enabled: false,
-            });
+            this.dispatchCanceledEvent();
         }
     };
 
@@ -290,13 +291,7 @@ export class CanvasViewImpl implements CanvasView, Listener {
                 const [state] = this.controller.objects
                     .filter((_state: any): boolean => _state.clientID === clientID);
                 this.onEditDone(state, points);
-
-                const event: CustomEvent = new CustomEvent('canvas.canceled', {
-                    bubbles: false,
-                    cancelable: true,
-                });
-
-                this.canvas.dispatchEvent(event);
+                this.dispatchCanceledEvent();
                 return;
             }
 
@@ -317,10 +312,7 @@ export class CanvasViewImpl implements CanvasView, Listener {
 
             this.canvas.dispatchEvent(event);
         } else if (!continueDraw) {
-            this.canvas.dispatchEvent(new CustomEvent('canvas.canceled', {
-                bubbles: false,
-                cancelable: true,
-            }));
+            this.dispatchCanceledEvent();
         }
 
         if (continueDraw) {
@@ -335,7 +327,8 @@ export class CanvasViewImpl implements CanvasView, Listener {
             );
         } else {
             // when draw stops from inside canvas (for example if use predefined number of points)
-            this.controller.draw({ enabled: false });
+            this.mode = Mode.IDLE;
+            this.canvas.style.cursor = '';
         }
     };
 
@@ -361,6 +354,7 @@ export class CanvasViewImpl implements CanvasView, Listener {
 
     private onEditDone = (state: any, points: number[], rotation?: number): void => {
         this.canvas.style.cursor = '';
+        this.mode = Mode.IDLE;
         if (state && points) {
             const event: CustomEvent = new CustomEvent('canvas.edited', {
                 bubbles: false,
@@ -374,18 +368,12 @@ export class CanvasViewImpl implements CanvasView, Listener {
 
             this.canvas.dispatchEvent(event);
         } else {
-            const event: CustomEvent = new CustomEvent('canvas.canceled', {
-                bubbles: false,
-                cancelable: true,
-            });
-
-            this.canvas.dispatchEvent(event);
+            this.dispatchCanceledEvent();
         }
 
         for (const clientID of Object.keys(this.innerObjectsFlags.editHidden)) {
             this.setupInnerFlags(+clientID, 'editHidden', false);
         }
-        this.mode = Mode.IDLE;
     };
 
     private onMergeDone = (objects: any[] | null, duration?: number): void => {
@@ -399,18 +387,11 @@ export class CanvasViewImpl implements CanvasView, Listener {
                 },
             });
 
+            this.mode = Mode.IDLE;
             this.canvas.dispatchEvent(event);
         } else {
-            const event: CustomEvent = new CustomEvent('canvas.canceled', {
-                bubbles: false,
-                cancelable: true,
-            });
-
-            this.canvas.dispatchEvent(event);
+            this.dispatchCanceledEvent();
         }
-
-        this.controller.merge({ enabled: false });
-        this.mode = Mode.IDLE;
     };
 
     private onSplitDone = (object?: any, duration?: number): void => {
@@ -425,23 +406,23 @@ export class CanvasViewImpl implements CanvasView, Listener {
                 },
             });
 
+            this.canvas.style.cursor = '';
+            this.mode = Mode.IDLE;
+            this.splitHandler.split({ enabled: false });
             this.canvas.dispatchEvent(event);
         } else {
-            const event: CustomEvent = new CustomEvent('canvas.canceled', {
-                bubbles: false,
-                cancelable: true,
-            });
-
-            this.canvas.dispatchEvent(event);
+            this.dispatchCanceledEvent();
         }
-
-        this.controller.split({ enabled: false });
-        this.mode = Mode.IDLE;
     };
 
     private onSelectDone = (objects?: any[], duration?: number): void => {
+        if (this.mode === Mode.JOIN) {
+            this.onMessage(null, 'join');
+        }
+
         if (objects && typeof duration !== 'undefined') {
             if (this.mode === Mode.GROUP && objects.length > 1) {
+                this.mode = Mode.IDLE;
                 this.canvas.dispatchEvent(new CustomEvent('canvas.groupped', {
                     bubbles: false,
                     cancelable: true,
@@ -451,6 +432,7 @@ export class CanvasViewImpl implements CanvasView, Listener {
                     },
                 }));
             } else if (this.mode === Mode.JOIN && objects.length > 1) {
+                this.mode = Mode.IDLE;
                 let [left, top, right, bottom] = objects[0].points.slice(-4);
                 objects.forEach((state) => {
                     const [curLeft, curTop, curRight, curBottom] = state.points.slice(-4);
@@ -487,26 +469,14 @@ export class CanvasViewImpl implements CanvasView, Listener {
                 }).catch(this.onError);
             }
         } else {
-            const event: CustomEvent = new CustomEvent('canvas.canceled', {
-                bubbles: false,
-                cancelable: true,
-            });
-
-            this.canvas.dispatchEvent(event);
+            this.dispatchCanceledEvent();
         }
-
-        if (this.mode === Mode.GROUP) {
-            this.controller.group({ enabled: false });
-        } else if (this.mode === Mode.JOIN) {
-            this.controller.join({ enabled: false });
-            this.onMessage(null, 'join');
-        }
-
-        this.mode = Mode.IDLE;
     };
 
     private onSliceDone = (state?: any, results?: number[][], duration?: number): void => {
         if (state && results && typeof duration !== 'undefined') {
+            this.mode = Mode.IDLE;
+            this.sliceHandler.slice({ enabled: false });
             this.canvas.dispatchEvent(new CustomEvent('canvas.sliced', {
                 bubbles: false,
                 cancelable: true,
@@ -517,40 +487,22 @@ export class CanvasViewImpl implements CanvasView, Listener {
                 },
             }));
         } else {
-            const event: CustomEvent = new CustomEvent('canvas.canceled', {
-                bubbles: false,
-                cancelable: true,
-            });
-
-            this.canvas.dispatchEvent(event);
+            this.dispatchCanceledEvent();
         }
-
-        this.controller.slice({ enabled: false });
-        this.mode = Mode.IDLE;
     };
 
     private onRegionSelected = (points?: number[]): void => {
         if (points) {
-            const event: CustomEvent = new CustomEvent('canvas.regionselected', {
+            this.canvas.dispatchEvent(new CustomEvent('canvas.regionselected', {
                 bubbles: false,
                 cancelable: true,
                 detail: {
                     points,
                 },
-            });
-
-            this.canvas.dispatchEvent(event);
+            }));
         } else {
-            const event: CustomEvent = new CustomEvent('canvas.canceled', {
-                bubbles: false,
-                cancelable: true,
-            });
-
-            this.canvas.dispatchEvent(event);
+            this.dispatchCanceledEvent();
         }
-
-        this.controller.selectRegion(false);
-        this.mode = Mode.IDLE;
     };
 
     private onFindObject = (e: MouseEvent): void => {
@@ -1711,8 +1663,6 @@ export class CanvasViewImpl implements CanvasView, Listener {
             if (data.enabled) {
                 this.canvas.style.cursor = 'copy';
                 this.mode = Mode.MERGE;
-            } else {
-                this.canvas.style.cursor = '';
             }
             this.mergeHandler.merge(data);
         } else if (reason === UpdateReasons.SPLIT) {
@@ -1720,10 +1670,8 @@ export class CanvasViewImpl implements CanvasView, Listener {
             if (data.enabled) {
                 this.canvas.style.cursor = 'copy';
                 this.mode = Mode.SPLIT;
-            } else {
-                this.canvas.style.cursor = '';
+                this.splitHandler.split(data);
             }
-            this.splitHandler.split(data);
         } else if ([UpdateReasons.JOIN, UpdateReasons.GROUP].includes(reason)) {
             let data: GroupData | JoinData = null;
             if (reason === UpdateReasons.GROUP) {
@@ -1745,18 +1693,12 @@ export class CanvasViewImpl implements CanvasView, Listener {
                     objectType: ['shape'],
                 });
             }
-
-            if (data.enabled) {
-                this.canvas.style.cursor = 'copy';
-            } else {
-                this.canvas.style.cursor = '';
-            }
         } else if (reason === UpdateReasons.SLICE) {
             const data = this.controller.sliceData;
             if (data.enabled && this.mode === Mode.IDLE) {
                 this.mode = Mode.SLICE;
+                this.sliceHandler.slice(data);
             }
-            this.sliceHandler.slice(data);
         } else if (reason === UpdateReasons.SELECT) {
             this.objectSelector.push(this.controller.selected);
             if (this.mode === Mode.MERGE) {
@@ -1805,8 +1747,8 @@ export class CanvasViewImpl implements CanvasView, Listener {
                     }),
                 );
             }
-            this.mode = Mode.IDLE;
             this.canvas.style.cursor = '';
+            this.dispatchCanceledEvent();
         } else if (reason === UpdateReasons.DATA_FAILED) {
             this.onError(model.exception, 'data fetching');
         } else if (reason === UpdateReasons.DESTROY) {
diff --git a/cvat-canvas/src/typescript/drawHandler.ts b/cvat-canvas/src/typescript/drawHandler.ts
index 75127693b297..b7e9cbb90130 100644
--- a/cvat-canvas/src/typescript/drawHandler.ts
+++ b/cvat-canvas/src/typescript/drawHandler.ts
@@ -1,5 +1,5 @@
 // Copyright (C) 2019-2022 Intel Corporation
-// Copyright (C) 2023 CVAT.ai Corporation
+// Copyright (C) 2023-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -388,8 +388,11 @@ export class DrawHandlerImpl implements DrawHandler {
             }
             // Clear drawing
             this.drawInstance.draw('stop');
-        } else if (this.drawInstance && this.drawData.shapeType === 'ellipse' && !this.drawData.initialState) {
-            this.drawInstance.fire('drawstop');
+        } else {
+            this.onDrawDone(null);
+            if (this.drawInstance && this.drawData.shapeType === 'ellipse' && !this.drawData.initialState) {
+                this.drawInstance.fire('drawstop');
+            }
         }
 
         if (this.pointsGroup) {
@@ -409,8 +412,6 @@ export class DrawHandlerImpl implements DrawHandler {
         if (this.crosshair) {
             this.removeCrosshair();
         }
-
-        this.onDrawDone(null);
     }
 
     private initDrawing(): void {
@@ -426,9 +427,12 @@ export class DrawHandlerImpl implements DrawHandler {
                 const points = readPointsFromShape((e.target as any as { instance: SVG.Rect }).instance);
                 const [xtl, ytl, xbr, ybr] = this.getFinalRectCoordinates(points, true);
                 const { shapeType, redraw: clientID } = this.drawData;
-                this.release();
 
-                if (this.canceled) return;
+                if (this.canceled) {
+                    return;
+                }
+
+                this.release();
                 if (checkConstraint('rectangle', [xtl, ytl, xbr, ybr])) {
                     this.onDrawDone({
                         clientID,
@@ -436,6 +440,8 @@ export class DrawHandlerImpl implements DrawHandler {
                         points: [xtl, ytl, xbr, ybr],
                     },
                     Date.now() - this.startTimestamp);
+                } else {
+                    this.onDrawDone(null);
                 }
             })
             .on('drawupdate', (): void => {
@@ -467,11 +473,13 @@ export class DrawHandlerImpl implements DrawHandler {
         };
 
         this.canvas.on('mousedown.draw', (e: MouseEvent): void => {
-            if (initialPoint.x === null || initialPoint.y === null) {
-                const translated = translateToSVG(this.canvas.node as any as SVGSVGElement, [e.clientX, e.clientY]);
-                [initialPoint.x, initialPoint.y] = translated;
-            } else {
-                this.drawInstance.fire('drawstop');
+            if (e.button === 0 && !e.altKey) {
+                if (initialPoint.x === null || initialPoint.y === null) {
+                    const translated = translateToSVG(this.canvas.node as any as SVGSVGElement, [e.clientX, e.clientY]);
+                    [initialPoint.x, initialPoint.y] = translated;
+                } else {
+                    this.drawInstance.fire('drawstop');
+                }
             }
         });
 
@@ -492,9 +500,12 @@ export class DrawHandlerImpl implements DrawHandler {
             this.drawInstance.off('drawstop');
             const points = this.getFinalEllipseCoordinates(readPointsFromShape(this.drawInstance), false);
             const { shapeType, redraw: clientID } = this.drawData;
-            this.release();
 
-            if (this.canceled) return;
+            if (this.canceled) {
+                return;
+            }
+
+            this.release();
             if (checkConstraint('ellipse', points)) {
                 this.onDrawDone(
                     {
@@ -504,6 +515,8 @@ export class DrawHandlerImpl implements DrawHandler {
                     },
                     Date.now() - this.startTimestamp,
                 );
+            } else {
+                this.onDrawDone(null);
             }
         });
     }
@@ -623,9 +636,12 @@ export class DrawHandlerImpl implements DrawHandler {
             const { points, box } = shapeType === 'cuboid' ?
                 this.getFinalCuboidCoordinates(targetPoints) :
                 this.getFinalPolyshapeCoordinates(targetPoints, true);
-            this.release();
 
-            if (this.canceled) return;
+            if (this.canceled) {
+                return;
+            }
+
+            this.release();
             if (checkConstraint(shapeType, points, box)) {
                 if (shapeType === 'cuboid') {
                     this.onDrawDone(
@@ -636,6 +652,8 @@ export class DrawHandlerImpl implements DrawHandler {
                 }
 
                 this.onDrawDone({ clientID, shapeType, points }, Date.now() - this.startTimestamp);
+            } else {
+                this.onDrawDone(null);
             }
         });
     }
@@ -699,9 +717,12 @@ export class DrawHandlerImpl implements DrawHandler {
                 const points = readPointsFromShape((e.target as any as { instance: SVG.Rect }).instance);
                 const [xtl, ytl, xbr, ybr] = this.getFinalRectCoordinates(points, true);
                 const { shapeType, redraw: clientID } = this.drawData;
-                this.release();
 
-                if (this.canceled) return;
+                if (this.canceled) {
+                    return;
+                }
+
+                this.release();
                 if (checkConstraint('cuboid', [xtl, ytl, xbr, ybr])) {
                     const d = { x: (xbr - xtl) * 0.1, y: (ybr - ytl) * 0.1 };
                     this.onDrawDone({
@@ -710,6 +731,8 @@ export class DrawHandlerImpl implements DrawHandler {
                         clientID,
                     },
                     Date.now() - this.startTimestamp);
+                } else {
+                    this.onDrawDone(null);
                 }
             })
             .on('drawupdate', (): void => {
@@ -765,9 +788,12 @@ export class DrawHandlerImpl implements DrawHandler {
                 });
 
                 const { shapeType, redraw: clientID } = this.drawData;
-                this.release();
 
-                if (this.canceled) return;
+                if (this.canceled) {
+                    return;
+                }
+
+                this.release();
                 if (checkConstraint('skeleton', [xtl, ytl, xbr, ybr])) {
                     this.onDrawDone({
                         clientID,
@@ -775,6 +801,8 @@ export class DrawHandlerImpl implements DrawHandler {
                         elements,
                     },
                     Date.now() - this.startTimestamp);
+                } else {
+                    this.onDrawDone(null);
                 }
             })
             .on('drawupdate', (): void => {
diff --git a/cvat-canvas/src/typescript/masksHandler.ts b/cvat-canvas/src/typescript/masksHandler.ts
index cd7aa58d69fe..7a12789ee276 100644
--- a/cvat-canvas/src/typescript/masksHandler.ts
+++ b/cvat-canvas/src/typescript/masksHandler.ts
@@ -138,7 +138,6 @@ export class MasksHandlerImpl implements MasksHandler {
         this.isInsertion = false;
         this.redraw = null;
         this.drawnObjects = this.createDrawnObjectsArray();
-        this.onDrawDone(null);
     }
 
     private releaseEdit(): void {
@@ -614,6 +613,8 @@ export class MasksHandlerImpl implements MasksHandler {
                             ...(Number.isInteger(this.redraw) ? { clientID: this.redraw } : {}),
                         }, Date.now() - this.startTimestamp, drawData.continue, this.drawData);
                     }
+                } else {
+                    this.onDrawDone(null);
                 }
             } finally {
                 this.releaseDraw();
@@ -627,6 +628,8 @@ export class MasksHandlerImpl implements MasksHandler {
                     enabled: true,
                     shapeType: 'mask',
                 };
+
+                this.onDrawRepeat({ enabled: true, shapeType: 'mask' });
                 this.onDrawRepeat(newDrawData);
                 return;
             }
diff --git a/cvat-cli/requirements/base.txt b/cvat-cli/requirements/base.txt
index 923a5c573f90..84eed943a020 100644
--- a/cvat-cli/requirements/base.txt
+++ b/cvat-cli/requirements/base.txt
@@ -1,3 +1,3 @@
-cvat-sdk~=2.11.0
+cvat-sdk~=2.11.1
 Pillow>=10.1.0
 setuptools>=65.5.1 # not directly required, pinned by Snyk to avoid a vulnerability
diff --git a/cvat-cli/src/cvat_cli/version.py b/cvat-cli/src/cvat_cli/version.py
index e80dd8624369..fd36d7a74976 100644
--- a/cvat-cli/src/cvat_cli/version.py
+++ b/cvat-cli/src/cvat_cli/version.py
@@ -1 +1 @@
-VERSION = "2.11.0"
+VERSION = "2.11.1"
diff --git a/cvat-core/package.json b/cvat-core/package.json
index 9e025040d04b..81a1937817f8 100644
--- a/cvat-core/package.json
+++ b/cvat-core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "cvat-core",
-  "version": "14.1.1",
+  "version": "15.0.0",
   "type": "module",
   "description": "Part of Computer Vision Tool which presents an interface for client-side integration",
   "main": "src/api.ts",
diff --git a/cvat-core/src/annotations-collection.ts b/cvat-core/src/annotations-collection.ts
index 86221e2bbefa..ed380838fa10 100644
--- a/cvat-core/src/annotations-collection.ts
+++ b/cvat-core/src/annotations-collection.ts
@@ -1208,17 +1208,30 @@ export default class Collection {
         };
     }
 
-    searchEmpty(frameFrom: number, frameTo: number): number | null {
+    _searchEmpty(
+        frameFrom: number,
+        frameTo: number,
+        searchParameters: {
+            allowDeletedFrames: boolean;
+        },
+    ): number | null {
+        const { allowDeletedFrames } = searchParameters;
         const sign = Math.sign(frameTo - frameFrom);
         const predicate = sign > 0 ? (frame) => frame <= frameTo : (frame) => frame >= frameTo;
         const update = sign > 0 ? (frame) => frame + 1 : (frame) => frame - 1;
         for (let frame = frameFrom; predicate(frame); frame = update(frame)) {
+            if (!allowDeletedFrames && this.frameMeta[frame].deleted) {
+                continue;
+            }
+
             if (frame in this.shapes && this.shapes[frame].some((shape) => !shape.removed)) {
                 continue;
             }
+
             if (frame in this.tags && this.tags[frame].some((tag) => !tag.removed)) {
                 continue;
             }
+
             const filteredTracks = this.tracks.filter((track) => !track.removed);
             let found = false;
             for (const track of filteredTracks) {
@@ -1241,14 +1254,58 @@ export default class Collection {
         return null;
     }
 
-    search(filters: string[], frameFrom: number, frameTo: number): number | null {
-        const sign = Math.sign(frameTo - frameFrom);
-        const filtersStr = JSON.stringify(filters);
-        const linearSearch = filtersStr.match(/"var":"width"/) || filtersStr.match(/"var":"height"/);
+    search(
+        frameFrom: number,
+        frameTo: number,
+        searchParameters: {
+            allowDeletedFrames: boolean;
+            annotationsFilters?: object[];
+            generalFilters?: {
+                isEmptyFrame?: boolean;
+            };
+        },
+    ): number | null {
+        const { allowDeletedFrames } = searchParameters;
+        let { annotationsFilters } = searchParameters;
+
+        if ('generalFilters' in searchParameters) {
+            // if we are looking for en empty frame, run a dedicated algorithm
+            if (searchParameters.generalFilters.isEmptyFrame) {
+                return this._searchEmpty(frameFrom, frameTo, { allowDeletedFrames });
+            }
+
+            // not empty frames corresponds to default behaviour of the function with empty annotation filters
+            annotationsFilters = [];
+        }
 
+        const sign = Math.sign(frameTo - frameFrom);
         const predicate = sign > 0 ? (frame) => frame <= frameTo : (frame) => frame >= frameTo;
         const update = sign > 0 ? (frame) => frame + 1 : (frame) => frame - 1;
+
+        // if not looking for an emty frame nor frame with annotations, return the next frame
+        // check if deleted frames are allowed additionally
+        if (!annotationsFilters) {
+            let frame = frameFrom;
+            while (predicate(frame)) {
+                if (!allowDeletedFrames && this.frameMeta[frame].deleted) {
+                    frame = update(frame);
+                    continue;
+                }
+
+                return frame;
+            }
+
+            return null;
+        }
+
+        const filtersStr = JSON.stringify(annotationsFilters);
+        const linearSearch = filtersStr.match(/"var":"width"/) || filtersStr.match(/"var":"height"/);
+
         for (let frame = frameFrom; predicate(frame); frame = update(frame)) {
+            if (!allowDeletedFrames && this.frameMeta[frame].deleted) {
+                continue;
+            }
+
             // First prepare all data for the frame
             // Consider all shapes, tags, and not outside tracks that have keyframe here
             // In particular consider first and last frame as keyframes for all tracks
@@ -1267,13 +1324,8 @@ export default class Collection {
                 .filter((track) => !track.removed);
             statesData.push(...tracks.map((track) => track.get(frame)).filter((state) => !state.outside));
 
-            // Nothing to filtering, go to the next iteration
-            if (!statesData.length) {
-                continue;
-            }
-
             // Filtering
-            const filtered = this.annotationsFilter.filter(statesData, filters);
+            const filtered = this.annotationsFilter.filter(statesData, annotationsFilters);
             if (filtered.length) {
                 return frame;
             }
diff --git a/cvat-core/src/annotations-filter.ts b/cvat-core/src/annotations-filter.ts
index c47c15ff334b..58c9e82a63e5 100644
--- a/cvat-core/src/annotations-filter.ts
+++ b/cvat-core/src/annotations-filter.ts
@@ -1,5 +1,5 @@
 // Copyright (C) 2020-2022 Intel Corporation
-// Copyright (C) 2023 CVAT.ai Corporation
+// Copyright (C) 2023-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -89,7 +89,7 @@ export default class AnnotationsFilter {
         return objects;
     }
 
-    filter(statesData: SerializedData[], filters: string[]): number[] {
+    filter(statesData: SerializedData[], filters: object[]): number[] {
         if (!filters.length) return statesData.map((stateData): number => stateData.clientID);
         const converted = this._convertObjects(statesData);
         return converted
diff --git a/cvat-core/src/frames.ts b/cvat-core/src/frames.ts
index 412cecde88d8..a6aa0a668238 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-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -612,7 +612,11 @@ export async function findFrame(
     const offset = filters.offset || 1;
     let meta;
     if (!frameDataCache[jobID]) {
-        meta = await serverProxy.frames.getMeta('job', jobID);
+        const serverMeta = await serverProxy.frames.getMeta('job', jobID);
+        meta = {
+            ...serverMeta,
+            deleted_frames: Object.fromEntries(serverMeta.deleted_frames.map((_frame) => [_frame, true])),
+        };
     } else {
         meta = frameDataCache[jobID].meta;
     }
diff --git a/cvat-core/src/logger.ts b/cvat-core/src/logger.ts
index cfb3861e9462..d13b1d7a6fe3 100644
--- a/cvat-core/src/logger.ts
+++ b/cvat-core/src/logger.ts
@@ -34,6 +34,7 @@ type IgnoredRules = EventScope.zoomImage | EventScope.changeAttribute | EventSco
 class Logger {
     public clientID: string;
     public collection: Array<Event>;
+    public lastSentEvent: Event | null;
     public ignoreRules: Record<IgnoredRules, IgnoreRule>;
     public isActiveChecker: (() => boolean) | null;
     public saving: boolean;
@@ -42,6 +43,7 @@ class Logger {
     constructor() {
         this.clientID = Date.now().toString().substr(-6);
         this.collection = [];
+        this.lastSentEvent = null;
         this.isActiveChecker = null;
         this.saving = false;
         this.compressedScopes = [EventScope.changeFrame];
@@ -209,9 +211,12 @@ Object.defineProperties(Logger.prototype.save, {
                 this.collection = [];
                 await serverProxy.events.save({
                     events: collectionToSend.map((event) => event.dump()),
+                    previous_event: this.lastSentEvent?.dump(),
                     timestamp: new Date().toISOString(),
                 });
 
+                this.lastSentEvent = collectionToSend[collectionToSend.length - 1];
+
                 for (const rule of Object.values<IgnoreRule>(this.ignoreRules)) {
                     rule.lastEvent = null;
                 }
diff --git a/cvat-core/src/session-implementation.ts b/cvat-core/src/session-implementation.ts
index 44e8639a8796..124424f78fb8 100644
--- a/cvat-core/src/session-implementation.ts
+++ b/cvat-core/src/session-implementation.ts
@@ -231,27 +231,19 @@ export function implementJob(Job) {
         return annotationsData;
     };
 
-    Job.prototype.annotations.search.implementation = function (filters, frameFrom, frameTo) {
-        if (!Array.isArray(filters)) {
-            throw new ArgumentError('Filters must be an array');
-        }
-
-        if (!Number.isInteger(frameFrom) || !Number.isInteger(frameTo)) {
-            throw new ArgumentError('The start and end frames both must be an integer');
+    Job.prototype.annotations.search.implementation = function (frameFrom, frameTo, searchParameters) {
+        if ('annotationsFilters' in searchParameters && !Array.isArray(searchParameters.annotationsFilters)) {
+            throw new ArgumentError('Annotations filters must be an array');
         }
 
-        if (frameFrom < this.startFrame || frameFrom > this.stopFrame) {
-            throw new ArgumentError('The start frame is out of the job');
+        if ('generalFilters' in searchParameters && typeof searchParameters.generalFilters.isEmptyFrame !== 'boolean') {
+            throw new ArgumentError('General filter isEmptyFrame must be a boolean');
         }
 
-        if (frameTo < this.startFrame || frameTo > this.stopFrame) {
-            throw new ArgumentError('The stop frame is out of the job');
+        if ('annotationsFilters' in searchParameters && 'generalFilters' in searchParameters) {
+            throw new ArgumentError('Both annotations filters and general fiters could not be used together');
         }
 
-        return getCollection(this).search(filters, frameFrom, frameTo);
-    };
-
-    Job.prototype.annotations.searchEmpty.implementation = function (frameFrom, frameTo) {
         if (!Number.isInteger(frameFrom) || !Number.isInteger(frameTo)) {
             throw new ArgumentError('The start and end frames both must be an integer');
         }
@@ -264,7 +256,7 @@ export function implementJob(Job) {
             throw new ArgumentError('The stop frame is out of the job');
         }
 
-        return getCollection(this).searchEmpty(frameFrom, frameTo);
+        return getCollection(this).search(frameFrom, frameTo, searchParameters);
     };
 
     Job.prototype.annotations.save.implementation = async function (onUpdate) {
@@ -682,7 +674,7 @@ export function implementTask(Task) {
             throw new ArgumentError(`Frame ${frame} does not exist in the task`);
         }
 
-        const result = await getAnnotations(this, frame, allTracks, filters, null);
+        const result = await getAnnotations(this, frame, allTracks, filters);
         const deletedFrames = await getDeletedFrames('task', this.id);
         if (frame in deletedFrames) {
             return [];
@@ -691,27 +683,19 @@ export function implementTask(Task) {
         return result;
     };
 
-    Task.prototype.annotations.search.implementation = function (filters, frameFrom, frameTo) {
-        if (!Array.isArray(filters) || filters.some((filter) => typeof filter !== 'string')) {
-            throw new ArgumentError('The filters argument must be an array of strings');
-        }
-
-        if (!Number.isInteger(frameFrom) || !Number.isInteger(frameTo)) {
-            throw new ArgumentError('The start and end frames both must be an integer');
+    Task.prototype.annotations.search.implementation = function (frameFrom, frameTo, searchParameters) {
+        if ('annotationsFilters' in searchParameters && !Array.isArray(searchParameters.annotationsFilters)) {
+            throw new ArgumentError('Annotations filters must be an array');
         }
 
-        if (frameFrom < 0 || frameFrom >= this.size) {
-            throw new ArgumentError('The start frame is out of the task');
+        if ('generalFilters' in searchParameters && typeof searchParameters.generalFilters.isEmptyFrame !== 'boolean') {
+            throw new ArgumentError('General filter isEmptyFrame must be a boolean');
         }
 
-        if (frameTo < 0 || frameTo >= this.size) {
-            throw new ArgumentError('The stop frame is out of the task');
+        if ('annotationsFilters' in searchParameters && 'generalFilters' in searchParameters) {
+            throw new ArgumentError('Both annotations filters and general fiters could not be used together');
         }
 
-        return getCollection(this).search(filters, frameFrom, frameTo);
-    };
-
-    Task.prototype.annotations.searchEmpty.implementation = function (frameFrom, frameTo) {
         if (!Number.isInteger(frameFrom) || !Number.isInteger(frameTo)) {
             throw new ArgumentError('The start and end frames both must be an integer');
         }
@@ -724,7 +708,7 @@ export function implementTask(Task) {
             throw new ArgumentError('The stop frame is out of the task');
         }
 
-        return getCollection(this).searchEmpty(frameFrom, frameTo);
+        return getCollection(this).search(frameFrom, frameTo, searchParameters);
     };
 
     Task.prototype.annotations.save.implementation = async function (onUpdate) {
diff --git a/cvat-core/src/session.ts b/cvat-core/src/session.ts
index 8c9aea99aa69..e1e8f46c732a 100644
--- a/cvat-core/src/session.ts
+++ b/cvat-core/src/session.ts
@@ -1,5 +1,5 @@
 // Copyright (C) 2019-2022 Intel Corporation
-// Copyright (C) 2022-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -82,23 +82,13 @@ function buildDuplicatedAPI(prototype) {
                     return result;
                 },
 
-                async search(filters, frameFrom, frameTo) {
+                async search(frameFrom, frameTo, searchParameters) {
                     const result = await PluginRegistry.apiWrapper.call(
                         this,
                         prototype.annotations.search,
-                        filters,
-                        frameFrom,
-                        frameTo,
-                    );
-                    return result;
-                },
-
-                async searchEmpty(frameFrom, frameTo) {
-                    const result = await PluginRegistry.apiWrapper.call(
-                        this,
-                        prototype.annotations.searchEmpty,
                         frameFrom,
                         frameTo,
+                        searchParameters,
                     );
                     return result;
                 },
@@ -324,7 +314,6 @@ export class Session {
         slice: CallableFunction;
         clear: CallableFunction;
         search: CallableFunction;
-        searchEmpty: CallableFunction;
         upload: CallableFunction;
         select: CallableFunction;
         import: CallableFunction;
@@ -377,7 +366,6 @@ export class Session {
             slice: Object.getPrototypeOf(this).annotations.slice.bind(this),
             clear: Object.getPrototypeOf(this).annotations.clear.bind(this),
             search: Object.getPrototypeOf(this).annotations.search.bind(this),
-            searchEmpty: Object.getPrototypeOf(this).annotations.searchEmpty.bind(this),
             upload: Object.getPrototypeOf(this).annotations.upload.bind(this),
             select: Object.getPrototypeOf(this).annotations.select.bind(this),
             import: Object.getPrototypeOf(this).annotations.import.bind(this),
diff --git a/cvat-core/tests/api/annotations.cjs b/cvat-core/tests/api/annotations.cjs
index fc3e9d00fea8..724ecfa06c95 100644
--- a/cvat-core/tests/api/annotations.cjs
+++ b/cvat-core/tests/api/annotations.cjs
@@ -1,5 +1,5 @@
 // Copyright (C) 2020-2022 Intel Corporation
-// Copyright (C) 2022-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -956,29 +956,29 @@ describe('Feature: search frame', () => {
     test('applying different filters', async () => {
         const job = (await cvat.jobs.get({ jobID: 102 }))[0];
         await job.annotations.clear(true);
-        let frame = await job.annotations.search(JSON.parse('[{"and":[{"==":[{"var":"type"},"tag"]}]}]'), 495, 994);
+        let frame = await job.annotations.search(495, 994, { annotationsFilters: JSON.parse('[{"and":[{"==":[{"var":"type"},"tag"]}]}]') });
         expect(frame).toBe(500);
-        frame = await job.annotations.search(JSON.parse('[{"and":[{"==":[{"var":"type"},"tag"]},{"==":[{"var":"label"},"bicycle"]}]}]'), 495, 994);
+        frame = await job.annotations.search(495, 994, { annotationsFilters: JSON.parse('[{"and":[{"==":[{"var":"type"},"tag"]},{"==":[{"var":"label"},"bicycle"]}]}]') });
         expect(frame).toBe(500);
-        frame = await job.annotations.search(JSON.parse('[{"and":[{"==":[{"var":"type"},"track"]},{"==":[{"var":"label"},"bicycle"]}]}]'), 495, 994);
+        frame = await job.annotations.search(495, 994, { annotationsFilters: JSON.parse('[{"and":[{"==":[{"var":"type"},"track"]},{"==":[{"var":"label"},"bicycle"]}]}]') });
         expect(frame).toBe(null);
 
-        frame = await job.annotations.search(JSON.parse('[{"and":[{"==":[{"var":"type"},"shape"]},{"==":[{"var":"shape"},"rectangle"]}]}]'), 495, 994);
+        frame = await job.annotations.search(495, 994, { annotationsFilters: JSON.parse('[{"and":[{"==":[{"var":"type"},"shape"]},{"==":[{"var":"shape"},"rectangle"]}]}]') });
         expect(frame).toBe(510);
-        frame = await job.annotations.search(JSON.parse('[{"and":[{"==":[{"var":"type"},"shape"]},{"==":[{"var":"shape"},"rectangle"]}]}]'), 511, 994);
+        frame = await job.annotations.search(511, 994, { annotationsFilters: JSON.parse('[{"and":[{"==":[{"var":"type"},"shape"]},{"==":[{"var":"shape"},"rectangle"]}]}]') });
         expect(frame).toBe(null);
-        frame = await job.annotations.search(JSON.parse('[{"and":[{"==":[{"var":"type"},"shape"]},{"==":[{"var":"shape"},"polygon"]}]}]'), 511, 994);
+        frame = await job.annotations.search(511, 994, { annotationsFilters: JSON.parse('[{"and":[{"==":[{"var":"type"},"shape"]},{"==":[{"var":"shape"},"polygon"]}]}]') });
         expect(frame).toBe(520);
-        frame = await job.annotations.search(JSON.parse('[{"and":[{"==":[{"var":"attr.motorcycle.model"},"some text for test"]}]}]'), 495, 994);
+        frame = await job.annotations.search(495, 994, { annotationsFilters: JSON.parse('[{"and":[{"==":[{"var":"attr.motorcycle.model"},"some text for test"]}]}]') });
         expect(frame).toBe(520);
-        frame = await job.annotations.search(JSON.parse('[{"and":[{"==":[{"var":"attr.motorcycle.model"},"some text for test"]},{"==":[{"var":"shape"},"ellipse"]}]}]'), 495, 994);
+        frame = await job.annotations.search(495, 994, { annotationsFilters: JSON.parse('[{"and":[{"==":[{"var":"attr.motorcycle.model"},"some text for test"]},{"==":[{"var":"shape"},"ellipse"]}]}]') });
         expect(frame).toBe(null);
 
-        frame = await job.annotations.search(JSON.parse('[{"and":[{"<=":[450,{"var":"width"},550]}]}]'), 540, 994);
+        frame = await job.annotations.search(540, 994, { annotationsFilters: JSON.parse('[{"and":[{"<=":[450,{"var":"width"},550]}]}]') });
         expect(frame).toBe(563);
-        frame = await job.annotations.search(JSON.parse('[{"and":[{"<=":[450,{"var":"width"},550]}]}]'), 588, 994);
+        frame = await job.annotations.search(588, 994, { annotationsFilters: JSON.parse('[{"and":[{"<=":[450,{"var":"width"},550]}]}]') });
         expect(frame).toBe(null);
-        frame = await job.annotations.search(JSON.parse('[{"and":[{">=":[{"var":"width"},500]},{"<=":[{"var":"height"},300]}]}]'), 540, 994);
+        frame = await job.annotations.search(540, 994, { annotationsFilters: JSON.parse('[{"and":[{">=":[{"var":"width"},500]},{"<=":[{"var":"height"},300]}]}]') });
         expect(frame).toBe(575);
     });
 });
diff --git a/cvat-sdk/gen/generate.sh b/cvat-sdk/gen/generate.sh
index 0ce2af39efd0..0c0e04c70fe4 100755
--- a/cvat-sdk/gen/generate.sh
+++ b/cvat-sdk/gen/generate.sh
@@ -8,7 +8,7 @@ set -e
 
 GENERATOR_VERSION="v6.0.1"
 
-VERSION="2.11.0"
+VERSION="2.11.1"
 LIB_NAME="cvat_sdk"
 LAYER1_LIB_NAME="${LIB_NAME}/api_client"
 DST_DIR="$(cd "$(dirname -- "$0")/.." && pwd)"
diff --git a/cvat-ui/package.json b/cvat-ui/package.json
index 21fe7cd13727..2211771e9038 100644
--- a/cvat-ui/package.json
+++ b/cvat-ui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "cvat-ui",
-  "version": "1.62.0",
+  "version": "1.63.1",
   "description": "CVAT single-page application",
   "main": "src/index.tsx",
   "scripts": {
diff --git a/cvat-ui/src/actions/annotation-actions.ts b/cvat-ui/src/actions/annotation-actions.ts
index d07c62cad1d6..091fe1e80d55 100644
--- a/cvat-ui/src/actions/annotation-actions.ts
+++ b/cvat-ui/src/actions/annotation-actions.ts
@@ -23,6 +23,7 @@ import {
     CombinedState,
     ContextMenuType,
     FrameSpeed,
+    NavigationType,
     ObjectType,
     OpenCVTool,
     Rotation,
@@ -175,7 +176,6 @@ export enum AnnotationActionTypes {
     SWITCH_Z_LAYER = 'SWITCH_Z_LAYER',
     ADD_Z_LAYER = 'ADD_Z_LAYER',
     SEARCH_ANNOTATIONS_FAILED = 'SEARCH_ANNOTATIONS_FAILED',
-    SEARCH_EMPTY_FRAME_FAILED = 'SEARCH_EMPTY_FRAME_FAILED',
     CHANGE_WORKSPACE = 'CHANGE_WORKSPACE',
     SAVE_LOGS_SUCCESS = 'SAVE_LOGS_SUCCESS',
     SAVE_LOGS_FAILED = 'SAVE_LOGS_FAILED',
@@ -184,6 +184,7 @@ export enum AnnotationActionTypes {
     CANVAS_ERROR_OCCURRED = 'CANVAS_ERROR_OCCURRED',
     SET_FORCE_EXIT_ANNOTATION_PAGE_FLAG = 'SET_FORCE_EXIT_ANNOTATION_PAGE_FLAG',
     SWITCH_NAVIGATION_BLOCKED = 'SWITCH_NAVIGATION_BLOCKED',
+    SET_NAVIGATION_TYPE = 'SET_NAVIGATION_TYPE',
     DELETE_FRAME = 'DELETE_FRAME',
     DELETE_FRAME_SUCCESS = 'DELETE_FRAME_SUCCESS',
     DELETE_FRAME_FAILED = 'DELETE_FRAME_FAILED',
@@ -704,7 +705,9 @@ export function changeFrameAsync(
                 Math.round(1000 / frameSpeed) - currentTime + (state.annotation.player.frame.changeTime as number),
             );
 
-            const { states, maxZ, minZ } = await fetchAnnotations(toFrame);
+            const {
+                states, maxZ, minZ, history,
+            } = await fetchAnnotations(toFrame);
             dispatch({
                 type: AnnotationActionTypes.CHANGE_FRAME_SUCCESS,
                 payload: {
@@ -713,6 +716,7 @@ export function changeFrameAsync(
                     filename: data.filename,
                     relatedFiles: data.relatedFiles,
                     states,
+                    history,
                     minZ,
                     maxZ,
                     curZ: maxZ,
@@ -866,13 +870,18 @@ export function closeJob(): ThunkAction {
 }
 
 export function getJobAsync({
-    taskID, jobID, initialFrame, initialFilters, initialOpenGuide,
+    taskID, jobID, initialFrame, initialFilters, queryParameters,
 }: {
     taskID: number;
     jobID: number;
     initialFrame: number | null;
     initialFilters: object[];
-    initialOpenGuide: boolean;
+    queryParameters: {
+        initialOpenGuide: boolean;
+        initialWorkspace: Workspace | null;
+        defaultLabel: string | null;
+        defaultPointsCount: number | null;
+    }
 }): ThunkAction {
     return async (dispatch: ActionCreator<Dispatch>, getState): Promise<void> => {
         try {
@@ -960,7 +969,7 @@ export function getJobAsync({
                 payload: {
                     openTime,
                     job,
-                    initialOpenGuide,
+                    queryParameters,
                     groundTruthInstance: gtJob || null,
                     groundTruthJobFramesMeta,
                     issues,
@@ -1237,7 +1246,14 @@ export function changeGroupColorAsync(group: number, color: string): ThunkAction
     };
 }
 
-export function searchAnnotationsAsync(sessionInstance: NonNullable<CombinedState['annotation']['job']['instance']>, frameFrom: number, frameTo: number): ThunkAction {
+export function searchAnnotationsAsync(
+    sessionInstance: NonNullable<CombinedState['annotation']['job']['instance']>,
+    frameFrom: number,
+    frameTo: number,
+    generalFilters?: {
+        isEmptyFrame: boolean;
+    },
+): ThunkAction {
     return async (dispatch: ActionCreator<Dispatch>, getState): Promise<void> => {
         try {
             const {
@@ -1249,18 +1265,17 @@ export function searchAnnotationsAsync(sessionInstance: NonNullable<CombinedStat
                 },
             } = getState();
 
-            const sign = Math.sign(frameTo - frameFrom);
-            let frame = await sessionInstance.annotations.search(filters, frameFrom, frameTo);
-            while (frame !== null) {
-                const isDeleted = (await sessionInstance.frames.get(frame)).deleted;
-                if (!isDeleted || showDeletedFrames) {
-                    break;
-                } else if (sign > 0 ? frame < frameTo : frame > frameTo) {
-                    frame = await sessionInstance.annotations.search(filters, frame + sign, frameTo);
-                } else {
-                    frame = null;
-                }
-            }
+            const frame = await sessionInstance.annotations
+                .search(
+                    frameFrom,
+                    frameTo,
+                    {
+                        allowDeletedFrames: showDeletedFrames,
+                        ...(
+                            generalFilters ? { generalFilters } : { annotationsFilters: filters }
+                        ),
+                    },
+                );
             if (frame !== null) {
                 dispatch(changeFrameAsync(frame));
             }
@@ -1275,41 +1290,6 @@ export function searchAnnotationsAsync(sessionInstance: NonNullable<CombinedStat
     };
 }
 
-export function searchEmptyFrameAsync(sessionInstance: NonNullable<CombinedState['annotation']['job']['instance']>, frameFrom: number, frameTo: number): ThunkAction {
-    return async (dispatch: ActionCreator<Dispatch>, getState): Promise<void> => {
-        try {
-            const {
-                settings: {
-                    player: { showDeletedFrames },
-                },
-            } = getState();
-
-            const sign = Math.sign(frameTo - frameFrom);
-            let frame = await sessionInstance.annotations.searchEmpty(frameFrom, frameTo);
-            while (frame !== null) {
-                const isDeleted = (await sessionInstance.frames.get(frame)).deleted;
-                if (!isDeleted || showDeletedFrames) {
-                    break;
-                } else if (sign > 0 ? frame < frameTo : frame > frameTo) {
-                    frame = await sessionInstance.annotations.searchEmpty(frame + sign, frameTo);
-                } else {
-                    frame = null;
-                }
-            }
-            if (frame !== null) {
-                dispatch(changeFrameAsync(frame));
-            }
-        } catch (error) {
-            dispatch({
-                type: AnnotationActionTypes.SEARCH_EMPTY_FRAME_FAILED,
-                payload: {
-                    error,
-                },
-            });
-        }
-    };
-}
-
 const ShapeTypeToControl: Record<ShapeType, ActiveControl> = {
     [ShapeType.RECTANGLE]: ActiveControl.DRAW_RECTANGLE,
     [ShapeType.POLYLINE]: ActiveControl.DRAW_POLYLINE,
@@ -1415,6 +1395,10 @@ export function repeatDrawShapeAsync(): ThunkAction {
 
         activeControl = ShapeTypeToControl[activeShapeType];
 
+        if (canvasInstance instanceof Canvas) {
+            canvasInstance.cancel();
+        }
+
         dispatch({
             type: AnnotationActionTypes.REPEAT_DRAW_SHAPE,
             payload: {
@@ -1422,10 +1406,6 @@ export function repeatDrawShapeAsync(): ThunkAction {
             },
         });
 
-        if (canvasInstance instanceof Canvas) {
-            canvasInstance.cancel();
-        }
-
         const [activeLabel] = labels.filter((label: any) => label.id === activeLabelID);
         if (!activeLabel) {
             throw new Error(`Label with ID ${activeLabelID}, was not found`);
@@ -1466,6 +1446,10 @@ export function redrawShapeAsync(): ThunkAction {
             const [state] = states.filter((_state: any): boolean => _state.clientID === activatedStateID);
             if (state && state.objectType !== ObjectType.TAG) {
                 const activeControl = ShapeTypeToControl[state.shapeType as ShapeType] || ActiveControl.CURSOR;
+                if (canvasInstance instanceof Canvas) {
+                    canvasInstance.cancel();
+                }
+
                 dispatch({
                     type: AnnotationActionTypes.REPEAT_DRAW_SHAPE,
                     payload: {
@@ -1473,10 +1457,6 @@ export function redrawShapeAsync(): ThunkAction {
                     },
                 });
 
-                if (canvasInstance instanceof Canvas) {
-                    canvasInstance.cancel();
-                }
-
                 canvasInstance.draw({
                     skeletonSVG: state.shapeType === ShapeType.SKELETON ? state.label.structure.svg : undefined,
                     enabled: true,
@@ -1507,6 +1487,15 @@ export function switchNavigationBlocked(navigationBlocked: boolean): AnyAction {
     };
 }
 
+export function setNavigationType(navigationType: NavigationType): AnyAction {
+    return {
+        type: AnnotationActionTypes.SET_NAVIGATION_TYPE,
+        payload: {
+            navigationType,
+        },
+    };
+}
+
 export function deleteFrameAsync(frame: number): ThunkAction {
     return async (dispatch: ActionCreator<Dispatch>): Promise<void> => {
         const { jobInstance } = receiveAnnotationsParameters();
diff --git a/cvat-ui/src/components/annotation-page/annotation-page.tsx b/cvat-ui/src/components/annotation-page/annotation-page.tsx
index 670fd3ce996b..46ef41ad5c2f 100644
--- a/cvat-ui/src/components/annotation-page/annotation-page.tsx
+++ b/cvat-ui/src/components/annotation-page/annotation-page.tsx
@@ -13,6 +13,7 @@ import Button from 'antd/lib/button';
 
 import './styles.scss';
 import AttributeAnnotationWorkspace from 'components/annotation-page/attribute-annotation-workspace/attribute-annotation-workspace';
+import SingleShapeWorkspace from 'components/annotation-page/single-shape-workspace/single-shape-workspace';
 import ReviewAnnotationsWorkspace from 'components/annotation-page/review-workspace/review-workspace';
 import StandardWorkspaceComponent from 'components/annotation-page/standard-workspace/standard-workspace';
 import StandardWorkspace3DComponent from 'components/annotation-page/standard3D-workspace/standard3D-workspace';
@@ -146,9 +147,10 @@ export default function AnnotationPageComponent(props: Props): JSX.Element {
             <Layout.Content className='cvat-annotation-layout-content'>
                 {workspace === Workspace.STANDARD3D && <StandardWorkspace3DComponent />}
                 {workspace === Workspace.STANDARD && <StandardWorkspaceComponent />}
-                {workspace === Workspace.ATTRIBUTE_ANNOTATION && <AttributeAnnotationWorkspace />}
-                {workspace === Workspace.TAG_ANNOTATION && <TagAnnotationWorkspace />}
-                {workspace === Workspace.REVIEW_WORKSPACE && <ReviewAnnotationsWorkspace />}
+                {workspace === Workspace.SINGLE_SHAPE && <SingleShapeWorkspace />}
+                {workspace === Workspace.ATTRIBUTES && <AttributeAnnotationWorkspace />}
+                {workspace === Workspace.TAGS && <TagAnnotationWorkspace />}
+                {workspace === Workspace.REVIEW && <ReviewAnnotationsWorkspace />}
             </Layout.Content>
             <FiltersModalComponent />
             <StatisticsModalComponent />
diff --git a/cvat-ui/src/components/annotation-page/attribute-annotation-workspace/attribute-annotation-sidebar/attribute-editor.tsx b/cvat-ui/src/components/annotation-page/attribute-annotation-workspace/attribute-annotation-sidebar/attribute-editor.tsx
index 707a7a6c556c..da5e4d2079aa 100644
--- a/cvat-ui/src/components/annotation-page/attribute-annotation-workspace/attribute-annotation-sidebar/attribute-editor.tsx
+++ b/cvat-ui/src/components/annotation-page/attribute-annotation-workspace/attribute-annotation-sidebar/attribute-editor.tsx
@@ -1,4 +1,5 @@
 // Copyright (C) 2020-2022 Intel Corporation
+// Copyright (C) 2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -30,6 +31,7 @@ function renderInputElement(parameters: InputElementParameters): JSX.Element {
 
     const ref = useRef<TextAreaRef>(null);
     const [selectionStart, setSelectionStart] = useState<number>(currentValue.length);
+    const [localAttrValue, setAttributeValue] = useState(currentValue);
 
     useEffect(() => {
         const textArea = ref?.current?.resizableTextArea?.textArea;
@@ -39,13 +41,28 @@ function renderInputElement(parameters: InputElementParameters): JSX.Element {
         }
     }, [currentValue]);
 
+    useEffect(() => {
+        // attribute value updated from inside the app (for example undo/redo)
+        if (currentValue !== localAttrValue) {
+            setAttributeValue(currentValue);
+        }
+    }, [currentValue]);
+
+    useEffect(() => {
+        // wrap to internal use effect to avoid issues
+        // with chinese keyboard
+        if (localAttrValue !== currentValue) {
+            onChange(localAttrValue);
+        }
+    }, [localAttrValue]);
+
     const renderCheckbox = (): JSX.Element => (
         <>
             <Text strong>Checkbox: </Text>
             <div className='attribute-annotation-sidebar-attr-elem-wrapper'>
                 <Checkbox
-                    onChange={(event: CheckboxChangeEvent): void => onChange(event.target.checked ? 'true' : 'false')}
-                    checked={currentValue === 'true'}
+                    onChange={(event: CheckboxChangeEvent): void => setAttributeValue(event.target.checked ? 'true' : 'false')}
+                    checked={localAttrValue === 'true'}
                 />
             </div>
         </>
@@ -56,9 +73,9 @@ function renderInputElement(parameters: InputElementParameters): JSX.Element {
             <Text strong>Values: </Text>
             <div className='attribute-annotation-sidebar-attr-elem-wrapper'>
                 <Select
-                    value={currentValue}
+                    value={localAttrValue}
                     style={{ width: '80%' }}
-                    onChange={(value: SelectValue) => onChange(value as string)}
+                    onChange={(value: SelectValue) => setAttributeValue(value as string)}
                 >
                     {values.map(
                         (value: string): JSX.Element => (
@@ -76,7 +93,10 @@ function renderInputElement(parameters: InputElementParameters): JSX.Element {
         <>
             <Text strong>Values: </Text>
             <div className='attribute-annotation-sidebar-attr-elem-wrapper'>
-                <Radio.Group value={currentValue} onChange={(event: RadioChangeEvent) => onChange(event.target.value)}>
+                <Radio.Group
+                    value={localAttrValue}
+                    onChange={(event: RadioChangeEvent) => setAttributeValue(event.target.value)}
+                >
                     {values.map(
                         (value: string): JSX.Element => (
                             <Radio style={{ display: 'block' }} key={value} value={value}>
@@ -93,7 +113,7 @@ function renderInputElement(parameters: InputElementParameters): JSX.Element {
         if (['ArrowDown', 'ArrowUp', 'ArrowLeft', 'ArrowRight', 'Tab', 'Shift', 'Control'].includes(event.key)) {
             event.preventDefault();
             event.stopPropagation();
-            const copyEvent = new KeyboardEvent('keydown', event);
+            const copyEvent = new KeyboardEvent('keydown', event.nativeEvent);
             window.document.dispatchEvent(copyEvent);
         }
     };
@@ -109,11 +129,11 @@ function renderInputElement(parameters: InputElementParameters): JSX.Element {
                         min={+min}
                         max={+max}
                         step={+step}
-                        value={+currentValue}
+                        value={+localAttrValue}
                         key={`${clientID}:${attrID}`}
                         onChange={(value: number | null) => {
                             if (typeof value === 'number') {
-                                onChange(`${value}`);
+                                setAttributeValue(`${value}`);
                             }
                         }}
                         onKeyDown={handleKeydown}
@@ -131,13 +151,13 @@ function renderInputElement(parameters: InputElementParameters): JSX.Element {
                     autoFocus
                     ref={ref}
                     key={`${clientID}:${attrID}`}
-                    value={currentValue}
+                    value={localAttrValue}
                     onChange={(event: React.ChangeEvent<HTMLTextAreaElement>) => {
                         const { value } = event.target;
                         if (ref.current?.resizableTextArea?.textArea) {
                             setSelectionStart(ref.current.resizableTextArea.textArea.selectionStart);
                         }
-                        onChange(value);
+                        setAttributeValue(value);
                     }}
                     onKeyDown={handleKeydown}
                 />
diff --git a/cvat-ui/src/components/annotation-page/canvas/views/canvas2d/brush-tools.tsx b/cvat-ui/src/components/annotation-page/canvas/views/canvas2d/brush-tools.tsx
index 0b7883ada510..142967634002 100644
--- a/cvat-ui/src/components/annotation-page/canvas/views/canvas2d/brush-tools.tsx
+++ b/cvat-ui/src/components/annotation-page/canvas/views/canvas2d/brush-tools.tsx
@@ -132,6 +132,10 @@ function BrushTools(): React.ReactPortal | null {
             const { offsetTop, offsetLeft } = canvasContainer.parentElement as HTMLElement;
             setTopLeft([offsetTop, offsetLeft]);
         }
+
+        return () => {
+            dispatch(updateCanvasBrushTools({ visible: false }));
+        };
     }, []);
 
     useEffect(() => {
diff --git a/cvat-ui/src/components/annotation-page/canvas/views/canvas2d/canvas-context-menu.tsx b/cvat-ui/src/components/annotation-page/canvas/views/canvas2d/canvas-context-menu.tsx
index 4c57555d330f..0f4011964825 100644
--- a/cvat-ui/src/components/annotation-page/canvas/views/canvas2d/canvas-context-menu.tsx
+++ b/cvat-ui/src/components/annotation-page/canvas/views/canvas2d/canvas-context-menu.tsx
@@ -130,7 +130,7 @@ export default function CanvasContextMenu(props: Props): JSX.Element | null {
     }
 
     const copyObject = state?.isGroundTruth ? state : null;
-    if (workspace === Workspace.REVIEW_WORKSPACE) {
+    if (workspace === Workspace.REVIEW) {
         const conflict = frameConflicts
             .find((qualityConflict: QualityConflict) => qualityConflict.annotationConflicts.some(
                 (annotationConflict: AnnotationConflict) => (
diff --git a/cvat-ui/src/components/annotation-page/canvas/views/canvas2d/canvas-wrapper.tsx b/cvat-ui/src/components/annotation-page/canvas/views/canvas2d/canvas-wrapper.tsx
index 79295c1ea594..ae8d44f7b3ba 100644
--- a/cvat-ui/src/components/annotation-page/canvas/views/canvas2d/canvas-wrapper.tsx
+++ b/cvat-ui/src/components/annotation-page/canvas/views/canvas2d/canvas-wrapper.tsx
@@ -372,7 +372,7 @@ class CanvasWrapperComponent extends React.PureComponent<Props> {
         wrapper.appendChild(canvasInstance.html());
 
         canvasInstance.configure({
-            forceDisableEditing: workspace === Workspace.REVIEW_WORKSPACE,
+            forceDisableEditing: workspace === Workspace.REVIEW,
             undefinedAttrValue: config.UNDEFINED_ATTRIBUTE_VALUE,
             displayAllText: showObjectsTextAlways,
             autoborders: automaticBordering,
@@ -548,11 +548,11 @@ class CanvasWrapperComponent extends React.PureComponent<Props> {
         }
 
         if (prevProps.workspace !== workspace) {
-            if (workspace === Workspace.REVIEW_WORKSPACE) {
+            if (workspace === Workspace.REVIEW) {
                 canvasInstance.configure({
                     forceDisableEditing: true,
                 });
-            } else if (prevProps.workspace === Workspace.REVIEW_WORKSPACE) {
+            } else if (prevProps.workspace === Workspace.REVIEW) {
                 canvasInstance.configure({
                     forceDisableEditing: false,
                 });
@@ -730,7 +730,7 @@ class CanvasWrapperComponent extends React.PureComponent<Props> {
         const { workspace, activatedStateID, onActivateObject } = this.props;
 
         if ((e.target as HTMLElement).tagName === 'svg' && e.button !== 2) {
-            if (activatedStateID !== null && workspace !== Workspace.ATTRIBUTE_ANNOTATION) {
+            if (activatedStateID !== null && workspace !== Workspace.ATTRIBUTES) {
                 onActivateObject(null, null);
             }
         }
@@ -796,7 +796,7 @@ class CanvasWrapperComponent extends React.PureComponent<Props> {
             jobInstance, activatedStateID, activatedElementID, workspace, onActivateObject,
         } = this.props;
 
-        if (![Workspace.STANDARD, Workspace.REVIEW_WORKSPACE].includes(workspace)) {
+        if (![Workspace.STANDARD, Workspace.REVIEW].includes(workspace)) {
             return;
         }
 
@@ -904,7 +904,7 @@ class CanvasWrapperComponent extends React.PureComponent<Props> {
 
         if (activatedStateID !== null) {
             const [activatedState] = annotations.filter((state: any): boolean => state.clientID === activatedStateID);
-            if (workspace === Workspace.ATTRIBUTE_ANNOTATION) {
+            if (workspace === Workspace.ATTRIBUTES) {
                 if (activatedState.objectType !== ObjectType.TAG) {
                     canvasInstance.focus(activatedStateID, aamZoomMargin);
                 } else {
@@ -914,7 +914,7 @@ class CanvasWrapperComponent extends React.PureComponent<Props> {
             if (activatedState && activatedState.objectType !== ObjectType.TAG) {
                 canvasInstance.activate(activatedStateID, activatedAttributeID);
             }
-        } else if (workspace === Workspace.ATTRIBUTE_ANNOTATION) {
+        } else if (workspace === Workspace.ATTRIBUTES) {
             canvasInstance.fit();
         }
     }
diff --git a/cvat-ui/src/components/annotation-page/single-shape-workspace/single-shape-sidebar/single-shape-sidebar.tsx b/cvat-ui/src/components/annotation-page/single-shape-workspace/single-shape-sidebar/single-shape-sidebar.tsx
new file mode 100644
index 000000000000..1775493993b3
--- /dev/null
+++ b/cvat-ui/src/components/annotation-page/single-shape-workspace/single-shape-sidebar/single-shape-sidebar.tsx
@@ -0,0 +1,533 @@
+// Copyright (C) 2024 CVAT.ai Corporation
+//
+// SPDX-License-Identifier: MIT
+
+import {
+    shallowEqual, useDispatch, useSelector, useStore,
+} from 'react-redux';
+import React, {
+    useCallback, useEffect, useReducer, useRef,
+} from 'react';
+import Layout, { SiderProps } from 'antd/lib/layout';
+import { Row, Col } from 'antd/lib/grid';
+import Text from 'antd/lib/typography/Text';
+import Checkbox, { CheckboxChangeEvent } from 'antd/lib/checkbox';
+import InputNumber from 'antd/lib/input-number';
+import Select from 'antd/lib/select';
+import Alert from 'antd/lib/alert';
+import Modal from 'antd/lib/modal';
+import Button from 'antd/lib/button';
+
+import { CombinedState, NavigationType } from 'reducers';
+import { Canvas, CanvasMode } from 'cvat-canvas-wrapper';
+import {
+    Job, JobState, Label, LabelType,
+} from 'cvat-core-wrapper';
+import { ActionUnion, createAction } from 'utils/redux';
+import { changeFrameAsync, saveAnnotationsAsync, setNavigationType } from 'actions/annotation-actions';
+import LabelSelector from 'components/label-selector/label-selector';
+import GlobalHotKeys from 'utils/mousetrap-react';
+
+enum ReducerActionType {
+    SWITCH_AUTO_NEXT_FRAME = 'SWITCH_AUTO_NEXT_FRAME',
+    SWITCH_AUTOSAVE_ON_FINISH = 'SWITCH_AUTOSAVE_ON_FINISH',
+    SWITCH_COUNT_OF_POINTS_IS_PREDEFINED = 'SWITCH_COUNT_OF_POINTS_IS_PREDEFINED',
+    SET_ACTIVE_LABEL = 'SET_ACTIVE_LABEL',
+    SET_POINTS_COUNT = 'SET_POINTS_COUNT',
+}
+
+export const reducerActions = {
+    switchAutoNextFrame: () => (
+        createAction(ReducerActionType.SWITCH_AUTO_NEXT_FRAME)
+    ),
+    switchAutoSaveOnFinish: () => (
+        createAction(ReducerActionType.SWITCH_AUTOSAVE_ON_FINISH)
+    ),
+    switchCountOfPointsIsPredefined: () => (
+        createAction(ReducerActionType.SWITCH_COUNT_OF_POINTS_IS_PREDEFINED)
+    ),
+    setActiveLabel: (label: Label, type?: LabelType) => (
+        createAction(ReducerActionType.SET_ACTIVE_LABEL, {
+            label,
+            labelType: type || label.type,
+        })
+    ),
+    setPointsCount: (pointsCount: number) => (
+        createAction(ReducerActionType.SET_POINTS_COUNT, { pointsCount })
+    ),
+};
+
+interface State {
+    autoNextFrame: boolean;
+    saveOnFinish: boolean;
+    pointsCountIsPredefined: boolean;
+    pointsCount: number;
+    labels: Label[];
+    label: Label | null;
+    labelType: LabelType;
+    initialNavigationType: NavigationType;
+}
+
+const reducer = (state: State, action: ActionUnion<typeof reducerActions>): State => {
+    const getMinimalPoints = (labelType: LabelType): number => {
+        let minimalPoints = 3;
+        if (labelType === LabelType.POLYLINE) {
+            minimalPoints = 2;
+        } else if (labelType === LabelType.POINTS) {
+            minimalPoints = 1;
+        }
+
+        return minimalPoints;
+    };
+
+    if (action.type === ReducerActionType.SWITCH_AUTO_NEXT_FRAME) {
+        return {
+            ...state,
+            autoNextFrame: !state.autoNextFrame,
+        };
+    }
+
+    if (action.type === ReducerActionType.SWITCH_AUTOSAVE_ON_FINISH) {
+        return {
+            ...state,
+            saveOnFinish: !state.saveOnFinish,
+        };
+    }
+
+    if (action.type === ReducerActionType.SWITCH_COUNT_OF_POINTS_IS_PREDEFINED) {
+        return {
+            ...state,
+            pointsCountIsPredefined: !state.pointsCountIsPredefined,
+        };
+    }
+
+    if (action.type === ReducerActionType.SET_ACTIVE_LABEL) {
+        return {
+            ...state,
+            label: action.payload.label,
+            labelType: action.payload.labelType,
+            pointsCount: Math.max(state.pointsCount, getMinimalPoints(action.payload.labelType)),
+        };
+    }
+
+    if (action.type === ReducerActionType.SET_POINTS_COUNT) {
+        return {
+            ...state,
+            pointsCount: Math.max(action.payload.pointsCount, getMinimalPoints(state.labelType)),
+        };
+    }
+
+    return state;
+};
+
+function cancelCurrentCanvasOp(state: CombinedState): void {
+    const canvas = state.annotation.canvas.instance as Canvas;
+    if (canvas.mode() !== CanvasMode.IDLE) {
+        canvas.cancel();
+    }
+}
+
+function SingleShapeSidebar(): JSX.Element {
+    const appDispatch = useDispatch();
+    const store = useStore<CombinedState>();
+    const {
+        isCanvasReady,
+        jobInstance,
+        frame,
+        normalizedKeyMap,
+        keyMap,
+        defaultLabel,
+        defaultPointsCount,
+        navigationType,
+    } = useSelector((_state: CombinedState) => ({
+        isCanvasReady: _state.annotation.canvas.ready,
+        jobInstance: _state.annotation.job.instance as Job,
+        frame: _state.annotation.player.frame.number,
+        keyMap: _state.shortcuts.keyMap,
+        normalizedKeyMap: _state.shortcuts.normalizedKeyMap,
+        defaultLabel: _state.annotation.job.queryParameters.defaultLabel,
+        defaultPointsCount: _state.annotation.job.queryParameters.defaultPointsCount,
+        navigationType: _state.annotation.player.navigationType,
+    }), shallowEqual);
+
+    const [state, dispatch] = useReducer(reducer, {
+        autoNextFrame: true,
+        saveOnFinish: true,
+        pointsCountIsPredefined: true,
+        pointsCount: defaultPointsCount || 1,
+        labels: jobInstance.labels.filter((label) => label.type !== LabelType.TAG && label.type !== LabelType.SKELETON),
+        label: null,
+        labelType: LabelType.ANY,
+        initialNavigationType: navigationType,
+    });
+
+    const savingRef = useRef(false);
+    const nextFrame = useCallback((): void => {
+        let promise = Promise.resolve(null);
+        if (frame < jobInstance.stopFrame) {
+            promise = jobInstance.annotations.search(frame + 1, jobInstance.stopFrame, {
+                allowDeletedFrames: false,
+                ...(navigationType === NavigationType.EMPTY ? {
+                    generalFilters: {
+                        isEmptyFrame: true,
+                    },
+                } : {}),
+            });
+        }
+
+        promise.then((foundFrame: number | null) => {
+            if (typeof foundFrame === 'number') {
+                appDispatch(changeFrameAsync(foundFrame));
+            } else if (state.saveOnFinish && !savingRef.current) {
+                Modal.confirm({
+                    title: 'You finished the job',
+                    content: 'Please, confirm further action',
+                    cancelText: 'Stay on the page',
+                    okText: 'Submit results',
+                    className: 'cvat-single-shape-annotation-submit-job-modal',
+                    onOk: () => {
+                        function reset(): void {
+                            savingRef.current = false;
+                        }
+
+                        function showSubmittedInfo(): void {
+                            Modal.info({
+                                closable: false,
+                                title: 'Annotations submitted',
+                                content: 'You may close the window',
+                                className: 'cvat-single-shape-annotation-submit-success-modal',
+                            });
+                        }
+
+                        savingRef.current = true;
+                        if (jobInstance.annotations.hasUnsavedChanges()) {
+                            appDispatch(saveAnnotationsAsync(() => {
+                                jobInstance.state = JobState.COMPLETED;
+                                jobInstance.save().then(showSubmittedInfo).finally(reset);
+                            })).catch(reset);
+                        } else {
+                            jobInstance.state = JobState.COMPLETED;
+                            jobInstance.save().then(showSubmittedInfo).finally(reset);
+                        }
+                    },
+                });
+            }
+        });
+    }, [state.saveOnFinish, frame, jobInstance, navigationType]);
+
+    const canvasInitializerRef = useRef<() => void | null>(() => {});
+    canvasInitializerRef.current = (): void => {
+        const canvas = store.getState().annotation.canvas.instance as Canvas;
+        if (isCanvasReady && canvas.mode() !== CanvasMode.DRAW && state.label && state.labelType !== LabelType.ANY) {
+            canvas.draw({
+                enabled: true,
+                shapeType: state.labelType,
+                numberOfPoints: state.pointsCountIsPredefined ? state.pointsCount : undefined,
+                crosshair: true,
+            });
+        }
+    };
+
+    useEffect(() => {
+        const canvas = store.getState().annotation.canvas.instance as Canvas;
+        const onDrawDone = (): void => {
+            setTimeout(() => {
+                if (state.autoNextFrame) {
+                    nextFrame();
+                } else {
+                    canvasInitializerRef.current();
+                }
+            }, 100);
+        };
+
+        const onCancel = (): void => {
+            // canvas.drawn should be triggered after canvas.cancel
+            // event in a usual scenario (when user drawn something)
+            // but there are some cases when only canvas.cancel is triggered (e.g. when drawn shape was not correct)
+            // in this case need to re-run drawing process
+            setTimeout(() => {
+                canvasInitializerRef.current();
+            });
+        };
+
+        (canvas as Canvas).html().addEventListener('canvas.drawn', onDrawDone);
+        (canvas as Canvas).html().addEventListener('canvas.canceled', onCancel);
+        return (() => {
+            // should stay prior mount useEffect to remove event handlers before final cancel() is called
+
+            (canvas as Canvas).html().removeEventListener('canvas.drawn', onDrawDone);
+            (canvas as Canvas).html().removeEventListener('canvas.canceled', onCancel);
+        });
+    }, [nextFrame, state.autoNextFrame, state.saveOnFinish]);
+
+    useEffect(() => {
+        const labelInstance = (defaultLabel ? jobInstance.labels
+            .find((_label) => _label.name === defaultLabel) : state.labels[0] || null);
+        if (labelInstance) {
+            dispatch(reducerActions.setActiveLabel(labelInstance));
+        }
+
+        appDispatch(setNavigationType(NavigationType.EMPTY));
+        cancelCurrentCanvasOp(store.getState());
+        return () => {
+            appDispatch(setNavigationType(state.initialNavigationType));
+            cancelCurrentCanvasOp(store.getState());
+        };
+    }, []);
+
+    useEffect(() => {
+        cancelCurrentCanvasOp(store.getState());
+        canvasInitializerRef.current();
+    }, [isCanvasReady, state.label, state.labelType, state.pointsCount, state.pointsCountIsPredefined]);
+
+    let message = '';
+    if (state.labelType === LabelType.POINTS) {
+        message = `${state.pointsCount === 1 ? 'one point' : `${state.pointsCount} points`}`;
+    } else {
+        message = `${state.labelType === LabelType.ELLIPSE ? 'an ellipse' : `a ${state.labelType}`}`;
+    }
+
+    const siderProps: SiderProps = {
+        className: 'cvat-single-shape-annotation-sidebar',
+        theme: 'light',
+        width: 300,
+        collapsedWidth: 0,
+        reverseArrow: true,
+        collapsible: true,
+        trigger: null,
+    };
+
+    const subKeyMap = {
+        CANCEL: keyMap.CANCEL,
+        SWITCH_DRAW_MODE: keyMap.SWITCH_DRAW_MODE,
+    };
+
+    const handlers = {
+        CANCEL: (event: KeyboardEvent | undefined) => {
+            event?.preventDefault();
+            (store.getState().annotation.canvas.instance as Canvas).cancel();
+        },
+        SWITCH_DRAW_MODE: (event: KeyboardEvent | undefined) => {
+            event?.preventDefault();
+            const canvas = store.getState().annotation.canvas.instance as Canvas;
+            canvas.draw({ enabled: false });
+        },
+    };
+
+    if (!state.labels.length) {
+        return (
+            <Layout.Sider {...siderProps}>
+                <div className='cvat-single-shape-annotation-sidebar-not-found-wrapper'>
+                    <Text strong>No available labels found</Text>
+                </div>
+            </Layout.Sider>
+        );
+    }
+
+    const isPolylabel = [LabelType.POINTS, LabelType.POLYGON, LabelType.POLYLINE].includes(state.labelType);
+    const withLabelsSelector = state.labels.length > 1;
+    const withLabelTypeSelector = state.label && state.label.type === 'any';
+
+    return (
+        <Layout.Sider {...siderProps}>
+            <GlobalHotKeys keyMap={subKeyMap} handlers={handlers} />
+            { state.label !== null && state.labelType !== LabelType.ANY && (
+                <Row>
+                    <Col>
+                        <Alert
+                            className='cvat-single-shape-annotation-sidebar-hint'
+                            type='info'
+                            message={(
+                                <>
+                                    <Text>Annotate</Text>
+                                    <Text strong>{` ${(state.label as Label).name} `}</Text>
+                                    <Text>on the image, using</Text>
+                                    <Text strong>{` ${message} `}</Text>
+                                </>
+                            )}
+                        />
+                        <Row justify='start' className='cvat-single-shape-annotation-sidebar-skip-wrapper'>
+                            <Col>
+                                <Button
+                                    size='large'
+                                    onClick={() => {
+                                        savingRef.current = false;
+                                        nextFrame();
+                                    }}
+                                >
+                                    Skip
+                                </Button>
+                            </Col>
+                        </Row>
+                        <Alert
+                            type='info'
+                            className='cvat-single-shape-annotation-sidebar-ux-hints'
+                            message={(
+                                <ul>
+                                    <li>
+                                        <Text>Click</Text>
+                                        <Text strong>{' Skip '}</Text>
+                                        <Text>if there is nothing to annotate</Text>
+                                    </li>
+                                    <li>
+                                        <Text>Hold</Text>
+                                        <Text strong>{' [Alt] '}</Text>
+                                        <Text>button to avoid drawing on click</Text>
+                                    </li>
+                                    <li>
+                                        <Text>Press</Text>
+                                        <Text strong>{` ${normalizedKeyMap.UNDO} `}</Text>
+                                        <Text>to undo a created object</Text>
+                                    </li>
+                                    { (!isPolylabel || !state.pointsCountIsPredefined || state.pointsCount > 1) && (
+                                        <li>
+                                            <Text>Press</Text>
+                                            <Text strong>{` ${normalizedKeyMap.CANCEL} `}</Text>
+                                            <Text>to reset drawing process</Text>
+                                        </li>
+                                    ) }
+
+                                    { (isPolylabel && (!state.pointsCountIsPredefined || state.pointsCount > 1)) && (
+                                        <li>
+                                            <Text>Press</Text>
+                                            <Text strong>{` ${normalizedKeyMap.SWITCH_DRAW_MODE} `}</Text>
+                                            <Text>to finish drawing process</Text>
+                                        </li>
+                                    ) }
+                                </ul>
+                            )}
+                        />
+                    </Col>
+                </Row>
+            )}
+            { withLabelsSelector && (
+                <>
+                    <Row justify='start' className='cvat-single-shape-annotation-sidebar-label'>
+                        <Col>
+                            <Text strong>Label selector</Text>
+                        </Col>
+                    </Row>
+                    <Row justify='start' className='cvat-single-shape-annotation-sidebar-label-select'>
+                        <Col>
+                            <LabelSelector
+                                labels={state.labels}
+                                value={state.label}
+                                onChange={(label) => dispatch(reducerActions.setActiveLabel(label))}
+                            />
+                        </Col>
+                    </Row>
+                </>
+            )}
+            { withLabelTypeSelector && (
+                <>
+                    <Row justify='start' className='cvat-single-shape-annotation-sidebar-label-type'>
+                        <Col>
+                            <Text strong>Label type selector</Text>
+                        </Col>
+                    </Row>
+                    <Row justify='start' className='cvat-single-shape-annotation-sidebar-label-type-selector'>
+                        <Col>
+                            <Select
+                                value={state.labelType}
+                                onChange={(labelType: LabelType) => dispatch(
+                                    reducerActions.setActiveLabel(state.label as Label, labelType),
+                                )}
+                            >
+                                <Select value={LabelType.RECTANGLE}>{LabelType.RECTANGLE}</Select>
+                                <Select value={LabelType.POLYGON}>{LabelType.POLYGON}</Select>
+                                <Select value={LabelType.POLYLINE}>{LabelType.POLYLINE}</Select>
+                                <Select value={LabelType.POINTS}>{LabelType.POINTS}</Select>
+                                <Select value={LabelType.ELLIPSE}>{LabelType.ELLIPSE}</Select>
+                                <Select value={LabelType.CUBOID}>{LabelType.CUBOID}</Select>
+                                <Select value={LabelType.MASK}>{LabelType.MASK}</Select>
+                            </Select>
+                        </Col>
+                    </Row>
+                </>
+            )}
+            <Row className='cvat-single-shape-annotation-sidebar-auto-next-frame-checkbox'>
+                <Col>
+                    <Checkbox
+                        checked={state.autoNextFrame}
+                        onChange={(): void => {
+                            (window.document.activeElement as HTMLInputElement)?.blur();
+                            dispatch(reducerActions.switchAutoNextFrame());
+                        }}
+                    >
+                        Automatically go to the next frame
+                    </Checkbox>
+                </Col>
+            </Row>
+            <Row className='cvat-single-shape-annotation-sidebar-auto-save-checkbox'>
+                <Col>
+                    <Checkbox
+                        checked={state.saveOnFinish}
+                        onChange={(): void => {
+                            (window.document.activeElement as HTMLInputElement)?.blur();
+                            dispatch(reducerActions.switchAutoSaveOnFinish());
+                        }}
+                    >
+                        Automatically save when finish
+                    </Checkbox>
+                </Col>
+            </Row>
+            <Row className='cvat-single-shape-annotation-sidebar-navigate-empty-checkbox'>
+                <Col>
+                    <Checkbox
+                        checked={navigationType === NavigationType.EMPTY}
+                        onChange={(event: CheckboxChangeEvent): void => {
+                            (window.document.activeElement as HTMLInputElement)?.blur();
+                            if (event.target.checked) {
+                                appDispatch(setNavigationType(NavigationType.EMPTY));
+                            } else {
+                                appDispatch(setNavigationType(NavigationType.REGULAR));
+                            }
+                        }}
+                    >
+                        Navigate only empty frames
+                    </Checkbox>
+                </Col>
+            </Row>
+            { isPolylabel && (
+                <Row className='cvat-single-shape-annotation-sidebar-predefined-pounts-count-checkbox'>
+                    <Col>
+                        <Checkbox
+                            checked={state.pointsCountIsPredefined}
+                            onChange={(): void => {
+                                (window.document.activeElement as HTMLInputElement)?.blur();
+                                dispatch(reducerActions.switchCountOfPointsIsPredefined());
+                            }}
+                        >
+                            Predefined number of points
+                        </Checkbox>
+                    </Col>
+                </Row>
+            )}
+            { isPolylabel && state.pointsCountIsPredefined ? (
+                <>
+                    <Row justify='start' className='cvat-single-shape-annotation-sidebar-points-count'>
+                        <Col>
+                            <Text strong>Number of points</Text>
+                        </Col>
+                    </Row>
+                    <Row justify='start' className='cvat-single-shape-annotation-sidebar-points-count-input'>
+                        <Col>
+                            <InputNumber
+                                value={state.pointsCount}
+                                min={1}
+                                step={1}
+                                onChange={(value: number | null) => {
+                                    if (value !== null) {
+                                        dispatch(reducerActions.setPointsCount(value));
+                                    }
+                                }}
+                            />
+                        </Col>
+                    </Row>
+                </>
+            ) : null }
+        </Layout.Sider>
+    );
+}
+
+export default React.memo(SingleShapeSidebar);
diff --git a/cvat-ui/src/components/annotation-page/single-shape-workspace/single-shape-workspace.tsx b/cvat-ui/src/components/annotation-page/single-shape-workspace/single-shape-workspace.tsx
new file mode 100644
index 000000000000..8f5efe603db5
--- /dev/null
+++ b/cvat-ui/src/components/annotation-page/single-shape-workspace/single-shape-workspace.tsx
@@ -0,0 +1,19 @@
+// Copyright (C) 2024 CVAT.ai Corporation
+//
+// SPDX-License-Identifier: MIT
+
+import './styles.scss';
+import React from 'react';
+import Layout from 'antd/lib/layout';
+
+import CanvasLayout from 'components/annotation-page/canvas/grid-layout/canvas-layout';
+import SingleShapeSidebar from './single-shape-sidebar/single-shape-sidebar';
+
+export default function SingleShapeWorkspace(): JSX.Element {
+    return (
+        <Layout hasSider className='cvat-single-shape-workspace'>
+            <CanvasLayout />
+            <SingleShapeSidebar />
+        </Layout>
+    );
+}
diff --git a/cvat-ui/src/components/annotation-page/single-shape-workspace/styles.scss b/cvat-ui/src/components/annotation-page/single-shape-workspace/styles.scss
new file mode 100644
index 000000000000..195dffd51814
--- /dev/null
+++ b/cvat-ui/src/components/annotation-page/single-shape-workspace/styles.scss
@@ -0,0 +1,76 @@
+// Copyright (C) 2024 CVAT.ai Corporation
+//
+// SPDX-License-Identifier: MIT
+
+@import 'base';
+
+.cvat-single-shape-workspace {
+    height: 100%;
+}
+
+.cvat-single-shape-annotation-sidebar {
+    padding: $grid-unit-size;
+    overflow: auto;
+
+    .cvat-single-shape-annotation-sidebar-label-select,
+    .cvat-single-shape-annotation-sidebar-label-type-selector {
+        .ant-select {
+            width: $grid-unit-size * 20;
+        }
+    }
+
+    .cvat-single-shape-annotation-sidebar-points-count-input {
+        .ant-input-number    {
+            width: $grid-unit-size * 20;
+        }
+    }
+
+    .cvat-single-shape-annotation-sidebar-label,
+    .cvat-single-shape-annotation-sidebar-label-type,
+    .cvat-single-shape-annotation-sidebar-points-count,
+    .cvat-single-shape-annotation-sidebar-label-select,
+    .cvat-single-shape-annotation-sidebar-points-count-input,
+    .cvat-single-shape-annotation-sidebar-navigate-empty-checkbox,
+    .cvat-single-shape-annotation-sidebar-predefined-pounts-count-checkbox,
+    .cvat-single-shape-annotation-sidebar-auto-save-checkbox {
+        margin-top: $grid-unit-size;
+    }
+
+    .cvat-single-shape-annotation-sidebar-auto-next-frame-checkbox {
+        margin-top: $grid-unit-size * 3;
+    }
+
+    .cvat-single-shape-annotation-sidebar-auto-next-frame-checkbox,
+    .cvat-single-shape-annotation-sidebar-auto-save-checkbox,
+    .cvat-single-shape-annotation-sidebar-navigate-empty-checkbox,
+    .cvat-single-shape-annotation-sidebar-predefined-pounts-count-checkbox {
+        user-select: none;
+    }
+
+    .cvat-single-shape-annotation-sidebar-hint {
+        row-gap: 0;
+        text-align: center;
+        font-size: large;
+        margin-bottom: $grid-unit-size;
+    }
+
+    .cvat-single-shape-annotation-sidebar-ux-hints {
+        ul {
+            padding-left: $grid-unit-size * 2;
+        }
+    }
+
+    .cvat-single-shape-annotation-sidebar-skip-wrapper {
+        margin-bottom: $grid-unit-size;
+
+        button {
+            width: $grid-unit-size * 35.5;
+        }
+    }
+
+    .cvat-single-shape-annotation-sidebar-not-found-wrapper {
+        margin-top: $grid-unit-size * 3;
+        text-align: center;
+        flex-grow: 10;
+    }
+}
diff --git a/cvat-ui/src/components/annotation-page/standard-workspace/objects-side-bar/issues-list.tsx b/cvat-ui/src/components/annotation-page/standard-workspace/objects-side-bar/issues-list.tsx
index 135568b82afa..463089d414ae 100644
--- a/cvat-ui/src/components/annotation-page/standard-workspace/objects-side-bar/issues-list.tsx
+++ b/cvat-ui/src/components/annotation-page/standard-workspace/objects-side-bar/issues-list.tsx
@@ -1,5 +1,5 @@
 // Copyright (C) 2020-2022 Intel Corporation
-// Copyright (C) 2023 CVAT.ai Corporation
+// Copyright (C) 2023-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -115,7 +115,7 @@ export default function LabelsListComponent(): JSX.Element {
                         </CVATTooltip>
                     </Col>
                     {
-                        workspace === Workspace.REVIEW_WORKSPACE ? (
+                        workspace === Workspace.REVIEW ? (
                             <Col offset={2}>
                                 <CVATTooltip title='Show Ground truth annotations and conflicts'>
                                     <Icon
diff --git a/cvat-ui/src/components/annotation-page/standard-workspace/objects-side-bar/objects-list-header.tsx b/cvat-ui/src/components/annotation-page/standard-workspace/objects-side-bar/objects-list-header.tsx
index 2ec233cdb022..304e6a1f225c 100644
--- a/cvat-ui/src/components/annotation-page/standard-workspace/objects-side-bar/objects-list-header.tsx
+++ b/cvat-ui/src/components/annotation-page/standard-workspace/objects-side-bar/objects-list-header.tsx
@@ -1,4 +1,5 @@
 // Copyright (C) 2020-2022 Intel Corporation
+// Copyright (C) 2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -112,7 +113,7 @@ function ObjectListHeader(props: Props): JSX.Element {
             <Row justify='space-between' align='middle'>
                 {!readonly && <LockAllSwitcher {...props} />}
                 <HideAllSwitcher {...props} />
-                { workspace === Workspace.REVIEW_WORKSPACE && (
+                { workspace === Workspace.REVIEW && (
                     <GTSwitcher {...props} />
                 )}
                 <CollapseAllSwitcher {...props} />
diff --git a/cvat-ui/src/components/annotation-page/tag-annotation-workspace/styles.scss b/cvat-ui/src/components/annotation-page/tag-annotation-workspace/styles.scss
index 713749ecde07..6436d7ac29ea 100644
--- a/cvat-ui/src/components/annotation-page/tag-annotation-workspace/styles.scss
+++ b/cvat-ui/src/components/annotation-page/tag-annotation-workspace/styles.scss
@@ -47,7 +47,7 @@
     }
 }
 
-.labels-tag-annotation-sidebar-not-found-wrapper {
+.cvat-tag-annotation-sidebar-empty {
     margin-top: $grid-unit-size * 4;
 }
 
diff --git a/cvat-ui/src/components/annotation-page/tag-annotation-workspace/tag-annotation-sidebar/tag-annotation-sidebar.tsx b/cvat-ui/src/components/annotation-page/tag-annotation-workspace/tag-annotation-sidebar/tag-annotation-sidebar.tsx
index 1f820686654a..0ab291beca97 100644
--- a/cvat-ui/src/components/annotation-page/tag-annotation-workspace/tag-annotation-sidebar/tag-annotation-sidebar.tsx
+++ b/cvat-ui/src/components/annotation-page/tag-annotation-workspace/tag-annotation-sidebar/tag-annotation-sidebar.tsx
@@ -1,5 +1,5 @@
 // Copyright (C) 2020-2022 Intel Corporation
-// Copyright (C) 2022-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -240,7 +240,7 @@ function TagAnnotationSidebar(props: StateToProps & DispatchToProps): JSX.Elemen
             >
                 {sidebarCollapsed ? <MenuFoldOutlined title='Show' /> : <MenuUnfoldOutlined title='Hide' />}
             </span>
-            <Row justify='center' className='labels-tag-annotation-sidebar-not-found-wrapper'>
+            <Row justify='center' className='cvat-tag-annotation-sidebar-empty'>
                 <Col>
                     <Text strong>Can&apos;t place tag on this frame.</Text>
                 </Col>
diff --git a/cvat-ui/src/components/annotation-page/top-bar/left-group.tsx b/cvat-ui/src/components/annotation-page/top-bar/left-group.tsx
index f1f2105fdf26..5a5838c7d067 100644
--- a/cvat-ui/src/components/annotation-page/top-bar/left-group.tsx
+++ b/cvat-ui/src/components/annotation-page/top-bar/left-group.tsx
@@ -16,6 +16,7 @@ import { MainMenuIcon, UndoIcon, RedoIcon } from 'icons';
 import { ActiveControl, ToolsBlockerState } from 'reducers';
 import CVATTooltip from 'components/common/cvat-tooltip';
 import customizableComponents from 'components/customizable-components';
+import GlobalHotKeys, { KeyMap } from 'utils/mousetrap-react';
 
 interface Props {
     saving: boolean;
@@ -27,6 +28,7 @@ interface Props {
     switchToolsBlockerShortcut: string;
     toolsBlockerState: ToolsBlockerState;
     activeControl: ActiveControl;
+    keyMap: KeyMap;
     onSaveAnnotation(): void;
     onUndoClick(): void;
     onRedoClick(): void;
@@ -37,6 +39,7 @@ interface Props {
 function LeftGroup(props: Props): JSX.Element {
     const {
         saving,
+        keyMap,
         undoAction,
         redoAction,
         undoShortcut,
@@ -66,8 +69,29 @@ function LeftGroup(props: Props): JSX.Element {
     const shouldEnableToolsBlockerOnClick = [ActiveControl.OPENCV_TOOLS].includes(activeControl);
     const SaveButtonComponent = customizableComponents.SAVE_ANNOTATION_BUTTON;
 
+    const subKeyMap = {
+        UNDO: keyMap.UNDO,
+        REDO: keyMap.REDO,
+    };
+
+    const handlers = {
+        UNDO: (event: KeyboardEvent | undefined) => {
+            event?.preventDefault();
+            if (undoAction) {
+                onUndoClick();
+            }
+        },
+        REDO: (event: KeyboardEvent | undefined) => {
+            event?.preventDefault();
+            if (redoAction) {
+                onRedoClick();
+            }
+        },
+    };
+
     return (
         <>
+            <GlobalHotKeys keyMap={subKeyMap} handlers={handlers} />
             <Modal className='cvat-saving-job-modal' title='Saving changes on the server' visible={saving} footer={[]} closable={false}>
                 <Text>CVAT is saving your annotations, please wait </Text>
                 <LoadingOutlined />
diff --git a/cvat-ui/src/components/annotation-page/top-bar/player-buttons.tsx b/cvat-ui/src/components/annotation-page/top-bar/player-buttons.tsx
index a3bbc7201e29..3bf8137b1ee3 100644
--- a/cvat-ui/src/components/annotation-page/top-bar/player-buttons.tsx
+++ b/cvat-ui/src/components/annotation-page/top-bar/player-buttons.tsx
@@ -1,14 +1,15 @@
-// Copyright (C) 2020-2022 Intel Corporation
+// Copyright (C) 2020-2024 Intel Corporation
 //
 // SPDX-License-Identifier: MIT
 
-import React from 'react';
+import React, { CSSProperties } from 'react';
 import { Col } from 'antd/lib/grid';
 import Icon from '@ant-design/icons';
 import Popover from 'antd/lib/popover';
 
 import CVATTooltip from 'components/common/cvat-tooltip';
-
+import GlobalHotKeys, { KeyMap } from 'utils/mousetrap-react';
+import { NavigationType, Workspace } from 'reducers';
 import {
     FirstIcon,
     BackJumpIcon,
@@ -31,8 +32,9 @@ interface Props {
     previousFrameShortcut: string;
     forwardShortcut: string;
     backwardShortcut: string;
-    prevButtonType: string;
-    nextButtonType: string;
+    keyMap: KeyMap;
+    workspace: Workspace;
+    navigationType: NavigationType;
     onSwitchPlay(): void;
     onPrevFrame(): void;
     onNextFrame(): void;
@@ -40,8 +42,8 @@ interface Props {
     onBackward(): void;
     onFirstFrame(): void;
     onLastFrame(): void;
-    setPrevButton(type: 'regular' | 'filtered' | 'empty'): void;
-    setNextButton(type: 'regular' | 'filtered' | 'empty'): void;
+    onSearchAnnotations(direction: 'forward' | 'backward'): void;
+    setNavigationType(navigationType: NavigationType): void;
 }
 
 function PlayerButtons(props: Props): JSX.Element {
@@ -52,8 +54,9 @@ function PlayerButtons(props: Props): JSX.Element {
         previousFrameShortcut,
         forwardShortcut,
         backwardShortcut,
-        prevButtonType,
-        nextButtonType,
+        keyMap,
+        navigationType,
+        workspace,
         onSwitchPlay,
         onPrevFrame,
         onNextFrame,
@@ -61,10 +64,56 @@ function PlayerButtons(props: Props): JSX.Element {
         onBackward,
         onFirstFrame,
         onLastFrame,
-        setPrevButton,
-        setNextButton,
+        setNavigationType,
+        onSearchAnnotations,
     } = props;
 
+    const subKeyMap = {
+        NEXT_FRAME: keyMap.NEXT_FRAME,
+        PREV_FRAME: keyMap.PREV_FRAME,
+        ...(workspace !== Workspace.SINGLE_SHAPE ? {
+            FORWARD_FRAME: keyMap.FORWARD_FRAME,
+            BACKWARD_FRAME: keyMap.BACKWARD_FRAME,
+            SEARCH_FORWARD: keyMap.SEARCH_FORWARD,
+            SEARCH_BACKWARD: keyMap.SEARCH_BACKWARD,
+            PLAY_PAUSE: keyMap.PLAY_PAUSE,
+            FOCUS_INPUT_FRAME: keyMap.FOCUS_INPUT_FRAME,
+        } : {}),
+    };
+
+    const handlers = {
+        NEXT_FRAME: (event: KeyboardEvent | undefined) => {
+            event?.preventDefault();
+            onNextFrame();
+        },
+        PREV_FRAME: (event: KeyboardEvent | undefined) => {
+            event?.preventDefault();
+            onPrevFrame();
+        },
+        ...(workspace !== Workspace.SINGLE_SHAPE ? {
+            FORWARD_FRAME: (event: KeyboardEvent | undefined) => {
+                event?.preventDefault();
+                onForward();
+            },
+            BACKWARD_FRAME: (event: KeyboardEvent | undefined) => {
+                event?.preventDefault();
+                onBackward();
+            },
+            SEARCH_FORWARD: (event: KeyboardEvent | undefined) => {
+                event?.preventDefault();
+                onSearchAnnotations('forward');
+            },
+            SEARCH_BACKWARD: (event: KeyboardEvent | undefined) => {
+                event?.preventDefault();
+                onSearchAnnotations('backward');
+            },
+            PLAY_PAUSE: (event: KeyboardEvent | undefined) => {
+                event?.preventDefault();
+                onSwitchPlay();
+            },
+        } : {}),
+    };
+
     const prevRegularText = 'Go back';
     const prevFilteredText = 'Go back with a filter';
     const prevEmptyText = 'Go back to an empty frame';
@@ -74,7 +123,7 @@ function PlayerButtons(props: Props): JSX.Element {
 
     let prevButton = <Icon className='cvat-player-previous-button' component={PreviousIcon} onClick={onPrevFrame} />;
     let prevButtonTooltipMessage = prevRegularText;
-    if (prevButtonType === 'filtered') {
+    if (navigationType === NavigationType.FILTERED) {
         prevButton = (
             <Icon
                 className='cvat-player-previous-button-filtered'
@@ -83,7 +132,7 @@ function PlayerButtons(props: Props): JSX.Element {
             />
         );
         prevButtonTooltipMessage = prevFilteredText;
-    } else if (prevButtonType === 'empty') {
+    } else if (navigationType === NavigationType.EMPTY) {
         prevButton = (
             <Icon className='cvat-player-previous-button-empty' component={PreviousEmptyIcon} onClick={onPrevFrame} />
         );
@@ -92,23 +141,39 @@ function PlayerButtons(props: Props): JSX.Element {
 
     let nextButton = <Icon className='cvat-player-next-button' component={NextIcon} onClick={onNextFrame} />;
     let nextButtonTooltipMessage = nextRegularText;
-    if (nextButtonType === 'filtered') {
+    if (navigationType === NavigationType.FILTERED) {
         nextButton = (
             <Icon className='cvat-player-next-button-filtered' component={NextFilteredIcon} onClick={onNextFrame} />
         );
         nextButtonTooltipMessage = nextFilteredText;
-    } else if (nextButtonType === 'empty') {
+    } else if (navigationType === NavigationType.EMPTY) {
         nextButton = <Icon className='cvat-player-next-button-empty' component={NextEmptyIcon} onClick={onNextFrame} />;
         nextButtonTooltipMessage = nextEmptyText;
     }
 
+    const navIconStyle: CSSProperties = workspace === Workspace.SINGLE_SHAPE ? {
+        pointerEvents: 'none',
+        opacity: 0.5,
+    } : {};
+
     return (
         <Col className='cvat-player-buttons'>
+            <GlobalHotKeys keyMap={subKeyMap} handlers={handlers} />
             <CVATTooltip title='Go to the first frame'>
-                <Icon className='cvat-player-first-button' component={FirstIcon} onClick={onFirstFrame} />
+                <Icon
+                    style={navIconStyle}
+                    className='cvat-player-first-button'
+                    component={FirstIcon}
+                    onClick={onFirstFrame}
+                />
             </CVATTooltip>
             <CVATTooltip title={`Go back with a step ${backwardShortcut}`}>
-                <Icon className='cvat-player-backward-button' component={BackJumpIcon} onClick={onBackward} />
+                <Icon
+                    style={navIconStyle}
+                    className='cvat-player-backward-button'
+                    component={BackJumpIcon}
+                    onClick={onBackward}
+                />
             </CVATTooltip>
             <Popover
                 trigger='contextMenu'
@@ -119,27 +184,21 @@ function PlayerButtons(props: Props): JSX.Element {
                             <Icon
                                 className='cvat-player-previous-inlined-button'
                                 component={PreviousIcon}
-                                onClick={() => {
-                                    setPrevButton('regular');
-                                }}
+                                onClick={() => setNavigationType(NavigationType.REGULAR)}
                             />
                         </CVATTooltip>
                         <CVATTooltip title={`${prevFilteredText}`}>
                             <Icon
                                 className='cvat-player-previous-filtered-inlined-button'
                                 component={PreviousFilteredIcon}
-                                onClick={() => {
-                                    setPrevButton('filtered');
-                                }}
+                                onClick={() => setNavigationType(NavigationType.FILTERED)}
                             />
                         </CVATTooltip>
                         <CVATTooltip title={`${prevEmptyText}`}>
                             <Icon
                                 className='cvat-player-previous-empty-inlined-button'
                                 component={PreviousEmptyIcon}
-                                onClick={() => {
-                                    setPrevButton('empty');
-                                }}
+                                onClick={() => setNavigationType(NavigationType.EMPTY)}
                             />
                         </CVATTooltip>
                     </>
@@ -152,11 +211,21 @@ function PlayerButtons(props: Props): JSX.Element {
 
             {!playing ? (
                 <CVATTooltip title={`Play ${playPauseShortcut}`}>
-                    <Icon className='cvat-player-play-button' component={PlayIcon} onClick={onSwitchPlay} />
+                    <Icon
+                        style={navIconStyle}
+                        className='cvat-player-play-button'
+                        component={PlayIcon}
+                        onClick={onSwitchPlay}
+                    />
                 </CVATTooltip>
             ) : (
                 <CVATTooltip title={`Pause ${playPauseShortcut}`}>
-                    <Icon className='cvat-player-pause-button' component={PauseIcon} onClick={onSwitchPlay} />
+                    <Icon
+                        style={navIconStyle}
+                        className='cvat-player-pause-button'
+                        component={PauseIcon}
+                        onClick={onSwitchPlay}
+                    />
                 </CVATTooltip>
             )}
 
@@ -169,27 +238,21 @@ function PlayerButtons(props: Props): JSX.Element {
                             <Icon
                                 className='cvat-player-next-inlined-button'
                                 component={NextIcon}
-                                onClick={() => {
-                                    setNextButton('regular');
-                                }}
+                                onClick={() => setNavigationType(NavigationType.REGULAR)}
                             />
                         </CVATTooltip>
                         <CVATTooltip title={`${nextFilteredText}`}>
                             <Icon
                                 className='cvat-player-next-filtered-inlined-button'
                                 component={NextFilteredIcon}
-                                onClick={() => {
-                                    setNextButton('filtered');
-                                }}
+                                onClick={() => setNavigationType(NavigationType.FILTERED)}
                             />
                         </CVATTooltip>
                         <CVATTooltip title={`${nextEmptyText}`}>
                             <Icon
                                 className='cvat-player-next-empty-inlined-button'
                                 component={NextEmptyIcon}
-                                onClick={() => {
-                                    setNextButton('empty');
-                                }}
+                                onClick={() => setNavigationType(NavigationType.EMPTY)}
                             />
                         </CVATTooltip>
                     </>
@@ -200,10 +263,20 @@ function PlayerButtons(props: Props): JSX.Element {
                 </CVATTooltip>
             </Popover>
             <CVATTooltip title={`Go next with a step ${forwardShortcut}`}>
-                <Icon className='cvat-player-forward-button' component={ForwardJumpIcon} onClick={onForward} />
+                <Icon
+                    style={navIconStyle}
+                    className='cvat-player-forward-button'
+                    component={ForwardJumpIcon}
+                    onClick={onForward}
+                />
             </CVATTooltip>
             <CVATTooltip title='Go to the last frame'>
-                <Icon className='cvat-player-last-button' component={LastIcon} onClick={onLastFrame} />
+                <Icon
+                    style={navIconStyle}
+                    className='cvat-player-last-button'
+                    component={LastIcon}
+                    onClick={onLastFrame}
+                />
             </CVATTooltip>
         </Col>
     );
diff --git a/cvat-ui/src/components/annotation-page/top-bar/player-navigation.tsx b/cvat-ui/src/components/annotation-page/top-bar/player-navigation.tsx
index 4a05b4444a1f..dfd4e24854e7 100644
--- a/cvat-ui/src/components/annotation-page/top-bar/player-navigation.tsx
+++ b/cvat-ui/src/components/annotation-page/top-bar/player-navigation.tsx
@@ -1,21 +1,23 @@
 // Copyright (C) 2020-2022 Intel Corporation
-// Copyright (C) 2023 CVAT.ai Corporation
+// Copyright (C) 2023-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
-import React, { useState, useEffect, useCallback } from 'react';
-
+import React, {
+    useState, useEffect, useCallback, CSSProperties,
+} from 'react';
 import { Row, Col } from 'antd/lib/grid';
 import Icon, { LinkOutlined, DeleteOutlined } from '@ant-design/icons';
 import Slider from 'antd/lib/slider';
 import InputNumber from 'antd/lib/input-number';
-import Input from 'antd/lib/input';
 import Text from 'antd/lib/typography/Text';
 import Modal from 'antd/lib/modal';
 
 import { RestoreIcon } from 'icons';
 import CVATTooltip from 'components/common/cvat-tooltip';
 import { clamp } from 'utils/math';
+import GlobalHotKeys, { KeyMap } from 'utils/mousetrap-react';
+import { Workspace } from 'reducers';
 
 interface Props {
     startFrame: number;
@@ -28,7 +30,9 @@ interface Props {
     deleteFrameAvailable: boolean;
     deleteFrameShortcut: string;
     focusFrameInputShortcut: string;
-    inputFrameRef: React.RefObject<Input>;
+    inputFrameRef: React.RefObject<HTMLInputElement>;
+    keyMap: KeyMap;
+    workspace: Workspace;
     onSliderChange(value: number): void;
     onInputChange(value: number): void;
     onURLIconClick(): void;
@@ -49,13 +53,15 @@ function PlayerNavigation(props: Props): JSX.Element {
         focusFrameInputShortcut,
         inputFrameRef,
         ranges,
+        keyMap,
+        workspace,
+        deleteFrameAvailable,
         onSliderChange,
         onInputChange,
         onURLIconClick,
         onDeleteFrame,
         onRestoreFrame,
         switchNavigationBlocked,
-        deleteFrameAvailable,
     } = props;
 
     const [frameInputValue, setFrameInputValue] = useState<number>(frameNumber);
@@ -85,18 +91,52 @@ function PlayerNavigation(props: Props): JSX.Element {
             });
         }
     }, [playing, frameNumber]);
+
+    const subKeyMap = {
+        DELETE_FRAME: keyMap.DELETE_FRAME,
+        FOCUS_INPUT_FRAME: keyMap.FOCUS_INPUT_FRAME,
+    };
+
+    const handlers = {
+        DELETE_FRAME: (event: KeyboardEvent | undefined) => {
+            event?.preventDefault();
+            onDeleteFrame();
+        },
+        FOCUS_INPUT_FRAME: (event: KeyboardEvent | undefined) => {
+            event?.preventDefault();
+            if (inputFrameRef.current) {
+                inputFrameRef.current.focus();
+            }
+        },
+    };
+
+    const deleteFrameIconStyle: CSSProperties = workspace === Workspace.SINGLE_SHAPE ? {
+        pointerEvents: 'none',
+        opacity: 0.5,
+    } : {};
+
     const deleteFrameIcon = !frameDeleted ? (
         <CVATTooltip title={`Delete the frame ${deleteFrameShortcut}`}>
-            <DeleteOutlined className='cvat-player-delete-frame' onClick={showDeleteFrameDialog} />
+            <DeleteOutlined
+                style={deleteFrameIconStyle}
+                className='cvat-player-delete-frame'
+                onClick={showDeleteFrameDialog}
+            />
         </CVATTooltip>
     ) : (
         <CVATTooltip title='Restore the frame'>
-            <Icon className='cvat-player-restore-frame' onClick={onRestoreFrame} component={RestoreIcon} />
+            <Icon
+                style={deleteFrameIconStyle}
+                className='cvat-player-restore-frame'
+                onClick={onRestoreFrame}
+                component={RestoreIcon}
+            />
         </CVATTooltip>
     );
 
     return (
         <>
+            { workspace !== Workspace.SINGLE_SHAPE && <GlobalHotKeys keyMap={subKeyMap} handlers={handlers} />}
             <Col className='cvat-player-controls'>
                 <Row align='bottom'>
                     <Col>
@@ -105,7 +145,7 @@ function PlayerNavigation(props: Props): JSX.Element {
                             min={startFrame}
                             max={stopFrame}
                             value={frameNumber || 0}
-                            onChange={onSliderChange}
+                            onChange={workspace !== Workspace.SINGLE_SHAPE ? onSliderChange : undefined}
                         />
                         {!!ranges && (
                             <svg className='cvat-player-slider-progress' viewBox='0 0 1000 16' xmlns='http://www.w3.org/2000/svg'>
@@ -148,6 +188,7 @@ function PlayerNavigation(props: Props): JSX.Element {
                         ref={inputFrameRef}
                         className='cvat-player-frame-selector'
                         type='number'
+                        disabled={workspace === Workspace.SINGLE_SHAPE}
                         value={frameInputValue}
                         onChange={(value: number | undefined | string | null) => {
                             if (typeof value !== 'undefined' && value !== null) {
diff --git a/cvat-ui/src/components/annotation-page/top-bar/top-bar.tsx b/cvat-ui/src/components/annotation-page/top-bar/top-bar.tsx
index 97952cbbfc8a..7af232e3332e 100644
--- a/cvat-ui/src/components/annotation-page/top-bar/top-bar.tsx
+++ b/cvat-ui/src/components/annotation-page/top-bar/top-bar.tsx
@@ -4,13 +4,14 @@
 // SPDX-License-Identifier: MIT
 
 import React from 'react';
-import Input from 'antd/lib/input';
 import { Col, Row } from 'antd/lib/grid';
 
 import {
-    ActiveControl, CombinedState, ToolsBlockerState, Workspace,
+    ActiveControl, CombinedState, NavigationType, ToolsBlockerState, Workspace,
 } from 'reducers';
+import { Job } from 'cvat-core-wrapper';
 import { usePlugins } from 'utils/hooks';
+import { KeyMap } from 'utils/mousetrap-react';
 import LeftGroup from './left-group';
 import PlayerButtons from './player-buttons';
 import PlayerNavigation from './player-navigation';
@@ -22,7 +23,7 @@ interface Props {
     frameNumber: number;
     frameFilename: string;
     frameDeleted: boolean;
-    inputFrameRef: React.RefObject<Input>;
+    inputFrameRef: React.RefObject<HTMLInputElement>;
     startFrame: number;
     stopFrame: number;
     undoAction?: string;
@@ -38,14 +39,16 @@ interface Props {
     previousFrameShortcut: string;
     forwardShortcut: string;
     backwardShortcut: string;
-    prevButtonType: string;
-    nextButtonType: string;
+    navigationType: NavigationType;
     focusFrameInputShortcut: string;
     activeControl: ActiveControl;
     toolsBlockerState: ToolsBlockerState;
     deleteFrameAvailable: boolean;
     annotationFilters: object[];
     initialOpenGuide: boolean;
+    keyMap: KeyMap;
+    jobInstance: Job;
+    ranges: string;
     changeWorkspace(workspace: Workspace): void;
     showStatistics(): void;
     showFilters(): void;
@@ -57,8 +60,7 @@ interface Props {
     onBackward(): void;
     onFirstFrame(): void;
     onLastFrame(): void;
-    setPrevButtonType(type: 'regular' | 'filtered' | 'empty'): void;
-    setNextButtonType(type: 'regular' | 'filtered' | 'empty'): void;
+    onSearchAnnotations(direction: 'forward' | 'backward'): void;
     onSliderChange(value: number): void;
     onInputChange(value: number): void;
     onURLIconClick(): void;
@@ -69,8 +71,7 @@ interface Props {
     onDeleteFrame(): void;
     onRestoreFrame(): void;
     switchNavigationBlocked(blocked: boolean): void;
-    jobInstance: any;
-    ranges: string;
+    setNavigationType(navigationType: NavigationType): void;
 }
 
 export default function AnnotationTopBarComponent(props: Props): JSX.Element {
@@ -97,13 +98,15 @@ export default function AnnotationTopBarComponent(props: Props): JSX.Element {
         previousFrameShortcut,
         forwardShortcut,
         backwardShortcut,
-        prevButtonType,
-        nextButtonType,
         focusFrameInputShortcut,
         activeControl,
         toolsBlockerState,
         annotationFilters,
         initialOpenGuide,
+        deleteFrameAvailable,
+        navigationType,
+        jobInstance,
+        keyMap,
         showStatistics,
         showFilters,
         changeWorkspace,
@@ -115,8 +118,7 @@ export default function AnnotationTopBarComponent(props: Props): JSX.Element {
         onBackward,
         onFirstFrame,
         onLastFrame,
-        setPrevButtonType,
-        setNextButtonType,
+        onSearchAnnotations,
         onSliderChange,
         onInputChange,
         onURLIconClick,
@@ -125,10 +127,9 @@ export default function AnnotationTopBarComponent(props: Props): JSX.Element {
         onFinishDraw,
         onSwitchToolsBlockerState,
         onDeleteFrame,
-        deleteFrameAvailable,
         onRestoreFrame,
+        setNavigationType,
         switchNavigationBlocked,
-        jobInstance,
     } = props;
 
     const playerPlugins = usePlugins(
@@ -151,8 +152,9 @@ export default function AnnotationTopBarComponent(props: Props): JSX.Element {
             previousFrameShortcut={previousFrameShortcut}
             forwardShortcut={forwardShortcut}
             backwardShortcut={backwardShortcut}
-            prevButtonType={prevButtonType}
-            nextButtonType={nextButtonType}
+            navigationType={navigationType}
+            keyMap={keyMap}
+            workspace={workspace}
             onPrevFrame={onPrevFrame}
             onNextFrame={onNextFrame}
             onForward={onForward}
@@ -160,8 +162,8 @@ export default function AnnotationTopBarComponent(props: Props): JSX.Element {
             onFirstFrame={onFirstFrame}
             onLastFrame={onLastFrame}
             onSwitchPlay={onSwitchPlay}
-            setPrevButton={setPrevButtonType}
-            setNextButton={setNextButtonType}
+            onSearchAnnotations={onSearchAnnotations}
+            setNavigationType={setNavigationType}
         />
     ), 0]);
 
@@ -178,6 +180,8 @@ export default function AnnotationTopBarComponent(props: Props): JSX.Element {
             deleteFrameShortcut={deleteFrameShortcut}
             focusFrameInputShortcut={focusFrameInputShortcut}
             inputFrameRef={inputFrameRef}
+            keyMap={keyMap}
+            workspace={workspace}
             onSliderChange={onSliderChange}
             onInputChange={onInputChange}
             onURLIconClick={onURLIconClick}
@@ -205,6 +209,7 @@ export default function AnnotationTopBarComponent(props: Props): JSX.Element {
                 onRedoClick={onRedoClick}
                 onFinishDraw={onFinishDraw}
                 onSwitchToolsBlockerState={onSwitchToolsBlockerState}
+                keyMap={keyMap}
             />
             <Col className='cvat-annotation-header-player-group'>
                 <Row align='middle'>
diff --git a/cvat-ui/src/components/create-job-page/job-form.tsx b/cvat-ui/src/components/create-job-page/job-form.tsx
index 06d37ff791cb..60445c6a0ef8 100644
--- a/cvat-ui/src/components/create-job-page/job-form.tsx
+++ b/cvat-ui/src/components/create-job-page/job-form.tsx
@@ -1,48 +1,47 @@
-// Copyright (C) 2023 CVAT.ai Corporation
+// Copyright (C) 2023-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
 import './styles.scss';
 
-import React, { useCallback } from 'react';
+import React, { useCallback, useState } from 'react';
+import { useHistory } from 'react-router';
+import { useDispatch } from 'react-redux';
 import { Row, Col } from 'antd/lib/grid';
 import Form from 'antd/lib/form';
 import Button from 'antd/lib/button';
 import Select from 'antd/lib/select';
 import InputNumber from 'antd/lib/input-number';
+import Space from 'antd/lib/space';
+import { QuestionCircleOutlined } from '@ant-design/icons';
 import CVATTooltip from 'components/common/cvat-tooltip';
 
-import { CombinedState } from 'reducers';
-import { useDispatch, useSelector } from 'react-redux';
 import { JobType } from 'cvat-core/src/enums';
 import { Task } from 'cvat-core-wrapper';
 import { createJobAsync } from 'actions/jobs-actions';
-import { useHistory } from 'react-router';
-import Space from 'antd/lib/space';
-import { QuestionCircleOutlined } from '@ant-design/icons';
 
 export enum FrameSelectionMethod {
     RANDOM = 'random_uniform',
 }
 
 interface JobDataMutual {
-    task_id: number,
-    frame_selection_method: FrameSelectionMethod,
-    type: JobType,
-    seed?: number,
+    task_id: number;
+    frame_selection_method: FrameSelectionMethod;
+    type: JobType;
+    seed?: number;
 }
 
 export interface JobData extends JobDataMutual {
-    frame_count: number,
+    frame_count: number;
 }
 
 export interface JobFormData extends JobDataMutual {
-    quantity: number,
-    frame_count: number,
+    quantity: number;
+    frame_count: number;
 }
 
 interface Props {
-    task: Task
+    task: Task;
 }
 
 const defaultQuantity = 5;
@@ -53,8 +52,7 @@ function JobForm(props: Props): JSX.Element {
     const [form] = Form.useForm();
     const dispatch = useDispatch();
     const history = useHistory();
-
-    const fetching = useSelector((state: CombinedState) => state.models.fetching);
+    const [fetching, setFetching] = useState(false);
 
     const submit = useCallback(async (): Promise<any> => {
         try {
@@ -66,8 +64,8 @@ function JobForm(props: Props): JSX.Element {
                 frame_count: values.frame_count,
                 task_id: task.id,
             };
-            const createdJob = await dispatch(createJobAsync(data));
 
+            const createdJob = await dispatch(createJobAsync(data));
             return createdJob;
         } catch (e) {
             return false;
@@ -75,9 +73,15 @@ function JobForm(props: Props): JSX.Element {
     }, [task]);
 
     const onSubmit = async (): Promise<void> => {
-        const createdJob = await submit();
-        if (createdJob) {
-            history.push(`/tasks/${task.id}/jobs/${createdJob.id}`);
+        try {
+            setFetching(true);
+
+            const createdJob = await submit();
+            if (createdJob) {
+                history.push(`/tasks/${task.id}/jobs/${createdJob.id}`);
+            }
+        } finally {
+            setFetching(false);
         }
     };
 
@@ -221,6 +225,7 @@ function JobForm(props: Props): JSX.Element {
                             type='primary'
                             onClick={onSubmit}
                             loading={fetching}
+                            disabled={fetching}
                         >
                             Submit
                         </Button>
diff --git a/cvat-ui/src/containers/annotation-page/annotation-page.tsx b/cvat-ui/src/containers/annotation-page/annotation-page.tsx
index 6adf53b63169..19929971a06f 100644
--- a/cvat-ui/src/containers/annotation-page/annotation-page.tsx
+++ b/cvat-ui/src/containers/annotation-page/annotation-page.tsx
@@ -64,6 +64,14 @@ function mapDispatchToProps(dispatch: any, own: OwnProps): DispatchToProps {
     const searchParams = new URLSearchParams(window.location.search);
     const initialFilters: object[] = [];
     const initialOpenGuide = searchParams.has('openGuide');
+
+    const parsedPointsCount = +(searchParams.get('defaultPointsCount') || 'NaN');
+    const defaultLabel = searchParams.get('defaultLabel') || null;
+    const defaultPointsCount = Number.isInteger(parsedPointsCount) && parsedPointsCount >= 1 ? parsedPointsCount : null;
+    const initialWorkspace = Object.entries(Workspace).find(([key]) => (
+        key === searchParams.get('defaultWorkspace')?.toUpperCase()
+    )) || null;
+
     const parsedFrame = +(searchParams.get('frame') || 'NaN');
     const initialFrame = Number.isInteger(parsedFrame) && parsedFrame >= 0 ? parsedFrame : null;
 
@@ -77,8 +85,14 @@ function mapDispatchToProps(dispatch: any, own: OwnProps): DispatchToProps {
         }
     }
 
-    if (searchParams.size) {
-        own.history.replace(own.history.location.pathname);
+    const initialSize = searchParams.size;
+    searchParams.delete('frame');
+    searchParams.delete('serverID');
+    searchParams.delete('type');
+    searchParams.delete('openGuide');
+
+    if (searchParams.size !== initialSize) {
+        own.history.replace(`${own.history.location.pathname}?${searchParams.toString()}`);
     }
 
     return {
@@ -88,7 +102,12 @@ function mapDispatchToProps(dispatch: any, own: OwnProps): DispatchToProps {
                 jobID,
                 initialFrame,
                 initialFilters,
-                initialOpenGuide,
+                queryParameters: {
+                    initialOpenGuide,
+                    defaultLabel,
+                    defaultPointsCount,
+                    ...(initialWorkspace ? { initialWorkspace: initialWorkspace[1] } : { initialWorkspace }),
+                },
             }));
         },
         saveLogs(): void {
diff --git a/cvat-ui/src/containers/annotation-page/top-bar/top-bar.tsx b/cvat-ui/src/containers/annotation-page/top-bar/top-bar.tsx
index 9944b90f3ff3..f00a6fbbb13f 100644
--- a/cvat-ui/src/containers/annotation-page/top-bar/top-bar.tsx
+++ b/cvat-ui/src/containers/annotation-page/top-bar/top-bar.tsx
@@ -7,7 +7,6 @@ import React from 'react';
 import { connect } from 'react-redux';
 import { withRouter } from 'react-router';
 import { RouteComponentProps } from 'react-router-dom';
-import Input from 'antd/lib/input';
 import copy from 'copy-to-clipboard';
 
 import {
@@ -17,7 +16,6 @@ import {
     redoActionAsync,
     saveAnnotationsAsync,
     searchAnnotationsAsync,
-    searchEmptyFrameAsync,
     setForceExitAnnotationFlag as setForceExitAnnotationFlagAction,
     showFilters as showFiltersAction,
     showStatistics as showStatisticsAction,
@@ -26,6 +24,7 @@ import {
     deleteFrameAsync,
     restoreFrameAsync,
     switchNavigationBlocked as switchNavigationBlockedAction,
+    setNavigationType as setNavigationTypeAction,
 } from 'actions/annotation-actions';
 import AnnotationTopBarComponent from 'components/annotation-page/top-bar/top-bar';
 import { Canvas } from 'cvat-canvas-wrapper';
@@ -37,9 +36,10 @@ import {
     Workspace,
     ActiveControl,
     ToolsBlockerState,
+    NavigationType,
 } from 'reducers';
 import isAbleToChangeFrame from 'utils/is-able-to-change-frame';
-import GlobalHotKeys, { KeyMap } from 'utils/mousetrap-react';
+import { KeyMap } from 'utils/mousetrap-react';
 import { switchToolsBlockerState } from 'actions/settings-actions';
 import { writeLatestFrame } from 'utils/remember-latest-frame';
 
@@ -70,24 +70,32 @@ interface StateToProps {
     activeControl: ActiveControl;
     annotationFilters: object[];
     initialOpenGuide: boolean;
+    navigationType: NavigationType;
 }
 
 interface DispatchToProps {
     onChangeFrame(frame: number, fillBuffer?: boolean, frameStep?: number): void;
     onSwitchPlay(playing: boolean): void;
     onSaveAnnotation(): void;
-    showStatistics(sessionInstance: any): void;
-    showFilters(sessionInstance: any): void;
+    showStatistics(sessionInstance: Job): void;
+    showFilters(): void;
     undo(): void;
     redo(): void;
-    searchAnnotations(sessionInstance: any, frameFrom: number, frameTo: number): void;
-    searchEmptyFrame(sessionInstance: any, frameFrom: number, frameTo: number): void;
+    searchAnnotations(
+        sessionInstance: Job,
+        frameFrom: number,
+        frameTo: number,
+        generalFilters?: {
+            isEmptyFrame: boolean;
+        },
+    ): void;
     setForceExitAnnotationFlag(forceExit: boolean): void;
     changeWorkspace(workspace: Workspace): void;
     onSwitchToolsBlockerState(toolsBlockerState: ToolsBlockerState): void;
     deleteFrame(frame: number): void;
     restoreFrame(frame: number): void;
     switchNavigationBlocked(blocked: boolean): void;
+    setNavigationType(navigationType: NavigationType): void;
 }
 
 function mapStateToProps(state: CombinedState): StateToProps {
@@ -103,13 +111,14 @@ function mapStateToProps(state: CombinedState): StateToProps {
                     delay: frameDelay,
                     fetching: frameFetching,
                 },
+                navigationType,
             },
             annotations: {
                 saving: { uploading: saving, forceExit },
                 history,
                 filters: annotationFilters,
             },
-            job: { instance: jobInstance, initialOpenGuide },
+            job: { instance: jobInstance, queryParameters: { initialOpenGuide } },
             canvas: { ready: canvasIsReady, instance: canvasInstance, activeControl },
             workspace,
         },
@@ -151,6 +160,7 @@ function mapStateToProps(state: CombinedState): StateToProps {
         ranges,
         annotationFilters,
         initialOpenGuide,
+        navigationType,
     };
 }
 
@@ -165,7 +175,7 @@ function mapDispatchToProps(dispatch: any): DispatchToProps {
         onSaveAnnotation(): void {
             dispatch(saveAnnotationsAsync());
         },
-        showStatistics(sessionInstance: any): void {
+        showStatistics(sessionInstance: Job): void {
             dispatch(collectStatisticsAsync(sessionInstance));
             dispatch(showStatisticsAction(true));
         },
@@ -178,11 +188,15 @@ function mapDispatchToProps(dispatch: any): DispatchToProps {
         redo(): void {
             dispatch(redoActionAsync());
         },
-        searchAnnotations(sessionInstance: any, frameFrom: number, frameTo: number): void {
-            dispatch(searchAnnotationsAsync(sessionInstance, frameFrom, frameTo));
-        },
-        searchEmptyFrame(sessionInstance: any, frameFrom: number, frameTo: number): void {
-            dispatch(searchEmptyFrameAsync(sessionInstance, frameFrom, frameTo));
+        searchAnnotations(
+            sessionInstance: Job,
+            frameFrom: number,
+            frameTo: number,
+            generalFilters?: {
+                isEmptyFrame: boolean;
+            },
+        ): void {
+            dispatch(searchAnnotationsAsync(sessionInstance, frameFrom, frameTo, generalFilters));
         },
         changeWorkspace(workspace: Workspace): void {
             dispatch(changeWorkspaceAction(workspace));
@@ -202,27 +216,21 @@ function mapDispatchToProps(dispatch: any): DispatchToProps {
         switchNavigationBlocked(blocked: boolean): void {
             dispatch(switchNavigationBlockedAction(blocked));
         },
+        setNavigationType(navigationType: NavigationType): void {
+            dispatch(setNavigationTypeAction(navigationType));
+        },
     };
 }
 
-interface State {
-    prevButtonType: 'regular' | 'filtered' | 'empty';
-    nextButtonType: 'regular' | 'filtered' | 'empty';
-}
-
 type Props = StateToProps & DispatchToProps & RouteComponentProps;
-class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
-    private inputFrameRef: React.RefObject<Input>;
+class AnnotationTopBarContainer extends React.PureComponent<Props> {
+    private inputFrameRef: React.RefObject<HTMLInputElement>;
     private autoSaveInterval: number | undefined;
     private unblock: any;
 
     constructor(props: Props) {
         super(props);
-        this.inputFrameRef = React.createRef<Input>();
-        this.state = {
-            prevButtonType: 'regular',
-            nextButtonType: 'regular',
-        };
+        this.inputFrameRef = React.createRef<HTMLInputElement>();
     }
 
     public componentDidMount(): void {
@@ -273,17 +281,17 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
     }
 
     private undo = (): void => {
-        const { undo } = this.props;
+        const { undo, canvasIsReady, undoAction } = this.props;
 
-        if (isAbleToChangeFrame()) {
+        if (isAbleToChangeFrame() && canvasIsReady && undoAction) {
             undo();
         }
     };
 
     private redo = (): void => {
-        const { redo } = this.props;
+        const { redo, canvasIsReady, redoAction } = this.props;
 
-        if (isAbleToChangeFrame()) {
+        if (isAbleToChangeFrame() && canvasIsReady && redoAction) {
             redo();
         }
     };
@@ -294,8 +302,8 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
     };
 
     private showFilters = (): void => {
-        const { jobInstance, showFilters } = this.props;
-        showFilters(jobInstance);
+        const { showFilters } = this.props;
+        showFilters();
     };
 
     private onSwitchPlay = (): void => {
@@ -312,12 +320,13 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
 
     private onFirstFrame = async (): Promise<void> => {
         const {
-            frameNumber, jobInstance, playing, onSwitchPlay, showDeletedFrames,
+            frameNumber, jobInstance, playing,
+            onSwitchPlay, showDeletedFrames, canvasIsReady,
         } = this.props;
 
         const newFrame =
             await jobInstance.frames.search({ notDeleted: !showDeletedFrames }, jobInstance.startFrame, frameNumber);
-        if (newFrame !== frameNumber && newFrame !== null) {
+        if (newFrame !== frameNumber && newFrame !== null && canvasIsReady) {
             if (playing) {
                 onSwitchPlay(false);
             }
@@ -327,7 +336,8 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
 
     private onBackward = async (): Promise<void> => {
         const {
-            frameNumber, frameStep, jobInstance, playing, onSwitchPlay, showDeletedFrames,
+            frameNumber, frameStep, jobInstance, playing,
+            onSwitchPlay, showDeletedFrames, canvasIsReady,
         } = this.props;
 
         const newFrame = await jobInstance.frames.search(
@@ -336,7 +346,7 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
             jobInstance.startFrame,
         );
 
-        if (newFrame !== frameNumber && newFrame !== null) {
+        if (newFrame !== frameNumber && newFrame !== null && canvasIsReady) {
             if (playing) {
                 onSwitchPlay(false);
             }
@@ -345,9 +355,9 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
     };
 
     private onPrevFrame = async (): Promise<void> => {
-        const { prevButtonType } = this.state;
         const {
-            frameNumber, jobInstance, playing, onSwitchPlay, showDeletedFrames,
+            frameNumber, jobInstance, playing, searchAnnotations,
+            onSwitchPlay, showDeletedFrames, canvasIsReady, navigationType,
         } = this.props;
         const { startFrame } = jobInstance;
 
@@ -358,25 +368,25 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
             jobInstance.startFrame,
         );
 
-        if (newFrame !== frameNumber && newFrame !== null) {
+        if (newFrame !== frameNumber && newFrame !== null && canvasIsReady && isAbleToChangeFrame()) {
             if (playing) {
                 onSwitchPlay(false);
             }
 
-            if (prevButtonType === 'regular') {
+            if (navigationType === NavigationType.REGULAR) {
                 this.changeFrame(newFrame);
-            } else if (prevButtonType === 'filtered') {
-                this.searchAnnotations(newFrame, startFrame);
+            } else if (navigationType === NavigationType.FILTERED) {
+                searchAnnotations(jobInstance, newFrame, startFrame);
             } else {
-                this.searchEmptyFrame(newFrame, startFrame);
+                searchAnnotations(jobInstance, newFrame, startFrame, { isEmptyFrame: true });
             }
         }
     };
 
     private onNextFrame = async (): Promise<void> => {
-        const { nextButtonType } = this.state;
         const {
-            frameNumber, jobInstance, playing, onSwitchPlay, showDeletedFrames,
+            frameNumber, jobInstance, playing, searchAnnotations,
+            onSwitchPlay, showDeletedFrames, canvasIsReady, navigationType,
         } = this.props;
         const { stopFrame } = jobInstance;
 
@@ -386,24 +396,25 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
             frameFrom,
             jobInstance.stopFrame,
         );
-        if (newFrame !== frameNumber && newFrame !== null) {
+        if (newFrame !== frameNumber && newFrame !== null && canvasIsReady && isAbleToChangeFrame()) {
             if (playing) {
                 onSwitchPlay(false);
             }
 
-            if (nextButtonType === 'regular') {
+            if (navigationType === NavigationType.REGULAR) {
                 this.changeFrame(newFrame);
-            } else if (nextButtonType === 'filtered') {
-                this.searchAnnotations(newFrame, stopFrame);
+            } else if (navigationType === NavigationType.FILTERED) {
+                searchAnnotations(jobInstance, newFrame, stopFrame);
             } else {
-                this.searchEmptyFrame(newFrame, stopFrame);
+                searchAnnotations(jobInstance, newFrame, stopFrame, { isEmptyFrame: true });
             }
         }
     };
 
     private onForward = async (): Promise<void> => {
         const {
-            frameNumber, frameStep, jobInstance, playing, onSwitchPlay, showDeletedFrames,
+            frameNumber, frameStep, jobInstance, playing,
+            onSwitchPlay, showDeletedFrames, canvasIsReady,
         } = this.props;
 
         const newFrame = await jobInstance.frames.search(
@@ -412,7 +423,7 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
             jobInstance.stopFrame,
         );
 
-        if (newFrame !== frameNumber && newFrame !== null) {
+        if (newFrame !== frameNumber && newFrame !== null && canvasIsReady) {
             if (playing) {
                 onSwitchPlay(false);
             }
@@ -422,12 +433,13 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
 
     private onLastFrame = async (): Promise<void> => {
         const {
-            frameNumber, jobInstance, playing, onSwitchPlay, showDeletedFrames,
+            frameNumber, jobInstance, playing,
+            onSwitchPlay, showDeletedFrames, canvasIsReady,
         } = this.props;
 
         const newFrame =
             await jobInstance.frames.search({ notDeleted: !showDeletedFrames }, jobInstance.stopFrame, frameNumber);
-        if (newFrame !== frameNumber && frameNumber !== null) {
+        if (newFrame !== frameNumber && frameNumber !== null && canvasIsReady) {
             if (playing) {
                 onSwitchPlay(false);
             }
@@ -435,16 +447,20 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
         }
     };
 
-    private onSetPreviousButtonType = (type: 'regular' | 'filtered' | 'empty'): void => {
-        this.setState({
-            prevButtonType: type,
-        });
-    };
+    private searchAnnotations = (direction: 'forward' | 'backward'): void => {
+        const {
+            frameNumber, jobInstance,
+            canvasIsReady, searchAnnotations,
+        } = this.props;
+        const { startFrame, stopFrame } = jobInstance;
 
-    private onSetNextButtonType = (type: 'regular' | 'filtered' | 'empty'): void => {
-        this.setState({
-            nextButtonType: type,
-        });
+        if (isAbleToChangeFrame() && canvasIsReady) {
+            if (direction === 'forward' && frameNumber + 1 <= stopFrame) {
+                searchAnnotations(jobInstance, frameNumber + 1, stopFrame);
+            } else if (direction === 'backward' && frameNumber - 1 >= startFrame) {
+                searchAnnotations(jobInstance, frameNumber - 1, startFrame);
+            }
+        }
     };
 
     private onSaveAnnotation = (): void => {
@@ -526,8 +542,10 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
     };
 
     private onDeleteFrame = (): void => {
-        const { deleteFrame, frameNumber, jobInstance } = this.props;
-        if (jobInstance.type !== JobType.GROUND_TRUTH) deleteFrame(frameNumber);
+        const {
+            deleteFrame, frameNumber, jobInstance, canvasIsReady,
+        } = this.props;
+        if (canvasIsReady && jobInstance.type !== JobType.GROUND_TRUTH) deleteFrame(frameNumber);
     };
 
     private onRestoreFrame = (): void => {
@@ -630,22 +648,7 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
         }
     }
 
-    private searchAnnotations(start: number, stop: number): void {
-        const { jobInstance, searchAnnotations } = this.props;
-        if (isAbleToChangeFrame()) {
-            searchAnnotations(jobInstance, start, stop);
-        }
-    }
-
-    private searchEmptyFrame(start: number, stop: number): void {
-        const { jobInstance, searchEmptyFrame } = this.props;
-        if (isAbleToChangeFrame()) {
-            searchEmptyFrame(jobInstance, start, stop);
-        }
-    }
-
     public render(): JSX.Element {
-        const { nextButtonType, prevButtonType } = this.state;
         const {
             playing,
             saving,
@@ -657,7 +660,6 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
             undoAction,
             redoAction,
             workspace,
-            canvasIsReady,
             keyMap,
             ranges,
             normalizedKeyMap,
@@ -665,158 +667,69 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
             annotationFilters,
             initialOpenGuide,
             toolsBlockerState,
-            searchAnnotations,
+            navigationType,
             switchNavigationBlocked,
+            setNavigationType,
         } = this.props;
 
-        const preventDefault = (event: KeyboardEvent | undefined): void => {
-            if (event) {
-                event.preventDefault();
-            }
-        };
-
-        const subKeyMap = {
-            UNDO: keyMap.UNDO,
-            REDO: keyMap.REDO,
-            DELETE_FRAME: keyMap.DELETE_FRAME,
-            NEXT_FRAME: keyMap.NEXT_FRAME,
-            PREV_FRAME: keyMap.PREV_FRAME,
-            FORWARD_FRAME: keyMap.FORWARD_FRAME,
-            BACKWARD_FRAME: keyMap.BACKWARD_FRAME,
-            SEARCH_FORWARD: keyMap.SEARCH_FORWARD,
-            SEARCH_BACKWARD: keyMap.SEARCH_BACKWARD,
-            PLAY_PAUSE: keyMap.PLAY_PAUSE,
-            FOCUS_INPUT_FRAME: keyMap.FOCUS_INPUT_FRAME,
-        };
-
-        const handlers = {
-            UNDO: (event: KeyboardEvent | undefined) => {
-                preventDefault(event);
-                if (undoAction) {
-                    this.undo();
-                }
-            },
-            REDO: (event: KeyboardEvent | undefined) => {
-                preventDefault(event);
-                if (redoAction) {
-                    this.redo();
-                }
-            },
-            DELETE_FRAME: (event: KeyboardEvent | undefined) => {
-                preventDefault(event);
-                if (canvasIsReady) {
-                    this.onDeleteFrame();
-                }
-            },
-            NEXT_FRAME: (event: KeyboardEvent | undefined) => {
-                preventDefault(event);
-                if (canvasIsReady) {
-                    this.onNextFrame();
-                }
-            },
-            PREV_FRAME: (event: KeyboardEvent | undefined) => {
-                preventDefault(event);
-                if (canvasIsReady) {
-                    this.onPrevFrame();
-                }
-            },
-            FORWARD_FRAME: (event: KeyboardEvent | undefined) => {
-                preventDefault(event);
-                if (canvasIsReady) {
-                    this.onForward();
-                }
-            },
-            BACKWARD_FRAME: (event: KeyboardEvent | undefined) => {
-                preventDefault(event);
-                if (canvasIsReady) {
-                    this.onBackward();
-                }
-            },
-            SEARCH_FORWARD: (event: KeyboardEvent | undefined) => {
-                preventDefault(event);
-                if (frameNumber + 1 <= stopFrame && canvasIsReady && isAbleToChangeFrame()) {
-                    searchAnnotations(jobInstance, frameNumber + 1, stopFrame);
-                }
-            },
-            SEARCH_BACKWARD: (event: KeyboardEvent | undefined) => {
-                preventDefault(event);
-                if (frameNumber - 1 >= startFrame && canvasIsReady && isAbleToChangeFrame()) {
-                    searchAnnotations(jobInstance, frameNumber - 1, startFrame);
-                }
-            },
-            PLAY_PAUSE: (event: KeyboardEvent | undefined) => {
-                preventDefault(event);
-                this.onSwitchPlay();
-            },
-            FOCUS_INPUT_FRAME: (event: KeyboardEvent | undefined) => {
-                preventDefault(event);
-                if (this.inputFrameRef.current) {
-                    this.inputFrameRef.current.focus();
-                }
-            },
-        };
-
         return (
-            <>
-                <GlobalHotKeys keyMap={subKeyMap} handlers={handlers} />
-                <AnnotationTopBarComponent
-                    showStatistics={this.showStatistics}
-                    showFilters={this.showFilters}
-                    onSwitchPlay={this.onSwitchPlay}
-                    onSaveAnnotation={this.onSaveAnnotation}
-                    onPrevFrame={this.onPrevFrame}
-                    onNextFrame={this.onNextFrame}
-                    onForward={this.onForward}
-                    onBackward={this.onBackward}
-                    onFirstFrame={this.onFirstFrame}
-                    onLastFrame={this.onLastFrame}
-                    setNextButtonType={this.onSetNextButtonType}
-                    setPrevButtonType={this.onSetPreviousButtonType}
-                    onSliderChange={this.onChangePlayerSliderValue}
-                    onInputChange={this.onChangePlayerInputValue}
-                    onURLIconClick={this.onURLIconClick}
-                    onDeleteFrame={this.onDeleteFrame}
-                    onRestoreFrame={this.onRestoreFrame}
-                    changeWorkspace={this.changeWorkspace}
-                    switchNavigationBlocked={switchNavigationBlocked}
-                    workspace={workspace}
-                    playing={playing}
-                    saving={saving}
-                    ranges={ranges}
-                    startFrame={startFrame}
-                    stopFrame={stopFrame}
-                    frameNumber={frameNumber}
-                    frameFilename={frameFilename}
-                    frameDeleted={frameIsDeleted}
-                    inputFrameRef={this.inputFrameRef}
-                    undoAction={undoAction}
-                    redoAction={redoAction}
-                    undoShortcut={normalizedKeyMap.UNDO}
-                    redoShortcut={normalizedKeyMap.REDO}
-                    drawShortcut={normalizedKeyMap.SWITCH_DRAW_MODE}
-                    // this shortcut is handled in interactionHandler.ts separately
-                    switchToolsBlockerShortcut={normalizedKeyMap.SWITCH_TOOLS_BLOCKER_STATE}
-                    playPauseShortcut={normalizedKeyMap.PLAY_PAUSE}
-                    deleteFrameShortcut={normalizedKeyMap.DELETE_FRAME}
-                    nextFrameShortcut={normalizedKeyMap.NEXT_FRAME}
-                    previousFrameShortcut={normalizedKeyMap.PREV_FRAME}
-                    forwardShortcut={normalizedKeyMap.FORWARD_FRAME}
-                    backwardShortcut={normalizedKeyMap.BACKWARD_FRAME}
-                    nextButtonType={nextButtonType}
-                    prevButtonType={prevButtonType}
-                    focusFrameInputShortcut={normalizedKeyMap.FOCUS_INPUT_FRAME}
-                    annotationFilters={annotationFilters}
-                    initialOpenGuide={initialOpenGuide}
-                    onUndoClick={this.undo}
-                    onRedoClick={this.redo}
-                    onFinishDraw={this.onFinishDraw}
-                    onSwitchToolsBlockerState={this.onSwitchToolsBlockerState}
-                    toolsBlockerState={toolsBlockerState}
-                    jobInstance={jobInstance}
-                    activeControl={activeControl}
-                    deleteFrameAvailable={jobInstance.type !== JobType.GROUND_TRUTH}
-                />
-            </>
+            <AnnotationTopBarComponent
+                showStatistics={this.showStatistics}
+                showFilters={this.showFilters}
+                onSwitchPlay={this.onSwitchPlay}
+                onSaveAnnotation={this.onSaveAnnotation}
+                onPrevFrame={this.onPrevFrame}
+                onNextFrame={this.onNextFrame}
+                onForward={this.onForward}
+                onBackward={this.onBackward}
+                onFirstFrame={this.onFirstFrame}
+                onLastFrame={this.onLastFrame}
+                onSearchAnnotations={this.searchAnnotations}
+                setNavigationType={setNavigationType}
+                onSliderChange={this.onChangePlayerSliderValue}
+                onInputChange={this.onChangePlayerInputValue}
+                onURLIconClick={this.onURLIconClick}
+                onDeleteFrame={this.onDeleteFrame}
+                onRestoreFrame={this.onRestoreFrame}
+                changeWorkspace={this.changeWorkspace}
+                switchNavigationBlocked={switchNavigationBlocked}
+                keyMap={keyMap}
+                workspace={workspace}
+                playing={playing}
+                saving={saving}
+                ranges={ranges}
+                startFrame={startFrame}
+                stopFrame={stopFrame}
+                frameNumber={frameNumber}
+                frameFilename={frameFilename}
+                frameDeleted={frameIsDeleted}
+                inputFrameRef={this.inputFrameRef}
+                undoAction={undoAction}
+                redoAction={redoAction}
+                undoShortcut={normalizedKeyMap.UNDO}
+                redoShortcut={normalizedKeyMap.REDO}
+                drawShortcut={normalizedKeyMap.SWITCH_DRAW_MODE}
+                // this shortcut is handled in interactionHandler.ts separately
+                switchToolsBlockerShortcut={normalizedKeyMap.SWITCH_TOOLS_BLOCKER_STATE}
+                playPauseShortcut={normalizedKeyMap.PLAY_PAUSE}
+                deleteFrameShortcut={normalizedKeyMap.DELETE_FRAME}
+                nextFrameShortcut={normalizedKeyMap.NEXT_FRAME}
+                previousFrameShortcut={normalizedKeyMap.PREV_FRAME}
+                forwardShortcut={normalizedKeyMap.FORWARD_FRAME}
+                backwardShortcut={normalizedKeyMap.BACKWARD_FRAME}
+                navigationType={navigationType}
+                focusFrameInputShortcut={normalizedKeyMap.FOCUS_INPUT_FRAME}
+                annotationFilters={annotationFilters}
+                initialOpenGuide={initialOpenGuide}
+                onUndoClick={this.undo}
+                onRedoClick={this.redo}
+                onFinishDraw={this.onFinishDraw}
+                onSwitchToolsBlockerState={this.onSwitchToolsBlockerState}
+                toolsBlockerState={toolsBlockerState}
+                jobInstance={jobInstance}
+                activeControl={activeControl}
+                deleteFrameAvailable={jobInstance.type !== JobType.GROUND_TRUTH}
+            />
         );
     }
 }
diff --git a/cvat-ui/src/reducers/annotation-reducer.ts b/cvat-ui/src/reducers/annotation-reducer.ts
index 53b8d62878a8..591e1241fa9b 100644
--- a/cvat-ui/src/reducers/annotation-reducer.ts
+++ b/cvat-ui/src/reducers/annotation-reducer.ts
@@ -17,6 +17,7 @@ import {
     ActiveControl,
     AnnotationState,
     ContextMenuType,
+    NavigationType,
     ObjectType,
     ShapeType,
     Workspace,
@@ -57,7 +58,11 @@ const defaultState: AnnotationState = {
         requestedId: null,
         groundTruthJobFramesMeta: null,
         groundTruthInstance: null,
-        initialOpenGuide: false,
+        queryParameters: {
+            initialOpenGuide: false,
+            defaultLabel: null,
+            defaultPointsCount: null,
+        },
         instance: null,
         attributes: {},
         fetching: false,
@@ -74,6 +79,7 @@ const defaultState: AnnotationState = {
             changeTime: null,
             changeFrameEvent: null,
         },
+        navigationType: NavigationType.REGULAR,
         ranges: '',
         playing: false,
         frameAngles: [],
@@ -154,19 +160,22 @@ export default (state = defaultState, action: AnyAction): AnnotationState => {
                 frameData: data,
                 minZ,
                 maxZ,
-                initialOpenGuide,
+                queryParameters,
                 groundTruthInstance,
                 groundTruthJobFramesMeta,
             } = action.payload;
 
-            const isReview = job.stage === JobStage.VALIDATION;
-            let workspaceSelected = Workspace.STANDARD;
-
             const defaultLabel = job.labels.length ? job.labels[0] : null;
+            const isReview = job.stage === JobStage.VALIDATION;
+            let workspaceSelected = null;
             let activeShapeType = defaultLabel && defaultLabel.type !== 'any' ?
                 defaultLabel.type : ShapeType.RECTANGLE;
-
-            if (job.dimension === DimensionType.DIMENSION_3D) {
+            if (job.dimension === DimensionType.DIMENSION_2D) {
+                if (queryParameters.initialWorkspace !== Workspace.STANDARD3D) {
+                    workspaceSelected = queryParameters.initialWorkspace;
+                }
+                workspaceSelected = workspaceSelected || (isReview ? Workspace.REVIEW : Workspace.STANDARD);
+            } else {
                 workspaceSelected = Workspace.STANDARD3D;
                 activeShapeType = ShapeType.CUBOID;
             }
@@ -188,9 +197,13 @@ export default (state = defaultState, action: AnyAction): AnnotationState => {
                             acc[label.id] = label.attributes;
                             return acc;
                         }, {}),
-                    initialOpenGuide,
                     groundTruthInstance,
                     groundTruthJobFramesMeta,
+                    queryParameters: {
+                        initialOpenGuide: queryParameters.initialOpenGuide,
+                        defaultLabel: queryParameters.defaultLabel,
+                        defaultPointsCount: queryParameters.defaultPointsCount,
+                    },
                 },
                 annotations: {
                     ...state.annotations,
@@ -225,7 +238,7 @@ export default (state = defaultState, action: AnyAction): AnnotationState => {
                 },
                 colors,
                 workspace: isReview && job.dimension === DimensionType.DIMENSION_2D ?
-                    Workspace.REVIEW_WORKSPACE : workspaceSelected,
+                    Workspace.REVIEW : workspaceSelected,
             };
         }
         case AnnotationActionTypes.GET_JOB_FAILED: {
@@ -283,6 +296,7 @@ export default (state = defaultState, action: AnyAction): AnnotationState => {
                 filename,
                 relatedFiles,
                 states,
+                history,
                 minZ,
                 maxZ,
                 curZ,
@@ -311,6 +325,7 @@ export default (state = defaultState, action: AnyAction): AnnotationState => {
                     activatedStateID: updateActivatedStateID(states, activatedStateID),
                     highlightedConflict: null,
                     states,
+                    history,
                     zLayer: {
                         min: minZ,
                         max: maxZ,
@@ -965,6 +980,15 @@ export default (state = defaultState, action: AnyAction): AnnotationState => {
                 },
             };
         }
+        case AnnotationActionTypes.SET_NAVIGATION_TYPE: {
+            return {
+                ...state,
+                player: {
+                    ...state.player,
+                    navigationType: action.payload.navigationType,
+                },
+            };
+        }
         case AnnotationActionTypes.DELETE_FRAME:
         case AnnotationActionTypes.RESTORE_FRAME: {
             return {
diff --git a/cvat-ui/src/reducers/index.ts b/cvat-ui/src/reducers/index.ts
index 7f585b5dc184..69017ac736ca 100644
--- a/cvat-ui/src/reducers/index.ts
+++ b/cvat-ui/src/reducers/index.ts
@@ -512,7 +512,6 @@ export interface NotificationsState {
             undo: null | ErrorState;
             redo: null | ErrorState;
             search: null | ErrorState;
-            searchEmptyFrame: null | ErrorState;
             deleteFrame: null | ErrorState;
             restoreFrame: null | ErrorState;
             savingLogs: null | ErrorState;
@@ -673,6 +672,12 @@ export enum Rotation {
     CLOCKWISE90,
 }
 
+export enum NavigationType {
+    REGULAR = 'regular',
+    FILTERED = 'filtered',
+    EMPTY = 'empty',
+}
+
 export interface AnnotationState {
     activities: {
         loads: {
@@ -704,7 +709,11 @@ export interface AnnotationState {
         labels: Label[];
         requestedId: number | null;
         instance: Job | null | undefined;
-        initialOpenGuide: boolean;
+        queryParameters: {
+            initialOpenGuide: boolean;
+            defaultLabel: string | null;
+            defaultPointsCount: number | null;
+        };
         groundTruthJobFramesMeta: FramesMetaData | null;
         groundTruthInstance: Job | null;
         attributes: Record<number, any[]>;
@@ -722,6 +731,7 @@ export interface AnnotationState {
             changeTime: number | null;
             changeFrameEvent: Event | null;
         };
+        navigationType: NavigationType;
         ranges: string;
         navigationBlocked: boolean;
         playing: boolean;
@@ -783,9 +793,10 @@ export interface AnnotationState {
 export enum Workspace {
     STANDARD3D = 'Standard 3D',
     STANDARD = 'Standard',
-    ATTRIBUTE_ANNOTATION = 'Attribute annotation',
-    TAG_ANNOTATION = 'Tag annotation',
-    REVIEW_WORKSPACE = 'Review',
+    ATTRIBUTES = 'Attribute annotation',
+    SINGLE_SHAPE = 'Single shape',
+    TAGS = 'Tag annotation',
+    REVIEW = 'Review',
 }
 
 export enum GridColor {
diff --git a/cvat-ui/src/reducers/notifications-reducer.ts b/cvat-ui/src/reducers/notifications-reducer.ts
index 7d58d95e0a3c..e9f26cd5db7a 100644
--- a/cvat-ui/src/reducers/notifications-reducer.ts
+++ b/cvat-ui/src/reducers/notifications-reducer.ts
@@ -108,7 +108,6 @@ const defaultState: NotificationsState = {
             undo: null,
             redo: null,
             search: null,
-            searchEmptyFrame: null,
             deleteFrame: null,
             restoreFrame: null,
             savingLogs: null,
@@ -1195,22 +1194,6 @@ export default function (state = defaultState, action: AnyAction): Notifications
                 },
             };
         }
-        case AnnotationActionTypes.SEARCH_EMPTY_FRAME_FAILED: {
-            return {
-                ...state,
-                errors: {
-                    ...state.errors,
-                    annotation: {
-                        ...state.errors.annotation,
-                        searchEmptyFrame: {
-                            message: 'Could not search an empty frame',
-                            reason: action.payload.error,
-                            shouldLog: !(action.payload.error instanceof ServerError),
-                        },
-                    },
-                },
-            };
-        }
         case AnnotationActionTypes.SAVE_LOGS_FAILED: {
             return {
                 ...state,
diff --git a/cvat-ui/src/utils/filter-annotations.ts b/cvat-ui/src/utils/filter-annotations.ts
index afdfc42df5e8..4e9b48c5b771 100644
--- a/cvat-ui/src/utils/filter-annotations.ts
+++ b/cvat-ui/src/utils/filter-annotations.ts
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 CVAT.ai Corporation
+// Copyright (C) 2023-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -32,7 +32,7 @@ export function filterAnnotations(annotations: ObjectState[], params: FilterAnno
         }
 
         // GT tracks are shown only on GT frames
-        if (workspace === Workspace.REVIEW_WORKSPACE && groundTruthJobFramesMeta && frame) {
+        if (workspace === Workspace.REVIEW && groundTruthJobFramesMeta && frame) {
             if (state.objectType === ObjectType.TRACK && state.isGroundTruth) {
                 return groundTruthJobFramesMeta.includedFrames.includes(frame);
             }
diff --git a/cvat/__init__.py b/cvat/__init__.py
index 2b392d9b3efc..950b50a7a444 100644
--- a/cvat/__init__.py
+++ b/cvat/__init__.py
@@ -4,6 +4,6 @@
 
 from cvat.utils.version import get_version
 
-VERSION = (2, 11, 0, 'final', 0)
+VERSION = (2, 11, 1, 'final', 0)
 
 __version__ = get_version(VERSION)
diff --git a/cvat/apps/events/serializers.py b/cvat/apps/events/serializers.py
index 26111d43c400..d17d5cdea49c 100644
--- a/cvat/apps/events/serializers.py
+++ b/cvat/apps/events/serializers.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2023 CVAT.ai Corporation
+# Copyright (C) 2023-2024 CVAT.ai Corporation
 #
 # SPDX-License-Identifier: MIT
 
@@ -28,11 +28,19 @@ class EventSerializer(serializers.Serializer):
 
 class ClientEventsSerializer(serializers.Serializer):
     events = EventSerializer(many=True, default=[])
+    previous_event = EventSerializer(default=None, allow_null=True, write_only=True)
     timestamp = serializers.DateTimeField()
     _TIME_THRESHOLD = datetime.timedelta(seconds=100)
     _WORKING_TIME_RESOLUTION = datetime.timedelta(milliseconds=1)
     _COLLAPSED_EVENT_SCOPES = frozenset(("change:frame",))
 
+    @classmethod
+    def _end_timestamp(cls, event: dict) -> datetime.datetime:
+        if event["scope"] in cls._COLLAPSED_EVENT_SCOPES:
+            return event["timestamp"] + datetime.timedelta(milliseconds=event["duration"])
+
+        return event["timestamp"]
+
     def to_internal_value(self, data):
         data = super().to_internal_value(data)
         request = self.context.get("request")
@@ -43,25 +51,29 @@ def to_internal_value(self, data):
         send_time = data["timestamp"]
         receive_time = datetime.datetime.now(datetime.timezone.utc)
         time_correction = receive_time - send_time
-        last_timestamp = datetime.datetime(datetime.MINYEAR, 1, 1, tzinfo=datetime.timezone.utc)
-        zero_t_delta = datetime.timedelta()
+
+        if previous_event := data["previous_event"]:
+            previous_end_timestamp = self._end_timestamp(previous_event)
+        elif data["events"]:
+            previous_end_timestamp = data["events"][0]["timestamp"]
 
         for event in data["events"]:
-            timestamp = event["timestamp"]
             working_time = datetime.timedelta()
-            event_duration = datetime.timedelta()
-            t_diff = timestamp - last_timestamp
-
-            payload = json.loads(event.get("payload", "{}"))
-
-            if t_diff >= zero_t_delta:
-                if event["scope"] in self._COLLAPSED_EVENT_SCOPES:
-                    event_duration += datetime.timedelta(milliseconds=event["duration"])
-                    working_time += event_duration
 
+            timestamp = event["timestamp"]
+            if timestamp > previous_end_timestamp:
+                t_diff = timestamp - previous_end_timestamp
                 if t_diff < self._TIME_THRESHOLD:
                     working_time += t_diff
 
+                previous_end_timestamp = timestamp
+
+            end_timestamp = self._end_timestamp(event)
+            if end_timestamp > previous_end_timestamp:
+                working_time += end_timestamp - previous_end_timestamp
+                previous_end_timestamp = end_timestamp
+
+            payload = json.loads(event.get("payload", "{}"))
             payload.update({
                 "working_time": working_time // self._WORKING_TIME_RESOLUTION,
                 "username": request.user.username,
@@ -78,6 +90,4 @@ def to_internal_value(self, data):
                 "payload": json.dumps(payload),
             })
 
-            last_timestamp = timestamp + event_duration
-
         return data
diff --git a/cvat/apps/events/tests/__init__.py b/cvat/apps/events/tests/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/cvat/apps/events/tests/test_events.py b/cvat/apps/events/tests/test_events.py
new file mode 100644
index 000000000000..990daa1ea325
--- /dev/null
+++ b/cvat/apps/events/tests/test_events.py
@@ -0,0 +1,177 @@
+# Copyright (C) 2024 CVAT.ai Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import json
+import unittest
+from datetime import datetime, timedelta, timezone
+from typing import List, Optional
+
+from django.contrib.auth import get_user_model
+from django.test import RequestFactory
+
+from cvat.apps.events.serializers import ClientEventsSerializer
+from cvat.apps.organizations.models import Organization
+
+class WorkingTimeTestCase(unittest.TestCase):
+    _START_TIMESTAMP = datetime(2024, 1, 1, 12)
+    _SHORT_GAP = ClientEventsSerializer._TIME_THRESHOLD - timedelta(milliseconds=1)
+    _SHORT_GAP_INT = _SHORT_GAP / ClientEventsSerializer._WORKING_TIME_RESOLUTION
+    _LONG_GAP = ClientEventsSerializer._TIME_THRESHOLD
+    _LONG_GAP_INT = _LONG_GAP / ClientEventsSerializer._WORKING_TIME_RESOLUTION
+
+    @staticmethod
+    def _instant_event(timestamp: datetime) -> dict:
+        return {
+            "scope": "click:element",
+            "timestamp": timestamp.isoformat(),
+            "duration": 123,
+        }
+
+    @staticmethod
+    def _compressed_event(timestamp: datetime, duration: timedelta) -> dict:
+        return {
+            "scope": "change:frame",
+            "timestamp": timestamp.isoformat(),
+            "duration": duration // ClientEventsSerializer._WORKING_TIME_RESOLUTION,
+        }
+
+    @staticmethod
+    def _working_time(event: dict) -> int:
+        payload = json.loads(event["payload"])
+        return payload["working_time"]
+
+    @staticmethod
+    def _deserialize(events: List[dict], previous_event: Optional[dict] = None) -> List[dict]:
+        request = RequestFactory().post("/api/events")
+        request.user = get_user_model()(id=100, username="testuser", email="testuser@example.org")
+        request.iam_context = {
+            "organization": Organization(id=101, slug="testorg", name="Test Organization"),
+        }
+
+        s = ClientEventsSerializer(
+            data={
+                "events": events,
+                "previous_event": previous_event,
+                "timestamp": datetime.now(timezone.utc)
+            },
+            context={"request": request},
+        )
+
+        s.is_valid(raise_exception=True)
+
+        return s.validated_data["events"]
+
+    def test_instant(self):
+        events = self._deserialize([
+            self._instant_event(self._START_TIMESTAMP),
+        ])
+        self.assertEqual(self._working_time(events[0]), 0)
+
+    def test_compressed(self):
+        events = self._deserialize([
+            self._compressed_event(self._START_TIMESTAMP, self._LONG_GAP),
+        ])
+        self.assertEqual(self._working_time(events[0]), self._LONG_GAP_INT)
+
+    def test_instants_with_short_gap(self):
+        events = self._deserialize([
+            self._instant_event(self._START_TIMESTAMP),
+            self._instant_event(self._START_TIMESTAMP + self._SHORT_GAP),
+        ])
+        self.assertEqual(self._working_time(events[0]), 0)
+        self.assertEqual(self._working_time(events[1]), self._SHORT_GAP_INT)
+
+    def test_instants_with_long_gap(self):
+        events = self._deserialize([
+            self._instant_event(self._START_TIMESTAMP),
+            self._instant_event(self._START_TIMESTAMP + self._LONG_GAP),
+        ])
+        self.assertEqual(self._working_time(events[0]), 0)
+        self.assertEqual(self._working_time(events[1]), 0)
+
+    def test_compressed_with_short_gap(self):
+        events = self._deserialize([
+            self._compressed_event(self._START_TIMESTAMP, timedelta(seconds=1)),
+            self._compressed_event(
+                self._START_TIMESTAMP + timedelta(seconds=1) + self._SHORT_GAP,
+                timedelta(seconds=5)
+            ),
+        ])
+        self.assertEqual(self._working_time(events[0]), 1000)
+        self.assertEqual(self._working_time(events[1]), self._SHORT_GAP_INT + 5000)
+
+    def test_compressed_with_long_gap(self):
+        events = self._deserialize([
+            self._compressed_event(self._START_TIMESTAMP, timedelta(seconds=1)),
+            self._compressed_event(
+                self._START_TIMESTAMP + timedelta(seconds=1) + self._LONG_GAP,
+                timedelta(seconds=5)
+            ),
+        ])
+        self.assertEqual(self._working_time(events[0]), 1000)
+        self.assertEqual(self._working_time(events[1]), 5000)
+
+    def test_compressed_contained(self):
+        events = self._deserialize([
+            self._compressed_event(self._START_TIMESTAMP, timedelta(seconds=5)),
+            self._compressed_event(
+                self._START_TIMESTAMP + timedelta(seconds=3),
+                timedelta(seconds=1)
+            ),
+        ])
+        self.assertEqual(self._working_time(events[0]), 5000)
+        self.assertEqual(self._working_time(events[1]), 0)
+
+    def test_compressed_overlapping(self):
+        events = self._deserialize([
+            self._compressed_event(self._START_TIMESTAMP, timedelta(seconds=5)),
+            self._compressed_event(
+                self._START_TIMESTAMP + timedelta(seconds=3),
+                timedelta(seconds=6)
+            ),
+        ])
+        self.assertEqual(self._working_time(events[0]), 5000)
+        self.assertEqual(self._working_time(events[1]), 4000)
+
+    def test_instant_inside_compressed(self):
+        events = self._deserialize([
+            self._compressed_event(self._START_TIMESTAMP, timedelta(seconds=5)),
+            self._instant_event(self._START_TIMESTAMP + timedelta(seconds=3)),
+            self._instant_event(self._START_TIMESTAMP + timedelta(seconds=6)),
+        ])
+        self.assertEqual(self._working_time(events[0]), 5000)
+        self.assertEqual(self._working_time(events[1]), 0)
+        self.assertEqual(self._working_time(events[2]), 1000)
+
+    def test_previous_instant_short_gap(self):
+        events = self._deserialize(
+            [self._instant_event(self._START_TIMESTAMP + self._SHORT_GAP)],
+            previous_event=self._instant_event(self._START_TIMESTAMP),
+        )
+
+        self.assertEqual(self._working_time(events[0]), self._SHORT_GAP_INT)
+
+    def test_previous_instant_long_gap(self):
+        events = self._deserialize(
+            [self._instant_event(self._START_TIMESTAMP + self._LONG_GAP)],
+            previous_event=self._instant_event(self._START_TIMESTAMP),
+        )
+
+        self.assertEqual(self._working_time(events[0]), 0)
+
+    def test_previous_compressed_short_gap(self):
+        events = self._deserialize(
+            [self._instant_event(self._START_TIMESTAMP + timedelta(seconds=1) + self._SHORT_GAP)],
+            previous_event=self._compressed_event(self._START_TIMESTAMP, timedelta(seconds=1)),
+        )
+
+        self.assertEqual(self._working_time(events[0]), self._SHORT_GAP_INT)
+
+    def test_previous_compressed_long_gap(self):
+        events = self._deserialize(
+            [self._instant_event(self._START_TIMESTAMP + timedelta(seconds=1) + self._LONG_GAP)],
+            previous_event=self._compressed_event(self._START_TIMESTAMP, timedelta(seconds=1)),
+        )
+
+        self.assertEqual(self._working_time(events[0]), 0)
diff --git a/cvat/apps/iam/rules/tasks.rego b/cvat/apps/iam/rules/tasks.rego
index 36180c610c83..79c057db434b 100644
--- a/cvat/apps/iam/rules/tasks.rego
+++ b/cvat/apps/iam/rules/tasks.rego
@@ -32,7 +32,6 @@ import data.organizations
 #         "assignee": { "id": <num> },
 #         "organization": { "id": <num> } or null,
 #         "project": {
-#             "id": <num>,
 #             "owner": { "id": <num> },
 #             "assignee": { "id": <num> },
 #             "organization": { "id": <num> } or null,
diff --git a/cvat/requirements/base.txt b/cvat/requirements/base.txt
index c8bf63e672a6..3b10c67bc585 100644
--- a/cvat/requirements/base.txt
+++ b/cvat/requirements/base.txt
@@ -50,7 +50,7 @@ coreschema==0.0.4
     # via coreapi
 crontab==1.0.1
     # via rq-scheduler
-cryptography==42.0.2
+cryptography==42.0.4
     # via
     #   azure-storage-blob
     #   pyjwt
diff --git a/cvat/schema.yml b/cvat/schema.yml
index 9a40fb547a00..739321276d9f 100644
--- a/cvat/schema.yml
+++ b/cvat/schema.yml
@@ -1,7 +1,7 @@
 openapi: 3.0.3
 info:
   title: CVAT REST API
-  version: 2.11.0
+  version: 2.11.1
   description: REST API for Computer Vision Annotation Tool (CVAT)
   termsOfService: https://www.google.com/policies/terms/
   contact:
@@ -6487,6 +6487,11 @@ components:
           items:
             $ref: '#/components/schemas/EventRequest'
           default: []
+        previous_event:
+          allOf:
+          - $ref: '#/components/schemas/EventRequest'
+          writeOnly: true
+          nullable: true
         timestamp:
           type: string
           format: date-time
diff --git a/docker-compose.yml b/docker-compose.yml
index 3426542ac331..b30680566b09 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -70,7 +70,7 @@ services:
 
   cvat_server:
     container_name: cvat_server
-    image: cvat/server:${CVAT_VERSION:-v2.11.0}
+    image: cvat/server:${CVAT_VERSION:-v2.11.1}
     restart: always
     depends_on:
       <<: *backend-deps
@@ -105,7 +105,7 @@ services:
 
   cvat_utils:
     container_name: cvat_utils
-    image: cvat/server:${CVAT_VERSION:-v2.11.0}
+    image: cvat/server:${CVAT_VERSION:-v2.11.1}
     restart: always
     depends_on: *backend-deps
     environment:
@@ -122,7 +122,7 @@ services:
 
   cvat_worker_import:
     container_name: cvat_worker_import
-    image: cvat/server:${CVAT_VERSION:-v2.11.0}
+    image: cvat/server:${CVAT_VERSION:-v2.11.1}
     restart: always
     depends_on: *backend-deps
     environment:
@@ -138,7 +138,7 @@ services:
 
   cvat_worker_export:
     container_name: cvat_worker_export
-    image: cvat/server:${CVAT_VERSION:-v2.11.0}
+    image: cvat/server:${CVAT_VERSION:-v2.11.1}
     restart: always
     depends_on: *backend-deps
     environment:
@@ -154,7 +154,7 @@ services:
 
   cvat_worker_annotation:
     container_name: cvat_worker_annotation
-    image: cvat/server:${CVAT_VERSION:-v2.11.0}
+    image: cvat/server:${CVAT_VERSION:-v2.11.1}
     restart: always
     depends_on: *backend-deps
     environment:
@@ -170,7 +170,7 @@ services:
 
   cvat_worker_webhooks:
     container_name: cvat_worker_webhooks
-    image: cvat/server:${CVAT_VERSION:-v2.11.0}
+    image: cvat/server:${CVAT_VERSION:-v2.11.1}
     restart: always
     depends_on: *backend-deps
     environment:
@@ -186,7 +186,7 @@ services:
 
   cvat_worker_quality_reports:
     container_name: cvat_worker_quality_reports
-    image: cvat/server:${CVAT_VERSION:-v2.11.0}
+    image: cvat/server:${CVAT_VERSION:-v2.11.1}
     restart: always
     depends_on: *backend-deps
     environment:
@@ -202,7 +202,7 @@ services:
 
   cvat_worker_analytics_reports:
     container_name: cvat_worker_analytics_reports
-    image: cvat/server:${CVAT_VERSION:-v2.11.0}
+    image: cvat/server:${CVAT_VERSION:-v2.11.1}
     restart: always
     depends_on: *backend-deps
     environment:
@@ -218,7 +218,7 @@ services:
 
   cvat_ui:
     container_name: cvat_ui
-    image: cvat/ui:${CVAT_VERSION:-v2.11.0}
+    image: cvat/ui:${CVAT_VERSION:-v2.11.1}
     restart: always
     depends_on:
       - cvat_server
diff --git a/helm-chart/values.yaml b/helm-chart/values.yaml
index 9f949ad81084..83875c4a324a 100644
--- a/helm-chart/values.yaml
+++ b/helm-chart/values.yaml
@@ -113,7 +113,7 @@ cvat:
       additionalVolumeMounts: []
     replicas: 1
     image: cvat/server
-    tag: v2.11.0
+    tag: v2.11.1
     imagePullPolicy: Always
     permissionFix:
       enabled: true
@@ -137,7 +137,7 @@ cvat:
   frontend:
     replicas: 1
     image: cvat/ui
-    tag: v2.11.0
+    tag: v2.11.1
     imagePullPolicy: Always
     labels: {}
     #  test: test
diff --git a/site/content/en/docs/administration/basics/installation.md b/site/content/en/docs/administration/basics/installation.md
index 7a258e76aed9..bac706535001 100644
--- a/site/content/en/docs/administration/basics/installation.md
+++ b/site/content/en/docs/administration/basics/installation.md
@@ -611,7 +611,6 @@ If you stay in China, for installation you need to override the following source
           "http://f1361db2.m.daocloud.io",
           "https://docker.mirrors.ustc.edu.cn",
           "https://hub-mirror.c.163.com",
-          "https://https://mirror.ccs.tencentyun.com",
           "https://mirror.ccs.tencentyun.com",
       ]
   }
diff --git a/site/content/en/docs/contributing/development-environment.md b/site/content/en/docs/contributing/development-environment.md
index 917e1566eca0..97dc62288b6d 100644
--- a/site/content/en/docs/contributing/development-environment.md
+++ b/site/content/en/docs/contributing/development-environment.md
@@ -42,8 +42,8 @@ description: 'Installing a development environment for different operating syste
   ```
 
   ```bash
-  # CVAT supports only Python 3.9, so install it if you don’t have it:
-  pikaur -S python39
+  # CVAT supports only Python 3.10, so install it if you don’t have it:
+  pikaur -S python310
   ```
 
   ```bash
@@ -66,7 +66,7 @@ description: 'Installing a development environment for different operating syste
   - [Trailing Spaces](https://marketplace.visualstudio.com/items?itemName=shardulm94.trailing-spaces)
   - [Code Spell Checker](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker)
 
-- Make sure to use Python 3.9.0 or higher
+- Make sure to use Python 3.10.0 or higher
 
   ```
   python3 --version
diff --git a/site/content/en/docs/enterprise/shapes-converter.md b/site/content/en/docs/enterprise/shapes-converter.md
index 8e0a62a854f2..69763a76f032 100644
--- a/site/content/en/docs/enterprise/shapes-converter.md
+++ b/site/content/en/docs/enterprise/shapes-converter.md
@@ -14,6 +14,7 @@ See:
 
 - [Run actions menu](#run-actions-menu)
 - [Convert shapes](#convert-shapes)
+- [Convert shapes video tutorial](#convert-shapes-video-tutorial)
 
 ## Run actions menu
 
@@ -33,31 +34,29 @@ With the following fields:
 
 <!--lint disable maximum-line-length-->
 
-| Field                                    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Field                                    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | **Select action**                        | Drop-down list with available actions: <br><li>**Remove filtered shapes** - removes all shapes in alignment with the set-up filter. Doesn't work with tracks.</li><li>**Shapes converter: masks to polygons** - converts all masks to polygons.</li><li>**Shapes converter: masks to rectangles** - converts all masks to rectangles in alignment with the set-up filter.</li><li>**Shapes converter: polygon to masks** - converts all polygons to masks.</li><li>**Shapes converter: polygon to rectangles** - converts all polygons to rectangles.</li><li>**Shapes converter: rectangles to masks** - converts all rectangles to masks.</li><li>**Shapes converter: rectangles to polygons** - converts all rectangles to polygons.</li><br>**Note:** only **Remove filtered shapes** is available on the **Free** plan. |
-| **Specify frames to run action**         | Field where you can specify the frame range for the selected action. Enter the starting frame in the **Starting from frame:** field, and the ending frame in the **up to frame** field. <br><br>If nothing is selected here or in **Choose one of the predefined options** section, the action will be applied to all fields.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| **Choose one of the predefined options** | Predefined options to apply to frames. Selection here is mutually exclusive with **Specify frames to run action**. <br><br>If nothing is selected here or in **Specify frames to run action** section, the action will be applied to all fields.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| **Specify frames to run action**         | Field where you can specify the frame range for the selected action. Enter the starting frame in the **Starting from frame:** field, and the ending frame in the **up to frame** field. <br><br>If nothing is selected here or in **Choose one of the predefined options** section, the action will be applied to all fields.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| **Choose one of the predefined options** | Predefined options to apply to frames. Selection here is mutually exclusive with **Specify frames to run action**. <br><br>If nothing is selected here or in **Specify frames to run action** section, the action will be applied to all fields.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 
 <!--lint enable maximum-line-length-->
 
-
-
 ## Convert shapes
 
 **Recommended Precautions Before Running Annotation Actions**
 
 - **Saving changes:** It is recommended to save all changes prior to initiating the annotation action.
- If unsaved changes are detected, a prompt will advise to save these changes
- to avoid any potential loss of data.
+  If unsaved changes are detected, a prompt will advise to save these changes
+  to avoid any potential loss of data.
 
 - **Disabу auto-save:** Prior to running the annotation action, disabling the auto-save feature
-is advisable. A notification will suggest this action if auto-save is currently active.
+  is advisable. A notification will suggest this action if auto-save is currently active.
 
 - **Committing changes:** Changes applied during the annotation session
-will not be committed to the server until the saving process is manually
-initiated. This can be done either by the user or through the
-auto-save feature, should it be enabled.
+  will not be committed to the server until the saving process is manually
+  initiated. This can be done either by the user or through the
+  auto-save feature, should it be enabled.
 
 To convert shapes, do the following:
 
@@ -79,3 +78,11 @@ To convert shapes, do the following:
    ![](/images/shapes-coverter-action-run.jpg)
 
 > **Note:** Once the action is applied, it cannot be undone.
+
+## Convert shapes video tutorial
+
+<!--lint disable maximum-line-length-->
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/sAVEdjmw0C0?si=ZhRuwdAMSNrdieBp" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
+
+<!--lint enable maximum-line-length-->
diff --git a/site/content/en/docs/manual/advanced/annotation-with-ellipses.md b/site/content/en/docs/manual/advanced/annotation-with-ellipses.md
index ff4765b1d753..528fb2227542 100644
--- a/site/content/en/docs/manual/advanced/annotation-with-ellipses.md
+++ b/site/content/en/docs/manual/advanced/annotation-with-ellipses.md
@@ -20,3 +20,13 @@ to complete the shape.
 
 You can rotate ellipses using a rotation point in the same way as
  [rectangles](/docs/manual/advanced/annotation-with-rectangles/#rotation-rectangle).
+
+## Annotation with ellipses video tutorial
+
+
+<!--lint disable maximum-line-length-->
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/jmwtePYCz94?si=wbfYEX4pzGziXf1Y" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
+
+<!--lint enable maximum-line-length-->
+
diff --git a/site/content/en/docs/manual/advanced/shape-grouping.md b/site/content/en/docs/manual/advanced/shape-grouping.md
index 84d659c35758..9a5c3ac2821d 100644
--- a/site/content/en/docs/manual/advanced/shape-grouping.md
+++ b/site/content/en/docs/manual/advanced/shape-grouping.md
@@ -25,3 +25,11 @@ Shapes that don't have `group_id`, will be highlighted in white.
 ![](/images/image078_detrac.jpg)
 
 ![](/images/image077_detrac.jpg)
+
+## Shapes grouping video tutorial
+
+<!--lint disable maximum-line-length-->
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/m8bB9f23wLs?si=N5EzIRG-1Wn6R15G" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
+
+<!--lint enable maximum-line-length-->
diff --git a/tests/cypress/e2e/actions_objects/test_annotations_saving.js b/tests/cypress/e2e/actions_objects/test_annotations_saving.js
index cb677cb28043..e39a0ae5a6c5 100644
--- a/tests/cypress/e2e/actions_objects/test_annotations_saving.js
+++ b/tests/cypress/e2e/actions_objects/test_annotations_saving.js
@@ -33,13 +33,7 @@ context('Test annotations saving works correctly', () => {
         cy.get(`#cvat-objects-sidebar-state-item-${clientID}`).trigger('mouseover');
         cy.get(`#cvat-objects-sidebar-state-item-${clientID}`).should('have.class', 'cvat-objects-sidebar-state-active-item');
         cy.get('body').type(shortcut);
-
-        cy.document().then((doc) => {
-            const tooltips = Array.from(doc.querySelectorAll('.ant-tooltip'));
-            if (tooltips.length > 0) {
-                cy.get('.ant-tooltip').invoke('hide');
-            }
-        });
+        cy.hideTooltips();
     }
 
     before(() => {
diff --git a/tests/cypress/e2e/features/single_object_annotation.js b/tests/cypress/e2e/features/single_object_annotation.js
new file mode 100644
index 000000000000..61efc6f7045f
--- /dev/null
+++ b/tests/cypress/e2e/features/single_object_annotation.js
@@ -0,0 +1,234 @@
+// Copyright (C) 2024 CVAT.ai Corporation
+//
+// SPDX-License-Identifier: MIT
+
+/// <reference types="cypress" />
+
+context('Single object annotation mode', { scrollBehavior: false }, () => {
+    const taskName = 'Single object annotation mode';
+    const serverFiles = ['images/image_1.jpg', 'images/image_2.jpg', 'images/image_3.jpg'];
+    const frameCount = serverFiles.length;
+
+    let taskID = null;
+    let jobID = null;
+
+    const rectangleShape = [
+        { x: 300, y: 100 },
+        { x: 400, y: 400 },
+    ];
+    const polygonShape = [
+        { x: 300, y: 100 },
+        { x: 400, y: 400 },
+        { x: 400, y: 250 },
+        { x: 450, y: 350 },
+    ];
+    const polylineShape = [
+        { x: 300, y: 100 },
+        { x: 400, y: 400 },
+        { x: 400, y: 250 },
+        { x: 450, y: 350 },
+        { x: 500, y: 450 },
+    ];
+    const pointsShape = [
+        { x: 300, y: 100 },
+        { x: 400, y: 400 },
+        { x: 400, y: 250 },
+        { x: 450, y: 350 },
+    ];
+    const ellipseShape = [
+        { x: 300, y: 100 },
+        { x: 400, y: 400 },
+    ];
+    const cuboidShape = [
+        { x: 300, y: 100 },
+        { x: 400, y: 400 },
+    ];
+    const maskActions = [{
+        method: 'brush',
+        coordinates: [[300, 300], [700, 300], [700, 700], [300, 700]],
+    }];
+
+    function clickPoints(shape) {
+        shape.forEach((element) => {
+            cy.get('.cvat-canvas-container').click(element.x, element.y);
+        });
+    }
+
+    function checkFrameNum(frameNum) {
+        cy.get('.cvat-player-frame-selector').within(() => {
+            cy.get('input[role="spinbutton"]').should('have.value', frameNum);
+        });
+    }
+
+    function submitJob() {
+        cy.get('.cvat-single-shape-annotation-submit-job-modal').should('exist');
+        cy.get('.cvat-single-shape-annotation-submit-job-modal').within(() => { cy.contains('Submit').click(); });
+
+        cy.intercept('PATCH', '/api/jobs/**').as('submitJob');
+        cy.wait('@submitJob').its('response.statusCode').should('equal', 200);
+
+        cy.get('.cvat-single-shape-annotation-submit-success-modal').should('exist');
+        cy.get('.cvat-single-shape-annotation-submit-success-modal').within(() => { cy.contains('OK').click(); });
+    }
+
+    function checkSingleShapeModeOpened() {
+        cy.get('.cvat-workspace-selector').should('have.text', 'Single shape');
+        cy.get('.cvat-canvas-controls-sidebar').should('not.exist');
+        cy.get('.cvat-player-frame-selector input').should('be.disabled');
+
+        cy.get('.cvat-single-shape-annotation-sidebar-hint').should('exist');
+        cy.get('.cvat-single-shape-annotation-sidebar-ux-hints').should('exist');
+    }
+
+    function openJob(params) {
+        cy.visit(`/tasks/${taskID}/jobs/${jobID}`, {
+            qs: {
+                defaultWorkspace: 'single_shape',
+                ...params,
+            },
+        });
+        cy.get('.cvat-canvas-container').should('exist').and('be.visible');
+    }
+
+    function drawObject(creatorFunction) {
+        checkSingleShapeModeOpened();
+
+        for (let frame = 0; frame < frameCount; frame++) {
+            checkFrameNum(frame);
+            creatorFunction();
+        }
+        submitJob();
+    }
+
+    before(() => {
+        cy.visit('auth/login');
+        cy.login();
+        cy.headlessCreateTask({
+            labels: [
+                { name: 'rectangle_label', attributes: [], type: 'rectangle' },
+                { name: 'polygon_label', attributes: [], type: 'polygon' },
+                { name: 'polyline_label', attributes: [], type: 'polyline' },
+                { name: 'points_label', attributes: [], type: 'points' },
+                { name: 'ellipse_label', attributes: [], type: 'ellipse' },
+                { name: 'cuboid_label', attributes: [], type: 'cuboid' },
+                { name: 'mask_label', attributes: [], type: 'mask' },
+            ],
+            name: taskName,
+            project_id: null,
+            source_storage: { location: 'local' },
+            target_storage: { location: 'local' },
+        }, {
+            server_files: serverFiles,
+            image_quality: 70,
+            use_zip_chunks: true,
+            use_cache: true,
+            sorting_method: 'lexicographical',
+        }).then((response) => {
+            taskID = response.taskID;
+            [jobID] = response.jobIDs;
+        }).then(() => {
+            cy.visit(`/tasks/${taskID}/jobs/${jobID}`);
+            cy.get('.cvat-canvas-container').should('exist').and('be.visible');
+        });
+    });
+
+    after(() => {
+        cy.logout();
+        cy.getAuthKey().then((response) => {
+            const authKey = response.body.key;
+            cy.request({
+                method: 'DELETE',
+                url: `/api/tasks/${taskID}`,
+                headers: {
+                    Authorization: `Token ${authKey}`,
+                },
+            });
+        });
+    });
+
+    describe('Tests basic features of single shape annotation mode', () => {
+        afterEach(() => {
+            cy.removeAnnotations();
+            cy.saveJob();
+        });
+
+        it('Check basic single shape annotation pipeline for polygon', () => {
+            openJob({ defaultLabel: 'polygon_label', defaultPointsCount: 4 });
+            drawObject(() => clickPoints(polygonShape));
+        });
+
+        it('Check basic single shape annotation pipeline for rectangle', () => {
+            openJob({ defaultLabel: 'rectangle_label' });
+            drawObject(() => clickPoints(rectangleShape));
+        });
+
+        it('Check basic single shape annotation pipeline for polyline', () => {
+            openJob({ defaultLabel: 'polyline_label', defaultPointsCount: 5 });
+            drawObject(() => clickPoints(polylineShape));
+        });
+
+        it('Check basic single shape annotation pipeline for ellipse', () => {
+            openJob({ defaultLabel: 'ellipse_label' });
+            drawObject(() => clickPoints(ellipseShape));
+        });
+
+        it('Check basic single shape annotation pipeline for points', () => {
+            openJob({ defaultLabel: 'points_label', defaultPointsCount: 4 });
+            drawObject(() => clickPoints(pointsShape));
+        });
+
+        it('Check basic single shape annotation pipeline for cuboid', () => {
+            openJob({ defaultLabel: 'cuboid_label' });
+            drawObject(() => clickPoints(cuboidShape));
+        });
+
+        it('Check basic single shape annotation pipeline for mask', () => {
+            openJob({ defaultLabel: 'mask_label' });
+            cy.drawMask(maskActions);
+            cy.finishMaskDrawing();
+        });
+    });
+
+    describe('Tests advanced features of single shape annotation mode', () => {
+        it('Check single shape annotation mode controls', () => {
+            openJob({ defaultLabel: 'polygon_label', defaultPointsCount: 4 });
+            checkSingleShapeModeOpened();
+
+            // Skip
+            cy.get('.cvat-single-shape-annotation-sidebar-skip-wrapper').within(() => {
+                cy.contains('Skip').click();
+            });
+            checkFrameNum(1);
+
+            // Auto next frame - disabled
+            cy.get('.cvat-single-shape-annotation-sidebar-auto-next-frame-checkbox').within(() => {
+                cy.get('[type="checkbox"]').uncheck();
+            });
+            clickPoints(polygonShape);
+            checkFrameNum(1);
+
+            // Auto save when finish - disabled
+            cy.get('.cvat-player-next-button-empty').click();
+            cy.get('.cvat-single-shape-annotation-sidebar-auto-save-checkbox').within(() => {
+                cy.get('[type="checkbox"]').uncheck();
+            });
+            clickPoints(polygonShape);
+            cy.get('.cvat-single-shape-annotation-submit-job-modal').should('not.exist');
+
+            // Navigate only on empty frames
+            cy.get('.cvat-player-previous-button-empty').click();
+            checkFrameNum(0);
+            cy.get('.cvat-player-next-button-empty').click();
+            checkFrameNum(0);
+            cy.get('.cvat-single-shape-annotation-sidebar-navigate-empty-checkbox').within(() => {
+                cy.get('[type="checkbox"]').uncheck();
+            });
+            cy.get('.cvat-player-next-button').click();
+            checkFrameNum(1);
+            cy.get('.cvat-player-next-button').click();
+            checkFrameNum(2);
+
+            cy.saveJob();
+        });
+    });
+});
diff --git a/tests/cypress/e2e/issues_prs/issue_2485_navigation_empty_frames.js b/tests/cypress/e2e/issues_prs/issue_2485_navigation_empty_frames.js
index 56563f5d5d8d..b19bc49474a0 100644
--- a/tests/cypress/e2e/issues_prs/issue_2485_navigation_empty_frames.js
+++ b/tests/cypress/e2e/issues_prs/issue_2485_navigation_empty_frames.js
@@ -1,4 +1,5 @@
 // Copyright (C) 2020-2022 Intel Corporation
+// Copyright (C) 2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -20,74 +21,57 @@ context('Navigation to empty frames', () => {
 
     before(() => {
         cy.openTaskJob(taskName);
-    });
-
-    describe(`Testing issue "${issueId}"`, () => {
-        it('Go to 2nd frame. Create a shape.', () => {
-            cy.goCheckFrameNumber(2);
-            cy.createRectangle(createRectangleShape2Points);
-        });
-
-        it('Go to 4th frame. Create a shape.', () => {
-            cy.goCheckFrameNumber(4);
-            cy.createRectangle(createRectangleShape2Points);
-        });
-
-        it('Set a filter to see the created objects.', () => {
-            cy.addFiltersRule(0);
-            cy.setFilter({
-                groupIndex: 0,
-                ruleIndex: 0,
-                field: 'Shape',
-                operator: '==',
-                value: 'rectangle',
-                submit: true,
-            });
-            cy.get('#cvat_canvas_shape_2').should('exist');
+        cy.goCheckFrameNumber(2);
+        cy.createRectangle(createRectangleShape2Points);
+        cy.goCheckFrameNumber(4);
+        cy.createRectangle(createRectangleShape2Points);
+        cy.addFiltersRule(0);
+        cy.setFilter({
+            groupIndex: 0,
+            ruleIndex: 0,
+            field: 'Shape',
+            operator: '==',
+            value: 'rectangle',
+            submit: true,
         });
+        cy.goCheckFrameNumber(3);
+    });
 
-        it('Go to 3rd frame.', () => {
-            cy.goCheckFrameNumber(3);
-        });
+    beforeEach(() => {
+        cy.wait(500); // wait while tooltips are opened
+        cy.hideTooltips();
+    });
 
-        it('Right click to navigation buttons: Previous, Next. Switch their mode to: Go next/previous with a filter.', () => {
-            cy.goCheckFrameNumber(3);
-            for (const i of ['previous', 'next']) {
-                cy.get(`.cvat-player-${i}-button`).rightclick();
-                cy.get(`.cvat-player-${i}-filtered-inlined-button`).click();
-            }
-        });
+    describe(`Testing issue "${issueId}"`, () => {
+        it('Check navigation is corrent for filtered and empty frames', () => {
+            // set mode to only filtered
+            cy.get('.cvat-player-previous-button').rightclick();
+            cy.get('.cvat-player-previous-filtered-inlined-button').click();
 
-        it("Press go previous with a filter. CVAT get 2nd frame. Press again. Frame wasn't changed.", () => {
+            // Press go previous with a filter. CVAT get 2nd frame. Press again. Frame wasn't changed
             for (let i = 1; i <= 2; i++) {
                 cy.get('.cvat-player-previous-button-filtered').click({ force: true });
                 cy.checkFrameNum(2);
                 cy.get('#cvat_canvas_shape_1').should('exist');
             }
-        });
 
-        it("Press go next with a filter. CVAT get 4th frame. Press again. Frame wasn't changed.", () => {
+            // Press go next with a filter. CVAT get 4th frame. Press again. Frame wasn't changed
             for (let i = 1; i <= 2; i++) {
                 cy.get('.cvat-player-next-button-filtered').click({ force: true });
                 cy.checkFrameNum(4);
                 cy.get('#cvat_canvas_shape_2').should('exist');
             }
-        });
 
-        it('Change navigation buttons mode to "Go next/previous to an empty frame".', () => {
-            for (const i of ['previous', 'next']) {
-                cy.get(`.cvat-player-${i}-button-filtered`).rightclick({ force: true });
-                cy.get(`.cvat-player-${i}-empty-inlined-button`).click({ force: true });
-            }
-        });
+            // set mode to only empty
+            cy.get('.cvat-player-next-button-filtered').rightclick();
+            cy.get('.cvat-player-next-empty-inlined-button').click();
 
-        it('Go previous to an empty frame. CVAT get 3rd frame.', () => {
+            // Go previous to an empty frame. CVAT get 3rd frame
             cy.get('.cvat-player-previous-button-empty').click({ force: true });
             cy.checkFrameNum(3);
             cy.get('.cvat_canvas_shape').should('not.exist');
-        });
 
-        it('Go next to an empty frame. CVAT get 5th frame.', () => {
+            // Go next to an empty frame. CVAT get 5th frame
             cy.get('.cvat-player-next-button-empty').click({ force: true });
             cy.checkFrameNum(5);
             cy.get('.cvat_canvas_shape').should('not.exist');
diff --git a/tests/cypress/support/commands.js b/tests/cypress/support/commands.js
index 0a492fece5af..385a23c7012e 100644
--- a/tests/cypress/support/commands.js
+++ b/tests/cypress/support/commands.js
@@ -1515,6 +1515,15 @@ Cypress.Commands.add('interactAnnotationObjectMenu', (parentSelector, button) =>
     });
 });
 
+Cypress.Commands.add('hideTooltips', () => {
+    cy.document().then((doc) => {
+        const tooltips = Array.from(doc.querySelectorAll('.ant-tooltip'));
+        if (tooltips.length > 0) {
+            cy.get('.ant-tooltip').invoke('hide');
+        }
+    });
+});
+
 Cypress.Commands.overwrite('visit', (orig, url, options) => {
     orig(url, options);
     cy.closeModalUnsupportedPlatform();