diff --git a/changelog.d/20240130_135306_boris_open_guide_automatically.md b/changelog.d/20240130_135306_boris_open_guide_automatically.md
new file mode 100644
index 000000000000..3b34ca7cf6be
--- /dev/null
+++ b/changelog.d/20240130_135306_boris_open_guide_automatically.md
@@ -0,0 +1,6 @@
+### Changed
+
+- Annotation guide is opened automatically if not seen yet when the job is "new annotation"
+  (<https://github.com/opencv/cvat/pull/7410>)
+- Annotation guide will be opened automatically if this is specified in a link `/tasks/<id>/jobs/<id>?openGuide`
+  (<https://github.com/opencv/cvat/pull/7410>)
diff --git a/cvat-ui/src/actions/annotation-actions.ts b/cvat-ui/src/actions/annotation-actions.ts
index 791f90c3d9b5..ac3be64331b7 100644
--- a/cvat-ui/src/actions/annotation-actions.ts
+++ b/cvat-ui/src/actions/annotation-actions.ts
@@ -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
 
@@ -321,7 +321,7 @@ export function fetchAnnotationsAsync(): ThunkAction {
     };
 }
 
-export function changeAnnotationsFilters(filters: any[]): AnyAction {
+export function changeAnnotationsFilters(filters: object[]): AnyAction {
     return {
         type: AnnotationActionTypes.CHANGE_ANNOTATIONS_FILTERS,
         payload: { filters },
@@ -677,8 +677,6 @@ export function changeFrameAsync(
                 payload: {},
             });
 
-            // commit the latest job frame to local storage
-            localStorage.setItem(`Job_${job.id}_frame`, `${toFrame}`);
             const changeFrameLog = await job.logger.log(LogType.changeFrame, {
                 from: frame,
                 to: toFrame,
@@ -867,9 +865,15 @@ export function closeJob(): ThunkAction {
     };
 }
 
-export function getJobAsync(
-    tid: number, jid: number, initialFrame: number | null, initialFilters: object[],
-): ThunkAction {
+export function getJobAsync({
+    taskID, jobID, initialFrame, initialFilters, initialOpenGuide,
+}: {
+    taskID: number;
+    jobID: number;
+    initialFrame: number | null;
+    initialFilters: object[];
+    initialOpenGuide: boolean;
+}): ThunkAction {
     return async (dispatch: ActionCreator<Dispatch>, getState): Promise<void> => {
         try {
             const state = getState();
@@ -885,29 +889,29 @@ export function getJobAsync(
             dispatch({
                 type: AnnotationActionTypes.GET_JOB,
                 payload: {
-                    requestedId: jid,
+                    requestedId: jobID,
                 },
             });
 
-            if (!Number.isInteger(tid) || !Number.isInteger(jid)) {
+            if (!Number.isInteger(taskID) || !Number.isInteger(jobID)) {
                 throw new Error('Requested resource id is not valid');
             }
 
             const loadJobEvent = await logger.log(
                 LogType.loadJob,
                 {
-                    task_id: tid,
-                    job_id: jid,
+                    task_id: taskID,
+                    job_id: jobID,
                 },
                 true,
             );
 
             getCore().config.globalObjectsCounter = 0;
-            const [job] = await cvat.jobs.get({ jobID: jid });
+            const [job] = await cvat.jobs.get({ jobID });
             let gtJob: Job | null = null;
             if (job.type === JobType.ANNOTATION) {
                 try {
-                    [gtJob] = await cvat.jobs.get({ taskID: tid, type: JobType.GROUND_TRUTH });
+                    [gtJob] = await cvat.jobs.get({ taskID, type: JobType.GROUND_TRUTH });
                 } catch (e) {
                     // gtJob is not available for workers
                     // do nothing
@@ -956,6 +960,7 @@ export function getJobAsync(
                 payload: {
                     openTime,
                     job,
+                    initialOpenGuide,
                     groundTruthInstance: gtJob || null,
                     groundTruthJobFramesMeta,
                     issues,
diff --git a/cvat-ui/src/components/annotation-page/annotation-page.tsx b/cvat-ui/src/components/annotation-page/annotation-page.tsx
index 90136383219f..670fd3ce996b 100644
--- a/cvat-ui/src/components/annotation-page/annotation-page.tsx
+++ b/cvat-ui/src/components/annotation-page/annotation-page.tsx
@@ -1,5 +1,5 @@
 // Copyright (C) 2021-2022 Intel Corporation
-// Copyright (C) 2023 CVAT.ai Corporation
+// Copyright (C) 2023-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -9,7 +9,9 @@ import Layout from 'antd/lib/layout';
 import Result from 'antd/lib/result';
 import Spin from 'antd/lib/spin';
 import notification from 'antd/lib/notification';
+import Button from 'antd/lib/button';
 
+import './styles.scss';
 import AttributeAnnotationWorkspace from 'components/annotation-page/attribute-annotation-workspace/attribute-annotation-workspace';
 import ReviewAnnotationsWorkspace from 'components/annotation-page/review-workspace/review-workspace';
 import StandardWorkspaceComponent from 'components/annotation-page/standard-workspace/standard-workspace';
@@ -20,8 +22,7 @@ import StatisticsModalComponent from 'components/annotation-page/top-bar/statist
 import AnnotationTopBarContainer from 'containers/annotation-page/top-bar/top-bar';
 import { Workspace } from 'reducers';
 import { usePrevious } from 'utils/hooks';
-import './styles.scss';
-import Button from 'antd/lib/button';
+import { readLatestFrame } from 'utils/remember-latest-frame';
 
 interface Props {
     job: any | null | undefined;
@@ -69,34 +70,36 @@ export default function AnnotationPageComponent(props: Props): JSX.Element {
 
     useEffect(() => {
         if (prevFetching && !fetching && !prevJob && job) {
-            const latestFrame = localStorage.getItem(`Job_${job.id}_frame`);
-            if (latestFrame && Number.isInteger(+latestFrame)) {
-                const parsedFrame = +latestFrame;
-                if (parsedFrame !== frameNumber && parsedFrame >= job.startFrame && parsedFrame <= job.stopFrame) {
-                    const notificationKey = `cvat-notification-continue-job-${job.id}`;
-                    notification.info({
-                        key: notificationKey,
-                        message: `You finished working on frame ${parsedFrame}`,
-                        description: (
-                            <span>
-                                Press
-                                <Button
-                                    className='cvat-notification-continue-job-button'
-                                    type='link'
-                                    onClick={() => {
-                                        changeFrame(parsedFrame);
-                                        notification.close(notificationKey);
-                                    }}
-                                >
-                                    here
-                                </Button>
-                                if you would like to continue
-                            </span>
-                        ),
-                        placement: 'topRight',
-                        className: 'cvat-notification-continue-job',
-                    });
-                }
+            const latestFrame = readLatestFrame(job.id);
+
+            if (typeof latestFrame === 'number' &&
+                latestFrame !== frameNumber &&
+                latestFrame >= job.startFrame &&
+                latestFrame <= job.stopFrame
+            ) {
+                const notificationKey = `cvat-notification-continue-job-${job.id}`;
+                notification.info({
+                    key: notificationKey,
+                    message: `You finished working on frame ${latestFrame}`,
+                    description: (
+                        <span>
+                            Press
+                            <Button
+                                className='cvat-notification-continue-job-button'
+                                type='link'
+                                onClick={() => {
+                                    changeFrame(latestFrame);
+                                    notification.close(notificationKey);
+                                }}
+                            >
+                                here
+                            </Button>
+                            if you would like to continue
+                        </span>
+                    ),
+                    placement: 'topRight',
+                    className: 'cvat-notification-continue-job',
+                });
             }
 
             if (!job.labels.length) {
diff --git a/cvat-ui/src/components/annotation-page/top-bar/filters-modal.tsx b/cvat-ui/src/components/annotation-page/top-bar/filters-modal.tsx
index 3a3373ffa229..b1f7ec1da6bb 100644
--- a/cvat-ui/src/components/annotation-page/top-bar/filters-modal.tsx
+++ b/cvat-ui/src/components/annotation-page/top-bar/filters-modal.tsx
@@ -1,5 +1,5 @@
 // Copyright (C) 2021-2022 Intel Corporation
-// Copyright (C) 2023 CVAT.ai Corporation
+// Copyright (C) 2023-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -203,7 +203,7 @@ function FiltersModalComponent(): JSX.Element {
         }
     }, [visible]);
 
-    const applyFilters = (filtersData: any[]): void => {
+    const applyFilters = (filtersData: object[]): void => {
         dispatch(changeAnnotationsFilters(filtersData));
         dispatch(fetchAnnotationsAsync());
         dispatch(showFilters(false));
diff --git a/cvat-ui/src/components/annotation-page/top-bar/right-group.tsx b/cvat-ui/src/components/annotation-page/top-bar/right-group.tsx
index 16a21bfbd932..7bc685b6cc33 100644
--- a/cvat-ui/src/components/annotation-page/top-bar/right-group.tsx
+++ b/cvat-ui/src/components/annotation-page/top-bar/right-group.tsx
@@ -1,10 +1,9 @@
 // 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 from 'react';
-import { useSelector } from 'react-redux';
+import React, { useEffect, useCallback } from 'react';
 import { Col } from 'antd/lib/grid';
 import Icon from '@ant-design/icons';
 import Select from 'antd/lib/select';
@@ -15,31 +14,97 @@ import notification from 'antd/lib/notification';
 import {
     FilterIcon, FullscreenIcon, GuideIcon, InfoIcon,
 } from 'icons';
-import { DimensionType } from 'cvat-core-wrapper';
-import { CombinedState, Workspace } from 'reducers';
+import config from 'config';
+import {
+    DimensionType, Job, JobStage, JobState,
+} from 'cvat-core-wrapper';
+import { Workspace } from 'reducers';
 
 import MDEditor from '@uiw/react-md-editor';
 
 interface Props {
-    workspace: Workspace;
     showStatistics(): void;
     showFilters(): void;
     changeWorkspace(workspace: Workspace): void;
-    jobInstance: any;
+    jobInstance: Job;
+    workspace: Workspace;
+    annotationFilters: object[];
+    initialOpenGuide: boolean;
 }
 
 function RightGroup(props: Props): JSX.Element {
     const {
         showStatistics,
         changeWorkspace,
+        showFilters,
         workspace,
         jobInstance,
-        showFilters,
+        annotationFilters,
+        initialOpenGuide,
     } = props;
 
-    const annotationFilters = useSelector((state: CombinedState) => state.annotation.annotations.filters);
     const filters = annotationFilters.length;
 
+    const openGuide = useCallback(() => {
+        const PADDING = Math.min(window.screen.availHeight, window.screen.availWidth) * 0.4;
+        jobInstance.guide().then((guide) => {
+            if (guide?.markdown) {
+                Modal.info({
+                    icon: null,
+                    width: window.screen.availWidth - PADDING,
+                    className: 'cvat-annotation-view-markdown-guide-modal',
+                    content: (
+                        <MDEditor
+                            visibleDragbar={false}
+                            data-color-mode='light'
+                            height={window.screen.availHeight - PADDING}
+                            preview='preview'
+                            hideToolbar
+                            value={guide.markdown}
+                        />
+                    ),
+                });
+            }
+        }).catch((error: unknown) => {
+            notification.error({
+                message: 'Could not receive annotation guide',
+                description: error instanceof Error ? error.message : console.error('error'),
+            });
+        });
+    }, [jobInstance]);
+
+    useEffect(() => {
+        if (Number.isInteger(jobInstance?.guideId)) {
+            if (initialOpenGuide) {
+                openGuide();
+            } else if (
+                jobInstance?.stage === JobStage.ANNOTATION &&
+                jobInstance?.state === JobState.NEW
+            ) {
+                let seenGuides = [];
+                try {
+                    seenGuides = JSON.parse(localStorage.getItem('seenGuides') || '[]');
+                    if (!Array.isArray(seenGuides) || seenGuides.some((el) => !Number.isInteger(el))) {
+                        throw new Error('Wrong structure stored in local storage');
+                    }
+                } catch (error: unknown) {
+                    seenGuides = [];
+                }
+
+                if (!seenGuides.includes(jobInstance.guideId)) {
+                    // open guide if the user have not seen it yet
+                    openGuide();
+                    const updatedSeenGuides = Array
+                        .from(new Set([
+                            jobInstance.guideId,
+                            ...seenGuides.slice(0, config.LOCAL_STORAGE_SEEN_GUIDES_MEMORY_LIMIT - 1),
+                        ]));
+                    localStorage.setItem('seenGuides', JSON.stringify(updatedSeenGuides));
+                }
+            }
+        }
+    }, []);
+
     return (
         <Col className='cvat-annotation-header-right-group'>
             <Button
@@ -62,32 +127,7 @@ function RightGroup(props: Props): JSX.Element {
                 <Button
                     type='link'
                     className='cvat-annotation-header-guide-button cvat-annotation-header-button'
-                    onClick={async (): Promise<void> => {
-                        const PADDING = Math.min(window.screen.availHeight, window.screen.availWidth) * 0.4;
-                        try {
-                            const guide = await jobInstance.guide();
-                            Modal.info({
-                                icon: null,
-                                width: window.screen.availWidth - PADDING,
-                                className: 'cvat-annotation-view-markdown-guide-modal',
-                                content: (
-                                    <MDEditor
-                                        visibleDragbar={false}
-                                        data-color-mode='light'
-                                        height={window.screen.availHeight - PADDING}
-                                        preview='preview'
-                                        hideToolbar
-                                        value={guide.markdown}
-                                    />
-                                ),
-                            });
-                        } catch (error: any) {
-                            notification.error({
-                                message: 'Could not receive annotation guide',
-                                description: error.toString(),
-                            });
-                        }
-                    }}
+                    onClick={openGuide}
                 >
                     <Icon component={GuideIcon} />
                     Guide
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 d4a647644ce3..97952cbbfc8a 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
@@ -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
 
@@ -44,6 +44,8 @@ interface Props {
     activeControl: ActiveControl;
     toolsBlockerState: ToolsBlockerState;
     deleteFrameAvailable: boolean;
+    annotationFilters: object[];
+    initialOpenGuide: boolean;
     changeWorkspace(workspace: Workspace): void;
     showStatistics(): void;
     showFilters(): void;
@@ -100,6 +102,8 @@ export default function AnnotationTopBarComponent(props: Props): JSX.Element {
         focusFrameInputShortcut,
         activeControl,
         toolsBlockerState,
+        annotationFilters,
+        initialOpenGuide,
         showStatistics,
         showFilters,
         changeWorkspace,
@@ -143,7 +147,6 @@ export default function AnnotationTopBarComponent(props: Props): JSX.Element {
             key='player_buttons'
             playing={playing}
             playPauseShortcut={playPauseShortcut}
-            deleteFrameShortcut={deleteFrameShortcut}
             nextFrameShortcut={nextFrameShortcut}
             previousFrameShortcut={previousFrameShortcut}
             forwardShortcut={forwardShortcut}
@@ -212,6 +215,8 @@ export default function AnnotationTopBarComponent(props: Props): JSX.Element {
             <RightGroup
                 workspace={workspace}
                 jobInstance={jobInstance}
+                annotationFilters={annotationFilters}
+                initialOpenGuide={initialOpenGuide}
                 changeWorkspace={changeWorkspace}
                 showStatistics={showStatistics}
                 showFilters={showFilters}
diff --git a/cvat-ui/src/config.tsx b/cvat-ui/src/config.tsx
index 0758c4a0f96e..146f0d139c32 100644
--- a/cvat-ui/src/config.tsx
+++ b/cvat-ui/src/config.tsx
@@ -129,6 +129,9 @@ const BUCKET_CONTENT_KEY = 'All files';
 const NUMERIC_VALUE_CLAMP_THRESHOLD = 5000;
 const OPENCV_PATH = '/assets/opencv_4.8.0.js';
 
+const LOCAL_STORAGE_SEEN_GUIDES_MEMORY_LIMIT = 10;
+const LOCAL_STORAGE_LAST_FRAME_MEMORY_LIMIT = 20;
+
 export default {
     UNDEFINED_ATTRIBUTE_VALUE,
     NO_BREAK_SPACE,
@@ -166,4 +169,6 @@ export default {
     BUCKET_CONTENT_KEY,
     NUMERIC_VALUE_CLAMP_THRESHOLD,
     OPENCV_PATH,
+    LOCAL_STORAGE_SEEN_GUIDES_MEMORY_LIMIT,
+    LOCAL_STORAGE_LAST_FRAME_MEMORY_LIMIT,
 };
diff --git a/cvat-ui/src/containers/annotation-page/annotation-page.tsx b/cvat-ui/src/containers/annotation-page/annotation-page.tsx
index 2629afc70799..6adf53b63169 100644
--- a/cvat-ui/src/containers/annotation-page/annotation-page.tsx
+++ b/cvat-ui/src/containers/annotation-page/annotation-page.tsx
@@ -1,4 +1,5 @@
 // Copyright (C) 2020-2022 Intel Corporation
+// Copyright (C) 2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -62,14 +63,9 @@ function mapDispatchToProps(dispatch: any, own: OwnProps): DispatchToProps {
     const jobID = +params.jid;
     const searchParams = new URLSearchParams(window.location.search);
     const initialFilters: object[] = [];
-    let initialFrame: number | null = null;
-
-    if (searchParams.has('frame')) {
-        const searchFrame = +(searchParams.get('frame') as string);
-        if (!Number.isNaN(searchFrame)) {
-            initialFrame = searchFrame;
-        }
-    }
+    const initialOpenGuide = searchParams.has('openGuide');
+    const parsedFrame = +(searchParams.get('frame') || 'NaN');
+    const initialFrame = Number.isInteger(parsedFrame) && parsedFrame >= 0 ? parsedFrame : null;
 
     if (searchParams.has('serverID') && searchParams.has('type')) {
         const serverID = searchParams.get('serverID');
@@ -81,13 +77,19 @@ function mapDispatchToProps(dispatch: any, own: OwnProps): DispatchToProps {
         }
     }
 
-    if (searchParams.has('frame') || searchParams.has('object')) {
+    if (searchParams.size) {
         own.history.replace(own.history.location.pathname);
     }
 
     return {
         getJob(): void {
-            dispatch(getJobAsync(taskID, jobID, initialFrame, initialFilters));
+            dispatch(getJobAsync({
+                taskID,
+                jobID,
+                initialFrame,
+                initialFilters,
+                initialOpenGuide,
+            }));
         },
         saveLogs(): void {
             dispatch(saveLogsAsync());
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 1542cf73206a..9944b90f3ff3 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
@@ -1,5 +1,5 @@
 // Copyright (C) 2021-2022 Intel Corporation
-// Copyright (C) 2023 CVAT.ai Corporation
+// Copyright (C) 2023-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -30,7 +30,7 @@ import {
 import AnnotationTopBarComponent from 'components/annotation-page/top-bar/top-bar';
 import { Canvas } from 'cvat-canvas-wrapper';
 import { Canvas3d } from 'cvat-canvas3d-wrapper';
-import { DimensionType, JobType } from 'cvat-core-wrapper';
+import { DimensionType, Job, JobType } from 'cvat-core-wrapper';
 import {
     CombinedState,
     FrameSpeed,
@@ -41,9 +41,10 @@ import {
 import isAbleToChangeFrame from 'utils/is-able-to-change-frame';
 import GlobalHotKeys, { KeyMap } from 'utils/mousetrap-react';
 import { switchToolsBlockerState } from 'actions/settings-actions';
+import { writeLatestFrame } from 'utils/remember-latest-frame';
 
 interface StateToProps {
-    jobInstance: any;
+    jobInstance: Job;
     frameIsDeleted: boolean;
     frameNumber: number;
     frameFilename: string;
@@ -67,6 +68,8 @@ interface StateToProps {
     forceExit: boolean;
     ranges: string;
     activeControl: ActiveControl;
+    annotationFilters: object[];
+    initialOpenGuide: boolean;
 }
 
 interface DispatchToProps {
@@ -104,8 +107,9 @@ function mapStateToProps(state: CombinedState): StateToProps {
             annotations: {
                 saving: { uploading: saving, forceExit },
                 history,
+                filters: annotationFilters,
             },
-            job: { instance: jobInstance },
+            job: { instance: jobInstance, initialOpenGuide },
             canvas: { ready: canvasIsReady, instance: canvasInstance, activeControl },
             workspace,
         },
@@ -131,7 +135,7 @@ function mapStateToProps(state: CombinedState): StateToProps {
         saving,
         frameNumber,
         frameFilename,
-        jobInstance,
+        jobInstance: jobInstance as Job,
         undoAction: history.undo.length ? history.undo[history.undo.length - 1][0] : undefined,
         redoAction: history.redo.length ? history.redo[history.redo.length - 1][0] : undefined,
         autoSave,
@@ -141,10 +145,12 @@ function mapStateToProps(state: CombinedState): StateToProps {
         workspace,
         keyMap,
         normalizedKeyMap,
-        canvasInstance,
+        canvasInstance: canvasInstance as NonNullable<typeof canvasInstance>,
         forceExit,
         activeControl,
         ranges,
+        annotationFilters,
+        initialOpenGuide,
     };
 }
 
@@ -228,8 +234,9 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
         this.unblock = history.block((location: any) => {
-            const { forceExit } = self.props;
+            const { forceExit, frameNumber } = self.props;
             const { id: jobID, taskId: taskID } = jobInstance;
+            writeLatestFrame(jobInstance.id, frameNumber);
 
             if (
                 jobInstance.annotations.hasUnsavedChanges() &&
@@ -538,6 +545,9 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
 
     private beforeUnloadCallback = (event: BeforeUnloadEvent): string | undefined => {
         const { jobInstance, forceExit, setForceExitAnnotationFlag } = this.props;
+        const { frameNumber } = this.props;
+
+        writeLatestFrame(jobInstance.id, frameNumber);
         if (jobInstance.annotations.hasUnsavedChanges() && !forceExit) {
             const confirmationMessage = 'You have unsaved changes, please confirm leaving this page.';
             // eslint-disable-next-line no-param-reassign
@@ -652,9 +662,11 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
             ranges,
             normalizedKeyMap,
             activeControl,
+            annotationFilters,
+            initialOpenGuide,
+            toolsBlockerState,
             searchAnnotations,
             switchNavigationBlocked,
-            toolsBlockerState,
         } = this.props;
 
         const preventDefault = (event: KeyboardEvent | undefined): void => {
@@ -793,6 +805,8 @@ class AnnotationTopBarContainer extends React.PureComponent<Props, State> {
                     nextButtonType={nextButtonType}
                     prevButtonType={prevButtonType}
                     focusFrameInputShortcut={normalizedKeyMap.FOCUS_INPUT_FRAME}
+                    annotationFilters={annotationFilters}
+                    initialOpenGuide={initialOpenGuide}
                     onUndoClick={this.undo}
                     onRedoClick={this.redo}
                     onFinishDraw={this.onFinishDraw}
diff --git a/cvat-ui/src/reducers/annotation-reducer.ts b/cvat-ui/src/reducers/annotation-reducer.ts
index 894103ab3be1..7579d50b8a9b 100644
--- a/cvat-ui/src/reducers/annotation-reducer.ts
+++ b/cvat-ui/src/reducers/annotation-reducer.ts
@@ -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
 
@@ -54,9 +54,10 @@ const defaultState: AnnotationState = {
     job: {
         openTime: null,
         labels: [],
-        groundTruthJobFramesMeta: null,
         requestedId: null,
+        groundTruthJobFramesMeta: null,
         groundTruthInstance: null,
+        initialOpenGuide: false,
         instance: null,
         attributes: {},
         fetching: false,
@@ -153,6 +154,7 @@ export default (state = defaultState, action: AnyAction): AnnotationState => {
                 frameData: data,
                 minZ,
                 maxZ,
+                initialOpenGuide,
                 groundTruthInstance,
                 groundTruthJobFramesMeta,
             } = action.payload;
@@ -186,6 +188,7 @@ export default (state = defaultState, action: AnyAction): AnnotationState => {
                             acc[label.id] = label.attributes;
                             return acc;
                         }, {}),
+                    initialOpenGuide,
                     groundTruthInstance,
                     groundTruthJobFramesMeta,
                 },
diff --git a/cvat-ui/src/reducers/index.ts b/cvat-ui/src/reducers/index.ts
index 4c52ae1635eb..a381c90e6f77 100644
--- a/cvat-ui/src/reducers/index.ts
+++ b/cvat-ui/src/reducers/index.ts
@@ -693,8 +693,9 @@ export interface AnnotationState {
         openTime: null | number;
         labels: Label[];
         requestedId: number | null;
-        groundTruthJobFramesMeta: FramesMetaData | null;
         instance: Job | null | undefined;
+        initialOpenGuide: boolean;
+        groundTruthJobFramesMeta: FramesMetaData | null;
         groundTruthInstance: Job | null;
         attributes: Record<number, any[]>;
         fetching: boolean;
@@ -734,7 +735,7 @@ export interface AnnotationState {
         collapsed: Record<number, boolean>;
         collapsedAll: boolean;
         states: any[];
-        filters: any[];
+        filters: object[];
         resetGroupFlag: boolean;
         history: {
             undo: [string, number][];
diff --git a/cvat-ui/src/utils/remember-latest-frame.ts b/cvat-ui/src/utils/remember-latest-frame.ts
new file mode 100644
index 000000000000..65771c1e04f2
--- /dev/null
+++ b/cvat-ui/src/utils/remember-latest-frame.ts
@@ -0,0 +1,44 @@
+// Copyright (C) 2024 CVAT.ai Corporation
+//
+// SPDX-License-Identifier: MIT
+
+import config from 'config';
+
+export function readLatestFrameStorage(): Map<number, number> {
+    let latestFrameStorage: [number, number][] = [];
+    try {
+        latestFrameStorage = JSON.parse(localStorage.getItem('latestFrameStorage') || '[]');
+        if (
+            !Array.isArray(latestFrameStorage) || latestFrameStorage.some((item) => (
+                !Array.isArray(item) ||
+                !Number.isInteger(item[0]) ||
+                !Number.isInteger(item[1])
+            ))
+        ) {
+            throw new Error('Incorrect format from local storage');
+        }
+    } catch (error: unknown) {
+        return new Map([]);
+    }
+
+    return new Map(latestFrameStorage);
+}
+
+export function writeLatestFrame(jobID: number, frame: number): void {
+    let storage = readLatestFrameStorage();
+    if (storage.has(jobID)) {
+        storage.set(jobID, frame);
+    } else {
+        storage = new Map([
+            [jobID, frame],
+            ...Array.from(storage.entries())
+                .slice(0, config.LOCAL_STORAGE_LAST_FRAME_MEMORY_LIMIT - 1),
+        ]);
+    }
+    localStorage.setItem('latestFrameStorage', JSON.stringify(Array.from(storage.entries())));
+}
+
+export function readLatestFrame(jobID: number): number | null {
+    const latestFrameStorage = readLatestFrameStorage();
+    return latestFrameStorage.get(jobID) || null;
+}
diff --git a/tests/cypress/e2e/actions_projects_models/markdown_base_pipeline.js b/tests/cypress/e2e/actions_projects_models/markdown_base_pipeline.js
index 9a669e3547c9..a1e186378b35 100644
--- a/tests/cypress/e2e/actions_projects_models/markdown_base_pipeline.js
+++ b/tests/cypress/e2e/actions_projects_models/markdown_base_pipeline.js
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 CVAT.ai Corporation
+// Copyright (C) 2023-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -166,30 +166,46 @@ context('Basic markdown pipeline', () => {
 
     describe('Staff can see markdown', () => {
         function checkGuideAndAssetAvailableOnAnnotationView() {
+            // when open job for the first time, guide is opened automatically
             cy.visit(`/tasks/${taskID}/jobs/${jobID}`);
             cy.intercept('GET', `/api/assets/${assetID}**`).as('assetGet');
-            cy.get('.cvat-annotation-header-guide-button').should('exist').and('be.visible').click();
+            cy.get('.cvat-annotation-view-markdown-guide-modal button').contains('OK').click();
             cy.wait('@assetGet');
+
+            // when reopen the job, guide is not opened automatically, but can be opened manually
+            cy.reload();
+            cy.get('.cvat-annotation-header-guide-button').should('not.exist');
+            cy.get('.cvat-annotation-header-guide-button').should('exist').and('be.visible').click();
             cy.get('.cvat-annotation-view-markdown-guide-modal').should('exist').and('be.visible');
             cy.get('.cvat-annotation-view-markdown-guide-modal button').contains('OK').click();
+
+            // when there is a request to open in a link, the guide is opened automatically
+            cy.visit(`/tasks/${taskID}/jobs/${jobID}?openGuide`);
+            cy.get('.cvat-annotation-header-guide-button').should('not.exist');
+            cy.get('.cvat-annotation-view-markdown-guide-modal button').contains('OK').click();
         }
 
+        beforeEach(() => {
+            cy.clearLocalStorage('seenGuides');
+        });
+
+        afterEach(() => {
+            cy.logout();
+        });
+
         it('Project owner can see markdown on annotation view', () => {
             cy.login();
             checkGuideAndAssetAvailableOnAnnotationView();
-            cy.logout();
         });
 
         it('Job assignee can see markdown on annotation view', () => {
             cy.login(additionalUsers.jobAssignee.username, additionalUsers.jobAssignee.password);
             checkGuideAndAssetAvailableOnAnnotationView();
-            cy.logout();
         });
 
         it('Task assignee can see markdown on annotation view', () => {
             cy.login(additionalUsers.taskAssignee.username, additionalUsers.taskAssignee.password);
             checkGuideAndAssetAvailableOnAnnotationView();
-            cy.logout();
         });
 
         it('Not assignee can not access the guide and the asset', () => {
@@ -204,7 +220,6 @@ context('Basic markdown pipeline', () => {
                 url: `/api/assets/${assetID}`,
                 failOnStatusCode: false,
             }).its('status').should('equal', 403);
-            cy.logout();
         });
     });
 });