diff --git a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/controller/TermController.java b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/controller/TermController.java
index c8ee8d1d2..5d7e6fc9f 100644
--- a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/controller/TermController.java
+++ b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/controller/TermController.java
@@ -6,6 +6,9 @@
 import org.opendatadiscovery.oddplatform.api.contract.model.CountableSearchFilter;
 import org.opendatadiscovery.oddplatform.api.contract.model.DataEntityList;
 import org.opendatadiscovery.oddplatform.api.contract.model.DatasetFieldList;
+import org.opendatadiscovery.oddplatform.api.contract.model.LinkedTerm;
+import org.opendatadiscovery.oddplatform.api.contract.model.LinkedTermFormData;
+import org.opendatadiscovery.oddplatform.api.contract.model.LinkedTermList;
 import org.opendatadiscovery.oddplatform.api.contract.model.MultipleFacetType;
 import org.opendatadiscovery.oddplatform.api.contract.model.Ownership;
 import org.opendatadiscovery.oddplatform.api.contract.model.OwnershipFormData;
@@ -111,6 +114,15 @@ public Mono<ResponseEntity<DatasetFieldList>> getTermLinkedColumns(final Long te
             .map(ResponseEntity::ok);
     }
 
+    @Override
+    public Mono<ResponseEntity<LinkedTermList>> getTermLinkedTerms(final Long termId, final Integer page,
+                                                                   final Integer size, final String query,
+                                                                   final ServerWebExchange exchange) {
+        return termService
+            .listByTerm(termId, query, page, size)
+            .map(ResponseEntity::ok);
+    }
+
     @Override
     public Mono<ResponseEntity<Flux<Tag>>> createTermTagsRelations(final Long termId,
                                                                    final Mono<TagsFormData> tagsFormData,
@@ -217,4 +229,20 @@ public Mono<ResponseEntity<Void>> deleteQueryExampleToTermRelationship(final Lon
         return queryExampleService.removeTermFromQueryExample(termId, exampleId)
             .thenReturn(ResponseEntity.noContent().build());
     }
+
+    @Override
+    public Mono<ResponseEntity<LinkedTerm>> addLinkedTermToTerm(final Long termId,
+                                                                final Mono<LinkedTermFormData> linkedTermFormData,
+                                                                final ServerWebExchange exchange) {
+        return linkedTermFormData
+            .flatMap(fd -> termService.linkTermWithTerm(fd.getLinkedTermId(), termId))
+            .map(ResponseEntity::ok);
+    }
+
+    @Override
+    public Mono<ResponseEntity<Void>> deleteLinkedTermFromTerm(final Long termId, final Long linkedTermId,
+                                                               final ServerWebExchange exchange) {
+        return termService.removeTermToLinkedTermRelation(termId, linkedTermId)
+            .thenReturn(ResponseEntity.noContent().build());
+    }
 }
diff --git a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/dto/term/TermDetailsDto.java b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/dto/term/TermDetailsDto.java
index 515c7a2c4..ec1ba65f9 100644
--- a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/dto/term/TermDetailsDto.java
+++ b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/dto/term/TermDetailsDto.java
@@ -1,5 +1,6 @@
 package org.opendatadiscovery.oddplatform.dto.term;
 
+import java.util.List;
 import java.util.Set;
 import lombok.Builder;
 import lombok.Getter;
@@ -12,9 +13,11 @@
 public class TermDetailsDto {
     private final TermDto termDto;
     private final Set<TagPojo> tags;
+    private final List<LinkedTermDto> terms;
 
     public TermDetailsDto(final TermRefDto termRefDto) {
         this.tags = null;
-        this.termDto = new TermDto(termRefDto, null, null, null, null);
+        this.terms = null;
+        this.termDto = new TermDto(termRefDto, null, null, null, null, null);
     }
 }
diff --git a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/dto/term/TermDto.java b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/dto/term/TermDto.java
index 4c0253edc..7e7f27194 100644
--- a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/dto/term/TermDto.java
+++ b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/dto/term/TermDto.java
@@ -10,6 +10,7 @@ public class TermDto {
     private final TermRefDto termRefDto;
     private final Integer entitiesUsingCount;
     private final Integer columnsUsingCount;
+    private final Integer linkedTermsUsingCount;
     private final Integer queryExampleUsingCount;
     private final Set<TermOwnershipDto> ownerships;
 }
diff --git a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/mapper/TermMapper.java b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/mapper/TermMapper.java
index 4d3c9faa7..aeb4125ba 100644
--- a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/mapper/TermMapper.java
+++ b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/mapper/TermMapper.java
@@ -75,6 +75,7 @@ default TermList mapToPage(final Page<TermDto> page) {
     @Mapping(source = "dto.termDto.ownerships", target = "ownership")
     @Mapping(source = "dto.termDto.entitiesUsingCount", target = "entitiesUsingCount")
     @Mapping(source = "dto.termDto.columnsUsingCount", target = "columnsUsingCount")
+    @Mapping(source = "dto.termDto.linkedTermsUsingCount", target = "linkedTermsUsingCount")
     @Mapping(source = "dto.termDto.queryExampleUsingCount", target = "queryExampleUsingCount")
     TermDetails mapToDetails(final TermDetailsDto dto);
 
diff --git a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/ReactiveTermRepository.java b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/ReactiveTermRepository.java
index 8f72f0c2b..81b5d2f18 100644
--- a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/ReactiveTermRepository.java
+++ b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/ReactiveTermRepository.java
@@ -37,4 +37,10 @@ public interface ReactiveTermRepository extends ReactiveCRUDRepository<TermPojo>
     Flux<LinkedTermDto> getDatasetFieldTerms(final long datasetFieldId);
 
     Mono<Boolean> hasDescriptionRelations(final long termId);
+
+    Flux<LinkedTermDto> getLinkedTermsByTargetTermId(long targetTermId);
+
+    Flux<LinkedTermDto> listByTerm(final Long termId, final String query, final Integer page, final Integer size);
+
+    Mono<LinkedTermDto> getTermByIdAndLinkedTermId(final Long assignedTermId, final Long targetTermId);
 }
diff --git a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/ReactiveTermRepositoryImpl.java b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/ReactiveTermRepositoryImpl.java
index 403892de4..023069a7b 100644
--- a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/ReactiveTermRepositoryImpl.java
+++ b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/ReactiveTermRepositoryImpl.java
@@ -32,8 +32,11 @@
 import org.opendatadiscovery.oddplatform.model.tables.pojos.TagPojo;
 import org.opendatadiscovery.oddplatform.model.tables.pojos.TermOwnershipPojo;
 import org.opendatadiscovery.oddplatform.model.tables.pojos.TermPojo;
+import org.opendatadiscovery.oddplatform.model.tables.pojos.TermToTermPojo;
 import org.opendatadiscovery.oddplatform.model.tables.pojos.TitlePojo;
+import org.opendatadiscovery.oddplatform.model.tables.records.NamespaceRecord;
 import org.opendatadiscovery.oddplatform.model.tables.records.TermRecord;
+import org.opendatadiscovery.oddplatform.model.tables.records.TermToTermRecord;
 import org.opendatadiscovery.oddplatform.repository.util.JooqFTSHelper;
 import org.opendatadiscovery.oddplatform.repository.util.JooqQueryHelper;
 import org.opendatadiscovery.oddplatform.repository.util.JooqReactiveOperations;
@@ -63,6 +66,7 @@
 import static org.opendatadiscovery.oddplatform.model.Tables.TERM;
 import static org.opendatadiscovery.oddplatform.model.Tables.TERM_OWNERSHIP;
 import static org.opendatadiscovery.oddplatform.model.Tables.TERM_SEARCH_ENTRYPOINT;
+import static org.opendatadiscovery.oddplatform.model.Tables.TERM_TO_TERM;
 import static org.opendatadiscovery.oddplatform.model.Tables.TITLE;
 import static org.opendatadiscovery.oddplatform.repository.util.FTSConstants.RANK_FIELD_ALIAS;
 import static org.opendatadiscovery.oddplatform.repository.util.FTSConstants.TERM_CONDITIONS;
@@ -76,8 +80,12 @@ public class ReactiveTermRepositoryImpl extends ReactiveAbstractSoftDeleteCRUDRe
     private static final String AGG_OWNERSHIPS_FIELD = "ownerships";
     private static final String AGG_TITLES_FIELD = "titles";
     private static final String AGG_TAGS_FIELD = "tags";
+    private static final String AGG_ASSIGNED_TERMS = "assigned_terms";
+    public static final String ASSIGNED_TERM_NAMESPACES = "assigned_term_namespaces";
+    public static final String ASSIGNED_TERM_RELATIONS = "assigned_term_relation";
     private static final String ENTITIES_COUNT = "entities_count";
     private static final String COLUMNS_COUNT = "columns_count";
+    private static final String LINKED_TERMS_COUNT = "linked_terms_count";
     private static final String QUERY_EXAMPLE_COUNT = "query_example_count";
     private static final String IS_DESCRIPTION_LINK = "is_description_link";
 
