diff --git a/packages/clerk-js/src/core/clerk.ts b/packages/clerk-js/src/core/clerk.ts
index 48d108389ce..418197c1644 100644
--- a/packages/clerk-js/src/core/clerk.ts
+++ b/packages/clerk-js/src/core/clerk.ts
@@ -110,6 +110,7 @@ import type {
   SignUpResource,
   TaskChooseOrganizationProps,
   TaskResetPasswordProps,
+  TaskSetupMfaProps,
   TasksRedirectOptions,
   UnsubscribeCallback,
   UserAvatarProps,
@@ -1415,6 +1416,28 @@ export class Clerk implements ClerkInterface {
     void this.#clerkUi?.then(ui => ui.ensureMounted()).then(controls => controls.unmountComponent({ node }));
   };
 
+  public mountTaskSetupMfa = (node: HTMLDivElement, props?: TaskSetupMfaProps) => {
+    this.assertComponentsReady(this.#clerkUi);
+
+    const component = 'TaskSetupMfa';
+    void this.#clerkUi
+      .then(ui => ui.ensureMounted())
+      .then(controls =>
+        controls.mountComponent({
+          name: component,
+          appearanceKey: 'taskSetupMfa',
+          node,
+          props,
+        }),
+      );
+
+    this.telemetry?.record(eventPrebuiltComponentMounted('TaskSetupMfa', props));
+  };
+
+  public unmountTaskSetupMfa = (node: HTMLDivElement) => {
+    void this.#clerkUi?.then(ui => ui.ensureMounted()).then(controls => controls.unmountComponent({ node }));
+  };
+
   /**
    * `setActive` can be used to set the active session and/or organization.
    */
diff --git a/packages/localizations/src/en-US.ts b/packages/localizations/src/en-US.ts
index 8f8cba4e707..6d7294ca6af 100644
--- a/packages/localizations/src/en-US.ts
+++ b/packages/localizations/src/en-US.ts
@@ -894,6 +894,19 @@ export const enUS: LocalizationResource = {
     subtitle: 'Your account requires a new password before you can continue',
     title: 'Reset your password',
   },
+  taskSetupMfa: {
+    title: 'Set up two-step verification',
+    subtitle: 'Protect your account with an extra layer of security',
+    methodSelection: {
+      totpButton: 'Authenticator app',
+      phoneCodeButton: 'SMS code',
+      backupCodeButton: 'Backup codes',
+    },
+    signOut: {
+      actionText: 'Signed in as {{identifier}}',
+      actionLink: 'Sign out',
+    },
+  },
   unstable__errors: {
     already_a_member_in_organization: '{{email}} is already a member of the organization.',
     avatar_file_size_exceeded: 'File size exceeds the maximum limit of 10MB. Please choose a smaller file.',
diff --git a/packages/shared/src/internal/clerk-js/sessionTasks.ts b/packages/shared/src/internal/clerk-js/sessionTasks.ts
index eb8a3f3ca99..e0d0fd1e0f8 100644
--- a/packages/shared/src/internal/clerk-js/sessionTasks.ts
+++ b/packages/shared/src/internal/clerk-js/sessionTasks.ts
@@ -9,6 +9,7 @@ import { buildURL } from './url';
 export const INTERNAL_SESSION_TASK_ROUTE_BY_KEY: Record<SessionTask['key'], string> = {
   'choose-organization': 'choose-organization',
   'reset-password': 'reset-password',
+  'setup-mfa': 'setup-mfa',
 } as const;
 
 /**
diff --git a/packages/shared/src/types/clerk.ts b/packages/shared/src/types/clerk.ts
index 33b15d3bfe8..f359bfaaecd 100644
--- a/packages/shared/src/types/clerk.ts
+++ b/packages/shared/src/types/clerk.ts
@@ -672,6 +672,23 @@ export interface Clerk {
    */
   unmountTaskResetPassword: (targetNode: HTMLDivElement) => void;
 
+  /**
+   * Mounts a TaskSetupMfa component at the target element.
+   * This component allows users to set up multi-factor authentication.
+   *
+   * @param targetNode - Target node to mount the TaskSetupMfa component.
+   * @param props - configuration parameters.
+   */
+  mountTaskSetupMfa: (targetNode: HTMLDivElement, props?: TaskSetupMfaProps) => void;
+
+  /**
+   * Unmount a TaskSetupMfa component from the target element.
+   * If there is no component mounted at the target node, results in a noop.
+   *
+   * @param targetNode - Target node to unmount the TaskSetupMfa component from.
+   */
+  unmountTaskSetupMfa: (targetNode: HTMLDivElement) => void;
+
   /**
    * @internal
    * Loads Stripe libraries for commerce functionality
@@ -2236,6 +2253,14 @@ export type TaskResetPasswordProps = {
   appearance?: ClerkAppearanceTheme;
 };
 
+export type TaskSetupMfaProps = {
+  /**
+   * Full URL or path to navigate to after successfully resolving all tasks
+   */
+  redirectUrlComplete: string;
+  appearance?: ClerkAppearanceTheme;
+};
+
 export type CreateOrganizationInvitationParams = {
   emailAddress: string;
   role: OrganizationCustomRoleKey;
diff --git a/packages/shared/src/types/localization.ts b/packages/shared/src/types/localization.ts
index 806826143d8..24882539c46 100644
--- a/packages/shared/src/types/localization.ts
+++ b/packages/shared/src/types/localization.ts
@@ -1324,6 +1324,19 @@ export type __internal_LocalizationResource = {
     };
     formButtonPrimary: LocalizationValue;
   };
+  taskSetupMfa: {
+    title: LocalizationValue;
+    subtitle: LocalizationValue;
+    methodSelection: {
+      totpButton: LocalizationValue;
+      phoneCodeButton: LocalizationValue;
+      backupCodeButton: LocalizationValue;
+    };
+    signOut: {
+      actionText: LocalizationValue<'identifier'>;
+      actionLink: LocalizationValue;
+    };
+  };
   web3SolanaWalletButtons: {
     connect: LocalizationValue<'walletName'>;
     continue: LocalizationValue<'walletName'>;
diff --git a/packages/shared/src/types/session.ts b/packages/shared/src/types/session.ts
index 727c044ad48..f35b1454c24 100644
--- a/packages/shared/src/types/session.ts
+++ b/packages/shared/src/types/session.ts
@@ -335,7 +335,7 @@ export interface SessionTask {
   /**
    * A unique identifier for the task
    */
-  key: 'choose-organization' | 'reset-password';
+  key: 'choose-organization' | 'reset-password' | 'setup-mfa';
 }
 
 export type GetTokenOptions = {
diff --git a/packages/ui/src/components/SessionTasks/index.tsx b/packages/ui/src/components/SessionTasks/index.tsx
index 9cca5b9b9c1..f51ee921e31 100644
--- a/packages/ui/src/components/SessionTasks/index.tsx
+++ b/packages/ui/src/components/SessionTasks/index.tsx
@@ -12,11 +12,13 @@ import {
   SessionTasksContext,
   TaskChooseOrganizationContext,
   TaskResetPasswordContext,
+  TaskSetupMfaContext,
   useSessionTasksContext,
 } from '../../contexts/components/SessionTasks';
 import { Route, Switch, useRouter } from '../../router';
 import { TaskChooseOrganization } from './tasks/TaskChooseOrganization';
 import { TaskResetPassword } from './tasks/TaskResetPassword';
+import { TaskSetupMfa } from './tasks/TaskSetupMfa';
 
 const SessionTasksStart = () => {
   const clerk = useClerk();
@@ -68,6 +70,13 @@ function SessionTasksRoutes(): JSX.Element {
             <TaskResetPassword />
           </TaskResetPasswordContext.Provider>
         </Route>
+        <Route path={INTERNAL_SESSION_TASK_ROUTE_BY_KEY['setup-mfa']}>
+          <TaskSetupMfaContext.Provider
+            value={{ componentName: 'TaskSetupMfa', redirectUrlComplete: ctx.redirectUrlComplete }}
+          >
+            <TaskSetupMfa />
+          </TaskSetupMfaContext.Provider>
+        </Route>
         <Route index>
           <SessionTasksStart />
         </Route>
diff --git a/packages/ui/src/components/SessionTasks/tasks/TaskSetupMfa/MfaMethodSelectionScreen.tsx b/packages/ui/src/components/SessionTasks/tasks/TaskSetupMfa/MfaMethodSelectionScreen.tsx
new file mode 100644
index 00000000000..7f40771d9f0
--- /dev/null
+++ b/packages/ui/src/components/SessionTasks/tasks/TaskSetupMfa/MfaMethodSelectionScreen.tsx
@@ -0,0 +1,95 @@
+import { useClerk, useSession, useUser } from '@clerk/shared/react';
+
+import { useSignOutContext } from '@/ui/contexts';
+import { Button, Col, Flow, localizationKeys } from '@/ui/customizables';
+import { Card } from '@/ui/elements/Card';
+import { Header } from '@/ui/elements/Header';
+import { useMultipleSessions } from '@/ui/hooks/useMultipleSessions';
+
+type MfaMethodSelectionScreenProps = {
+  availableMethods: string[];
+  onMethodSelect: (method: string) => void;
+};
+
+export const MfaMethodSelectionScreen = (props: MfaMethodSelectionScreenProps) => {
+  const { availableMethods, onMethodSelect } = props;
+  const { signOut } = useClerk();
+  const { user } = useUser();
+  const { session } = useSession();
+  const { otherSessions } = useMultipleSessions({ user });
+  const { navigateAfterSignOut, navigateAfterMultiSessionSingleSignOutUrl } = useSignOutContext();
+
+  const handleSignOut = () => {
+    if (otherSessions.length === 0) {
+      return signOut(navigateAfterSignOut);
+    }
+    return signOut(navigateAfterMultiSessionSingleSignOutUrl, { sessionId: session?.id });
+  };
+
+  const getMethodLabel = (method: string) => {
+    switch (method) {
+      case 'totp':
+        return localizationKeys('taskSetupMfa.methodSelection.totpButton');
+      case 'phone_code':
+        return localizationKeys('taskSetupMfa.methodSelection.phoneCodeButton');
+      case 'backup_code':
+        return localizationKeys('taskSetupMfa.methodSelection.backupCodeButton');
+      default:
+        return method;
+    }
+  };
+
+  const identifier = user?.primaryEmailAddress?.emailAddress ?? user?.username;
+
+  return (
+    <Flow.Root flow='taskSetupMfa'>
+      <Flow.Part part='methodSelection'>
+        <Card.Root>
+          <Card.Content>
+            <Header.Root showLogo>
+              <Header.Title localizationKey={localizationKeys('taskSetupMfa.title')} />
+              <Header.Subtitle localizationKey={localizationKeys('taskSetupMfa.subtitle')} />
+            </Header.Root>
+            <Col
+              gap={3}
+              sx={t => ({ marginTop: t.space.$4 })}
+            >
+              {availableMethods.map(method => (
+                <Button
+                  key={method}
+                  variant='outline'
+                  colorScheme='neutral'
+                  onClick={() => onMethodSelect(method)}
+                  localizationKey={getMethodLabel(method)}
+                />
+              ))}
+            </Col>
+          </Card.Content>
+
+          <Card.Footer>
+            <Card.Action
+              elementId='signOut'
+              gap={2}
+              justify='center'
+              sx={() => ({ width: '100%' })}
+            >
+              {identifier && (
+                <Card.ActionText
+                  truncate
+                  localizationKey={localizationKeys('taskSetupMfa.signOut.actionText', {
+                    identifier,
+                  })}
+                />
+              )}
+              <Card.ActionLink
+                sx={() => ({ flexShrink: 0 })}
+                onClick={handleSignOut}
+                localizationKey={localizationKeys('taskSetupMfa.signOut.actionLink')}
+              />
+            </Card.Action>
+          </Card.Footer>
+        </Card.Root>
+      </Flow.Part>
+    </Flow.Root>
+  );
+};
diff --git a/packages/ui/src/components/SessionTasks/tasks/TaskSetupMfa/__tests__/MfaMethodSelectionScreen.test.tsx b/packages/ui/src/components/SessionTasks/tasks/TaskSetupMfa/__tests__/MfaMethodSelectionScreen.test.tsx
new file mode 100644
index 00000000000..ef1872151af
--- /dev/null
+++ b/packages/ui/src/components/SessionTasks/tasks/TaskSetupMfa/__tests__/MfaMethodSelectionScreen.test.tsx
@@ -0,0 +1,313 @@
+import { act } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { bindCreateFixtures } from '@/test/create-fixtures';
+import { render } from '@/test/utils';
+
+import { MfaMethodSelectionScreen } from '../MfaMethodSelectionScreen';
+
+const { createFixtures } = bindCreateFixtures('TaskSetupMfa');
+
+describe('MfaMethodSelectionScreen', () => {
+  describe('Rendering', () => {
+    it('renders title and subtitle', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+      });
+
+      const onMethodSelect = vi.fn();
+      const { findByText } = render(
+        <MfaMethodSelectionScreen
+          availableMethods={['totp', 'phone_code']}
+          onMethodSelect={onMethodSelect}
+        />,
+        { wrapper },
+      );
+
+      expect(await findByText('Set up two-step verification')).toBeInTheDocument();
+      expect(await findByText('Protect your account with an extra layer of security')).toBeInTheDocument();
+    });
+
+    it('renders all provided method buttons', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+      });
+
+      const onMethodSelect = vi.fn();
+      const { findByRole } = render(
+        <MfaMethodSelectionScreen
+          availableMethods={['totp', 'phone_code', 'backup_code']}
+          onMethodSelect={onMethodSelect}
+        />,
+        { wrapper },
+      );
+
+      expect(await findByRole('button', { name: /authenticator app/i })).toBeInTheDocument();
+      expect(await findByRole('button', { name: /sms code/i })).toBeInTheDocument();
+      expect(await findByRole('button', { name: /backup code/i })).toBeInTheDocument();
+    });
+
+    it('renders only TOTP button when only totp is available', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+      });
+
+      const onMethodSelect = vi.fn();
+      const { findByRole, queryByRole } = render(
+        <MfaMethodSelectionScreen
+          availableMethods={['totp']}
+          onMethodSelect={onMethodSelect}
+        />,
+        { wrapper },
+      );
+
+      expect(await findByRole('button', { name: /authenticator app/i })).toBeInTheDocument();
+      expect(queryByRole('button', { name: /sms code/i })).not.toBeInTheDocument();
+      expect(queryByRole('button', { name: /backup code/i })).not.toBeInTheDocument();
+    });
+
+    it('renders only phone code button when only phone_code is available', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+      });
+
+      const onMethodSelect = vi.fn();
+      const { findByRole, queryByRole } = render(
+        <MfaMethodSelectionScreen
+          availableMethods={['phone_code']}
+          onMethodSelect={onMethodSelect}
+        />,
+        { wrapper },
+      );
+
+      expect(await findByRole('button', { name: /sms code/i })).toBeInTheDocument();
+      expect(queryByRole('button', { name: /authenticator app/i })).not.toBeInTheDocument();
+      expect(queryByRole('button', { name: /backup code/i })).not.toBeInTheDocument();
+    });
+  });
+
+  describe('Method Selection', () => {
+    it('calls onMethodSelect with correct method when TOTP is clicked', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+      });
+
+      const onMethodSelect = vi.fn();
+      const { findByRole, userEvent } = render(
+        <MfaMethodSelectionScreen
+          availableMethods={['totp', 'phone_code']}
+          onMethodSelect={onMethodSelect}
+        />,
+        { wrapper },
+      );
+
+      const totpButton = await findByRole('button', { name: /authenticator app/i });
+
+      await act(async () => {
+        await userEvent.click(totpButton);
+      });
+
+      expect(onMethodSelect).toHaveBeenCalledWith('totp');
+    });
+
+    it('calls onMethodSelect with correct method when phone code is clicked', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+      });
+
+      const onMethodSelect = vi.fn();
+      const { findByRole, userEvent } = render(
+        <MfaMethodSelectionScreen
+          availableMethods={['totp', 'phone_code']}
+          onMethodSelect={onMethodSelect}
+        />,
+        { wrapper },
+      );
+
+      const phoneCodeButton = await findByRole('button', { name: /sms code/i });
+
+      await act(async () => {
+        await userEvent.click(phoneCodeButton);
+      });
+
+      expect(onMethodSelect).toHaveBeenCalledWith('phone_code');
+    });
+
+    it('calls onMethodSelect with correct method when backup code is clicked', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+      });
+
+      const onMethodSelect = vi.fn();
+      const { findByRole, userEvent } = render(
+        <MfaMethodSelectionScreen
+          availableMethods={['totp', 'phone_code', 'backup_code']}
+          onMethodSelect={onMethodSelect}
+        />,
+        { wrapper },
+      );
+
+      const backupCodeButton = await findByRole('button', { name: /backup code/i });
+
+      await act(async () => {
+        await userEvent.click(backupCodeButton);
+      });
+
+      expect(onMethodSelect).toHaveBeenCalledWith('backup_code');
+    });
+  });
+
+  describe('Sign Out', () => {
+    it('displays user identifier in sign out section', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['user@test.com'],
+          identifier: 'user@test.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+      });
+
+      const onMethodSelect = vi.fn();
+      const { findByText } = render(
+        <MfaMethodSelectionScreen
+          availableMethods={['totp']}
+          onMethodSelect={onMethodSelect}
+        />,
+        { wrapper },
+      );
+
+      expect(await findByText(/user@test\.com/)).toBeInTheDocument();
+      expect(await findByText('Sign out')).toBeInTheDocument();
+    });
+
+    it('displays username when email is not available', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          username: 'testuser',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+      });
+
+      const onMethodSelect = vi.fn();
+      const { findByText } = render(
+        <MfaMethodSelectionScreen
+          availableMethods={['totp']}
+          onMethodSelect={onMethodSelect}
+        />,
+        { wrapper },
+      );
+
+      expect(await findByText(/testuser/)).toBeInTheDocument();
+    });
+
+    it('handles sign out correctly with single session', async () => {
+      const { wrapper, fixtures } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+      });
+
+      const onMethodSelect = vi.fn();
+      const { findByRole, userEvent } = render(
+        <MfaMethodSelectionScreen
+          availableMethods={['totp']}
+          onMethodSelect={onMethodSelect}
+        />,
+        { wrapper },
+      );
+
+      const signOutButton = await findByRole('link', { name: /sign out/i });
+
+      await act(async () => {
+        await userEvent.click(signOutButton);
+      });
+
+      expect(fixtures.clerk.signOut).toHaveBeenCalled();
+    });
+
+    it('does not display identifier when neither email nor username is available', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          tasks: [{ key: 'setup-mfa' }],
+        });
+      });
+
+      const onMethodSelect = vi.fn();
+      const { findByText, queryByText } = render(
+        <MfaMethodSelectionScreen
+          availableMethods={['totp']}
+          onMethodSelect={onMethodSelect}
+        />,
+        { wrapper },
+      );
+
+      expect(await findByText('Sign out')).toBeInTheDocument();
+      // Should not show "Signed in as" text when no identifier
+      expect(queryByText(/Signed in as/)).not.toBeInTheDocument();
+    });
+  });
+
+  describe('Multiple Sessions', () => {
+    it('handles sign out with multiple sessions correctly', async () => {
+      const { wrapper, fixtures } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withMultipleSessions();
+      });
+
+      const onMethodSelect = vi.fn();
+      const { findByRole, userEvent } = render(
+        <MfaMethodSelectionScreen
+          availableMethods={['totp']}
+          onMethodSelect={onMethodSelect}
+        />,
+        { wrapper },
+      );
+
+      const signOutButton = await findByRole('link', { name: /sign out/i });
+
+      await act(async () => {
+        await userEvent.click(signOutButton);
+      });
+
+      expect(fixtures.clerk.signOut).toHaveBeenCalled();
+      // Should pass sessionId when multiple sessions exist
+      expect(fixtures.clerk.signOut).toHaveBeenCalledWith(expect.anything(), {
+        sessionId: expect.any(String),
+      });
+    });
+  });
+});
diff --git a/packages/ui/src/components/SessionTasks/tasks/TaskSetupMfa/__tests__/TaskSetupMfa.test.tsx b/packages/ui/src/components/SessionTasks/tasks/TaskSetupMfa/__tests__/TaskSetupMfa.test.tsx
new file mode 100644
index 00000000000..4c92d20912f
--- /dev/null
+++ b/packages/ui/src/components/SessionTasks/tasks/TaskSetupMfa/__tests__/TaskSetupMfa.test.tsx
@@ -0,0 +1,332 @@
+import { act } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+
+import { bindCreateFixtures } from '@/test/create-fixtures';
+import { render, waitFor } from '@/test/utils';
+
+import { TaskSetupMfa } from '..';
+
+const { createFixtures } = bindCreateFixtures('TaskSetupMfa');
+
+describe('TaskSetupMfa', () => {
+  describe('Task Guard', () => {
+    it('does not render component without existing session task', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+        });
+        f.withAuthenticatorApp();
+      });
+
+      const { queryByText, queryByRole } = render(<TaskSetupMfa />, { wrapper });
+
+      expect(queryByText('Set up two-step verification')).not.toBeInTheDocument();
+      expect(queryByRole('link', { name: /sign out/i })).not.toBeInTheDocument();
+    });
+
+    it('renders component when session task exists', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withAuthenticatorApp();
+      });
+
+      const { findByText } = render(<TaskSetupMfa />, { wrapper });
+
+      expect(await findByText('Set up two-step verification')).toBeInTheDocument();
+    });
+  });
+
+  describe('Method Selection', () => {
+    it('shows method selection screen when multiple methods available', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withAuthenticatorApp();
+        f.withPhoneNumber({ second_factors: ['phone_code'] });
+      });
+
+      const { findByText, findByRole } = render(<TaskSetupMfa />, { wrapper });
+
+      expect(await findByText('Set up two-step verification')).toBeInTheDocument();
+      expect(await findByText('Protect your account with an extra layer of security')).toBeInTheDocument();
+      expect(await findByRole('button', { name: /authenticator app/i })).toBeInTheDocument();
+      expect(await findByRole('button', { name: /sms code/i })).toBeInTheDocument();
+    });
+
+    it('auto-selects method when only one available', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withAuthenticatorApp();
+      });
+
+      const { findByText, queryByRole } = render(<TaskSetupMfa />, { wrapper });
+
+      // Should not show method selection screen
+      expect(queryByRole('button', { name: /authenticator app/i })).not.toBeInTheDocument();
+      expect(queryByRole('button', { name: /sms code/i })).not.toBeInTheDocument();
+
+      // Should directly show the TOTP setup form
+      await waitFor(() => expect(findByText(/Add authenticator app/i)).toBeTruthy());
+    });
+
+    it('allows user to select TOTP method from multiple options', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withAuthenticatorApp();
+        f.withPhoneNumber({ second_factors: ['phone_code'] });
+      });
+
+      const { findByText, findByRole, userEvent } = render(<TaskSetupMfa />, { wrapper });
+
+      const totpButton = await findByRole('button', { name: /authenticator app/i });
+
+      await act(async () => {
+        await userEvent.click(totpButton);
+      });
+
+      // Should navigate to TOTP setup
+      await waitFor(() => expect(findByText(/Add authenticator app/i)).toBeTruthy());
+    });
+
+    it('allows user to select phone code method from multiple options', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withAuthenticatorApp();
+        f.withPhoneNumber({ second_factors: ['phone_code'] });
+      });
+
+      const { findByRole, userEvent, queryByText } = render(<TaskSetupMfa />, { wrapper });
+
+      const phoneCodeButton = await findByRole('button', { name: /sms code/i });
+
+      await act(async () => {
+        await userEvent.click(phoneCodeButton);
+      });
+
+      // Should navigate to phone code setup
+      await waitFor(() => {
+        expect(queryByText(/Add SMS code/i)).toBeInTheDocument();
+      });
+    });
+  });
+
+  describe('Sign Out', () => {
+    it('displays user identifier in sign out section', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['user@test.com'],
+          identifier: 'user@test.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withAuthenticatorApp();
+        f.withPhoneNumber({ second_factors: ['phone_code'] });
+      });
+
+      const { findByText } = render(<TaskSetupMfa />, { wrapper });
+
+      expect(await findByText(/user@test\.com/)).toBeInTheDocument();
+      expect(await findByText('Sign out')).toBeInTheDocument();
+    });
+
+    it('renders with username when email is not available', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          username: 'testuser',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withAuthenticatorApp();
+      });
+
+      const { findByText } = render(<TaskSetupMfa />, { wrapper });
+
+      expect(await findByText(/testuser/)).toBeInTheDocument();
+    });
+
+    it('handles sign out correctly with single session', async () => {
+      const { wrapper, fixtures } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withAuthenticatorApp();
+      });
+
+      const { findByRole, userEvent } = render(<TaskSetupMfa />, { wrapper });
+      const signOutButton = await findByRole('link', { name: /sign out/i });
+
+      await act(async () => {
+        await userEvent.click(signOutButton);
+      });
+
+      expect(fixtures.clerk.signOut).toHaveBeenCalled();
+    });
+  });
+
+  describe('Method Availability', () => {
+    it('shows only TOTP when only authenticator app is enabled', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withAuthenticatorApp();
+      });
+
+      const { queryByRole } = render(<TaskSetupMfa />, { wrapper });
+
+      // Should auto-select TOTP and not show method selection
+      expect(queryByRole('button', { name: /authenticator app/i })).not.toBeInTheDocument();
+      expect(queryByRole('button', { name: /sms code/i })).not.toBeInTheDocument();
+      expect(queryByRole('button', { name: /backup code/i })).not.toBeInTheDocument();
+    });
+
+    it('shows only phone code when only SMS is enabled', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withPhoneNumber({ second_factors: ['phone_code'] });
+      });
+
+      const { queryByRole, queryByText } = render(<TaskSetupMfa />, { wrapper });
+
+      // Should auto-select phone code and not show method selection
+      expect(queryByRole('button', { name: /authenticator app/i })).not.toBeInTheDocument();
+      expect(queryByRole('button', { name: /sms code/i })).not.toBeInTheDocument();
+
+      // Should show phone code setup
+      await waitFor(() => {
+        expect(queryByText(/Add SMS code/i)).toBeInTheDocument();
+      });
+    });
+
+    it('shows both TOTP and phone code when both are enabled', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withAuthenticatorApp();
+        f.withPhoneNumber({ second_factors: ['phone_code'] });
+      });
+
+      const { findByRole } = render(<TaskSetupMfa />, { wrapper });
+
+      expect(await findByRole('button', { name: /authenticator app/i })).toBeInTheDocument();
+      expect(await findByRole('button', { name: /sms code/i })).toBeInTheDocument();
+    });
+
+    it('includes backup codes in method selection when available', async () => {
+      const { wrapper } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withAuthenticatorApp();
+        f.withPhoneNumber({ second_factors: ['phone_code'] });
+        f.withBackupCode();
+      });
+
+      const { findByRole } = render(<TaskSetupMfa />, { wrapper });
+
+      expect(await findByRole('button', { name: /authenticator app/i })).toBeInTheDocument();
+      expect(await findByRole('button', { name: /sms code/i })).toBeInTheDocument();
+      expect(await findByRole('button', { name: /backup code/i })).toBeInTheDocument();
+    });
+  });
+
+  describe('Task Completion', () => {
+    it('calls setActive after successful MFA setup', async () => {
+      const { wrapper, fixtures } = await createFixtures(f => {
+        f.withUser({
+          email_addresses: ['test@clerk.com'],
+          identifier: 'test@clerk.com',
+          tasks: [{ key: 'setup-mfa' }],
+        });
+        f.withAuthenticatorApp();
+      });
+
+      // Mock the TOTP creation and verification
+      const mockTOTP = {
+        id: 'totp_123',
+        secret: 'secret',
+        uri: 'otpauth://totp/test',
+        verified: false,
+        backup_codes: [],
+      };
+
+      const mockVerifiedTOTP = {
+        ...mockTOTP,
+        verified: true,
+        backup_codes: ['code1', 'code2', 'code3'],
+      };
+
+      fixtures.clerk.user!.createTOTP = vi.fn().mockResolvedValue(mockTOTP);
+      fixtures.clerk.user!.verifyTOTP = vi.fn().mockResolvedValue(mockVerifiedTOTP);
+
+      const { findByRole, findByLabelText, userEvent } = render(<TaskSetupMfa />, { wrapper });
+
+      // Should be on TOTP setup page (auto-selected)
+      const continueButton = await findByRole('button', { name: /continue/i });
+
+      await act(async () => {
+        await userEvent.click(continueButton);
+      });
+
+      // Wait for verification step
+      await waitFor(() => findByLabelText(/enter verification code/i));
+
+      const codeInput = await findByLabelText(/enter verification code/i);
+
+      await act(async () => {
+        await userEvent.type(codeInput, '123456');
+      });
+
+      const verifyButton = await findByRole('button', { name: /continue/i });
+
+      await act(async () => {
+        await userEvent.click(verifyButton);
+      });
+
+      // Wait for backup codes to appear
+      await waitFor(() => findByRole('button', { name: /continue/i }));
+
+      const finalContinueButton = await findByRole('button', { name: /continue/i });
+
+      await act(async () => {
+        await userEvent.click(finalContinueButton);
+      });
+
+      // Should call setActive to complete the task
+      await waitFor(() => {
+        expect(fixtures.clerk.setActive).toHaveBeenCalled();
+      });
+    });
+  });
+});
diff --git a/packages/ui/src/components/SessionTasks/tasks/TaskSetupMfa/index.tsx b/packages/ui/src/components/SessionTasks/tasks/TaskSetupMfa/index.tsx
new file mode 100644
index 00000000000..cf10daae483
--- /dev/null
+++ b/packages/ui/src/components/SessionTasks/tasks/TaskSetupMfa/index.tsx
@@ -0,0 +1,68 @@
+import { useClerk, useUser } from '@clerk/shared/react';
+import { useMemo, useState } from 'react';
+
+import { useEnvironment, withCoreSessionSwitchGuard } from '@/ui/contexts';
+import { useSessionTasksContext, useTaskSetupMfaContext } from '@/ui/contexts/components/SessionTasks';
+import { Flow } from '@/ui/customizables';
+import { withCardStateProvider } from '@/ui/elements/contexts';
+
+import { MfaForm } from '../../../UserProfile/MfaForm';
+import { getSecondFactorsAvailableToAdd } from '../../../UserProfile/utils';
+import { withTaskGuard } from '../shared';
+import { MfaMethodSelectionScreen } from './MfaMethodSelectionScreen';
+
+const TaskSetupMfaInternal = () => {
+  const clerk = useClerk();
+  const { user } = useUser();
+  const {
+    userSettings: { attributes },
+  } = useEnvironment();
+  const { redirectUrlComplete } = useTaskSetupMfaContext();
+  const { navigateOnSetActive } = useSessionTasksContext();
+  const [selectedMethod, setSelectedMethod] = useState<string | undefined>();
+
+  const secondFactorsAvailableToAdd = useMemo(
+    () => (user ? getSecondFactorsAvailableToAdd(attributes, user) : []),
+    [attributes, user],
+  );
+
+  const handleMfaSuccess = async () => {
+    // Task completion: refresh session and navigate
+    await clerk.setActive({
+      session: clerk.session,
+      navigate: async ({ session }) => {
+        await navigateOnSetActive?.({ session, redirectUrlComplete });
+      },
+    });
+  };
+
+  // If only one method available, auto-select it
+  const autoSelectedMethod = secondFactorsAvailableToAdd.length === 1 ? secondFactorsAvailableToAdd[0] : selectedMethod;
+
+  // If method is selected, show the MFA setup form
+  if (autoSelectedMethod) {
+    return (
+      <Flow.Root flow='taskSetupMfa'>
+        <Flow.Part part='setupMfa'>
+          <MfaForm
+            selectedStrategy={autoSelectedMethod}
+            onSuccess={handleMfaSuccess}
+            onReset={secondFactorsAvailableToAdd.length > 1 ? () => setSelectedMethod(undefined) : undefined}
+          />
+        </Flow.Part>
+      </Flow.Root>
+    );
+  }
+
+  // Show method selection screen
+  return (
+    <MfaMethodSelectionScreen
+      availableMethods={secondFactorsAvailableToAdd}
+      onMethodSelect={setSelectedMethod}
+    />
+  );
+};
+
+export const TaskSetupMfa = withCoreSessionSwitchGuard(
+  withTaskGuard(withCardStateProvider(TaskSetupMfaInternal), 'setup-mfa'),
+);
diff --git a/packages/ui/src/contexts/components/SessionTasks.ts b/packages/ui/src/contexts/components/SessionTasks.ts
index 9fc69910fa2..7cc3ffc2b7c 100644
--- a/packages/ui/src/contexts/components/SessionTasks.ts
+++ b/packages/ui/src/contexts/components/SessionTasks.ts
@@ -4,7 +4,7 @@ import { createContext, useContext } from 'react';
 
 import { useRouter } from '@/ui/router';
 
