diff --git a/src/WebSocketApp.tsx b/src/WebSocketApp.tsx
index fb638362..dc0f035a 100644
--- a/src/WebSocketApp.tsx
+++ b/src/WebSocketApp.tsx
@@ -86,7 +86,12 @@ export type StompSessionProviderType = (
  */
 export const WebSocketWrapper: React.FC<{
   Provider?: StompSessionProviderType;
-}> = ({ children, Provider = StompSessionProvider }) => {
+  loadDispatchers?: boolean;
+}> = ({
+  children,
+  Provider = StompSessionProvider,
+  loadDispatchers = true,
+}) => {
   const [securityToken, setSecurityToken] = useState<string>("");
 
   useEffect(() => {
@@ -115,7 +120,7 @@ export const WebSocketWrapper: React.FC<{
         console.warn("Unhandled STOMP receipt", receipt)
       }
     >
-      {registerDispatchers()}
+      {loadDispatchers && registerDispatchers()}
       {children}
     </Provider>
   );
diff --git a/src/__tests__/environment/Environment.tsx b/src/__tests__/environment/Environment.tsx
index 9b53af7c..e8c6301f 100644
--- a/src/__tests__/environment/Environment.tsx
+++ b/src/__tests__/environment/Environment.tsx
@@ -7,7 +7,7 @@ import { Provider } from "react-redux";
 import configureMockStore from "redux-mock-store";
 import thunk from "redux-thunk";
 import TermItState from "../../model/TermItState";
-import { mock as stompMock } from "react-stomp-hooks";
+import { mock as stompMock, StompSessionProvider } from "react-stomp-hooks";
 // @ts-ignore
 import TimeAgo from "javascript-time-ago";
 import IntlData from "../../model/IntlData";
@@ -91,3 +91,7 @@ export function withWebSocket(node: ReactElement) {
     </WebSocketWrapper>
   );
 }
+
+export const webSocketProviderWrappingComponentOptions = {
+  wrappingComponent: StompSessionProvider,
+};
diff --git a/src/action/ActionType.ts b/src/action/ActionType.ts
index f270544c..91fdd726 100644
--- a/src/action/ActionType.ts
+++ b/src/action/ActionType.ts
@@ -246,6 +246,7 @@ enum ActionType {
   REMOVE_CRUMB = "REMOVE_CRUMB",
 
   DOES_USERNAME_EXISTS = "DOES_USERNAME_EXISTS",
+  LONG_RUNNING_TASKS_UPDATE = "LONG_RUNNING_TASKS_UPDATE",
 }
 
 export default ActionType;
diff --git a/src/action/AsyncActions.ts b/src/action/AsyncActions.ts
index 0bb05cf5..17623ddc 100644
--- a/src/action/AsyncActions.ts
+++ b/src/action/AsyncActions.ts
@@ -708,17 +708,7 @@ export function executeFileTextAnalysis(fileIri: IRI, vocabularyIri: string) {
       params(reqParams)
     )
       .then(() => {
-        dispatch(asyncActionSuccess(action));
-        return dispatch(
-          publishMessage(
-            new Message(
-              {
-                messageId: "file.text-analysis.finished.message",
-              },
-              MessageType.SUCCESS
-            )
-          )
-        );
+        return dispatch(asyncActionSuccess(action));
       })
       .catch((error: ErrorData) => {
         dispatch(asyncActionFailure(action, error));
diff --git a/src/action/__tests__/AsyncActions.test.ts b/src/action/__tests__/AsyncActions.test.ts
index 64ef3d7b..c62a062c 100644
--- a/src/action/__tests__/AsyncActions.test.ts
+++ b/src/action/__tests__/AsyncActions.test.ts
@@ -608,25 +608,6 @@ describe("Async actions", () => {
         expect((found as MessageAction).message.type).toBe(MessageType.ERROR);
       });
     });
-
-    it("publishes message on success", () => {
-      Ajax.put = jest.fn().mockImplementation(() => Promise.resolve("Success"));
-      return Promise.resolve(
-        (store.dispatch as ThunkDispatch)(
-          executeFileTextAnalysis(
-            VocabularyUtils.create(file.iri),
-            Generator.generateUri()
-          )
-        )
-      ).then(() => {
-        const actions: Action[] = store.getActions();
-        const found = actions.find(
-          (a) => a.type === ActionType.PUBLISH_MESSAGE
-        );
-        expect(found).toBeDefined();
-        expect((found as MessageAction).message.type).toBe(MessageType.SUCCESS);
-      });
-    });
   });
 
   describe("load terms", () => {
diff --git a/src/component/MainView.tsx b/src/component/MainView.tsx
index 15e75358..61bc9f2a 100644
--- a/src/component/MainView.tsx
+++ b/src/component/MainView.tsx
@@ -30,6 +30,7 @@ import Routing from "src/util/Routing";
 import { Configuration, DEFAULT_CONFIGURATION } from "../model/Configuration";
 import Breadcrumbs from "./breadcrumb/Breadcrumbs";
 import { loadTermStates } from "../action/AsyncActions";
+import { LongRunningTasksStatus } from "./main/LongRunningTasksStatus";
 
 const AdministrationRoute = React.lazy(
   () => import("./administration/AdministrationRoute")
@@ -142,8 +143,11 @@ export class MainView extends React.Component<MainViewProps, MainViewState> {
                   <NavbarSearch navbar={true} />
                 </Nav>
 
-                <Nav navbar={true} className="nav-menu-user flex-row-reverse">
-                  <UserDropdown dark={false} />
+                <Nav>
+                  <LongRunningTasksStatus />
+                  <Nav navbar={true} className="nav-menu-user flex-row-reverse">
+                    <UserDropdown dark={false} />
+                  </Nav>
                 </Nav>
               </Navbar>
             )}
diff --git a/src/component/annotator/TextAnalysisInvocationButton.tsx b/src/component/annotator/TextAnalysisInvocationButton.tsx
index c2efa6d2..606deaf9 100644
--- a/src/component/annotator/TextAnalysisInvocationButton.tsx
+++ b/src/component/annotator/TextAnalysisInvocationButton.tsx
@@ -1,21 +1,22 @@
 import * as React from "react";
 import { injectIntl } from "react-intl";
 import withI18n, { HasI18n } from "../hoc/withI18n";
-import withInjectableLoading, {
-  InjectsLoading,
-} from "../hoc/withInjectableLoading";
 import { GoClippy } from "react-icons/go";
 import { Button } from "reactstrap";
 import { connect } from "react-redux";
 import { ThunkDispatch } from "../../util/Types";
 import { executeFileTextAnalysis } from "../../action/AsyncActions";
-import { publishNotification } from "../../action/SyncActions";
-import NotificationType from "../../model/NotificationType";
 import ResourceSelectVocabulary from "../resource/ResourceSelectVocabulary";
 import Vocabulary from "../../model/Vocabulary";
-import { IRI } from "../../util/VocabularyUtils";
+import { IRI, IRIImpl } from "../../util/VocabularyUtils";
+import { IMessage, withSubscription } from "react-stomp-hooks";
+import Constants from "../../util/Constants";
+import { publishMessage, publishNotification } from "../../action/SyncActions";
+import NotificationType from "../../model/NotificationType";
+import Message from "../../model/Message";
+import MessageType from "../../model/MessageType";
 
-interface TextAnalysisInvocationButtonProps extends HasI18n, InjectsLoading {
+interface TextAnalysisInvocationButtonProps extends HasI18n {
   id?: string;
   fileIri: IRI;
   defaultVocabularyIri?: string;
@@ -32,7 +33,7 @@ export class TextAnalysisInvocationButton extends React.Component<
   TextAnalysisInvocationButtonProps,
   TextAnalysisInvocationButtonState
 > {
-  constructor(props: InjectsLoading & TextAnalysisInvocationButtonProps) {
+  constructor(props: TextAnalysisInvocationButtonProps) {
     super(props);
     this.state = { showVocabularySelector: false };
   }
@@ -42,11 +43,7 @@ export class TextAnalysisInvocationButton extends React.Component<
   };
 
   private invokeTextAnalysis(fileIri: IRI, vocabularyIri: string) {
-    this.props.loadingOn();
-    this.props.executeTextAnalysis(fileIri, vocabularyIri).then(() => {
-      this.props.loadingOff();
-      this.props.notifyAnalysisFinish();
-    });
+    this.props.executeTextAnalysis(fileIri, vocabularyIri);
   }
 
   public onVocabularySelect = (vocabulary: Vocabulary | null) => {
@@ -61,6 +58,18 @@ export class TextAnalysisInvocationButton extends React.Component<
     this.setState({ showVocabularySelector: false });
   };
 
+  public onMessage(message: IMessage) {
+    if (!message?.body) {
+      return;
+    }
+    if (
+      message.body.substring(1, message.body.length - 1) ===
+      IRIImpl.toString(this.props.fileIri)
+    ) {
+      this.props.notifyAnalysisFinish();
+    }
+  }
+
   public render() {
     const i18n = this.props.i18n;
     return (
@@ -92,11 +101,31 @@ export default connect(undefined, (dispatch: ThunkDispatch) => {
   return {
     executeTextAnalysis: (fileIri: IRI, vocabularyIri: string) =>
       dispatch(executeFileTextAnalysis(fileIri, vocabularyIri)),
-    notifyAnalysisFinish: () =>
+    notifyAnalysisFinish: () => {
+      dispatch(
+        publishMessage(
+          new Message(
+            {
+              messageId: "file.text-analysis.finished.message",
+            },
+            MessageType.SUCCESS
+          )
+        )
+      );
       dispatch(
         publishNotification({
           source: { type: NotificationType.TEXT_ANALYSIS_FINISHED },
         })
-      ),
+      );
+    },
   };
-})(injectIntl(withI18n(withInjectableLoading(TextAnalysisInvocationButton))));
+})(
+  injectIntl(
+    withI18n(
+      withSubscription(
+        TextAnalysisInvocationButton,
+        Constants.WEBSOCKET_ENDPOINT.VOCABULARIES_TEXT_ANALYSIS_FINISHED_FILE
+      )
+    )
+  )
+);
diff --git a/src/component/annotator/__tests__/Annotator.test.tsx b/src/component/annotator/__tests__/Annotator.test.tsx
index abf0dce2..31af1e03 100644
--- a/src/component/annotator/__tests__/Annotator.test.tsx
+++ b/src/component/annotator/__tests__/Annotator.test.tsx
@@ -1,6 +1,7 @@
 import {
   mockWindowSelection,
   mountWithIntl,
+  withWebSocket,
 } from "../../../__tests__/environment/Environment";
 import { Element } from "domhandler";
 import { AnnotationSpanProps, Annotator } from "../Annotator";
@@ -100,16 +101,18 @@ describe("Annotator", () => {
 
   it("renders body of provided html content", () => {
     const wrapper = mountWithIntl(
-      <MemoryRouter>
-        <Annotator
-          fileIri={fileIri}
-          vocabularyIri={vocabularyIri}
-          {...mockedCallbackProps}
-          {...stateProps}
-          initialHtml={generalHtmlContent}
-          {...intlFunctions()}
-        />
-      </MemoryRouter>
+      withWebSocket(
+        <MemoryRouter>
+          <Annotator
+            fileIri={fileIri}
+            vocabularyIri={vocabularyIri}
+            {...mockedCallbackProps}
+            {...stateProps}
+            initialHtml={generalHtmlContent}
+            {...intlFunctions()}
+          />
+        </MemoryRouter>
+      )
     );
 
     expect(wrapper.html().includes(sampleContent)).toBe(true);
@@ -121,16 +124,18 @@ describe("Annotator", () => {
     );
 
     const wrapper = mountWithIntl(
-      <MemoryRouter>
-        <Annotator
-          fileIri={fileIri}
-          vocabularyIri={vocabularyIri}
-          {...mockedCallbackProps}
-          {...stateProps}
-          initialHtml={htmlContent}
-          {...intlFunctions()}
-        />
-      </MemoryRouter>
+      withWebSocket(
+        <MemoryRouter>
+          <Annotator
+            fileIri={fileIri}
+            vocabularyIri={vocabularyIri}
+            {...mockedCallbackProps}
+            {...stateProps}
+            initialHtml={htmlContent}
+            {...intlFunctions()}
+          />
+        </MemoryRouter>
+      )
     );
     const sampleOutput =
       'This is a <a data-href="https://example.org/link">link</a>';
@@ -142,16 +147,18 @@ describe("Annotator", () => {
       createAnnotation(suggestedOccProps, "města")
     );
     const wrapper = mountWithIntlAttached(
-      <MemoryRouter>
-        <Annotator
-          fileIri={fileIri}
-          vocabularyIri={vocabularyIri}
-          {...mockedCallbackProps}
-          {...stateProps}
-          initialHtml={htmlWithOccurrence}
-          {...intlFunctions()}
-        />
-      </MemoryRouter>
+      withWebSocket(
+        <MemoryRouter>
+          <Annotator
+            fileIri={fileIri}
+            vocabularyIri={vocabularyIri}
+            {...mockedCallbackProps}
+            {...stateProps}
+            initialHtml={htmlWithOccurrence}
+            {...intlFunctions()}
+          />
+        </MemoryRouter>
+      )
     );
 
     const constructedAnnProps = wrapper.find(Annotation).props();
@@ -516,16 +523,18 @@ describe("Annotator", () => {
       });
       HtmlDomUtils.isInPopup = jest.fn().mockReturnValue(false);
       const wrapper = mountWithIntl(
-        <MemoryRouter>
-          <Annotator
-            fileIri={fileIri}
-            vocabularyIri={vocabularyIri}
-            {...mockedCallbackProps}
-            {...stateProps}
-            initialHtml={generalHtmlContent}
-            {...intlFunctions()}
-          />
-        </MemoryRouter>
+        withWebSocket(
+          <MemoryRouter>
+            <Annotator
+              fileIri={fileIri}
+              vocabularyIri={vocabularyIri}
+              {...mockedCallbackProps}
+              {...stateProps}
+              initialHtml={generalHtmlContent}
+              {...intlFunctions()}
+            />
+          </MemoryRouter>
+        )
       );
       wrapper.find("#annotator").simulate("mouseUp");
       wrapper.update();
@@ -537,16 +546,18 @@ describe("Annotator", () => {
         getPropertyValue: () => "16px",
       });
       const wrapper = mountWithIntl(
-        <MemoryRouter>
-          <Annotator
-            fileIri={fileIri}
-            vocabularyIri={vocabularyIri}
-            {...mockedCallbackProps}
-            {...stateProps}
-            initialHtml={generalHtmlContent}
-            {...intlFunctions()}
-          />
-        </MemoryRouter>
+        withWebSocket(
+          <MemoryRouter>
+            <Annotator
+              fileIri={fileIri}
+              vocabularyIri={vocabularyIri}
+              {...mockedCallbackProps}
+              {...stateProps}
+              initialHtml={generalHtmlContent}
+              {...intlFunctions()}
+            />
+          </MemoryRouter>
+        )
       );
       wrapper.find("#annotator").simulate("mouseUp");
       expect(wrapper.find(SelectionPurposeDialog).props().show).toBeTruthy();
diff --git a/src/component/annotator/__tests__/TextAnalysisInvocationButton.test.tsx b/src/component/annotator/__tests__/TextAnalysisInvocationButton.test.tsx
index 6cfa7bc2..2a65bdd4 100644
--- a/src/component/annotator/__tests__/TextAnalysisInvocationButton.test.tsx
+++ b/src/component/annotator/__tests__/TextAnalysisInvocationButton.test.tsx
@@ -7,6 +7,7 @@ import { intlFunctions } from "../../../__tests__/environment/IntlUtil";
 import { InjectsLoading } from "../../hoc/withInjectableLoading";
 import ResourceSelectVocabulary from "../../resource/ResourceSelectVocabulary";
 import Vocabulary from "../../../model/Vocabulary";
+import { webSocketProviderWrappingComponentOptions } from "../../../__tests__/environment/Environment";
 
 describe("TextAnalysisInvocationButton", () => {
   const namespace = "http://onto.fel.cvut.cz/ontologies/termit/resources/";
@@ -59,64 +60,6 @@ describe("TextAnalysisInvocationButton", () => {
     expect(executeTextAnalysis).toHaveBeenCalledWith(fileIri, vocabularyIri);
   });
 
-  it("starts loading when text analysis is invoked", () => {
-    const fileIri = VocabularyUtils.create(Generator.generateUri());
-    const vocabularyIri = Generator.generateUri();
-    vocabulary.iri = vocabularyIri;
-    const wrapper = shallow<TextAnalysisInvocationButton>(
-      <TextAnalysisInvocationButton
-        fileIri={fileIri}
-        executeTextAnalysis={executeTextAnalysis}
-        notifyAnalysisFinish={notifyAnalysisFinish}
-        defaultVocabularyIri={vocabularyIri}
-        {...loadingProps}
-        {...intlFunctions()}
-      />
-    );
-    wrapper.instance().onVocabularySelect(vocabulary);
-    expect(loadingOn).toHaveBeenCalled();
-  });
-
-  it("stops loading after text analysis invocation finishes", () => {
-    const fileIri = VocabularyUtils.create(Generator.generateUri());
-    const vocabularyIri = Generator.generateUri();
-    vocabulary.iri = vocabularyIri;
-    const wrapper = shallow<TextAnalysisInvocationButton>(
-      <TextAnalysisInvocationButton
-        fileIri={fileIri}
-        executeTextAnalysis={executeTextAnalysis}
-        notifyAnalysisFinish={notifyAnalysisFinish}
-        defaultVocabularyIri={vocabularyIri}
-        {...loadingProps}
-        {...intlFunctions()}
-      />
-    );
-    wrapper.instance().onVocabularySelect(vocabulary);
-    return Promise.resolve().then(() => {
-      expect(loadingOff).toHaveBeenCalled();
-    });
-  });
-
-  it("publishes notification after text analysis invocation finishes", () => {
-    const fileIri = VocabularyUtils.create(Generator.generateUri());
-    const vocabularyIri = Generator.generateUri();
-    vocabulary.iri = vocabularyIri;
-    const wrapper = shallow<TextAnalysisInvocationButton>(
-      <TextAnalysisInvocationButton
-        fileIri={fileIri}
-        executeTextAnalysis={executeTextAnalysis}
-        notifyAnalysisFinish={notifyAnalysisFinish}
-        defaultVocabularyIri={vocabularyIri}
-        {...loadingProps}
-        {...intlFunctions()}
-      />
-    );
-    wrapper.instance().onVocabularySelect(vocabulary);
-    return Promise.resolve().then(() => {
-      expect(notifyAnalysisFinish).toHaveBeenCalled();
-    });
-  });
-
   it("shows vocabulary selector when no default vocabulary was specified", () => {
     const fileIri = VocabularyUtils.create(Generator.generateUri());
     const wrapper = shallow<TextAnalysisInvocationButton>(
@@ -126,7 +69,8 @@ describe("TextAnalysisInvocationButton", () => {
         notifyAnalysisFinish={notifyAnalysisFinish}
         {...loadingProps}
         {...intlFunctions()}
-      />
+      />,
+      webSocketProviderWrappingComponentOptions
     );
     wrapper.instance().onClick();
     wrapper.update();
diff --git a/src/component/main/LongRunningTasksStatus.scss b/src/component/main/LongRunningTasksStatus.scss
new file mode 100644
index 00000000..6fdb6abf
--- /dev/null
+++ b/src/component/main/LongRunningTasksStatus.scss
@@ -0,0 +1,31 @@
+.long-running-tasks-dropdown {
+  width: 32px;
+  margin: 0 1rem;
+}
+
+.long-running-tasks-toggle {
+  height: 100%;
+  width: 100%;
+}
+
+.long-running-tasks-menu {
+  width: max-content;
+}
+
+.long-running-tasks-label p {
+  margin: 0;
+}
+
+.long-running-tasks-task {
+  display: flex !important;
+  align-items: center;
+}
+
+.long-running-tasks-task i {
+  width: 24px;
+  color: var(--primary);
+}
+
+.long-running-tasks-task span {
+  margin: 0 0.5rem 0 0;
+}
diff --git a/src/component/main/LongRunningTasksStatus.tsx b/src/component/main/LongRunningTasksStatus.tsx
new file mode 100644
index 00000000..7562e68a
--- /dev/null
+++ b/src/component/main/LongRunningTasksStatus.tsx
@@ -0,0 +1,155 @@
+import * as React from "react";
+import { useEffect, useMemo, useState } from "react";
+import {
+  DropdownItem,
+  DropdownMenu,
+  DropdownToggle,
+  UncontrolledDropdown,
+} from "reactstrap";
+import "./LongRunningTasksStatus.scss";
+import classNames from "classnames";
+import Mask from "../misc/Mask";
+import { useSelector } from "react-redux";
+import TermItState from "../../model/TermItState";
+import { useI18n } from "../hook/useI18n";
+import {
+  LongRunningTask,
+  LongRunningTaskState,
+} from "../../model/LongRunningTask";
+import { isEqual, padStart } from "lodash";
+import If from "../misc/If";
+
+function icon(task: LongRunningTask, i18n: (id?: string) => string) {
+  switch (task.state) {
+    case LongRunningTaskState.DONE:
+      return (
+        <i
+          className="fas fa-check"
+          title={i18n("longrunningtasks.state.done")}
+        />
+      );
+    case LongRunningTaskState.PENDING:
+      return (
+        <i
+          className="far fa-clock"
+          title={i18n("longrunningtasks.state.pending")}
+        />
+      );
+    case LongRunningTaskState.RUNNING:
+      return (
+        <i
+          className="fas fa-bars-progress"
+          title={i18n("longrunningtasks.state.running")}
+        />
+      );
+    default:
+      return <i className="fas fa-question" />;
+  }
+}
+
+export const LongRunningTasksStatus: React.FC = () => {
+  const runningTasks = useSelector(
+    (state: TermItState) => state.runningTasks,
+    isEqual
+  );
+  const { i18n } = useI18n();
+
+  const tasksToUpdate = useMemo<Set<() => void>>(() => new Set(), []);
+
+  useEffect(() => {
+    const timer = setInterval(() => {
+      tasksToUpdate.forEach((task) => task());
+    }, 250);
+    return () => clearInterval(timer);
+  }, [tasksToUpdate]);
+
+  if (Object.keys(runningTasks).length === 0) {
+    return null;
+  }
+
+  return (
+    <UncontrolledDropdown nav={true} className="long-running-tasks-dropdown">
+      <DropdownToggle
+        nav={true}
+        caret={false}
+        className={classNames(
+          "text-dark text-dropdown",
+          "d-flex",
+          "align-items-center",
+          "long-running-tasks-toggle"
+        )}
+      >
+        <Mask classes="align-middle" withoutText={true} />
+      </DropdownToggle>
+      <DropdownMenu
+        className="dropdown-menu-arrow long-running-tasks-menu"
+        right={true}
+      >
+        <DropdownItem
+          text={true}
+          className="dropdown-item-text long-running-tasks-label"
+        >
+          <p>{i18n("longrunningtasks.description")}</p>
+        </DropdownItem>
+
+        {Object.keys(runningTasks).map((uuid, i) => {
+          const task = runningTasks[uuid];
+          return (
+            <DropdownItem
+              key={"long-running-task-" + uuid + i}
+              text={true}
+              className="long-running-tasks-task"
+            >
+              {icon(task, i18n)}
+              <span>{i18n(task.name)}</span>
+              <If
+                expression={
+                  !!task.startedAt &&
+                  task.state === LongRunningTaskState.RUNNING
+                }
+              >
+                <span className="text-muted">
+                  <DurationDisplay
+                    since={task.startedAt!}
+                    tasksToUpdate={tasksToUpdate}
+                  />
+                </span>
+              </If>
+            </DropdownItem>
+          );
+        })}
+      </DropdownMenu>
+    </UncontrolledDropdown>
+  );
+};
+
+const DurationDisplay: React.FC<{
+  since: Date;
+  tasksToUpdate: Set<() => void>;
+}> = ({ since, tasksToUpdate }) => {
+  const tZero = useMemo(() => {
+    if (since.getTime() > Date.now()) {
+      return Date.now();
+    }
+    return since.getTime();
+  }, [since]);
+
+  const [time, setTime] = useState(0);
+  useEffect(() => {
+    const task = () => {
+      setTime(Date.now() - tZero);
+    };
+    tasksToUpdate.add(task);
+
+    return () => {
+      tasksToUpdate.delete(task);
+    };
+  }, [tZero, tasksToUpdate]);
+
+  const date = new Date(time);
+  const hours = date.getUTCHours() > 0 ? date.getUTCHours() + ":" : "";
+  const minutes = padStart(date.getUTCMinutes().toString(), 2, "0");
+  const seconds = padStart(date.getUTCSeconds().toString(), 2, "0");
+
+  return <>{`${hours}${minutes}:${seconds}`}</>;
+};
diff --git a/src/component/term/TermDetail.tsx b/src/component/term/TermDetail.tsx
index 4ed82be6..7fd6cd85 100644
--- a/src/component/term/TermDetail.tsx
+++ b/src/component/term/TermDetail.tsx
@@ -23,7 +23,7 @@ import Utils from "../../util/Utils";
 import AppNotification from "../../model/AppNotification";
 import { publishNotification } from "../../action/SyncActions";
 import NotificationType from "../../model/NotificationType";
-import { IRI } from "../../util/VocabularyUtils";
+import VocabularyUtils, { IRI } from "../../util/VocabularyUtils";
 import * as _ from "lodash";
 import Vocabulary from "../../model/Vocabulary";
 import { FaTrashAlt } from "react-icons/fa";
@@ -39,6 +39,7 @@ import { DefinitionRelatedChanges } from "./DefinitionRelatedTermsEdit";
 import TermOccurrence from "../../model/TermOccurrence";
 import {
   approveOccurrence,
+  loadDefinitionRelatedTermsTargeting,
   loadTerm,
   removeOccurrence,
 } from "../../action/AsyncTermActions";
@@ -56,6 +57,9 @@ import Constants from "../../util/Constants";
 import { vocabularyValidation } from "../../reducer/WebSocketVocabularyDispatchers";
 import { requestVocabularyValidation } from "../../action/WebSocketVocabularyActions";
 
+const USER_VOCABULARIES_VALIDATION_ENDPOINT =
+  "/user" + Constants.WEBSOCKET_ENDPOINT.VOCABULARIES_VALIDATION;
+
 export interface CommonTermDetailProps extends HasI18n {
   configuredLanguage: string;
   versionSeparator: string;
@@ -75,6 +79,7 @@ interface TermDetailProps
     vocabularyIri: IRI,
     stompClient: StompClient
   ) => void;
+  loadDefinitionRelatedTermsTargeting: (termIri: IRI) => void;
   vocabularyValidation: (message: IMessage, vocabularyIri: string) => void;
   approveOccurrence: (occurrence: TermOccurrence) => Promise<any>;
   removeOccurrence: (occurrence: TermOccurrence) => Promise<any>;
@@ -144,9 +149,22 @@ export class TermDetail extends EditableComponent<
     }
   }
 
-  public onMessage(message: IMessage) {
-    this.props.vocabularyValidation(message, this.props.vocabulary.iri);
-  }
+  // used by withSubscription
+  public onMessage = (message: IMessage) => {
+    switch (message?.headers?.destination) {
+      case USER_VOCABULARIES_VALIDATION_ENDPOINT:
+        this.props.vocabularyValidation(message, this.props.vocabulary.iri);
+        break;
+      case Constants.WEBSOCKET_ENDPOINT
+        .VOCABULARIES_TEXT_ANALYSIS_FINISHED_TERM_DEFINITION:
+        if (this.props.term?.iri && this.props.term.iri === message.body) {
+          this.props.loadDefinitionRelatedTermsTargeting(
+            VocabularyUtils.create(this.props.term.iri)
+          );
+        }
+        break;
+    }
+  };
 
   public setLanguage = (language: string) => {
     this.setState({ language });
@@ -205,7 +223,10 @@ export class TermDetail extends EditableComponent<
     const actions = [];
     if (!this.state.edit) {
       actions.push(
-        <IfNotInTerminalState term={this.props.term!}>
+        <IfNotInTerminalState
+          term={this.props.term!}
+          key="term-detail-edit-terminal"
+        >
           <IfVocabularyActionAuthorized
             key="term-detail-edit"
             vocabulary={this.props.vocabulary}
@@ -336,6 +357,8 @@ export default connect(
         vocabularyIri: IRI,
         stompClient: StompClient
       ) => dispatch(requestVocabularyValidation(vocabularyIri, stompClient)),
+      loadDefinitionRelatedTermsTargeting: (termIri: IRI) =>
+        dispatch(loadDefinitionRelatedTermsTargeting(termIri)),
       vocabularyValidation: (message: IMessage, vocabularyIri: string) =>
         dispatch(vocabularyValidation(message, vocabularyIri)),
       loadTerm: (termName: string, vocabularyIri: IRI, timestamp?: string) =>
@@ -355,10 +378,11 @@ export default connect(
     withI18n(
       withRouter(
         withStompClient(
-          withSubscription(
-            TermDetail,
-            "/user" + Constants.WEBSOCKET_ENDPOINT.VOCABULARIES_VALIDATION
-          )
+          withSubscription(TermDetail, [
+            USER_VOCABULARIES_VALIDATION_ENDPOINT,
+            Constants.WEBSOCKET_ENDPOINT
+              .VOCABULARIES_TEXT_ANALYSIS_FINISHED_TERM_DEFINITION,
+          ])
         )
       )
     )
diff --git a/src/i18n/cs.ts b/src/i18n/cs.ts
index 2846e46a..23f36a98 100644
--- a/src/i18n/cs.ts
+++ b/src/i18n/cs.ts
@@ -870,6 +870,19 @@ const cs = {
     "auth.action.unauthorized": "K této akci nemáte dostatečná práva.",
     "auth.view.unauthorized": "K zobrazení nemáte dostatečná práva.",
     "auth.notEditable.message.readOnly": "Tento { type } je pouze pro čtení.",
+
+    "longrunningtasks.description": "V systému právě probíhá:",
+    "longrunningtasks.state.done": "Dokončeno",
+    "longrunningtasks.state.pending": "Bude spuštěno",
+    "longrunningtasks.state.running": "Probíhá",
+    "longrunningtasks.name.termDefinitionAnalysis": "Analýza definice pojmu",
+    "longrunningtasks.name.allTermsVocabularyAnalysis":
+      "Analýza pojmů ze slovníku",
+    "longrunningtasks.name.allVocabulariesAnalysis": "Analýza všech slovníků",
+    "longrunningtasks.name.fileAnalysis": "Analýza souboru",
+    "longrunningtasks.name.vocabularyValidation": "Validace slovníku",
+    "longrunningtasks.name.documentAnnotationGeneration":
+      "Generování anotací dokumentu",
   },
 };
 
diff --git a/src/i18n/en.ts b/src/i18n/en.ts
index 9c886173..47c2b2d1 100644
--- a/src/i18n/en.ts
+++ b/src/i18n/en.ts
@@ -859,6 +859,21 @@ const en = {
     "auth.action.unauthorized": "You have insufficient rights for this action.",
     "auth.view.unauthorized": "You have insufficient rights to view this.",
     "auth.notEditable.message.readOnly": "This { type } is read only.",
+
+    "longrunningtasks.description": "The system is currently running:",
+    "longrunningtasks.state.done": "Completed",
+    "longrunningtasks.state.pending": "Pending",
+    "longrunningtasks.state.running": "Running",
+    "longrunningtasks.name.termDefinitionAnalysis":
+      "Analysis of a term definition",
+    "longrunningtasks.name.allTermsVocabularyAnalysis":
+      "Analysis of terms in a vocabulary",
+    "longrunningtasks.name.allVocabulariesAnalysis":
+      "Analysis of all vocabularies",
+    "longrunningtasks.name.fileAnalysis": "Analysis of a file",
+    "longrunningtasks.name.vocabularyValidation": "Vocabulary validation",
+    "longrunningtasks.name.documentAnnotationGeneration":
+      "Generation of a file annotations",
   },
 };
 
diff --git a/src/model/LongRunningTask.ts b/src/model/LongRunningTask.ts
new file mode 100644
index 00000000..f6425d48
--- /dev/null
+++ b/src/model/LongRunningTask.ts
@@ -0,0 +1,12 @@
+export type LongRunningTask = {
+  uuid: string;
+  name: string;
+  state: LongRunningTaskState;
+  startedAt?: Date;
+};
+
+export enum LongRunningTaskState {
+  PENDING = "PENDING",
+  RUNNING = "RUNNING",
+  DONE = "DONE",
+}
diff --git a/src/model/TermItState.ts b/src/model/TermItState.ts
index 64377d0c..ba9ff8e2 100644
--- a/src/model/TermItState.ts
+++ b/src/model/TermItState.ts
@@ -18,6 +18,7 @@ import TermOccurrence from "./TermOccurrence";
 import { Breadcrumb } from "./Breadcrumb";
 import AnnotatorLegendFilter from "./AnnotatorLegendFilter";
 import ActionType, { PendingAsyncAction } from "../action/ActionType";
+import { LongRunningTask } from "./LongRunningTask";
 
 /**
  * This is the basic shape of the application"s state managed by Redux.
@@ -64,6 +65,7 @@ export default class TermItState {
   public breadcrumbs: Breadcrumb[];
 
   public annotatorLegendFilter: AnnotatorLegendFilter;
+  public runningTasks: { [key: string]: LongRunningTask };
 
   // Administration
   public users: User[];
@@ -104,6 +106,7 @@ export default class TermItState {
     this.users = [];
     this.accessLevels = {};
     this.annotatorLegendFilter = new AnnotatorLegendFilter();
+    this.runningTasks = {};
   }
 
   /**
diff --git a/src/reducer/TermItReducers.ts b/src/reducer/TermItReducers.ts
index 81c25641..baebede5 100644
--- a/src/reducer/TermItReducers.ts
+++ b/src/reducer/TermItReducers.ts
@@ -41,6 +41,7 @@ import VocabularyUtils, { IRIImpl } from "../util/VocabularyUtils";
 import TermOccurrence from "../model/TermOccurrence";
 import { Breadcrumb } from "../model/Breadcrumb";
 import AnnotatorLegendFilter from "../model/AnnotatorLegendFilter";
+import { LongRunningTask } from "../model/LongRunningTask";
 
 function isAsyncSuccess(action: AsyncAction) {
   return action.status === AsyncActionStatus.SUCCESS;
@@ -702,6 +703,19 @@ function accessLevels(
   return state;
 }
 
+function runningTasks(
+  state: { [uuid: string]: LongRunningTask } = {},
+  action: AsyncActionSuccess<{ [uuid: string]: LongRunningTask }>
+) {
+  if (action.type === ActionType.LONG_RUNNING_TASKS_UPDATE) {
+    if (!action.payload) {
+      return {};
+    }
+    return Object.assign({}, action.payload);
+  }
+  return state;
+}
+
 const rootReducer = combineReducers<TermItState>({
   user,
   loading,
@@ -738,6 +752,7 @@ const rootReducer = combineReducers<TermItState>({
   annotatorLegendFilter,
   users,
   accessLevels,
+  runningTasks,
 });
 
 export default rootReducer;
diff --git a/src/reducer/WebSocketDispatchers.ts b/src/reducer/WebSocketDispatchers.ts
index 142f0512..e909b8c9 100644
--- a/src/reducer/WebSocketDispatchers.ts
+++ b/src/reducer/WebSocketDispatchers.ts
@@ -4,6 +4,8 @@ import ActionType from "../action/ActionType";
 import { asyncActionFailure } from "../action/SyncActions";
 import { Action } from "redux";
 import { vocabularyValidation } from "./WebSocketVocabularyDispatchers";
+import { updateLongRunningTasks } from "./WebSocketUtilityDispatchers";
+import Constants from "../util/Constants";
 
 export interface WebSocketDispatcher<A extends Action> {
   action: A;
@@ -32,12 +34,23 @@ function d<A extends Action>(
 
 const DISPATCHERS: { [key in ActionType]?: WebSocketDispatcher<any> } = {
   ...d(
-    "/vocabularies/validation",
+    Constants.WEBSOCKET_ENDPOINT.VOCABULARIES_VALIDATION,
     {
       type: ActionType.FETCH_VALIDATION_RESULTS,
     },
     (message, action, dispatch) => dispatch(vocabularyValidation(message, null))
   ),
+  ...d(
+    [
+      Constants.WEBSOCKET_ENDPOINT.LONG_RUNNING_TASKS_UPDATE,
+      "/user" + Constants.WEBSOCKET_ENDPOINT.LONG_RUNNING_TASKS_UPDATE,
+    ],
+    {
+      type: ActionType.LONG_RUNNING_TASKS_UPDATE,
+    },
+    (message, action, dispatch) =>
+      dispatch(updateLongRunningTasks(message, action))
+  ),
 };
 
 export function dispatcherExceptionHandler(
diff --git a/src/reducer/WebSocketUtilityDispatchers.ts b/src/reducer/WebSocketUtilityDispatchers.ts
new file mode 100644
index 00000000..05e87c38
--- /dev/null
+++ b/src/reducer/WebSocketUtilityDispatchers.ts
@@ -0,0 +1,25 @@
+import { IMessage } from "react-stomp-hooks";
+import { Action } from "redux";
+import { ThunkDispatch } from "../util/Types";
+import { LongRunningTask } from "../model/LongRunningTask";
+import { asyncActionSuccessWithPayload } from "../action/SyncActions";
+
+export function updateLongRunningTasks(message: IMessage, action: Action) {
+  return async (dispatch: ThunkDispatch) => {
+    const tasks: [LongRunningTask] = JSON.parse(message.body);
+    const mapped: { [uuid: string]: LongRunningTask } = {};
+
+    tasks.forEach((task) => {
+      if (task.startedAt) {
+        // @ts-ignore
+        task.startedAt = new Date(task.startedAt * 1000);
+      }
+
+      task.name = "longrunningtasks.name." + task.name;
+
+      mapped[task.uuid] = task;
+    });
+
+    dispatch(asyncActionSuccessWithPayload(action, mapped));
+  };
+}
diff --git a/src/reducer/__tests__/TermItReducers.test.ts b/src/reducer/__tests__/TermItReducers.test.ts
index 36b78881..76949d80 100644
--- a/src/reducer/__tests__/TermItReducers.test.ts
+++ b/src/reducer/__tests__/TermItReducers.test.ts
@@ -88,6 +88,7 @@ function stateToPlainObject(state: TermItState): TermItState {
     users: state.users,
     accessLevels: state.accessLevels,
     annotatorLegendFilter: state.annotatorLegendFilter,
+    runningTasks: state.runningTasks,
   };
 }
 
diff --git a/src/util/Constants.ts b/src/util/Constants.ts
index 1d29e3ac..4e961678 100644
--- a/src/util/Constants.ts
+++ b/src/util/Constants.ts
@@ -124,6 +124,11 @@ const constants = {
 
   WEBSOCKET_ENDPOINT: {
     VOCABULARIES_VALIDATION: "/vocabularies/validation",
+    VOCABULARIES_TEXT_ANALYSIS_FINISHED_TERM_DEFINITION:
+      "/vocabularies/text_analysis/finished/term-definition",
+    VOCABULARIES_TEXT_ANALYSIS_FINISHED_FILE:
+      "/vocabularies/text_analysis/finished/file",
+    LONG_RUNNING_TASKS_UPDATE: "/long-running-tasks/update",
   },
   // Number of milliseconds after which a websocket request should be retried
   WEBSOCKET_REQUEST_TIMEOUT: 60 * 1000 /* 1 minute */,