@@ -177,6 +185,11 @@ public Mono<TermRefDto> getTermRefDto(final Long id) {
 
     @Override
     public Mono<TermDetailsDto> getTermDetailsDto(final Long id) {
+        final Table<TermRecord> assignedTerms = TERM.asTable("assigned_terms");
+        final Table<NamespaceRecord> assignedTermsNamespace = NAMESPACE.asTable("assigned_terms_namespace");
+        final Table<TermToTermRecord> assignedTermRelations = TERM_TO_TERM.asTable("assigned_term_relations");
+        final Table<TermToTermRecord> linkedTerms = TERM_TO_TERM.asTable("linked_terms");
+
         final List<Field<?>> groupByFields = Stream.of(TERM.fields(), NAMESPACE.fields())
             .flatMap(Arrays::stream)
             .toList();
@@ -187,9 +200,13 @@ public Mono<TermDetailsDto> getTermDetailsDto(final Long id) {
             .select(jsonArrayAgg(field(OWNER.asterisk().toString())).as(AGG_OWNERS_FIELD))
             .select(jsonArrayAgg(field(TITLE.asterisk().toString())).as(AGG_TITLES_FIELD))
             .select(jsonArrayAgg(field(TAG.asterisk().toString())).as(AGG_TAGS_FIELD))
+            .select(jsonArrayAgg(field(assignedTerms.asterisk().toString())).as(AGG_ASSIGNED_TERMS))
+            .select(jsonArrayAgg(field(NAMESPACE.asterisk().toString())).as(ASSIGNED_TERM_NAMESPACES))
+            .select(jsonArrayAgg(field(assignedTermRelations.asterisk().toString())).as(ASSIGNED_TERM_RELATIONS))
             .select(DSL.countDistinct(DATA_ENTITY_TO_TERM.DATA_ENTITY_ID).as(ENTITIES_COUNT))
             .select(DSL.countDistinct(DATASET_FIELD_TO_TERM.DATASET_FIELD_ID).as(COLUMNS_COUNT))
             .select(DSL.countDistinct(QUERY_EXAMPLE_TO_TERM.QUERY_EXAMPLE_ID).as(QUERY_EXAMPLE_COUNT))
+            .select(DSL.countDistinct(linkedTerms.field(TERM_TO_TERM.TARGET_TERM_ID)).as(LINKED_TERMS_COUNT))
             .from(TERM)
             .join(NAMESPACE).on(NAMESPACE.ID.eq(TERM.NAMESPACE_ID))
             .leftJoin(TERM_OWNERSHIP).on(TERM_OWNERSHIP.TERM_ID.eq(TERM.ID))
@@ -200,6 +217,13 @@ public Mono<TermDetailsDto> getTermDetailsDto(final Long id) {
             .leftJoin(DATA_ENTITY_TO_TERM).on(DATA_ENTITY_TO_TERM.TERM_ID.eq(TERM.ID))
             .leftJoin(DATASET_FIELD_TO_TERM).on(DATASET_FIELD_TO_TERM.TERM_ID.eq(TERM.ID))
             .leftJoin(QUERY_EXAMPLE_TO_TERM).on(QUERY_EXAMPLE_TO_TERM.TERM_ID.eq(TERM.ID))
+            .leftJoin(linkedTerms).on(linkedTerms.field(TERM_TO_TERM.ASSIGNED_TERM_ID).eq(TERM.ID))
+            .leftJoin(assignedTermRelations)
+            .on(assignedTermRelations.field(TERM_TO_TERM.TARGET_TERM_ID).eq(TERM.ID))
+            .leftJoin(assignedTerms)
+            .on(assignedTerms.field(TERM.ID).eq(assignedTermRelations.field(TERM_TO_TERM.ASSIGNED_TERM_ID)))
+            .leftJoin(assignedTermsNamespace)
+            .on(assignedTerms.field(TERM.NAMESPACE_ID).eq(assignedTermsNamespace.field(NAMESPACE.ID)))
             .where(TERM.ID.eq(id).and(TERM.DELETED_AT.isNull()))
             .groupBy(groupByFields);
         return jooqReactiveOperations.mono(query)
@@ -290,6 +314,8 @@ public Mono<Page<TermDto>> findByState(final FacetStateDto state, final int page
             .flatMap(Arrays::stream)
             .toList();
 
+        final Table<TermToTermRecord> linkedTerms = TERM_TO_TERM.asTable("linked_terms");
+
         final var query = DSL.with(termCTE.getName())
             .as(termSelect)
             .select(termCTE.fields())
@@ -300,6 +326,7 @@ public Mono<Page<TermDto>> findByState(final FacetStateDto state, final int page
             .select(DSL.countDistinct(DATA_ENTITY_TO_TERM.DATA_ENTITY_ID).as(ENTITIES_COUNT))
             .select(DSL.countDistinct(DATASET_FIELD_TO_TERM.DATASET_FIELD_ID).as(COLUMNS_COUNT))
             .select(DSL.countDistinct(QUERY_EXAMPLE_TO_TERM.QUERY_EXAMPLE_ID).as(QUERY_EXAMPLE_COUNT))
+            .select(DSL.countDistinct(linkedTerms.field(TERM_TO_TERM.TARGET_TERM_ID)).as(LINKED_TERMS_COUNT))
             .from(termCTE.getName())
             .join(NAMESPACE).on(NAMESPACE.ID.eq(termCTE.field(TERM.NAMESPACE_ID)))
             .leftJoin(TERM_OWNERSHIP).on(TERM_OWNERSHIP.TERM_ID.eq(termCTE.field(TERM.ID)))
@@ -308,6 +335,7 @@ public Mono<Page<TermDto>> findByState(final FacetStateDto state, final int page
             .leftJoin(DATA_ENTITY_TO_TERM).on(DATA_ENTITY_TO_TERM.TERM_ID.eq(termCTE.field(TERM.ID)))
             .leftJoin(DATASET_FIELD_TO_TERM).on(DATASET_FIELD_TO_TERM.TERM_ID.eq(termCTE.field(TERM.ID)))
             .leftJoin(QUERY_EXAMPLE_TO_TERM).on(QUERY_EXAMPLE_TO_TERM.TERM_ID.eq(termCTE.field(TERM.ID)))
+            .leftJoin(linkedTerms).on(linkedTerms.field(TERM_TO_TERM.ASSIGNED_TERM_ID).eq(termCTE.field(TERM.ID)))
             .groupBy(groupByFields);
 
         return jooqReactiveOperations.flux(query)
@@ -389,10 +417,108 @@ public Mono<Boolean> hasDescriptionRelations(final long termId) {
                 .and(DATASET_FIELD_TO_TERM.IS_DESCRIPTION_LINK.isTrue())
                 .and(DATA_ENTITY.STATUS.ne(DataEntityStatusDto.DELETED.getId()))
             ));
-        final var query = DSL.select(dataEntityDescriptionRelations.or(datasetFieldDescriptionRelations));
+        final Condition termDescriptionRelations = exists(DSL.selectOne()
+            .from(TERM_TO_TERM)
+            .join(TERM).on(TERM_TO_TERM.TARGET_TERM_ID.eq(TERM.ID))
+            .where(TERM_TO_TERM.ASSIGNED_TERM_ID.eq(termId)
+                .and(TERM_TO_TERM.IS_DESCRIPTION_LINK.isTrue())
+                .and(TERM.DELETED_AT.isNull())
+            ));
+        final var query = DSL.select(dataEntityDescriptionRelations
+            .or(datasetFieldDescriptionRelations)
+            .or(termDescriptionRelations));
         return jooqReactiveOperations.mono(query).map(Record1::component1);
     }
 
+    @Override
+    public Flux<LinkedTermDto> getLinkedTermsByTargetTermId(final long targetTermId) {
+        final var query = DSL
+            .select(TERM.fields())
+            .select(NAMESPACE.fields())
+            .select(TERM_TO_TERM.IS_DESCRIPTION_LINK.as(IS_DESCRIPTION_LINK))
+            .from(TERM)
+            .join(NAMESPACE).on(NAMESPACE.ID.eq(TERM.NAMESPACE_ID))
+            .join(TERM_TO_TERM)
+            .on(TERM_TO_TERM.ASSIGNED_TERM_ID.eq(TERM.ID)
+                .and(TERM_TO_TERM.TARGET_TERM_ID.eq(targetTermId)))
+            .where(TERM.DELETED_AT.isNull());
+        return jooqReactiveOperations.flux(query)
+            .map(this::mapRecordToLinkedTermDto);
+    }
+
+    @Override
+    public Flux<LinkedTermDto> listByTerm(final Long termId, final String query,
+                                          final Integer page, final Integer size) {
+        final List<Condition> conditions = new ArrayList<>();
+
+        conditions.add(TERM.DELETED_AT.isNull());
+
+        if (StringUtils.isNotBlank(query)) {
+            conditions.add(TERM.NAME.containsIgnoreCase(query));
+        }
+
+        final var baseQuery = DSL.select(TERM.fields())
+            .from(TERM)
+            .where(conditions)
+            .orderBy(TERM.ID.desc());
+
+        final Table<Record> termCTE = baseQuery.asTable("term_cte");
+        final Table<TermToTermRecord> assignedTermRelations = TERM_TO_TERM.asTable("assigned_term_relations");
+
+        final List<Field<?>> groupByFields = Stream.of(termCTE.fields(), NAMESPACE.fields(),
+                assignedTermRelations.fields(TERM_TO_TERM.IS_DESCRIPTION_LINK))
+            .flatMap(Arrays::stream)
+            .toList();
+
+        final var finalQuery = DSL.with(termCTE.getName())
+            .as(baseQuery)
+            .select(termCTE.fields())
+            .select(NAMESPACE.fields())
+            .select(assignedTermRelations.field(TERM_TO_TERM.IS_DESCRIPTION_LINK).as(IS_DESCRIPTION_LINK))
+            .from(termCTE)
+            .join(NAMESPACE).on(NAMESPACE.ID.eq(termCTE.field(TERM.NAMESPACE_ID)))
+            .leftJoin(DATA_ENTITY_TO_TERM).on(DATA_ENTITY_TO_TERM.TERM_ID.eq(termCTE.field(TERM.ID)))
+            .leftJoin(DATASET_FIELD_TO_TERM).on(DATASET_FIELD_TO_TERM.TERM_ID.eq(termCTE.field(TERM.ID)))
+            .leftJoin(assignedTermRelations)
+            .on(assignedTermRelations.field(TERM_TO_TERM.TARGET_TERM_ID).eq(termCTE.field(TERM.ID)))
+            .where(assignedTermRelations.field(TERM_TO_TERM.ASSIGNED_TERM_ID).eq(termId))
+            .groupBy(groupByFields)
+            .orderBy(List.of(jooqQueryHelper.getField(termCTE, TERM.ID).desc()))
+            .limit(size)
+            .offset((page - 1) * size);
+
+        return jooqReactiveOperations.flux(finalQuery)
+            .map(this::mapRecordToLinkedTermDto);
+    }
+
+    @Override
+    public Mono<LinkedTermDto> getTermByIdAndLinkedTermId(final Long assignedTermId, final Long targetTermId) {
+        final var baseQuery = DSL.select(TERM.fields())
+            .from(TERM)
+            .where(TERM.DELETED_AT.isNull())
+            .and(TERM.ID.eq(targetTermId))
+            .orderBy(TERM.ID.desc());
+
+        final Table<Record> termCTE = baseQuery.asTable("term_cte");
+        final Table<TermToTermRecord> assignedTermRelations = TERM_TO_TERM.asTable("assigned_term_relations");
+
+        final var finalQuery = DSL.with(termCTE.getName())
+            .as(baseQuery)
+            .select(termCTE.fields())
+            .select(NAMESPACE.fields())
+            .select(assignedTermRelations.field(TERM_TO_TERM.IS_DESCRIPTION_LINK).as(IS_DESCRIPTION_LINK))
+            .from(termCTE)
+            .join(NAMESPACE).on(NAMESPACE.ID.eq(termCTE.field(TERM.NAMESPACE_ID)))
+            .leftJoin(DATA_ENTITY_TO_TERM).on(DATA_ENTITY_TO_TERM.TERM_ID.eq(termCTE.field(TERM.ID)))
+            .leftJoin(DATASET_FIELD_TO_TERM).on(DATASET_FIELD_TO_TERM.TERM_ID.eq(termCTE.field(TERM.ID)))
+            .leftJoin(assignedTermRelations)
+            .on(assignedTermRelations.field(TERM_TO_TERM.TARGET_TERM_ID).eq(termCTE.field(TERM.ID)))
+            .where(assignedTermRelations.field(TERM_TO_TERM.ASSIGNED_TERM_ID).eq(assignedTermId));
+
+        return jooqReactiveOperations.mono(finalQuery)
+            .map(this::mapRecordToLinkedTermDto);
+    }
+
     private LinkedTermDto mapRecordToLinkedTermDto(final Record record) {
         final TermRefDto termRefDto = mapRecordToRefDto(record);
         return new LinkedTermDto(termRefDto, record.get(IS_DESCRIPTION_LINK, Boolean.class));
@@ -418,6 +544,7 @@ private TermDto mapRecordToDto(final Record record) {
             .termRefDto(refDto)
             .entitiesUsingCount(record.get(ENTITIES_COUNT, Integer.class))
             .columnsUsingCount(record.get(COLUMNS_COUNT, Integer.class))
+            .linkedTermsUsingCount(record.get(LINKED_TERMS_COUNT, Integer.class))
             .queryExampleUsingCount(record.get(QUERY_EXAMPLE_COUNT, Integer.class))
             .ownerships(extractOwnershipRelation(record))
             .build();
@@ -429,6 +556,7 @@ private TermDto mapRecordToDto(final Record record, final String cteName) {
             .termRefDto(refDto)
             .entitiesUsingCount(record.get(ENTITIES_COUNT, Integer.class))
             .columnsUsingCount(record.get(COLUMNS_COUNT, Integer.class))
+            .linkedTermsUsingCount(record.get(LINKED_TERMS_COUNT, Integer.class))
             .queryExampleUsingCount(record.get(QUERY_EXAMPLE_COUNT, Integer.class))
             .ownerships(extractOwnershipRelation(record))
             .build();
@@ -439,6 +567,7 @@ private TermDetailsDto mapRecordToDetailsDto(final Record record) {
         return TermDetailsDto.builder()
             .termDto(termDto)
             .tags(jooqRecordHelper.extractAggRelation(record, AGG_TAGS_FIELD, TagPojo.class))
+            .terms(extractTerms(record))
             .build();
     }
 
@@ -470,4 +599,32 @@ private Set<TermOwnershipDto> extractOwnershipRelation(final Record r) {
             })
             .collect(Collectors.toSet());
     }
+
+    private List<LinkedTermDto> extractTerms(final Record record) {
+        final Set<TermPojo> terms =
+            jooqRecordHelper.extractAggRelation(record, AGG_ASSIGNED_TERMS, TermPojo.class);
+
+        final Map<Long, NamespacePojo> namespaces = jooqRecordHelper
+            .extractAggRelation(record, ASSIGNED_TERM_NAMESPACES, NamespacePojo.class)
+            .stream()
+            .collect(Collectors.toMap(NamespacePojo::getId, identity()));
+
+        final Map<Long, List<TermToTermPojo>> relations = jooqRecordHelper
+            .extractAggRelation(record, ASSIGNED_TERM_RELATIONS, TermToTermPojo.class)
+            .stream()
+            .collect(Collectors.groupingBy(TermToTermPojo::getAssignedTermId));
+
+        return terms.stream()
+            .map(pojo -> {
+                final TermRefDto termRefDto = TermRefDto.builder()
+                    .term(pojo)
+                    .namespace(namespaces.get(pojo.getNamespaceId()))
+                    .build();
+                final boolean isDescriptionLink = relations.getOrDefault(pojo.getId(), List.of()).stream()
+                    .anyMatch(r -> Boolean.TRUE.equals(r.getIsDescriptionLink()));
+
+                return new LinkedTermDto(termRefDto, isDescriptionLink);
+            })
+            .toList();
+    }
 }
diff --git a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermDefinitionUnhandledTermRepository.java b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermDefinitionUnhandledTermRepository.java
new file mode 100644
index 000000000..440151894
--- /dev/null
+++ b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermDefinitionUnhandledTermRepository.java
@@ -0,0 +1,15 @@
+package org.opendatadiscovery.oddplatform.repository.reactive;
+
+import java.util.List;
+import org.opendatadiscovery.oddplatform.dto.term.TermBaseInfoDto;
+import org.opendatadiscovery.oddplatform.model.tables.pojos.TermDefinitionUnhandledTermPojo;
+import reactor.core.publisher.Flux;
+
+public interface TermDefinitionUnhandledTermRepository {
+
+    Flux<TermDefinitionUnhandledTermPojo> deleteForTermExceptSpecified(long termId,
+                                                                       final List<TermBaseInfoDto> termsToKeep);
+
+    Flux<TermDefinitionUnhandledTermPojo> createUnhandledTerms(
+        final List<TermDefinitionUnhandledTermPojo> unhandledTerms);
+}
diff --git a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermDefinitionUnhandledTermRepositoryImpl.java b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermDefinitionUnhandledTermRepositoryImpl.java
new file mode 100644
index 000000000..594fca928
--- /dev/null
+++ b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermDefinitionUnhandledTermRepositoryImpl.java
@@ -0,0 +1,71 @@
+package org.opendatadiscovery.oddplatform.repository.reactive;
+
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.collections4.CollectionUtils;
+import org.jooq.Condition;
+import org.jooq.Row2;
+import org.jooq.impl.DSL;
+import org.opendatadiscovery.oddplatform.dto.term.TermBaseInfoDto;
+import org.opendatadiscovery.oddplatform.model.tables.pojos.TermDefinitionUnhandledTermPojo;
+import org.opendatadiscovery.oddplatform.model.tables.records.TermDefinitionUnhandledTermRecord;
+import org.opendatadiscovery.oddplatform.repository.util.JooqReactiveOperations;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+
+import static org.jooq.impl.DSL.lower;
+import static org.jooq.impl.DSL.row;
+import static org.opendatadiscovery.oddplatform.model.Keys.TERM_DEFINITION_UNHANDLED_TERM_UNIQUE_KEY;
+import static org.opendatadiscovery.oddplatform.model.Tables.TERM_DEFINITION_UNHANDLED_TERM;
+
+@Repository
+@RequiredArgsConstructor
+public class TermDefinitionUnhandledTermRepositoryImpl implements TermDefinitionUnhandledTermRepository {
+
+    private final JooqReactiveOperations jooqReactiveOperations;
+
+    @Override
+    public Flux<TermDefinitionUnhandledTermPojo>
+        deleteForTermExceptSpecified(final long termId,
+                                     final List<TermBaseInfoDto> termsToKeep) {
+        final List<Row2<String, String>> termRows = termsToKeep.stream()
+            .map(term -> row(lower(term.name()), lower(term.namespaceName())))
+            .toList();
+        final Condition condition;
+        if (CollectionUtils.isNotEmpty(termRows)) {
+            condition = row(lower(TERM_DEFINITION_UNHANDLED_TERM.TERM_NAME),
+                lower(TERM_DEFINITION_UNHANDLED_TERM.TERM_NAMESPACE_NAME)).notIn(termRows);
+        } else {
+            condition = DSL.noCondition();
+        }
+        final var query = DSL.deleteFrom(TERM_DEFINITION_UNHANDLED_TERM)
+            .where(TERM_DEFINITION_UNHANDLED_TERM.TARGET_TERM_ID.eq(termId)).and(condition)
+            .returning();
+        return jooqReactiveOperations.flux(query)
+            .map(r -> r.into(TermDefinitionUnhandledTermPojo.class));
+    }
+
+    @Override
+    public Flux<TermDefinitionUnhandledTermPojo> createUnhandledTerms(
+        final List<TermDefinitionUnhandledTermPojo> unhandledTerms) {
+        if (unhandledTerms.isEmpty()) {
+            return Flux.just();
+        }
+        final List<TermDefinitionUnhandledTermRecord> records = unhandledTerms.stream()
+            .map(p -> jooqReactiveOperations.newRecord(TERM_DEFINITION_UNHANDLED_TERM, p))
+            .toList();
+
+        var insertStep = DSL.insertInto(TERM_DEFINITION_UNHANDLED_TERM);
+
+        for (int i = 0; i < records.size() - 1; i++) {
+            insertStep = insertStep.set(records.get(i)).newRecord();
+        }
+
+        return jooqReactiveOperations.flux(
+            insertStep.set(records.get(records.size() - 1))
+                .onConflictOnConstraint(TERM_DEFINITION_UNHANDLED_TERM_UNIQUE_KEY)
+                .doNothing()
+                .returning(TERM_DEFINITION_UNHANDLED_TERM.fields())
+        ).map(r -> r.into(TermDefinitionUnhandledTermPojo.class));
+    }
+}
diff --git a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermRelationsRepository.java b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermRelationsRepository.java
index fbb6bafb9..da9299292 100644
--- a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermRelationsRepository.java
+++ b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermRelationsRepository.java
@@ -3,6 +3,7 @@
 import java.util.List;
 import org.opendatadiscovery.oddplatform.model.tables.pojos.DataEntityToTermPojo;
 import org.opendatadiscovery.oddplatform.model.tables.pojos.DatasetFieldToTermPojo;
+import org.opendatadiscovery.oddplatform.model.tables.pojos.TermToTermPojo;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
@@ -23,7 +24,15 @@ public interface TermRelationsRepository {
 
     Flux<DatasetFieldToTermPojo> createRelationsWithDatasetField(final List<DatasetFieldToTermPojo> relations);
 
+    Flux<TermToTermPojo> createRelationsWithTerm(final List<TermToTermPojo> relations);
+
+    Mono<TermToTermPojo> createRelationWithTerm(final Long linkedTermId, final Long termId);
+
     Mono<DatasetFieldToTermPojo> deleteRelationWithDatasetField(final long datasetFieldId, final long termId);
 
     Flux<DatasetFieldToTermPojo> deleteTermDatasetFieldRelations(final List<DatasetFieldToTermPojo> pojos);
+
+    Flux<TermToTermPojo> deleteTermToTermRelations(final List<TermToTermPojo> pojos);
+
+    Mono<TermToTermPojo> deleteTermToLinkedTermRelation(final Long linkedTermId, final Long termId);
 }
diff --git a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermRelationsRepositoryImpl.java b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermRelationsRepositoryImpl.java
index 760667aff..1c5341100 100644
--- a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermRelationsRepositoryImpl.java
+++ b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/TermRelationsRepositoryImpl.java
@@ -7,8 +7,10 @@
 import org.jooq.impl.DSL;
 import org.opendatadiscovery.oddplatform.model.tables.pojos.DataEntityToTermPojo;
 import org.opendatadiscovery.oddplatform.model.tables.pojos.DatasetFieldToTermPojo;
+import org.opendatadiscovery.oddplatform.model.tables.pojos.TermToTermPojo;
 import org.opendatadiscovery.oddplatform.model.tables.records.DataEntityToTermRecord;
 import org.opendatadiscovery.oddplatform.model.tables.records.DatasetFieldToTermRecord;
+import org.opendatadiscovery.oddplatform.model.tables.records.TermToTermRecord;
 import org.opendatadiscovery.oddplatform.repository.util.JooqReactiveOperations;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
@@ -16,6 +18,7 @@
 
 import static org.opendatadiscovery.oddplatform.model.Tables.DATASET_FIELD_TO_TERM;
 import static org.opendatadiscovery.oddplatform.model.Tables.DATA_ENTITY_TO_TERM;
+import static org.opendatadiscovery.oddplatform.model.Tables.TERM_TO_TERM;
 
 @RequiredArgsConstructor
 @Repository
@@ -135,6 +138,39 @@ public Flux<DatasetFieldToTermPojo> createRelationsWithDatasetField(final List<D
         ).map(r -> r.into(DatasetFieldToTermPojo.class));
     }
 
+    @Override
+    public Flux<TermToTermPojo> createRelationsWithTerm(final List<TermToTermPojo> relations) {
+        if (relations.isEmpty()) {
+            return Flux.just();
+        }
+        final List<TermToTermRecord> records = relations.stream()
+            .map(p -> jooqReactiveOperations.newRecord(TERM_TO_TERM, p))
+            .toList();
+
+        var insertStep = DSL.insertInto(TERM_TO_TERM);
+
+        for (int i = 0; i < records.size() - 1; i++) {
+            insertStep = insertStep.set(records.get(i)).newRecord();
+        }
+
+        return jooqReactiveOperations.flux(
+            insertStep.set(records.get(records.size() - 1))
+                .onDuplicateKeyIgnore()
+                .returning(TERM_TO_TERM.fields())
+        ).map(r -> r.into(TermToTermPojo.class));
+    }
+
+    @Override
+    public Mono<TermToTermPojo> createRelationWithTerm(final Long linkedTermId, final Long termId) {
+        final var query = DSL.insertInto(TERM_TO_TERM)
+            .set(TERM_TO_TERM.TARGET_TERM_ID, termId)
+            .set(TERM_TO_TERM.ASSIGNED_TERM_ID, linkedTermId)
+            .onDuplicateKeyIgnore()
+            .returning();
+        return jooqReactiveOperations.mono(query)
+            .map(r -> r.into(TermToTermPojo.class));
+    }
+
     @Override
     public Mono<DatasetFieldToTermPojo> deleteRelationWithDatasetField(final long datasetFieldId, final long termId) {
         final var query = DSL.deleteFrom(DATASET_FIELD_TO_TERM)
@@ -163,4 +199,33 @@ public Flux<DatasetFieldToTermPojo> deleteTermDatasetFieldRelations(final List<D
         return jooqReactiveOperations.flux(query)
             .map(r -> r.into(DatasetFieldToTermPojo.class));
     }
+
+    @Override
+    public Flux<TermToTermPojo> deleteTermToTermRelations(final List<TermToTermPojo> pojos) {
+        if (CollectionUtils.isEmpty(pojos)) {
+            return Flux.just();
+        }
+        final Condition condition = pojos.stream()
+            .map(pojo -> TERM_TO_TERM.TARGET_TERM_ID.eq(pojo.getTargetTermId())
+                .and(TERM_TO_TERM.ASSIGNED_TERM_ID.eq(pojo.getAssignedTermId()))
+                .and(TERM_TO_TERM.IS_DESCRIPTION_LINK.eq(pojo.getIsDescriptionLink())))
+            .reduce(Condition::or)
+            .orElseThrow(() -> new RuntimeException("Couldn't build condition for deletion"));
+        final var query = DSL.delete(TERM_TO_TERM)
+            .where(condition)
+            .returning();
+        return jooqReactiveOperations.flux(query)
+            .map(r -> r.into(TermToTermPojo.class));
+    }
+
+    @Override
+    public Mono<TermToTermPojo> deleteTermToLinkedTermRelation(final Long linkedTermId, final Long termId) {
+        final var query = DSL.deleteFrom(TERM_TO_TERM)
+            .where(TERM_TO_TERM.ASSIGNED_TERM_ID.eq(linkedTermId)
+                .and(TERM_TO_TERM.TARGET_TERM_ID.eq(termId))
+                .and(TERM_TO_TERM.IS_DESCRIPTION_LINK.isFalse()))
+            .returning();
+        return jooqReactiveOperations.mono(query)
+            .map(r -> r.into(TermToTermPojo.class));
+    }
 }
diff --git a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/service/term/TermService.java b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/service/term/TermService.java
index a36910aa6..b44243caa 100644
--- a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/service/term/TermService.java
+++ b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/service/term/TermService.java
@@ -2,6 +2,7 @@
 
 import java.util.List;
 import org.opendatadiscovery.oddplatform.api.contract.model.LinkedTerm;
+import org.opendatadiscovery.oddplatform.api.contract.model.LinkedTermList;
 import org.opendatadiscovery.oddplatform.api.contract.model.Tag;
 import org.opendatadiscovery.oddplatform.api.contract.model.TagsFormData;
 import org.opendatadiscovery.oddplatform.api.contract.model.TermDetails;
@@ -44,4 +45,10 @@ Mono<List<LinkedTermDto>> handleDatasetFieldDescriptionTerms(final long datasetF
     Mono<List<LinkedTermDto>> getDataEntityTerms(final long dataEntityId);
 
     Mono<List<LinkedTermDto>> getDatasetFieldTerms(final long datasetFieldId);
+
+    Mono<LinkedTermList> listByTerm(final Long termId, final String query, final Integer page, final Integer size);
+
+    Mono<LinkedTerm> linkTermWithTerm(final Long linkedTermId, final Long termId);
+
+    Mono<Void> removeTermToLinkedTermRelation(final Long termId, final Long linkedTermId);
 }
diff --git a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/service/term/TermServiceImpl.java b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/service/term/TermServiceImpl.java
index da9c67ccc..c89d188fa 100644
--- a/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/service/term/TermServiceImpl.java
+++ b/odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/service/term/TermServiceImpl.java
@@ -12,6 +12,8 @@
 import org.apache.commons.lang3.StringUtils;
 import org.opendatadiscovery.oddplatform.annotation.ReactiveTransactional;
 import org.opendatadiscovery.oddplatform.api.contract.model.LinkedTerm;
+import org.opendatadiscovery.oddplatform.api.contract.model.LinkedTermList;
+import org.opendatadiscovery.oddplatform.api.contract.model.PageInfo;
 import org.opendatadiscovery.oddplatform.api.contract.model.Tag;
 import org.opendatadiscovery.oddplatform.api.contract.model.TagsFormData;
 import org.opendatadiscovery.oddplatform.api.contract.model.TermDetails;
@@ -33,11 +35,14 @@
 import org.opendatadiscovery.oddplatform.model.tables.pojos.DatasetFieldDescriptionUnhandledTermPojo;
 import org.opendatadiscovery.oddplatform.model.tables.pojos.DatasetFieldToTermPojo;
 import org.opendatadiscovery.oddplatform.model.tables.pojos.NamespacePojo;
+import org.opendatadiscovery.oddplatform.model.tables.pojos.TermDefinitionUnhandledTermPojo;
 import org.opendatadiscovery.oddplatform.model.tables.pojos.TermPojo;
+import org.opendatadiscovery.oddplatform.model.tables.pojos.TermToTermPojo;
 import org.opendatadiscovery.oddplatform.repository.reactive.DataEntityDescriptionUnhandledTermRepository;
 import org.opendatadiscovery.oddplatform.repository.reactive.DatasetFieldDescriptionUnhandledTermRepositoryImpl;
 import org.opendatadiscovery.oddplatform.repository.reactive.ReactiveTermRepository;
 import org.opendatadiscovery.oddplatform.repository.reactive.ReactiveTermSearchEntrypointRepository;
+import org.opendatadiscovery.oddplatform.repository.reactive.TermDefinitionUnhandledTermRepository;
 import org.opendatadiscovery.oddplatform.repository.reactive.TermRelationsRepository;
 import org.opendatadiscovery.oddplatform.service.DataEntityFilledService;
 import org.opendatadiscovery.oddplatform.service.NamespaceService;
@@ -66,6 +71,7 @@ public class TermServiceImpl implements TermService {
 
     private final ReactiveTermRepository termRepository;
     private final TermRelationsRepository termRelationsRepository;
+    private final TermDefinitionUnhandledTermRepository termDefinitionUnhandledTermRepository;
     private final ReactiveTermSearchEntrypointRepository termSearchEntrypointRepository;
     private final DataEntityDescriptionUnhandledTermRepository dataEntityDescriptionUnhandledTermRepository;
     private final DatasetFieldDescriptionUnhandledTermRepositoryImpl datasetFieldDescriptionUnhandledTermRepository;
@@ -92,7 +98,8 @@ public Mono<TermRef> getTermByNamespaceAndName(final String namespaceName, final
     public Mono<TermDetails> createTerm(final TermFormData formData) {
         final Mono<TermDetails> createTermMono = Mono.defer(() -> namespaceService
             .getOrCreate(formData.getNamespaceName())
-            .flatMap(namespace -> create(formData, namespace)));
+            .zipWith(findTermsInDescription(formData.getDefinition()))
+            .flatMap(tuple -> create(formData, tuple.getT1(), tuple.getT2())));
 
         return termRepository.getByNameAndNamespace(formData.getNamespaceName(), formData.getName())
             .handle((dto, sink) -> {
@@ -265,18 +272,49 @@ public Mono<List<LinkedTermDto>> getDatasetFieldTerms(final long datasetFieldId)
         return removeDuplicateNonDescriptionTerms(datasetFieldTerms).collectList();
     }
 
+    @Override
+    public Mono<LinkedTermList> listByTerm(final Long termId, final String query,
+                                           final Integer page, final Integer size) {
+        return termRepository.listByTerm(termId, query, page, size)
+            .collectList()
+            .map(item -> new LinkedTermList()
+                .items(termMapper.mapListToLinkedTermList(item))
+                .pageInfo(new PageInfo().total((long) item.size()).hasNext(false)));
+    }
+
+    @Override
+    @ReactiveTransactional
+    public Mono<LinkedTerm> linkTermWithTerm(final Long linkedTermId, final Long termId) {
+        return termRelationsRepository.createRelationWithTerm(linkedTermId, termId)
+            .flatMap(relation -> termRepository.getTermRefDto(relation.getAssignedTermId()))
+            .map(termRefDto -> new LinkedTermDto(termRefDto, false))
+            .map(termMapper::mapToLinkedTerm);
+    }
+
+    @Override
+    @ReactiveTransactional
+    public Mono<Void> removeTermToLinkedTermRelation(final Long termId, final Long linkedTermId) {
+        return termRelationsRepository.deleteTermToLinkedTermRelation(linkedTermId, termId)
+            .then();
+    }
+
     private Mono<TermDetails> update(final TermPojo pojo) {
         return termRepository.update(pojo)
+            .flatMap(term -> findTermsInDescription(term.getDefinition())
+                .flatMap(linkedTerms -> updateTermDefinitionTermsState(linkedTerms, term.getId()))
+                    .thenReturn(term))
             .flatMap(term -> termRepository.getTermDetailsDto(term.getId()))
             .map(termMapper::mapToDetails);
     }
 
     private Mono<TermDetails> create(final TermFormData formData,
-                                     final NamespacePojo namespace) {
+                                     final NamespacePojo namespace,
+                                     final DescriptionParsedTerms linkedTerms) {
         final TermPojo pojo = termMapper.mapToPojo(formData, namespace);
         return termRepository
             .create(pojo)
-            .map(term -> TermRefDto.builder().term(term).namespace(namespace).build())
+            .flatMap(term -> updateTermDefinitionTermsState(linkedTerms, term.getId())
+                .thenReturn(TermRefDto.builder().term(term).namespace(namespace).build()))
             .map(termRefDto -> termMapper.mapToDetails(new TermDetailsDto(termRefDto)));
     }
 
@@ -406,6 +444,37 @@ private Flux<LinkedTermDto> removeDuplicateNonDescriptionTerms(final Flux<Linked
             .flatMap(group -> group.reduce((dto1, dto2) -> dto1.isDescriptionLink() ? dto1 : dto2));
     }
 
+    private Mono<Void> updateTermDefinitionTermsState(final DescriptionParsedTerms terms,
+                                                      final long termId) {
+        final Mono<List<LinkedTermDto>> existingDescriptionRelations = termRepository
+            .getLinkedTermsByTargetTermId(termId)
+            .filter(LinkedTermDto::isDescriptionLink)
+            .collectList();
+
+        return existingDescriptionRelations.flatMap(existing -> {
+            final List<TermToTermPojo> relationsToDelete = existing.stream()
+                .map(dto -> dto.term().getTerm())
+                .filter(pojo -> !terms.foundTerms().contains(pojo))
+                .map(pojo -> new TermToTermPojo()
+                    .setTargetTermId(termId)
+                    .setAssignedTermId(pojo.getId())
+                    .setIsDescriptionLink(true))
+                .toList();
+
+            final List<TermToTermPojo> relations =
+                buildTermDescriptionTermRelations(terms.foundTerms(), termId);
+            final List<TermDefinitionUnhandledTermPojo> unknownPojos =
+                buildTermUnknownTerms(terms.unknownTerms(), termId);
+
+            return termRelationsRepository.deleteTermToTermRelations(relationsToDelete)
+                .thenMany(termRelationsRepository.createRelationsWithTerm(relations))
+                .thenMany(termDefinitionUnhandledTermRepository
+                    .deleteForTermExceptSpecified(termId, terms.unknownTerms()))
+                .thenMany(termDefinitionUnhandledTermRepository.createUnhandledTerms(unknownPojos))
+                .then();
+        });
+    }
+
     private List<DataEntityToTermPojo> buildDataEntityDescriptionTermRelations(final List<TermPojo> terms,
                                                                                final long dataEntityId) {
         return terms.stream()
@@ -426,6 +495,18 @@ private List<DatasetFieldToTermPojo> buildDatasetFieldDescriptionTermRelations(f
             .toList();
     }
 
+    private List<DatasetFieldDescriptionUnhandledTermPojo> buildDatasetFieldUnknownTerms(
+        final List<TermBaseInfoDto> terms,
+        final long datasetFieldId) {
+        return terms.stream()
+            .map(t -> new DatasetFieldDescriptionUnhandledTermPojo()
+                .setDatasetFieldId(datasetFieldId)
+                .setTermName(t.name().toLowerCase())
+                .setTermNamespaceName(t.namespaceName().toLowerCase())
+                .setCreatedAt(DateTimeUtil.generateNow()))
+            .toList();
+    }
+
     private List<DataEntityDescriptionUnhandledTermPojo> buildDataEntityUnknownTerms(final List<TermBaseInfoDto> terms,
                                                                                      final long dataEntityId) {
         return terms.stream()
@@ -437,12 +518,22 @@ private List<DataEntityDescriptionUnhandledTermPojo> buildDataEntityUnknownTerms
             .toList();
     }
 
-    private List<DatasetFieldDescriptionUnhandledTermPojo> buildDatasetFieldUnknownTerms(
+    private List<TermToTermPojo> buildTermDescriptionTermRelations(final List<TermPojo> terms,
+                                                                   final long termId) {
+        return terms.stream()
+            .map(t -> new TermToTermPojo()
+                .setTargetTermId(termId)
+                .setAssignedTermId(t.getId())
+                .setIsDescriptionLink(true))
+            .toList();
+    }
+
+    private List<TermDefinitionUnhandledTermPojo> buildTermUnknownTerms(
         final List<TermBaseInfoDto> terms,
         final long datasetFieldId) {
         return terms.stream()
-            .map(t -> new DatasetFieldDescriptionUnhandledTermPojo()
-                .setDatasetFieldId(datasetFieldId)
+            .map(t -> new TermDefinitionUnhandledTermPojo()
+                .setTargetTermId(datasetFieldId)
                 .setTermName(t.name().toLowerCase())
                 .setTermNamespaceName(t.namespaceName().toLowerCase())
                 .setCreatedAt(DateTimeUtil.generateNow()))
diff --git a/odd-platform-api/src/main/resources/db/migration/V0_0_91__add_term_to_term.sql b/odd-platform-api/src/main/resources/db/migration/V0_0_91__add_term_to_term.sql
new file mode 100644
index 000000000..7edbf0b8a
--- /dev/null
+++ b/odd-platform-api/src/main/resources/db/migration/V0_0_91__add_term_to_term.sql
@@ -0,0 +1,24 @@
+CREATE TABLE IF NOT EXISTS term_to_term
+(
+    target_term_id      bigint NOT NULL,
+    assigned_term_id    bigint NOT NULL,
+    is_description_link boolean DEFAULT FALSE,
+    deleted_at TIMESTAMP WITHOUT TIME ZONE,
+
+    CONSTRAINT term_to_term_pk PRIMARY KEY (target_term_id, assigned_term_id),
+
+    CONSTRAINT term_to_term_target_term_id_fkey FOREIGN KEY (target_term_id) REFERENCES term (id),
+    CONSTRAINT term_to_term_assigned_term_id_fkey FOREIGN KEY (assigned_term_id) REFERENCES term (id)
+);
+
+CREATE TABLE IF NOT EXISTS term_definition_unhandled_term
+(
+    id                  BIGSERIAL PRIMARY KEY,
+    target_term_id      BIGINT                      NOT NULL,
+    term_name           varchar(255)                NOT NULL,
+    term_namespace_name varchar(64)                 NOT NULL,
+    created_at          TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE ('UTC')),
+
+    CONSTRAINT fk_term_definition_unhandled_term_target_term_id FOREIGN KEY (target_term_id) REFERENCES term (id),
+    CONSTRAINT term_definition_unhandled_term_unique_key UNIQUE (target_term_id, term_name, term_namespace_name)
+);
\ No newline at end of file
diff --git a/odd-platform-specification/components.yaml b/odd-platform-specification/components.yaml
index 24025cb6e..decd7940b 100644
--- a/odd-platform-specification/components.yaml
+++ b/odd-platform-specification/components.yaml
@@ -2505,6 +2505,11 @@ components:
           type: array
           items:
             $ref: '#/components/schemas/LinkedTerm'
+        page_info:
+          $ref: '#/components/schemas/PageInfo'
+      required:
+        - items
+        - page_info
 
     LinkedTerm:
       type: object
@@ -2572,6 +2577,8 @@ components:
               type: integer
             columns_using_count:
               type: integer
+            linked_terms_using_count:
+              type: integer
             query_example_using_count:
               type: integer
             created_at:
@@ -2591,6 +2598,10 @@ components:
           properties:
             tags:
               $ref: '#/components/schemas/TagList'
+            terms:
+              type: array
+              items:
+                $ref: '#/components/schemas/LinkedTerm'
 
     TermFormData:
       type: object
@@ -2633,6 +2644,15 @@ components:
       required:
         - query_example_id
 
+    LinkedTermFormData:
+      type: object
+      properties:
+        linked_term_id:
+          type: integer
+          format: int64
+      required:
+        - linked_term_id
+
     TermSearchFormData:
       type: object
       properties:
@@ -4296,6 +4316,14 @@ components:
         type: integer
         format: int64
 
+    LinkedTermIdParam:
+      name: linked_term_id
+      in: path
+      required: true
+      schema:
+        type: integer
+        format: int64
+
     PolicyIdParam:
       name: policy_id
       in: path
diff --git a/odd-platform-specification/openapi.yaml b/odd-platform-specification/openapi.yaml
index e8cd7074a..60e90c010 100644
--- a/odd-platform-specification/openapi.yaml
+++ b/odd-platform-specification/openapi.yaml
@@ -2873,6 +2873,26 @@ paths:
       tags:
         - term
 
+  /api/terms/{term_id}/linked_terms:
+    get:
+      summary: Get term linked terms
+      description: Get data columns, which are using this term
+      operationId: getTermLinkedTerms
+      parameters:
+        - $ref: './components.yaml/#/components/parameters/TermIdParam'
+        - $ref: './components.yaml/#/components/parameters/PageParam'
+        - $ref: './components.yaml/#/components/parameters/SizeParam'
+        - $ref: './components.yaml/#/components/parameters/SearchParam'
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: './components.yaml/#/components/schemas/LinkedTermList'
+      tags:
+        - term
+
   /api/terms/{term_id}/queryexample:
     post:
       summary: add Term to QueryExample
@@ -2910,6 +2930,43 @@ paths:
       tags:
         - term
 
+  /api/terms/{term_id}/term:
+    post:
+      summary: Add term to term
+      description: Link existing term with term
+      operationId: addLinkedTermToTerm
+      parameters:
+        - $ref: './components.yaml/#/components/parameters/TermIdParam'
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: './components.yaml/#/components/schemas/LinkedTermFormData'
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: './components.yaml/#/components/schemas/LinkedTerm'
+      tags:
+        - term
+
+  /api/terms/{term_id}/term/{linked_term_id}:
+    delete:
+      summary: Delete term from term
+      description: Delete term from current linked terms list
+      operationId: deleteLinkedTermFromTerm
+      parameters:
+        - $ref: './components.yaml/#/components/parameters/TermIdParam'
+        - $ref: './components.yaml/#/components/parameters/LinkedTermIdParam'
+      responses:
+        '204':
+          $ref: './components.yaml/#/components/responses/Deleted'
+      tags:
+        - term
+
   /api/terms/search:
     post:
       summary: Terms search by query
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/Overview/Overview.tsx b/odd-platform-ui/src/components/Terms/TermDetails/Overview/Overview.tsx
index 736fd9592..92a059a6c 100644
--- a/odd-platform-ui/src/components/Terms/TermDetails/Overview/Overview.tsx
+++ b/odd-platform-ui/src/components/Terms/TermDetails/Overview/Overview.tsx
@@ -1,30 +1,32 @@
 import { Grid, Typography } from '@mui/material';
-import React, { type FC } from 'react';
+import React, { useMemo, type FC } from 'react';
 import { Markdown, SkeletonWrapper } from 'components/shared/elements';
-import { useAppSelector } from 'redux/lib/hooks';
-import {
-  getResourcePermissions,
-  getTermDetails,
-  getTermDetailsFetchingStatuses,
-} from 'redux/selectors';
 import { Permission, PermissionResourceType } from 'generated-sources';
 import { WithPermissionsProvider } from 'components/shared/contexts';
 import { useTermsRouteParams } from 'routes';
+import { useGetTermByID } from 'lib/hooks';
+import { useResourcePermissions } from 'lib/hooks/api/permissions';
 import OverviewGeneral from './OverviewGeneral/OverviewGeneral';
 import OverviewSkeleton from './OverviewSkeleton/OverviewSkeleton';
-import OverviewTags from './OverviewTags/OverviewTags';
 import * as S from './OverviewStyles';
+import TermLinkedTerms from './TermLinkedTerms/TermLinkedTerms';
+import TermDefinition from './TermDefinition/TermDefinition';
 
 const Overview: FC = () => {
   const { termId } = useTermsRouteParams();
 
-  const termDetails = useAppSelector(getTermDetails(termId));
-  const termPermissions = useAppSelector(
-    getResourcePermissions(PermissionResourceType.TERM, termId)
-  );
+  const { data: termDetails, isLoading: isTermDetailsFetching } = useGetTermByID({
+    termId,
+  });
+  const { data: termPermissions } = useResourcePermissions({
+    resourceId: termId,
+    permissionResourceType: PermissionResourceType.TERM,
+  });
 
-  const { isLoading: isTermDetailsFetching } = useAppSelector(
-    getTermDetailsFetchingStatuses
+  const linkedTerms = useMemo(() => termDetails?.terms || [], [termDetails]);
+  const termsRef = useMemo(
+    () => termDetails?.terms?.map(linkedTerm => linkedTerm.term),
+    [termDetails?.terms]
   );
 
   return (
@@ -33,10 +35,11 @@ const Overview: FC = () => {
         <Grid container spacing={2} sx={{ mt: 0 }}>
           <Grid item xs={8}>
             <S.DefinitionContainer elevation={9}>
-              <Typography variant='h2' mb={1}>
-                Definition
-              </Typography>
-              <Markdown value={termDetails.definition} />
+              <TermDefinition
+                termId={termId}
+                definition={termDetails.definition ?? ''}
+                terms={termsRef}
+              />
             </S.DefinitionContainer>
           </Grid>
           <Grid item xs={4}>
@@ -47,15 +50,17 @@ const Overview: FC = () => {
                   Permission.TERM_OWNERSHIP_UPDATE,
                   Permission.TERM_OWNERSHIP_DELETE,
                 ]}
-                resourcePermissions={termPermissions}
+                resourcePermissions={termPermissions ?? []}
                 Component={OverviewGeneral}
               />
             </S.Container>
             <S.Container square elevation={0}>
               <WithPermissionsProvider
-                allowedPermissions={[Permission.TERM_TAGS_UPDATE]}
-                resourcePermissions={termPermissions}
-                render={() => <OverviewTags tags={termDetails.tags} />}
+                allowedPermissions={[Permission.TERM_UPDATE]}
+                resourcePermissions={termPermissions ?? []}
+                render={() => (
+                  <TermLinkedTerms linkedTerms={linkedTerms} termId={termId} />
+                )}
               />
             </S.Container>
           </Grid>
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermDefinition/TermDefinition.styles.ts b/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermDefinition/TermDefinition.styles.ts
new file mode 100644
index 000000000..45607c86b
--- /dev/null
+++ b/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermDefinition/TermDefinition.styles.ts
@@ -0,0 +1,17 @@
+import styled from 'styled-components';
+
+export const Tooltip = styled('div')(({ theme }) => ({
+  fontSize: '14px',
+  padding: theme.spacing(1),
+  maxWidth: '430px',
+  border: '1px solid',
+  borderRadius: '8px',
+  borderColor: theme.palette.border.primary,
+  boxShadow: theme.shadows[9],
+}));
+
+export const Definition = styled('div')(({ theme }) => ({
+  display: 'flex',
+  alignItems: 'center',
+  marginBottom: theme.spacing(1),
+}));
\ No newline at end of file
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermDefinition/TermDefinition.tsx b/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermDefinition/TermDefinition.tsx
new file mode 100644
index 000000000..c874d6cd9
--- /dev/null
+++ b/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermDefinition/TermDefinition.tsx
@@ -0,0 +1,53 @@
+import React, { type FC } from 'react';
+import { Box, Grid, Typography } from '@mui/material';
+import { WithPermissions } from 'components/shared/contexts';
+import type { TermRef } from 'generated-sources';
+import { Permission } from 'generated-sources';
+import { AppTooltip, Button, Markdown } from 'components/shared/elements';
+import { useTermWiki } from 'lib/hooks';
+import { updateDataSetFieldDescription } from 'redux/thunks';
+import { InformationIcon, StrokedInfoIcon } from 'components/shared/icons';
+import * as S from './TermDefinition.styles';
+
+interface TermDefinitionProps {
+  termId: number;
+  definition: string;
+  terms: TermRef[] | undefined;
+}
+
+const TermDefinition: FC<TermDefinitionProps> = ({ definition, termId, terms }) => {
+  const { error, internalDescription, transformDescriptionToMarkdown, editMode } =
+    useTermWiki({
+      terms,
+      description: definition,
+      entityId: termId,
+      updateDescription: updateDataSetFieldDescription,
+      isDatasetField: false,
+    });
+
+  const tooltipInfoContent = (
+    <S.Tooltip>
+      You can link an existing term by entering information about the term according to
+      the pattern [[NamespaceName:TermName]]
+      <br />
+      <br />
+      <b>Example: This entity describes [[Finance:User]]</b>
+    </S.Tooltip>
+  );
+
+  return (
+    <>
+      <S.Definition>
+        <Typography variant='h2' mr={1}>
+          Definition
+        </Typography>
+        <AppTooltip title={tooltipInfoContent} checkForOverflow={false}>
+          <InformationIcon width={14} height={14} />
+        </AppTooltip>
+      </S.Definition>
+      <Markdown value={transformDescriptionToMarkdown(definition)} />
+    </>
+  );
+};
+
+export default TermDefinition;
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermLinkedTerms/LinkedTermTermForm/LinkedTermTermForm.tsx b/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermLinkedTerms/LinkedTermTermForm/LinkedTermTermForm.tsx
new file mode 100644
index 000000000..5ebc519e6
--- /dev/null
+++ b/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermLinkedTerms/LinkedTermTermForm/LinkedTermTermForm.tsx
@@ -0,0 +1,49 @@
+import React, { type FC, useCallback } from 'react';
+import type { LinkedTerm } from 'generated-sources';
+import { useAddLinkedTermToTerm } from 'lib/hooks';
+import { AssignTermForm } from 'components/shared/elements';
+
+interface AssignLinkedTermTermFormProps {
+  openBtnEl: JSX.Element;
+  termId: number;
+  handleAddTerm: (linkedTerm: LinkedTerm) => void;
+}
+
+const LinkedTermTermForm: FC<AssignLinkedTermTermFormProps> = ({
+  openBtnEl,
+  termId,
+  handleAddTerm,
+}) => {
+  const {
+    isPending,
+    isSuccess,
+    mutateAsync: addTerm,
+  } = useAddLinkedTermToTerm({ termId });
+
+  const onSubmit = useCallback(
+    (clearState: () => void) =>
+      async ({ termId: linkedTermId }: { termId: number }) => {
+        const linkedTerm = await addTerm({
+          termId,
+          linkedTermFormData: {
+            linkedTermId,
+          },
+        });
+
+        handleAddTerm(linkedTerm);
+        clearState();
+      },
+    [addTerm, handleAddTerm]
+  );
+
+  return (
+    <AssignTermForm
+      onSubmit={onSubmit}
+      openBtnEl={openBtnEl}
+      handleCloseSubmittedForm={isSuccess}
+      isLoading={isPending}
+    />
+  );
+};
+
+export default LinkedTermTermForm;
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermLinkedTerms/TermItem/TermItem.tsx b/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermLinkedTerms/TermItem/TermItem.tsx
new file mode 100644
index 000000000..f1241942b
--- /dev/null
+++ b/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermLinkedTerms/TermItem/TermItem.tsx
@@ -0,0 +1,78 @@
+import React, { type FC, useCallback } from 'react';
+import { Box, Typography } from '@mui/material';
+import { Permission, type TermRef } from 'generated-sources';
+import { WithPermissions } from 'components/shared/contexts';
+import {
+  Button,
+  CollapsibleInfoContainer,
+  InfoItem,
+  Markdown,
+} from 'components/shared/elements';
+import { DeleteIcon, LinkedTermIcon } from 'components/shared/icons';
+import { useDeleteLinkedTermToTerm } from 'lib/hooks';
+import { termDetailsPath } from 'routes';
+import { Link } from 'react-router-dom';
+
+interface TermItemProps {
+  name: TermRef['name'];
+  definition: TermRef['definition'];
+  linkedTermId: TermRef['id'];
+  termId: number;
+  isDescriptionLink: boolean;
+  removeTerm: (linkedTermId: number) => void;
+}
+
+const TermItem: FC<TermItemProps> = ({
+  name,
+  definition,
+  linkedTermId,
+  termId,
+  removeTerm,
+  isDescriptionLink,
+}) => {
+  const { mutateAsync: deleteTerm } = useDeleteLinkedTermToTerm({ termId });
+
+  const termDetailsLink = termDetailsPath(linkedTermId, 'overview');
+
+  const handleDelete = useCallback(
+    (e: React.MouseEvent) => {
+      e.preventDefault();
+      removeTerm(linkedTermId);
+    },
+    [deleteTerm, linkedTermId, removeTerm]
+  );
+
+  return (
+    <InfoItem
+      sx={{ width: '100%' }}
+      label={
+        <Box p={0.75} display='flex' flexWrap='nowrap' alignItems='center' gap={0.5}>
+          <Link to={termDetailsLink}>
+            <Typography color='button.link.normal.color'>{name}</Typography>
+          </Link>
+          {isDescriptionLink && <LinkedTermIcon />}
+        </Box>
+      }
+      info={
+        <CollapsibleInfoContainer
+          style={{ width: '100%' }}
+          content={<Markdown value={definition} />}
+          actions={
+            !isDescriptionLink ? (
+              <WithPermissions permissionTo={Permission.TERM_UPDATE}>
+                <Button
+                  sx={{ mt: 0.25 }}
+                  buttonType='link-m'
+                  icon={<DeleteIcon />}
+                  onClick={handleDelete}
+                />
+              </WithPermissions>
+            ) : undefined
+          }
+        />
+      }
+    />
+  );
+};
+
+export default TermItem;
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermLinkedTerms/TermLinkedTerms.tsx b/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermLinkedTerms/TermLinkedTerms.tsx
new file mode 100644
index 000000000..d664d1317
--- /dev/null
+++ b/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermLinkedTerms/TermLinkedTerms.tsx
@@ -0,0 +1,101 @@
+import React, { type FC, useCallback } from 'react';
+import { Grid, Typography } from '@mui/material';
+import { useTranslation } from 'react-i18next';
+import { Button } from 'components/shared/elements';
+import { WithPermissions } from 'components/shared/contexts';
+import type { LinkedTerm } from 'generated-sources';
+import { Permission } from 'generated-sources';
+import { useAddLinkedTermToTerm, useDeleteLinkedTermToTerm } from 'lib/hooks';
+import * as S from '../TermOverview.styles';
+import TermItem from './TermItem/TermItem';
+import LinkedTermTermForm from './LinkedTermTermForm/LinkedTermTermForm';
+
+interface LinkedTermTermsProps {
+  linkedTerms: LinkedTerm[];
+  termId: number;
+}
+
+const TermLinkedTerms: FC<LinkedTermTermsProps> = ({ linkedTerms, termId }) => {
+  const { t } = useTranslation();
+
+  const { mutateAsync: addTermMutation } = useAddLinkedTermToTerm({ termId });
+  const { mutateAsync: deleteTermMutation } = useDeleteLinkedTermToTerm({ termId });
+
+  const handleAddTerm = useCallback(
+    async (linkedTerm: LinkedTerm) => {
+      await addTermMutation({
+        termId,
+        linkedTermFormData: {
+          linkedTermId: linkedTerm.term.id,
+        },
+      });
+    },
+    [termId]
+  );
+
+  const removeTerm = useCallback(
+    async (linkedTermId: number) => {
+      await deleteTermMutation({
+        termId,
+        linkedTermId,
+      });
+    },
+    [termId]
+  );
+
+  const content = React.useMemo(
+    () =>
+      linkedTerms && linkedTerms.length > 0 ? (
+        <Grid container mt={1}>
+          {linkedTerms.map(({ term, isDescriptionLink }) => (
+            <TermItem
+              key={term.id}
+              linkedTermId={term.id}
+              name={term.name}
+              definition={term.definition}
+              termId={termId}
+              removeTerm={removeTerm}
+              isDescriptionLink={isDescriptionLink}
+            />
+          ))}
+        </Grid>
+      ) : (
+        <Typography mt={1} variant='subtitle1'>
+          {t('Terms are not added yet')}
+        </Typography>
+      ),
+    [linkedTerms?.length, linkedTerms]
+  );
+
+  return (
+    <S.SectionContainer container>
+      <Grid container justifyContent='space-between'>
+        <Typography variant='h5' color='texts.hint'>
+          {t('TERMS')}
+        </Typography>
+        <WithPermissions
+          permissionTo={Permission.TERM_UPDATE}
+          renderContent={({ isAllowedTo: addTerm }) => (
+            <LinkedTermTermForm
+              termId={termId}
+              handleAddTerm={handleAddTerm}
+              openBtnEl={
+                <Button
+                  disabled={!addTerm}
+                  text={t('Add term')}
+                  buttonType='secondary-m'
+                  sx={{ mr: 1 }}
+                />
+              }
+            />
+          )}
+        />
+      </Grid>
+      <Grid container flexDirection='column' alignItems='flex-start'>
+        {content}
+      </Grid>
+    </S.SectionContainer>
+  );
+};
+
+export default TermLinkedTerms;
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermOverview.styles.ts b/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermOverview.styles.ts
new file mode 100644
index 000000000..285376ac9
--- /dev/null
+++ b/odd-platform-ui/src/components/Terms/TermDetails/Overview/TermOverview.styles.ts
@@ -0,0 +1,18 @@
+import styled from 'styled-components';
+import { Grid } from '@mui/material';
+
+export const Container = styled(Grid)(({ theme }) => ({
+  display: 'flex',
+  alignContent: 'flex-start',
+  height: 'calc(100vh - 251px)',
+  width: '100%',
+  overflowY: 'auto',
+  padding: theme.spacing(2),
+}));
+
+export const SectionContainer = styled(Grid)(({ theme }) => ({
+  flexDirection: 'column',
+  borderBottom: `1px solid ${theme.palette.divider}`,
+  marginTop: theme.spacing(2),
+  paddingBottom: theme.spacing(2),
+}));
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/TermDetailsRoutes/TermDetailsRoutes.tsx b/odd-platform-ui/src/components/Terms/TermDetails/TermDetailsRoutes/TermDetailsRoutes.tsx
index d5cc383b7..6cf0af2cb 100644
--- a/odd-platform-ui/src/components/Terms/TermDetails/TermDetailsRoutes/TermDetailsRoutes.tsx
+++ b/odd-platform-ui/src/components/Terms/TermDetails/TermDetailsRoutes/TermDetailsRoutes.tsx
@@ -10,6 +10,7 @@ const Overview = lazy(() => import('../Overview/Overview'));
 const LinkedEntitiesList = lazy(
   () => import('../TermLinkedEntitiesList/LinkedEntitiesList')
 );
+const LinkedTermsList = lazy(() => import('../TermLinkedTermsList/LinkedTermsList'));
 const LinkedColumnsList = lazy(
   () => import('../TermLinkedColumnsList/LinkedColumnsList')
 );
@@ -28,6 +29,7 @@ const TermDetailsRoutes: React.FC = () => {
         <Route path='overview' element={<Overview />} />
         <Route path='linked-entities' element={<LinkedEntitiesList />} />
         <Route path='linked-columns' element={<LinkedColumnsList />} />
+        <Route path='linked-terms' element={<LinkedTermsList />} />
         <Route
           path='query-examples'
           element={
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/TermDetailsTabs/TermDetailsTabs.tsx b/odd-platform-ui/src/components/Terms/TermDetails/TermDetailsTabs/TermDetailsTabs.tsx
index ade380662..822c3e3c0 100644
--- a/odd-platform-ui/src/components/Terms/TermDetails/TermDetailsTabs/TermDetailsTabs.tsx
+++ b/odd-platform-ui/src/components/Terms/TermDetails/TermDetailsTabs/TermDetailsTabs.tsx
@@ -29,6 +29,12 @@ const TermDetailsTabs: React.FC = () => {
         hint: termDetails?.columnsUsingCount,
         hidden: !termDetails?.columnsUsingCount,
       },
+      {
+        name: 'Linked terms',
+        link: termDetailsPath(termId, 'linked-terms'),
+        hint: termDetails?.linkedTermsUsingCount,
+        hidden: !termDetails?.linkedTermsUsingCount,
+      },
       {
         name: 'Query examples',
         link: termDetailsPath(termId, 'query-examples'),
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTerm/LinkedTerm.tsx b/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTerm/LinkedTerm.tsx
new file mode 100644
index 000000000..ca3859050
--- /dev/null
+++ b/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTerm/LinkedTerm.tsx
@@ -0,0 +1,43 @@
+import React from 'react';
+import { Box, Typography } from '@mui/material';
+import type { LinkedTerm } from 'generated-sources';
+import { termDetailsPath } from 'routes';
+import { TermLinkedTermsColContainer } from '../LinkedTermsListStyles';
+import { Container, EntityLink, NameContainer } from './LinkedTermStyles';
+
+interface LinkedTermProps {
+  linkedTerm: LinkedTerm;
+}
+
+const LinkedTermView: React.FC<LinkedTermProps> = ({ linkedTerm }) => {
+  const detailsLink = termDetailsPath(linkedTerm.term.id);
+
+  return (
+    <EntityLink to={detailsLink}>
+      <Container container>
+        <TermLinkedTermsColContainer
+          $colType='colmd'
+          item
+          container
+          justifyContent='space-between'
+          wrap='nowrap'
+        >
+          <NameContainer container item>
+            <Box display='flex' flexWrap='nowrap' alignItems='center' overflow='hidden'>
+              <Typography ml={0.5} variant='body1' noWrap title={linkedTerm.term.name}>
+                {linkedTerm.term.name}
+              </Typography>
+            </Box>
+          </NameContainer>
+        </TermLinkedTermsColContainer>
+        <TermLinkedTermsColContainer item $colType='collg'>
+          <Typography variant='body1' title={linkedTerm.term.namespace?.name} noWrap>
+            {linkedTerm.term.namespace?.name}
+          </Typography>
+        </TermLinkedTermsColContainer>
+      </Container>
+    </EntityLink>
+  );
+};
+
+export default LinkedTermView;
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTerm/LinkedTermStyles.ts b/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTerm/LinkedTermStyles.ts
new file mode 100644
index 000000000..d6d8f8206
--- /dev/null
+++ b/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTerm/LinkedTermStyles.ts
@@ -0,0 +1,31 @@
+import type { GridProps } from '@mui/material';
+import { Grid } from '@mui/material';
+import styled from 'styled-components';
+import { Link } from 'react-router-dom';
+import { colWidthStyles } from '../LinkedTermsListSkeleton/LinkedTermsListSkeletonStyles';
+
+export const Container = styled(Grid)(({ theme }) => ({
+  borderBottom: '1px solid',
+  borderBottomColor: theme.palette.divider,
+  padding: theme.spacing(1.25, 0),
+  textDecoration: 'none',
+  cursor: 'pointer',
+  alignItems: 'center',
+  '&:hover': {
+    backgroundColor: theme.palette.backgrounds.primary,
+  },
+}));
+
+export const EntityLink = styled(Link)(() => ({
+  color: 'initial',
+  textDecoration: 'none',
+  flexGrow: 1,
+  overflow: 'hidden',
+}));
+
+export const NameContainer = styled(Grid)<GridProps>(() => ({
+  ...colWidthStyles.col,
+  padding: 0,
+  justifyContent: 'flex-start',
+  flexWrap: 'nowrap',
+}));
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsList.tsx b/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsList.tsx
new file mode 100644
index 000000000..e5e862de2
--- /dev/null
+++ b/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsList.tsx
@@ -0,0 +1,100 @@
+import React, { type FC, useState } from 'react';
+import { Grid, Typography } from '@mui/material';
+import InfiniteScroll from 'react-infinite-scroll-component';
+import { AppErrorPage, EmptyContentPlaceholder, Input } from 'components/shared/elements';
+import { useTermsRouteParams } from 'routes';
+import { useGetTermLinkedTerms } from 'lib/hooks';
+import LinkedTerm from './LinkedTerm/LinkedTerm';
+import {
+  TermLinkedTermsColContainer,
+  TermLinkedTermsListContainer,
+  TermLinkedTermsResultsTableHeader,
+} from './LinkedTermsListStyles';
+import LinkedTermsListSkeleton from './LinkedTermsListSkeleton/LinkedTermsListSkeleton';
+
+const LinkedTermsList: FC = () => {
+  const { termId } = useTermsRouteParams();
+
+  const [query, setQuery] = useState('');
+
+  const {
+    data: termLinks,
+    isLoading: isLinkedListFetching,
+    isFetched: isLinkedListFetched,
+    fetchNextPage,
+    refetch,
+    hasNextPage,
+    error,
+  } = useGetTermLinkedTerms({
+    termId,
+    size: 50,
+    query,
+  });
+  const termLinkedList = termLinks?.pages.flatMap(list => list.items);
+  const total = termLinks?.pages[0].pageInfo.total;
+
+  return (
+    <Grid>
+      <Grid container flexWrap='nowrap' justifyContent='flex-start' sx={{ mt: 2 }}>
+        <Grid item xs={3} sx={{ mr: 1 }}>
+          <Input
+            variant='search-m'
+            placeholder='Search'
+            maxWidth={640}
+            onChange={e => {
+              setQuery(e.target.value);
+            }}
+            value={query}
+            handleSearchClick={() => refetch()}
+          />
+        </Grid>
+      </Grid>
+      <TermLinkedTermsResultsTableHeader container sx={{ mt: 2 }} wrap='nowrap'>
+        <TermLinkedTermsColContainer item $colType='colmd'>
+          <Typography variant='caption'>Name</Typography>
+        </TermLinkedTermsColContainer>
+        <TermLinkedTermsColContainer item $colType='collg'>
+          <Typography variant='caption'>Namespace</Typography>
+        </TermLinkedTermsColContainer>
+      </TermLinkedTermsResultsTableHeader>
+      {isLinkedListFetching && <LinkedTermsListSkeleton />}
+      <TermLinkedTermsListContainer
+        $isListEmpty={!total || !isLinkedListFetched}
+        id='term-linked-entities-list'
+      >
+        {termLinkedList && (
+          <InfiniteScroll
+            dataLength={termLinkedList?.length}
+            next={fetchNextPage}
+            hasMore={hasNextPage}
+            loader={isLinkedListFetching && <LinkedTermsListSkeleton />}
+            scrollThreshold='200px'
+            scrollableTarget='term-linked-entities-list'
+          >
+            {termLinkedList?.map(linkedItem => (
+              <LinkedTerm key={linkedItem.term.id} linkedTerm={linkedItem} />
+            ))}
+          </InfiniteScroll>
+        )}
+      </TermLinkedTermsListContainer>
+      <EmptyContentPlaceholder
+        text='No linked entities'
+        isContentLoaded={isLinkedListFetched}
+        isContentEmpty={!total}
+      />
+      <AppErrorPage
+        showError={!isLinkedListFetched}
+        // FIXME
+        error={{
+          status: 500,
+          statusText: error?.message ?? 'Unknown Error',
+          url: query,
+          message: error?.message ?? 'Unknown Error',
+        }}
+        offsetTop={194}
+      />
+    </Grid>
+  );
+};
+
+export default LinkedTermsList;
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsListSkeleton/LinkedTermsListSkeleton.tsx b/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsListSkeleton/LinkedTermsListSkeleton.tsx
new file mode 100644
index 000000000..e8dc8fe82
--- /dev/null
+++ b/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsListSkeleton/LinkedTermsListSkeleton.tsx
@@ -0,0 +1,23 @@
+import React from 'react';
+import Skeleton from '@mui/material/Skeleton';
+import { Grid } from '@mui/material';
+import { mainSkeletonHeight } from 'lib/constants';
+import { SkeletonWrapper } from 'components/shared/elements';
+import { ColContainer } from 'components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsListSkeleton/LinkedTermsListSkeletonStyles';
+
+const LinkedTermsListSkeleton: React.FC = () => (
+  <SkeletonWrapper
+    length={10}
+    renderContent={({ randWidth, key }) => (
+      <Grid container sx={{ py: 1.25 }} key={key} wrap='nowrap'>
+        <ColContainer item $colType='colmd'>
+          <Skeleton width={randWidth()} height={mainSkeletonHeight} />
+        </ColContainer>
+        <ColContainer item $colType='collg'>
+          <Skeleton width={randWidth()} height={mainSkeletonHeight} />
+        </ColContainer>
+      </Grid>
+    )}
+  />
+);
+export default LinkedTermsListSkeleton;
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsListSkeleton/LinkedTermsListSkeletonStyles.ts b/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsListSkeleton/LinkedTermsListSkeletonStyles.ts
new file mode 100644
index 000000000..8b9ffcb1d
--- /dev/null
+++ b/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsListSkeleton/LinkedTermsListSkeletonStyles.ts
@@ -0,0 +1,22 @@
+import styled from 'styled-components';
+import { Grid } from '@mui/material';
+
+export type ColType = 'col' | 'colxs' | 'colsm' | 'colmd' | 'collg';
+export const colWidthStyles = {
+  colxs: { flex: '2 0 6%' },
+  colsm: { flex: '2 0 7%' },
+  colmd: { flex: '3 0 9%' },
+  collg: { flex: '4 0 12%' },
+  col: {
+    display: 'flex',
+    alignItems: 'center',
+    overflow: 'hidden',
+    paddingRight: '8px',
+    paddingLeft: '8px',
+    '&:last-of-type': { paddingRight: 0 },
+  },
+};
+
+export const ColContainer = styled(Grid)<{
+  $colType: ColType;
+}>(({ $colType }) => ({ ...colWidthStyles.col, ...colWidthStyles[$colType] }));
diff --git a/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsListStyles.ts b/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsListStyles.ts
new file mode 100644
index 000000000..5940b548e
--- /dev/null
+++ b/odd-platform-ui/src/components/Terms/TermDetails/TermLinkedTermsList/LinkedTermsListStyles.ts
@@ -0,0 +1,30 @@
+import { Grid } from '@mui/material';
+import styled from 'styled-components';
+import { primaryTabsHeight, tabsContainerMargin, toolbarHeight } from 'lib/constants';
+import type { TermSearchResultsColType } from 'components/Terms/TermSearch/TermSearchResults/TermSearchResultsStyles';
+import { termSearchResultsColWidthStyles } from 'components/Terms/TermSearch/TermSearchResults/TermSearchResultsStyles';
+
+const itemHeight = 40;
+
+export const TermLinkedTermsResultsTableHeader = styled(Grid)(({ theme }) => ({
+  borderBottom: '1px solid',
+  borderBottomColor: theme.palette.divider,
+}));
+
+export const TermLinkedTermsColContainer = styled(Grid)<{
+  $colType: TermSearchResultsColType;
+}>(({ $colType }) => ({
+  ...termSearchResultsColWidthStyles.col,
+  ...termSearchResultsColWidthStyles[$colType],
+}));
+
+export const TermLinkedTermsListContainer = styled(Grid)<{ $isListEmpty: boolean }>(
+  ({ theme, $isListEmpty }) => ({
+    height: $isListEmpty
+      ? 'auto'
+      : `calc(100vh - ${toolbarHeight}px - ${itemHeight}px - ${primaryTabsHeight}px - ${tabsContainerMargin}px - ${theme.spacing(
+          13.25
+        )})`,
+    overflow: 'auto',
+  })
+);
diff --git a/odd-platform-ui/src/components/Terms/TermSearch/TermForm/TermsForm.tsx b/odd-platform-ui/src/components/Terms/TermSearch/TermForm/TermsForm.tsx
index 9860a4743..e8ee7bf44 100644
--- a/odd-platform-ui/src/components/Terms/TermSearch/TermForm/TermsForm.tsx
+++ b/odd-platform-ui/src/components/Terms/TermSearch/TermForm/TermsForm.tsx
@@ -19,6 +19,7 @@ import {
   getTermUpdatingStatuses,
 } from 'redux/selectors';
 import { termDetailsPath, useTermsRouteParams } from 'routes';
+import { useQueryClient } from '@tanstack/react-query';
 
 interface TermsFormDialogProps {
   btnCreateEl: JSX.Element;
@@ -26,6 +27,7 @@ interface TermsFormDialogProps {
 
 const TermsForm: FC<TermsFormDialogProps> = ({ btnCreateEl }) => {
   const { t } = useTranslation();
+  const queryClient = useQueryClient();
   const dispatch = useAppDispatch();
   const navigate = useNavigate();
   const { termId } = useTermsRouteParams();
@@ -68,7 +70,10 @@ const TermsForm: FC<TermsFormDialogProps> = ({ btnCreateEl }) => {
       : dispatch(createTerm({ termFormData: parsedData }))
     )
       .unwrap()
-      .then((response: TermDetails) => {
+      .then(async (response: TermDetails) => {
+        await queryClient.invalidateQueries({
+          queryKey: ['term', termId],
+        });
         clearState();
         navigate(termDetailsPath(response.id));
       });
diff --git a/odd-platform-ui/src/components/Terms/TermSearch/TermSearchResults/TermSearchResultItem/TermSearchResultItem.tsx b/odd-platform-ui/src/components/Terms/TermSearch/TermSearchResults/TermSearchResultItem/TermSearchResultItem.tsx
index e01364c11..aa7e3271d 100644
--- a/odd-platform-ui/src/components/Terms/TermSearch/TermSearchResults/TermSearchResultItem/TermSearchResultItem.tsx
+++ b/odd-platform-ui/src/components/Terms/TermSearch/TermSearchResults/TermSearchResultItem/TermSearchResultItem.tsx
@@ -19,7 +19,8 @@ const TermSearchResultItem: React.FC<TermsResultItemProps> = ({ termSearchResult
   const termDetailsOverviewLink = termDetailsPath(termSearchResult.id);
   const usingCount =
     (termSearchResult.entitiesUsingCount ?? 0) +
-    (termSearchResult.columnsUsingCount ?? 0);
+    (termSearchResult.columnsUsingCount ?? 0) +
+    (termSearchResult.linkedTermsUsingCount ?? 0);
 
   return (
     <S.TermSearchResultsItemLink to={termDetailsOverviewLink}>
diff --git a/odd-platform-ui/src/lib/hooks/api/terms.ts b/odd-platform-ui/src/lib/hooks/api/terms.ts
index cc228d998..fa6ffbbf5 100644
--- a/odd-platform-ui/src/lib/hooks/api/terms.ts
+++ b/odd-platform-ui/src/lib/hooks/api/terms.ts
@@ -1,14 +1,20 @@
 import {
+  useInfiniteQuery,
   useMutation,
   useQuery,
   useQueryClient,
 } from '@tanstack/react-query';
 import { termApi } from 'lib/api';
 import type {
+  PageInfo,
   TermApiGetTermByNamespaceAndNameRequest,
+  TermApiGetTermDetailsRequest,
   TermApiGetTermLinkedColumnsRequest,
+  TermApiGetTermLinkedTermsRequest,
   TermApiCreateQueryExampleToTermRelationshipRequest,
   TermApiDeleteQueryExampleToTermRelationshipRequest,
+  TermApiDeleteLinkedTermFromTermRequest,
+  TermApiAddLinkedTermToTermRequest,
 } from 'generated-sources';
 import { showSuccessToast, type AppError } from 'lib/errorHandling';
 
@@ -36,6 +42,56 @@ export function useGetTermLinkedColumns(params: TermApiGetTermLinkedColumnsReque
   });
 }
 
+export function useGetTermByID(params: TermApiGetTermDetailsRequest) {
+  return useQuery({
+    queryKey: ['term', params.termId],
+    queryFn: () => termApi.getTermDetails(params),
+  });
+}
+
+type ResponseWithPageInfo = {
+  items: Array<unknown>;
+  pageInfo: PageInfo & { nextPage?: number };
+};
+
+function addNextPage<R extends ResponseWithPageInfo>(
+  response: R,
+  pageParam: number,
+  size: number
+) {
+  const hasNext = size === response.pageInfo.total;
+  const nextPage = hasNext ? pageParam + 1 : undefined;
+
+  return {
+    ...response,
+    pageInfo: {
+      ...response.pageInfo,
+      nextPage,
+      hasNext,
+    },
+  };
+}
+
+export function useGetTermLinkedTerms(
+  params: Omit<TermApiGetTermLinkedTermsRequest, 'page'>
+) {
+  return useInfiniteQuery({
+    queryKey: ['termLinkedTerms', params.termId, params.size, params.query],
+    queryFn: async ({ pageParam }) => {
+      const response = await termApi.getTermLinkedTerms({
+        page: pageParam,
+        size: params.size,
+        termId: params.termId,
+        query: params.query,
+      });
+      // this is retarded, but we need to add the next page to the response manually
+      return addNextPage(response, pageParam, params.size);
+    },
+    initialPageParam: 1,
+    getNextPageParam: lastPage => lastPage.pageInfo.nextPage,
+  });
+}
+
 export function useAssignTermQueryExample(termId: number) {
   const queryClient = useQueryClient();
 
@@ -77,3 +133,39 @@ export function useUnassignTermQueryExample() {
     },
   });
 }
+
+export function useAddLinkedTermToTerm({ termId }: { termId: number }) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({
+      termId: termIdParam,
+      linkedTermFormData,
+    }: TermApiAddLinkedTermToTermRequest) =>
+      termApi.addLinkedTermToTerm({
+        termId: termIdParam, // target
+        linkedTermFormData, // assigned term
+      }),
+    onSuccess: async () => {
+      showSuccessToast({ message: 'Term successfully added!' });
+      await queryClient.invalidateQueries({
+        queryKey: ['term', termId],
+      });
+    },
+  });
+}
+
+export function useDeleteLinkedTermToTerm({ termId }: { termId: number }) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (params: TermApiDeleteLinkedTermFromTermRequest) => {
+      await termApi.deleteLinkedTermFromTerm(params);
+      return params.linkedTermId;
+    },
+    onSuccess: async () => {
+      showSuccessToast({ message: 'Term successfully deleted!' });
+      await queryClient.invalidateQueries({
+        queryKey: ['term', termId],
+      });
+    },
+  });
+}
diff --git a/odd-platform-ui/src/routes/termsRoutes.ts b/odd-platform-ui/src/routes/termsRoutes.ts
index 433b5c525..b5eb7e429 100644
--- a/odd-platform-ui/src/routes/termsRoutes.ts
+++ b/odd-platform-ui/src/routes/termsRoutes.ts
@@ -26,6 +26,7 @@ const TermDetailsRoutes = {
   OVERVIEW: 'overview',
   LINKED_ENTITIES: 'linked-entities',
   LINKED_COLUMNS: 'linked-columns',
+  LINKED_TERMS: 'linked-terms',
   QUERY_EXAMPLES: 'query-examples',
 } as const;