-import type { SessionTasksCtx, TaskChooseOrganizationCtx, TaskResetPasswordCtx } from '../../types';
+import type { SessionTasksCtx, TaskChooseOrganizationCtx, TaskResetPasswordCtx, TaskSetupMfaCtx } from '../../types';
 
 export const SessionTasksContext = createContext<SessionTasksCtx | null>(null);
 
@@ -67,3 +67,15 @@ export const useTaskResetPasswordContext = (): TaskResetPasswordCtx => {
 
   return context;
 };
+
+export const TaskSetupMfaContext = createContext<TaskSetupMfaCtx | null>(null);
+
+export const useTaskSetupMfaContext = (): TaskSetupMfaCtx => {
+  const context = useContext(TaskSetupMfaContext);
+
+  if (context === null) {
+    throw new Error('Clerk: useTaskSetupMfaContext called outside of the mounted TaskSetupMfa component.');
+  }
+
+  return context;
+};
diff --git a/packages/ui/src/types.ts b/packages/ui/src/types.ts
index 0156899b081..e87b2019a12 100644
--- a/packages/ui/src/types.ts
+++ b/packages/ui/src/types.ts
@@ -20,6 +20,7 @@ import type {
   SignUpProps,
   TaskChooseOrganizationProps,
   TaskResetPasswordProps,
+  TaskSetupMfaProps,
   UserAvatarProps,
   UserButtonProps,
   UserProfileProps,
@@ -62,7 +63,8 @@ export type AvailableComponentProps =
   | __internal_PlanDetailsProps
   | APIKeysProps
   | TaskChooseOrganizationProps
-  | TaskResetPasswordProps;
+  | TaskResetPasswordProps
+  | TaskSetupMfaProps;
 
 type ComponentMode = 'modal' | 'mounted';
 type SignInMode = 'modal' | 'redirect';
@@ -156,6 +158,10 @@ export type TaskResetPasswordCtx = TaskResetPasswordProps & {
   componentName: 'TaskResetPassword';
 };
 
+export type TaskSetupMfaCtx = TaskSetupMfaProps & {
+  componentName: 'TaskSetupMfa';
+};
+
 export type OAuthConsentCtx = __internal_OAuthConsentProps & {
   componentName: 'OAuthConsent';
 };
@@ -188,5 +194,6 @@ export type AvailableComponentCtx =
   | SubscriptionDetailsCtx
   | PlanDetailsCtx
   | TaskChooseOrganizationCtx
-  | TaskResetPasswordCtx;
+  | TaskResetPasswordCtx
+  | TaskSetupMfaCtx;
 export type AvailableComponentName = AvailableComponentCtx['componentName'];