diff --git a/models/task/src/index.ts b/models/task/src/index.ts
index 288c95d57ff..266f1e1f43c 100644
--- a/models/task/src/index.ts
+++ b/models/task/src/index.ts
@@ -210,6 +210,9 @@ export class TTaskType extends TDoc implements TaskType {
   @Prop(ArrOf(TypeRef(task.class.TaskType)), getEmbeddedLabel('Parent'))
     allowedAsChildOf!: Ref<TaskType>[] // In case of specified, task type is for sub-tasks
 
+  @Prop(TypeRef(core.class.Mixin), getEmbeddedLabel('Base Mixin'))
+    baseMixin?: Ref<Mixin<Task>> // Existing mixin to inherit attributes from
+
   @Prop(TypeRef(core.class.Class), getEmbeddedLabel('Task class'))
     ofClass!: Ref<Class<Task>> // Base class for task
 
diff --git a/plugins/task-assets/lang/en.json b/plugins/task-assets/lang/en.json
index 3c9edeb61cb..8b345751cef 100644
--- a/plugins/task-assets/lang/en.json
+++ b/plugins/task-assets/lang/en.json
@@ -79,6 +79,14 @@
     "StatusChange": "Status changed",
     "TaskCreated": "Task created",
     "TaskType": "Task type",
+    "BaseMixin": "Inherit from",
+    "BaseMixinDescription": "Inherit attributes from an existing task type",
+    "NoBaseMixin": "None (create new)",
+    "CreateNew": "Create new",
+    "CloneExisting": "Clone existing",
+    "CloneTaskTypes": "Clone",
+    "SelectTaskTypesToClone": "Select task types to clone",
+    "NoTaskTypesAvailable": "No task types available to clone",
     "ManageProjects": "Project types",
     "Export": "Export",
     "CreateProjectType": "Create project type",
diff --git a/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte b/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte
new file mode 100644
index 00000000000..209ec822f29
--- /dev/null
+++ b/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte
@@ -0,0 +1,145 @@
+<script lang="ts">
+  import { Class, Mixin, Ref, SortingOrder } from '@hcengineering/core'
+  import task, { Task, TaskType } from '@hcengineering/task'
+  import { ButtonMenu, Label } from '@hcengineering/ui'
+  import { createEventDispatcher } from 'svelte'
+  import { createQuery, getClient } from '@hcengineering/presentation'
+  import plugin from '../../plugin'
+
+  export let baseClass: Ref<Class<Task>>
+  export let value: Ref<Mixin<Task>> | undefined = undefined
+  export let readonly = false
+  export let buttonKind: 'primary' | 'secondary' | 'tertiary' | 'negative' = 'secondary'
+  export let buttonSize: 'large' | 'medium' | 'small' = 'large'
+
+  const dispatch = createEventDispatcher()
+  const client = getClient()
+  const hierarchy = client.getHierarchy()
+
+  interface MixinItem {
+    id: string
+    label: string
+    targetClass: Ref<Mixin<Task>>
+    parentMixin: Ref<Mixin<Task>> | undefined
+  }
+
+  let allTaskTypes: TaskType[] = []
+
+  // Query all TaskTypes to get their names and targetClass mixins
+  const taskTypeQuery = createQuery()
+  $: {
+    const compatibleClasses = hierarchy.getDescendants(baseClass)
+    taskTypeQuery.query(
+      task.class.TaskType,
+      { ofClass: { $in: compatibleClasses } },
+      (res) => {
+        allTaskTypes = res
+      },
+      { sort: { name: SortingOrder.Ascending } }
+    )
+  }
+
+  // Build hierarchical items from TaskTypes using recursive tree structure
+  function buildItems (taskTypes: TaskType[]): MixinItem[] {
+    const result: MixinItem[] = []
+
+    // Create a map of targetClass -> TaskType for lookup
+    const targetClassToTaskType = new Map<string, TaskType>()
+    for (const tt of taskTypes) {
+      targetClassToTaskType.set(tt.targetClass as string, tt)
+    }
+
+    // Find children of a given targetClass
+    function getChildren (parentTargetClass: Ref<Mixin<Task>> | undefined): TaskType[] {
+      return taskTypes.filter((tt) => tt.baseMixin === parentTargetClass)
+    }
+
+    // Get root TaskTypes (those without baseMixin or with baseMixin not in our set)
+    function getRoots (): TaskType[] {
+      return taskTypes.filter((tt) => {
+        if (tt.baseMixin === undefined) return true
+        return !targetClassToTaskType.has(tt.baseMixin as string)
+      })
+    }
+
+    // Recursively add items with proper indentation
+    function addItems (parent: Ref<Mixin<Task>> | undefined, level: number, prefix: string): void {
+      const children = parent === undefined ? getRoots() : getChildren(parent)
+
+      for (let i = 0; i < children.length; i++) {
+        const tt = children[i]
+        const isLast = i === children.length - 1
+        const connector = level === 0 ? '' : (isLast ? '└─ ' : '├─ ')
+        const nextPrefix = level === 0 ? '' : (isLast ? '   ' : '│  ')
+
+        result.push({
+          id: tt.targetClass as string,
+          label: prefix + connector + tt.name,
+          targetClass: tt.targetClass,
+          parentMixin: tt.baseMixin
+        })
+
+        addItems(tt.targetClass, level + 1, prefix + nextPrefix)
+      }
+    }
+
+    addItems(undefined, 0, '')
+    return result
+  }
+
+  $: mixinItems = buildItems(allTaskTypes)
+
+  // Build items for ButtonMenu
+  $: items = [
+    { id: '', label: 'None (create new)' },
+    ...mixinItems.map((m) => ({
+      id: m.id,
+      label: m.label
+    }))
+  ]
+
+  $: selected = items.find((it) => it.id === (value ?? ''))
+
+  function handleSelect (evt: CustomEvent<string>): void {
+    if (evt.detail !== undefined) {
+      value = evt.detail === '' ? undefined : (evt.detail as Ref<Mixin<Task>>)
+      dispatch('change', value)
+    }
+  }
+</script>
+
+<div class="mixin-selector">
+  <span class="label">
+    <Label label={plugin.string.BaseMixin} />
+  </span>
+  {#if readonly}
+    {#if selected}
+      <span class="selected-value">{selected.label}</span>
+    {/if}
+  {:else}
+    <ButtonMenu
+      selected={value ?? ''}
+      {items}
+      label={selected?.label ?? plugin.string.NoBaseMixin}
+      kind={buttonKind}
+      size={buttonSize}
+      on:selected={handleSelect}
+    />
+  {/if}
+</div>
+
+<style lang="scss">
+  .mixin-selector {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .selected-value {
+    color: var(--theme-content-color);
+  }
+
+  .label {
+    color: var(--theme-halfcontent-color);
+  }
+</style>
diff --git a/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte b/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte
index 9d7dfa4844c..5289cc42bfe 100644
--- a/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte
+++ b/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte
@@ -25,9 +25,11 @@
     createState,
     findStatusAttr
   } from '@hcengineering/task'
-  import { DropdownIntlItem, Modal, ModernEditbox, Label, ButtonMenu } from '@hcengineering/ui'
+  import { DropdownIntlItem, Modal, ModernEditbox, Label, ButtonMenu, Toggle } from '@hcengineering/ui'
   import task from '../../plugin'
   import TaskTypeKindEditor from './TaskTypeKindEditor.svelte'
+  import ClassMixinSelector from './ClassMixinSelector.svelte'
+  import LinkTaskTypeSelector from './LinkTaskTypeSelector.svelte'
   import { clearSettingsStore } from '@hcengineering/setting-resources'
 
   const client = getClient()
@@ -68,6 +70,12 @@
   let { kind, name, targetClass, statusCategories, statuses, allowedAsChildOf } =
     taskType !== undefined ? { ...taskType } : { ...defaultTaskType(type) }
 
+  let baseMixin = taskType?.baseMixin
+
+  // Mode: 'create' for new TaskType, 'clone' for cloning existing
+  let mode: 'create' | 'clone' = 'create'
+  let selectedTaskTypesToClone: Ref<TaskType>[] = []
+
   function findStatusClass (_class: Ref<Class<Task>>): Ref<Class<Status>> | undefined {
     const h = getClient().getHierarchy()
     const attrs = h.getAllAttributes(_class)
@@ -83,6 +91,12 @@
   async function save (): Promise<void> {
     if (type === undefined) return
 
+    // Clone mode: clone selected TaskTypes
+    if (mode === 'clone') {
+      await cloneSelectedTaskTypes()
+      return
+    }
+
     const descr = taskTypeDescriptors.find((it) => it._id === taskTypeDescriptor._id)
     if (descr === undefined) return
 
@@ -98,7 +112,8 @@
       allowedAsChildOf,
       statusClass: findStatusClass(ofClass) ?? core.class.Status,
       parent: type._id,
-      icon: descr.icon
+      icon: descr.icon,
+      baseMixin
     }
 
     if (taskType === undefined && descr.statusCategoriesFunc !== undefined) {
@@ -136,8 +151,10 @@
     } else {
       const ofClassClass = client.getHierarchy().getClass(ofClass)
       // Create target class for custom field.
+      // Use baseMixin if provided, otherwise use ofClass
+      const extendsClass = baseMixin ?? ofClass
       _taskType.targetClass = await client.createDoc(core.class.Class, core.space.Model, {
-        extends: ofClass,
+        extends: extendsClass,
         kind: ClassifierKind.MIXIN,
         label: getEmbeddedLabel(name),
         icon: ofClassClass.icon
@@ -158,49 +175,158 @@
     icon: it.icon,
     label: it.name
   }))
+
+  async function cloneSelectedTaskTypes (): Promise<void> {
+    if (selectedTaskTypesToClone.length === 0) return
+
+    // Fetch the selected TaskTypes
+    const sourceTaskTypes = await client.findAll(task.class.TaskType, {
+      _id: { $in: selectedTaskTypesToClone }
+    })
+
+    for (const source of sourceTaskTypes) {
+      const newTaskTypeId: Ref<TaskType> = generateId()
+
+      // Create new targetClass (mixin) that extends the source's targetClass
+      const sourceClass = client.getHierarchy().getClass(source.ofClass)
+      const newTargetClass = await client.createDoc(core.class.Class, core.space.Model, {
+        extends: source.targetClass, // Inherit from source's mixin
+        kind: ClassifierKind.MIXIN,
+        label: getEmbeddedLabel(source.name),
+        icon: sourceClass.icon
+      })
+
+      // Clone statuses for this TaskType
+      const clonedStatuses: Ref<Status>[] = []
+      const statusAttr = findStatusAttr(client.getHierarchy(), source.ofClass) ??
+        client.getHierarchy().getAttribute(task.class.Task, 'status')
+
+      for (const statusId of source.statuses) {
+        const originalStatus = await client.findOne(core.class.Status, { _id: statusId })
+        if (originalStatus !== undefined) {
+          const newStatus = await createState(client, source.statusClass, {
+            name: originalStatus.name,
+            ofAttribute: statusAttr._id,
+            category: originalStatus.category
+          })
+          clonedStatuses.push(newStatus)
+
+          // Add to ProjectType statuses
+          if (type.statuses.find((it) => it._id === newStatus) === undefined) {
+            await client.update(type, {
+              $push: { statuses: { _id: newStatus, taskType: newTaskTypeId } }
+            })
+          }
+        }
+      }
+
+      // Create the cloned TaskType
+      const clonedTaskType: Data<TaskType> = {
+        name: source.name,
+        kind: source.kind,
+        parent: type._id,
+        descriptor: source.descriptor,
+        ofClass: source.ofClass,
+        targetClass: newTargetClass,
+        statusCategories: source.statusCategories,
+        statuses: clonedStatuses,
+        statusClass: source.statusClass,
+        allowedAsChildOf: source.allowedAsChildOf,
+        baseMixin: source.targetClass, // Point to source's targetClass for inheritance
+        icon: source.icon,
+        color: source.color
+      }
+
+      await client.createDoc(task.class.TaskType, core.space.Model, clonedTaskType, newTaskTypeId)
+
+      // Add to ProjectType tasks array
+      if (!type.tasks.includes(newTaskTypeId)) {
+        await client.update(type, { $push: { tasks: newTaskTypeId } })
+      }
+    }
+
+    clearSettingsStore()
+  }
+
+  $: canSave = mode === 'create' ? name.trim().length > 0 : selectedTaskTypesToClone.length > 0
 </script>
 
 <Modal
   label={task.string.TaskType}
   type={'type-aside'}
   okAction={save}
-  canSave
-  okLabel={taskType !== undefined ? presentation.string.Save : presentation.string.Create}
+  canSave={canSave}
+  okLabel={mode === 'clone' ? task.string.CloneTaskTypes : (taskType !== undefined ? presentation.string.Save : presentation.string.Create)}
   on:changeContent
   onCancel={() => {
     clearSettingsStore()
   }}
 >
-  <div class="hulyModal-content__titleGroup">
-    <ModernEditbox bind:value={name} label={task.string.TaskName} size={'large'} kind={'ghost'} autoFocus />
-  </div>
-  <div class="hulyModal-content__settingsSet">
-    <div class="hulyModal-content__settingsSet-line">
-      <span class="label">
-        <Label label={task.string.TaskType} />
-      </span>
-      <TaskTypeKindEditor bind:kind />
+  <!-- Mode Toggle -->
+  {#if taskType === undefined}
+    <div class="hulyModal-content__settingsSet">
+      <div class="hulyModal-content__settingsSet-line mode-toggle">
+        <span class="label">
+          <Label label={task.string.CreateNew} />
+        </span>
+        <Toggle
+          on={mode === 'clone'}
+          on:change={() => { mode = mode === 'create' ? 'clone' : 'create' }}
+        />
+        <span class="label">
+          <Label label={task.string.CloneExisting} />
+        </span>
+      </div>
+    </div>
+  {/if}
+
+  {#if mode === 'clone' && taskType === undefined}
+    <!-- Clone Mode: Select existing TaskTypes -->
+    <div class="hulyModal-content__settingsSet">
+      <LinkTaskTypeSelector
+        currentProjectType={type._id}
+        bind:selectedTaskTypes={selectedTaskTypesToClone}
+      />
     </div>
-    {#if taskTypeDescriptors.length > 1}
+  {:else}
+    <!-- Create Mode: Original form -->
+    <div class="hulyModal-content__titleGroup">
+      <ModernEditbox bind:value={name} label={task.string.TaskName} size={'large'} kind={'ghost'} autoFocus />
+    </div>
+    <div class="hulyModal-content__settingsSet">
       <div class="hulyModal-content__settingsSet-line">
         <span class="label">
-          <Label label={task.string.Type} />
+          <Label label={task.string.TaskType} />
         </span>
-        <ButtonMenu
-          selected={taskTypeDescriptor._id}
-          items={descriptorItems}
-          icon={taskTypeDescriptor.icon}
-          label={taskTypeDescriptor.name}
-          kind={'secondary'}
-          size={'large'}
-          on:selected={(evt) => {
-            if (evt.detail != null) {
-              const tt = taskTypeDescriptors.find((tt) => tt._id === evt.detail)
-              if (tt) taskTypeDescriptor = tt
-            }
-          }}
+        <TaskTypeKindEditor bind:kind />
+      </div>
+      <div class="hulyModal-content__settingsSet-line">
+        <ClassMixinSelector
+          baseClass={taskTypeDescriptor?.baseClass ?? task.class.Task}
+          bind:value={baseMixin}
         />
       </div>
-    {/if}
-  </div>
+      {#if taskTypeDescriptors.length > 1}
+        <div class="hulyModal-content__settingsSet-line">
+          <span class="label">
+            <Label label={task.string.Type} />
+          </span>
+          <ButtonMenu
+            selected={taskTypeDescriptor._id}
+            items={descriptorItems}
+            icon={taskTypeDescriptor.icon}
+            label={taskTypeDescriptor.name}
+            kind={'secondary'}
+            size={'large'}
+            on:selected={(evt) => {
+              if (evt.detail != null) {
+                const tt = taskTypeDescriptors.find((tt) => tt._id === evt.detail)
+                if (tt) taskTypeDescriptor = tt
+              }
+            }}
+          />
+        </div>
+      {/if}
+    </div>
+  {/if}
 </Modal>
diff --git a/plugins/task-resources/src/components/taskTypes/LinkTaskTypeSelector.svelte b/plugins/task-resources/src/components/taskTypes/LinkTaskTypeSelector.svelte
new file mode 100644
index 00000000000..5e64184ada5
--- /dev/null
+++ b/plugins/task-resources/src/components/taskTypes/LinkTaskTypeSelector.svelte
@@ -0,0 +1,188 @@
+<script lang="ts">
+  import { Ref, SortingOrder } from '@hcengineering/core'
+  import task, { ProjectType, TaskType } from '@hcengineering/task'
+  import { CheckBox, Label } from '@hcengineering/ui'
+  import { createEventDispatcher } from 'svelte'
+  import { createQuery, getClient } from '@hcengineering/presentation'
+  import plugin from '../../plugin'
+
+  export let currentProjectType: Ref<ProjectType>
+  export let selectedTaskTypes: Ref<TaskType>[] = []
+
+  const dispatch = createEventDispatcher()
+  getClient() // Initialize client for queries
+
+  let allTaskTypes: TaskType[] = []
+  let projectTypes: ProjectType[] = []
+
+  // Query all TaskTypes except those already in current ProjectType
+  const taskTypeQuery = createQuery()
+  $: taskTypeQuery.query(
+    task.class.TaskType,
+    { parent: { $ne: currentProjectType } },
+    (res) => {
+      allTaskTypes = res
+    },
+    { sort: { name: SortingOrder.Ascending } }
+  )
+
+  // Query all ProjectTypes for grouping
+  const projectTypeQuery = createQuery()
+  $: projectTypeQuery.query(
+    task.class.ProjectType,
+    {},
+    (res) => {
+      projectTypes = res
+    }
+  )
+
+  // Group TaskTypes by their parent ProjectType
+  $: groupedTaskTypes = projectTypes
+    .filter((pt) => pt._id !== currentProjectType)
+    .map((pt) => ({
+      projectType: pt,
+      taskTypes: allTaskTypes.filter((tt) => tt.parent === pt._id)
+    }))
+    .filter((group) => group.taskTypes.length > 0)
+
+  function toggleSelection (taskTypeId: Ref<TaskType>): void {
+    const index = selectedTaskTypes.indexOf(taskTypeId)
+    if (index === -1) {
+      selectedTaskTypes = [...selectedTaskTypes, taskTypeId]
+    } else {
+      selectedTaskTypes = selectedTaskTypes.filter((id) => id !== taskTypeId)
+    }
+    dispatch('change', selectedTaskTypes)
+  }
+
+  function isSelected (taskTypeId: Ref<TaskType>): boolean {
+    return selectedTaskTypes.includes(taskTypeId)
+  }
+</script>
+
+<div class="link-selector">
+  <div class="header">
+    <Label label={plugin.string.SelectTaskTypesToClone} />
+  </div>
+
+  {#if groupedTaskTypes.length === 0}
+    <div class="empty">
+      <Label label={plugin.string.NoTaskTypesAvailable} />
+    </div>
+  {:else}
+    <div class="groups">
+      {#each groupedTaskTypes as group}
+        <div class="group">
+          <div class="group-header">
+            {group.projectType.name}
+          </div>
+          <div class="group-items">
+            {#each group.taskTypes as taskType}
+              <button
+                class="task-type-item"
+                class:selected={isSelected(taskType._id)}
+                on:click={() => { toggleSelection(taskType._id) }}
+              >
+                <CheckBox checked={isSelected(taskType._id)} />
+                <span class="name">{taskType.name}</span>
+                <span class="kind">({taskType.kind})</span>
+              </button>
+            {/each}
+          </div>
+        </div>
+      {/each}
+    </div>
+  {/if}
+
+  {#if selectedTaskTypes.length > 0}
+    <div class="selection-count">
+      {selectedTaskTypes.length} selected
+    </div>
+  {/if}
+</div>
+
+<style lang="scss">
+  .link-selector {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+    max-height: 400px;
+    overflow-y: auto;
+  }
+
+  .header {
+    font-weight: 500;
+    color: var(--theme-content-color);
+  }
+
+  .empty {
+    color: var(--theme-halfcontent-color);
+    padding: 1rem;
+    text-align: center;
+  }
+
+  .groups {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+  }
+
+  .group {
+    border: 1px solid var(--theme-divider-color);
+    border-radius: 0.5rem;
+    overflow: hidden;
+  }
+
+  .group-header {
+    background: var(--theme-bg-accent-color);
+    padding: 0.5rem 1rem;
+    font-weight: 500;
+    font-size: 0.875rem;
+    color: var(--theme-halfcontent-color);
+  }
+
+  .group-items {
+    display: flex;
+    flex-direction: column;
+  }
+
+  .task-type-item {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    padding: 0.75rem 1rem;
+    border: none;
+    background: transparent;
+    cursor: pointer;
+    text-align: left;
+    width: 100%;
+    transition: background-color 0.15s;
+
+    &:hover {
+      background: var(--theme-bg-accent-hover);
+    }
+
+    &.selected {
+      background: var(--theme-bg-accent-color);
+    }
+
+    .name {
+      flex: 1;
+      color: var(--theme-content-color);
+    }
+
+    .kind {
+      color: var(--theme-halfcontent-color);
+      font-size: 0.875rem;
+    }
+  }
+
+  .selection-count {
+    padding: 0.5rem;
+    text-align: center;
+    background: var(--theme-bg-accent-color);
+    border-radius: 0.25rem;
+    font-size: 0.875rem;
+    color: var(--theme-accent-color);
+  }
+</style>
diff --git a/plugins/task-resources/src/components/taskTypes/MixinSelector.svelte b/plugins/task-resources/src/components/taskTypes/MixinSelector.svelte
new file mode 100644
index 00000000000..9532bd9bb98
--- /dev/null
+++ b/plugins/task-resources/src/components/taskTypes/MixinSelector.svelte
@@ -0,0 +1,93 @@
+<script lang="ts">
+  import { Class, Mixin, Ref } from '@hcengineering/core'
+  import task, { Task, TaskType } from '@hcengineering/task'
+  import { ButtonMenu, Label } from '@hcengineering/ui'
+  import { createEventDispatcher } from 'svelte'
+  import { createQuery, getClient } from '@hcengineering/presentation'
+  import plugin from '../../plugin'
+
+  export let baseClass: Ref<Class<Task>>
+  export let value: Ref<Mixin<Task>> | undefined = undefined
+  export let readonly = false
+  export let buttonKind: 'primary' | 'secondary' | 'tertiary' | 'negative' = 'secondary'
+  export let buttonSize: 'large' | 'medium' | 'small' = 'large'
+  export let excludeTaskType: Ref<TaskType> | undefined = undefined
+
+  const dispatch = createEventDispatcher()
+  const client = getClient()
+  const hierarchy = client.getHierarchy()
+
+  let availableTaskTypes: TaskType[] = []
+
+  // Query all TaskTypes that have a compatible ofClass
+  const taskTypeQuery = createQuery()
+  $: {
+    // Get all classes derived from baseClass to find compatible TaskTypes
+    const compatibleClasses = hierarchy.getDescendants(baseClass)
+
+    taskTypeQuery.query(
+      task.class.TaskType,
+      { ofClass: { $in: compatibleClasses } },
+      (res) => {
+        // Filter out the current TaskType if editing
+        availableTaskTypes = excludeTaskType !== undefined
+          ? res.filter((tt: TaskType) => tt._id !== excludeTaskType)
+          : res
+      }
+    )
+  }
+
+  // Build items list from TaskTypes
+  $: items = [
+    { id: '', label: 'None (create new)' },
+    ...availableTaskTypes.map((tt) => ({
+      id: tt.targetClass as string,
+      label: tt.name
+    }))
+  ]
+
+  $: selected = items.find((it) => it.id === (value ?? ''))
+
+  function handleSelect (evt: CustomEvent<string>): void {
+    if (evt.detail !== undefined) {
+      value = evt.detail === '' ? undefined : (evt.detail as Ref<Mixin<Task>>)
+      dispatch('change', value)
+    }
+  }
+</script>
+
+<div class="mixin-selector">
+  <span class="label">
+    <Label label={plugin.string.BaseMixin} />
+  </span>
+  {#if readonly}
+    {#if selected}
+      <span class="selected-value">{selected.label}</span>
+    {/if}
+  {:else}
+    <ButtonMenu
+      selected={value ?? ''}
+      {items}
+      label={selected?.label ?? plugin.string.NoBaseMixin}
+      kind={buttonKind}
+      size={buttonSize}
+      on:selected={handleSelect}
+    />
+  {/if}
+</div>
+
+<style lang="scss">
+  .mixin-selector {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .selected-value {
+    color: var(--theme-content-color);
+  }
+
+  .label {
+    color: var(--theme-halfcontent-color);
+  }
+</style>
diff --git a/plugins/task-resources/src/plugin.ts b/plugins/task-resources/src/plugin.ts
index 88ef8abd842..8ecdb5a2cd3 100644
--- a/plugins/task-resources/src/plugin.ts
+++ b/plugins/task-resources/src/plugin.ts
@@ -89,7 +89,15 @@ export default mergeIds(taskId, task, {
     RenameStatus: '' as IntlString,
     UpdateTasksStatusRequest: '' as IntlString,
     TaskTypes: '' as IntlString,
-    Collections: '' as IntlString
+    Collections: '' as IntlString,
+    BaseMixin: '' as IntlString,
+    BaseMixinDescription: '' as IntlString,
+    NoBaseMixin: '' as IntlString,
+    CreateNew: '' as IntlString,
+    CloneExisting: '' as IntlString,
+    CloneTaskTypes: '' as IntlString,
+    SelectTaskTypesToClone: '' as IntlString,
+    NoTaskTypesAvailable: '' as IntlString
   },
   status: {
     AssigneeRequired: '' as IntlString
diff --git a/plugins/task/src/index.ts b/plugins/task/src/index.ts
index 412161345ce..547bc2b4e73 100644
--- a/plugins/task/src/index.ts
+++ b/plugins/task/src/index.ts
@@ -120,6 +120,9 @@ export interface TaskType extends Doc, IconProps {
   // Specify if task is allowed to be used as subtask of following tasks.
   allowedAsChildOf?: Ref<TaskType>[]
 
+  // Existing mixin to inherit attributes from (optional)
+  baseMixin?: Ref<Mixin<Task>>
+
   ofClass: Ref<Class<Task>> // Base class for task
   targetClass: Ref<Class<Task>> // Class or Mixin mixin to hold all user defined attributes.
 
diff --git a/plugins/task/src/utils.ts b/plugins/task/src/utils.ts
index 69f43946385..f88cf3a83d3 100644
--- a/plugins/task/src/utils.ts
+++ b/plugins/task/src/utils.ts
@@ -21,6 +21,7 @@ import core, {
   DocumentQuery,
   Hierarchy,
   IdMap,
+  Mixin,
   Ref,
   Status,
   TxOperations,
@@ -330,11 +331,14 @@ async function createTaskTypes (
       const targetClassId = `${taskId}:type:mixin` as Ref<Class<Task>>
       tdata.targetClass = targetClassId
 
+      // Use baseMixin if provided, otherwise extend ofClass directly
+      const extendsClass = data.baseMixin ?? data.ofClass
+
       await client.createDoc(
         core.class.Mixin,
         core.space.Model,
         {
-          extends: data.ofClass,
+          extends: extendsClass,
           kind: ClassifierKind.MIXIN,
           label: ofClassClass.label,
           icon: ofClassClass.icon
@@ -353,3 +357,17 @@ async function createTaskTypes (
   }
   return hasUpdates
 }
+
+/**
+ * @public
+ * Validates that a baseMixin is compatible with the ofClass hierarchy.
+ * Returns true if baseMixin is undefined or if it derives from ofClass.
+ */
+export function validateMixinHierarchy (
+  hierarchy: Hierarchy,
+  baseMixin: Ref<Mixin<Task>> | undefined,
+  ofClass: Ref<Class<Task>>
+): boolean {
+  if (baseMixin === undefined) return true
+  return hierarchy.isDerived(baseMixin, ofClass)
+}