diff --git a/src/app/(app)/dashboard/setup/actions.test.ts b/src/app/(app)/dashboard/setup/actions.test.ts
index 5c0999d..d3fcb2b 100644
--- a/src/app/(app)/dashboard/setup/actions.test.ts
+++ b/src/app/(app)/dashboard/setup/actions.test.ts
@@ -233,6 +233,83 @@ describe('getEnsOwnerAction', () => {
   })
 })
 
+describe('resolveFounderIdentityAction', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    process.env.NEXT_PUBLIC_CHAIN_ID = '11155111'
+    process.env.ALCHEMY_API_KEY = 'https://example-rpc'
+  })
+
+  it('returns direct address payload for valid 0x address input', async () => {
+    const { resolveFounderIdentityAction } = await import('./actions.js')
+    const result = await resolveFounderIdentityAction(
+      '0x1234567890abcdef1234567890abcdef12345678'
+    )
+
+    expect(result).toEqual({
+      input: '0x1234567890abcdef1234567890abcdef12345678',
+      source: 'address',
+      resolvedAddress: '0x1234567890abcdef1234567890abcdef12345678',
+      ensName: null,
+      error: null,
+    })
+    expect(mockGetOwner).not.toHaveBeenCalled()
+  })
+
+  it('resolves owned ENS input to owner address', async () => {
+    mockGetOwner.mockResolvedValue({
+      owner: '0x00000000000000000000000000000000000000aa',
+    })
+
+    const { resolveFounderIdentityAction } = await import('./actions.js')
+    const result = await resolveFounderIdentityAction('founder')
+
+    expect(result).toEqual({
+      input: 'founder',
+      source: 'ens',
+      resolvedAddress: '0x00000000000000000000000000000000000000aa',
+      ensName: 'founder.eth',
+      error: null,
+    })
+  })
+
+  it('returns actionable message for invalid ENS format', async () => {
+    const { resolveFounderIdentityAction } = await import('./actions.js')
+    const result = await resolveFounderIdentityAction('ab')
+
+    expect(result.resolvedAddress).toBeNull()
+    expect(result.error).toBe(
+      'Enter a valid ENS name (like yourname.eth) or a 0x address.'
+    )
+  })
+
+  it('returns actionable message for unregistered ENS names', async () => {
+    mockGetOwner.mockResolvedValue({
+      owner: '0x0000000000000000000000000000000000000000',
+    })
+
+    const { resolveFounderIdentityAction } = await import('./actions.js')
+    const result = await resolveFounderIdentityAction('available-name')
+
+    expect(result.resolvedAddress).toBeNull()
+    expect(result.error).toContain(
+      'available-name.eth is not registered yet. Enter a registered ENS name or a 0x address.'
+    )
+  })
+
+  it('returns actionable message when ENS resolution fails', async () => {
+    mockGetOwner.mockRejectedValue(new Error('rpc down'))
+
+    const { resolveFounderIdentityAction } = await import('./actions.js')
+    const result = await resolveFounderIdentityAction('founder')
+
+    expect(result.resolvedAddress).toBeNull()
+    expect(result.error).toBe(
+      'Unable to resolve ENS right now. Try again or use a 0x address.'
+    )
+  })
+})
+
 describe('finalizeEnsRegistrationAction', () => {
   const safeAddress = '0x00000000000000000000000000000000000000aa' as const
   const existingRegistrationTxHash =
diff --git a/src/app/(app)/dashboard/setup/actions.ts b/src/app/(app)/dashboard/setup/actions.ts
index 7b902de..4535359 100644
--- a/src/app/(app)/dashboard/setup/actions.ts
+++ b/src/app/(app)/dashboard/setup/actions.ts
@@ -157,6 +157,79 @@ export async function getEnsOwnerAction(name: string) {
   return { name: fullName, owner }
 }
 
+export interface FounderIdentityResolution {
+  input: string
+  source: 'address' | 'ens'
+  resolvedAddress: string | null
+  ensName: string | null
+  error: string | null
+}
+
+export async function resolveFounderIdentityAction(
+  input: string
+): Promise<FounderIdentityResolution> {
+  const trimmedInput = input.trim()
+
+  if (!trimmedInput) {
+    return {
+      input: trimmedInput,
+      source: 'ens',
+      resolvedAddress: null,
+      ensName: null,
+      error: 'Enter an ENS name or Ethereum address.',
+    }
+  }
+
+  if (isAddress(trimmedInput)) {
+    return {
+      input: trimmedInput,
+      source: 'address',
+      resolvedAddress: trimmedInput,
+      ensName: null,
+      error: null,
+    }
+  }
+
+  try {
+    const { fullName } = normalizeEnsInput(trimmedInput)
+    const result = await getOwner(ensPublicClient, { name: fullName })
+    const owner =
+      result?.owner && result.owner !== ZERO_ADDRESS ? result.owner : null
+
+    if (!owner) {
+      return {
+        input: trimmedInput,
+        source: 'ens',
+        resolvedAddress: null,
+        ensName: fullName,
+        error: `${fullName} is not registered yet. Enter a registered ENS name or a 0x address.`,
+      }
+    }
+
+    return {
+      input: trimmedInput,
+      source: 'ens',
+      resolvedAddress: owner,
+      ensName: fullName,
+      error: null,
+    }
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : 'Unknown ENS resolution error'
+    const isFormatError = message.includes('Invalid ENS name')
+
+    return {
+      input: trimmedInput,
+      source: 'ens',
+      resolvedAddress: null,
+      ensName: null,
+      error: isFormatError
+        ? 'Enter a valid ENS name (like yourname.eth) or a 0x address.'
+        : 'Unable to resolve ENS right now. Try again or use a 0x address.',
+    }
+  }
+}
+
 type PendingRecord = PendingRegistration
 export type EnsRegistrationRecord = PendingRegistration
 
diff --git a/src/app/(app)/dashboard/setup/components/founder-validation-utils.test.ts b/src/app/(app)/dashboard/setup/components/founder-validation-utils.test.ts
new file mode 100644
index 0000000..f4aecbf
--- /dev/null
+++ b/src/app/(app)/dashboard/setup/components/founder-validation-utils.test.ts
@@ -0,0 +1,104 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  clearFounderValidationTimer,
+  createIdleFounderValidation,
+  scheduleFounderValidation,
+  shouldApplyFounderResolution,
+} from './founder-validation-utils'
+
+describe('founder-validation-utils', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+
+  it('debounces founder validation and only fires latest input once', () => {
+    const timers: Record<string, ReturnType<typeof setTimeout> | undefined> = {}
+    const onDebouncedValidate = vi.fn()
+
+    scheduleFounderValidation({
+      founderId: 'f-1',
+      input: 'p',
+      delayMs: 350,
+      timers,
+      onDebouncedValidate,
+    })
+    scheduleFounderValidation({
+      founderId: 'f-1',
+      input: 'pe',
+      delayMs: 350,
+      timers,
+      onDebouncedValidate,
+    })
+    scheduleFounderValidation({
+      founderId: 'f-1',
+      input: 'peter.eth',
+      delayMs: 350,
+      timers,
+      onDebouncedValidate,
+    })
+
+    vi.advanceTimersByTime(349)
+    expect(onDebouncedValidate).not.toHaveBeenCalled()
+
+    vi.advanceTimersByTime(1)
+    expect(onDebouncedValidate).toHaveBeenCalledTimes(1)
+    expect(onDebouncedValidate).toHaveBeenCalledWith('f-1', 'peter.eth')
+  })
+
+  it('applies resolution only when version and input still match', () => {
+    const shouldApplyCurrent = shouldApplyFounderResolution({
+      requestVersion: 3,
+      latestVersion: 3,
+      requestInput: 'peter.eth',
+      latestInput: 'peter.eth',
+    })
+    expect(shouldApplyCurrent).toBe(true)
+
+    const shouldIgnoreStaleVersion = shouldApplyFounderResolution({
+      requestVersion: 2,
+      latestVersion: 3,
+      requestInput: 'peter.eth',
+      latestInput: 'peter.eth',
+    })
+    expect(shouldIgnoreStaleVersion).toBe(false)
+
+    const shouldIgnoreStaleInput = shouldApplyFounderResolution({
+      requestVersion: 3,
+      latestVersion: 3,
+      requestInput: 'pet',
+      latestInput: 'peter.eth',
+    })
+    expect(shouldIgnoreStaleInput).toBe(false)
+  })
+
+  it('clears timer for removed founder row', () => {
+    const timers: Record<string, ReturnType<typeof setTimeout> | undefined> = {}
+    const onDebouncedValidate = vi.fn()
+
+    scheduleFounderValidation({
+      founderId: 'f-2',
+      input: 'remove.me.eth',
+      delayMs: 350,
+      timers,
+      onDebouncedValidate,
+    })
+
+    clearFounderValidationTimer('f-2', timers)
+    vi.advanceTimersByTime(400)
+
+    expect(onDebouncedValidate).not.toHaveBeenCalled()
+    expect(timers['f-2']).toBeUndefined()
+  })
+
+  it('creates idle validation state when founder input is cleared', () => {
+    expect(createIdleFounderValidation('')).toEqual({
+      status: 'idle',
+      input: '',
+      resolvedAddress: null,
+      ensName: null,
+      source: null,
+      error: null,
+    })
+  })
+})
diff --git a/src/app/(app)/dashboard/setup/components/founder-validation-utils.ts b/src/app/(app)/dashboard/setup/components/founder-validation-utils.ts
new file mode 100644
index 0000000..8b3bfa4
--- /dev/null
+++ b/src/app/(app)/dashboard/setup/components/founder-validation-utils.ts
@@ -0,0 +1,78 @@
+export type FounderValidationStatus = 'idle' | 'validating' | 'valid' | 'invalid'
+
+export interface FounderValidationState {
+  status: FounderValidationStatus
+  input: string
+  resolvedAddress: string | null
+  ensName: string | null
+  source: 'address' | 'ens' | null
+  error: string | null
+}
+
+export function createIdleFounderValidation(input = ''): FounderValidationState {
+  return {
+    status: 'idle',
+    input,
+    resolvedAddress: null,
+    ensName: null,
+    source: null,
+    error: null,
+  }
+}
+
+interface ScheduleFounderValidationParams {
+  founderId: string
+  input: string
+  delayMs: number
+  timers: Record<string, ReturnType<typeof setTimeout> | undefined>
+  onDebouncedValidate: (founderId: string, input: string) => void
+  setTimeoutFn?: typeof setTimeout
+  clearTimeoutFn?: typeof clearTimeout
+}
+
+export function scheduleFounderValidation({
+  founderId,
+  input,
+  delayMs,
+  timers,
+  onDebouncedValidate,
+  setTimeoutFn = setTimeout,
+  clearTimeoutFn = clearTimeout,
+}: ScheduleFounderValidationParams) {
+  const existingTimer = timers[founderId]
+  if (existingTimer) {
+    clearTimeoutFn(existingTimer)
+  }
+
+  timers[founderId] = setTimeoutFn(() => {
+    onDebouncedValidate(founderId, input)
+  }, delayMs)
+}
+
+export function clearFounderValidationTimer(
+  founderId: string,
+  timers: Record<string, ReturnType<typeof setTimeout> | undefined>,
+  clearTimeoutFn: typeof clearTimeout = clearTimeout
+) {
+  const existingTimer = timers[founderId]
+  if (existingTimer) {
+    clearTimeoutFn(existingTimer)
+    delete timers[founderId]
+  }
+}
+
+interface ShouldApplyFounderResolutionParams {
+  requestVersion: number
+  latestVersion: number
+  requestInput: string
+  latestInput: string
+}
+
+export function shouldApplyFounderResolution({
+  requestVersion,
+  latestVersion,
+  requestInput,
+  latestInput,
+}: ShouldApplyFounderResolutionParams) {
+  return requestVersion === latestVersion && requestInput === latestInput.trim()
+}
diff --git a/src/app/(app)/dashboard/setup/components/founders-form.tsx b/src/app/(app)/dashboard/setup/components/founders-form.tsx
index 195a4f1..a738761 100644
--- a/src/app/(app)/dashboard/setup/components/founders-form.tsx
+++ b/src/app/(app)/dashboard/setup/components/founders-form.tsx
@@ -1,8 +1,9 @@
 'use client'
 
-import { Plus, Trash2 } from 'lucide-react'
+import { AlertCircle, CheckCircle, Loader2, Plus, Trash2 } from 'lucide-react'
 
 import { type Shareholder } from '@/lib/store/draft'
+import { type FounderValidationState } from './founder-validation-utils'
 
 interface FoundersFormProps {
   shareholders: Shareholder[]
@@ -17,6 +18,8 @@ interface FoundersFormProps {
     field: 'walletAddress' | 'equityPercentage',
     value: string
   ) => void
+  onFounderInputChange: (id: string, value: string) => void
+  validationByFounderId: Record<string, FounderValidationState | undefined>
   onRegisterToDifferentAddressChange: (checked: boolean) => void
   onCustomAddressChange: (value: string) => void
 }
@@ -30,6 +33,8 @@ export function FoundersForm({
   onAddFounder,
   onRemoveFounder,
   onUpdateFounder,
+  onFounderInputChange,
+  validationByFounderId,
   onRegisterToDifferentAddressChange,
   onCustomAddressChange,
 }: FoundersFormProps) {
@@ -127,66 +132,80 @@ export function FoundersForm({
         </div>
 
         <div className="space-y-2">
-          {shareholders.map((founder, index) => (
-            <div
-              key={founder.id}
-              className="border-border rounded-lg border p-3"
-            >
-              <div className="flex items-center gap-2">
-                <div className="flex-1">
-                  <input
-                    type="text"
-                    placeholder="Email or ETH address"
-                    value={founder.walletAddress}
-                    disabled={!isMultipleFounders && index === 0}
-                    onChange={(event) =>
-                      onUpdateFounder(
-                        founder.id,
-                        'walletAddress',
-                        event.target.value
-                      )
-                    }
-                    className="border-border bg-background placeholder:text-muted-foreground focus:border-primary focus:ring-primary disabled:bg-muted disabled:text-muted-foreground disabled:cursor-not-allowed w-full rounded-lg border px-3 py-2 text-sm transition-all duration-200 focus:ring-2"
-                  />
-                </div>
+          {shareholders.map((founder, index) => {
+            const validation = validationByFounderId[founder.id]
+            const validationStatus = validation?.status ?? 'idle'
+            const isValidating = validationStatus === 'validating'
+            const isValid = validationStatus === 'valid'
+            const isInvalid = validationStatus === 'invalid'
+
+            return (
+              <div
+                key={founder.id}
+                className="border-border rounded-lg border p-3"
+              >
+                <div className="flex items-center gap-2">
+                  <div className="relative flex-1">
+                    <input
+                      type="text"
+                      placeholder="ENS name or ETH address"
+                      value={founder.walletAddress}
+                      disabled={!isMultipleFounders && index === 0}
+                      onChange={(event) =>
+                        onFounderInputChange(founder.id, event.target.value)
+                      }
+                      className="border-border bg-background placeholder:text-muted-foreground focus:border-primary focus:ring-primary disabled:bg-muted disabled:text-muted-foreground disabled:cursor-not-allowed w-full rounded-lg border px-3 py-2 pr-9 text-sm transition-all duration-200 focus:ring-2"
+                    />
+                    {isValidating && (
+                      <Loader2 className="text-muted-foreground pointer-events-none absolute top-1/2 right-3 h-4 w-4 -translate-y-1/2 animate-spin" />
+                    )}
+                    {isValid && (
+                      <CheckCircle className="text-primary pointer-events-none absolute top-1/2 right-3 h-4 w-4 -translate-y-1/2" />
+                    )}
+                    {isInvalid && (
+                      <AlertCircle className="text-destructive pointer-events-none absolute top-1/2 right-3 h-4 w-4 -translate-y-1/2" />
+                    )}
+                  </div>
 
-                {isMultipleFounders && (
-                  <div className="w-20">
-                    <div className="relative">
-                      <input
-                        type="number"
-                        min="0"
-                        max="100"
-                        step="0.1"
-                        value={founder.equityPercentage}
-                        onChange={(event) =>
-                          onUpdateFounder(
-                            founder.id,
-                            'equityPercentage',
-                            event.target.value
-                          )
-                        }
-                        className="border-border bg-background focus:border-primary focus:ring-primary w-full rounded-lg border px-2 py-2 pr-6 text-center text-sm transition-all duration-200 focus:ring-2"
-                      />
-                      <div className="text-muted-foreground absolute top-1/2 right-2 -translate-y-1/2 text-xs">
-                        %
+                  {isMultipleFounders && (
+                    <div className="w-20">
+                      <div className="relative">
+                        <input
+                          type="number"
+                          min="0"
+                          max="100"
+                          step="0.1"
+                          value={founder.equityPercentage}
+                          onChange={(event) =>
+                            onUpdateFounder(
+                              founder.id,
+                              'equityPercentage',
+                              event.target.value
+                            )
+                          }
+                          className="border-border bg-background focus:border-primary focus:ring-primary w-full rounded-lg border px-2 py-2 pr-6 text-center text-sm transition-all duration-200 focus:ring-2"
+                        />
+                        <div className="text-muted-foreground absolute top-1/2 right-2 -translate-y-1/2 text-xs">
+                          %
+                        </div>
                       </div>
                     </div>
-                  </div>
-                )}
+                  )}
+
+                  {isMultipleFounders && shareholders.length > 1 && (
+                    <button
+                      type="button"
+                      onClick={() => onRemoveFounder(founder.id)}
+                      className="text-muted-foreground hover:text-destructive rounded-lg p-2 transition-colors"
+                    >
+                      <Trash2 className="h-4 w-4" />
+                    </button>
+                  )}
+                </div>
 
-                {isMultipleFounders && shareholders.length > 1 && (
-                  <button
-                    type="button"
-                    onClick={() => onRemoveFounder(founder.id)}
-                    className="text-muted-foreground hover:text-destructive rounded-lg p-2 transition-colors"
-                  >
-                    <Trash2 className="h-4 w-4" />
-                  </button>
-                )}
               </div>
-            </div>
-          ))}
+            )
+          })}
 
           {isMultipleFounders && (
             <button
diff --git a/src/app/(app)/dashboard/setup/components/setup-wizard.tsx b/src/app/(app)/dashboard/setup/components/setup-wizard.tsx
index 4209832..1d073ae 100644
--- a/src/app/(app)/dashboard/setup/components/setup-wizard.tsx
+++ b/src/app/(app)/dashboard/setup/components/setup-wizard.tsx
@@ -1,9 +1,13 @@
 'use client'
 
 import { useRouter } from 'next/navigation'
-import { useEffect, useState } from 'react'
+import { useEffect, useRef, useState } from 'react'
 import { isAddress } from 'viem'
 
+import {
+  resolveFounderIdentityAction,
+  type FounderIdentityResolution,
+} from '../actions'
 import { useCompanyRegistration } from '@/hooks/use-company-registration'
 import { useWalletAuth } from '@/hooks/use-wallet-auth'
 import { calculateThreshold } from '@/lib/blockchain/safe-factory'
@@ -20,6 +24,15 @@ interface SetupWizardProps {
   initialEnsName: string
 }
 
+type FounderValidationMap = Record<string, FounderValidationState | undefined>
+
+interface FounderValidationResult {
+  founderId: string
+  valid: boolean
+  resolvedAddress: string | null
+}
+const FOUNDER_VALIDATION_DEBOUNCE_MS = 350
+
 const launchSteps = new Set([
   'awaiting-payment',
   'payment-pending',
@@ -63,6 +76,12 @@ export function SetupWizard({ initialEnsName }: SetupWizardProps) {
 
   const [isLoadingCosts, setIsLoadingCosts] = useState(false)
   const [localError, setLocalError] = useState<string | null>(null)
+  const [validationByFounderId, setValidationByFounderId] =
+    useState<FounderValidationMap>({})
+  const validationTimersRef = useRef<
+    Record<string, ReturnType<typeof setTimeout> | undefined>
+  >({})
+  const validationVersionByFounderIdRef = useRef<Record<string, number>>({})
 
   // Use wallet chain or fall back to default
   const chainId = walletChainId ?? STARTUPCHAIN_CHAIN_ID
@@ -117,6 +136,80 @@ export function SetupWizard({ initialEnsName }: SetupWizardProps) {
     }
   }, [authenticated, user, draft, addShareholder])
 
+  // Keep founder validation map in sync with current shareholder rows.
+  // Auto-mark the single read-only founder row as valid when it already has a 0x address.
+  useEffect(() => {
+    if (!draft) {
+      return
+    }
+
+    setValidationByFounderId((previous) => {
+      const next: FounderValidationMap = {}
+      let changed = Object.keys(previous).length !== draft.shareholders.length
+
+      draft.shareholders.forEach((founder, index) => {
+        const existing = previous[founder.id]
+        const founderInput = founder.walletAddress
+
+        if (existing && existing.input === founderInput) {
+          next[founder.id] = existing
+          return
+        }
+
+        const autoMarkAsValidAddress =
+          !draft.isMultipleFounders &&
+          index === 0 &&
+          Boolean(founderInput.trim()) &&
+          isAddress(founderInput.trim())
+
+        if (autoMarkAsValidAddress) {
+          next[founder.id] = {
+            status: 'valid',
+            input: founderInput,
+            resolvedAddress: founderInput.trim(),
+            ensName: null,
+            source: 'address',
+            error: null,
+          }
+        } else {
+          next[founder.id] = createIdleFounderValidation(founderInput)
+        }
+
+        changed = true
+      })
+
+      return changed ? next : previous
+    })
+  }, [draft])
+
+  // Clear timers/version slots for founders removed from the form.
+  useEffect(() => {
+    if (!draft) {
+      return
+    }
+
+    const activeFounderIds = new Set(draft.shareholders.map((founder) => founder.id))
+    const timerFounderIds = Object.keys(validationTimersRef.current)
+
+    timerFounderIds.forEach((founderId) => {
+      if (!activeFounderIds.has(founderId)) {
+        clearFounderValidationTimer(founderId, validationTimersRef.current)
+        delete validationVersionByFounderIdRef.current[founderId]
+      }
+    })
+  }, [draft])
+
+  // Prevent debounce timers from firing after unmount.
+  useEffect(() => {
+    const timers = validationTimersRef.current
+    return () => {
+      const founderIds = Object.keys(timers)
+      founderIds.forEach((founderId) => {
+        clearFounderValidationTimer(founderId, timers)
+      })
+    }
+  }, [])
+
   // Load costs when draft is ready
   useEffect(() => {
     if (!draft || !authenticated) return
@@ -173,6 +266,183 @@ export function SetupWizard({ initialEnsName }: SetupWizardProps) {
     0
   )
 
+  const applyFounderResolution = (
+    input: string,
+    resolution: FounderIdentityResolution
+  ): FounderValidationState => {
+    if (resolution.error || !resolution.resolvedAddress) {
+      return {
+        status: 'invalid',
+        input,
+        resolvedAddress: null,
+        ensName: resolution.ensName,
+        source: resolution.source,
+        error: resolution.error || 'Unable to resolve founder identity.',
+      }
+    }
+
+    return {
+      status: 'valid',
+      input,
+      resolvedAddress: resolution.resolvedAddress,
+      ensName: resolution.ensName,
+      source: resolution.source,
+      error: null,
+    }
+  }
+
+  const getNextFounderValidationVersion = (founderId: string) => {
+    const nextVersion = (validationVersionByFounderIdRef.current[founderId] ?? 0) + 1
+    validationVersionByFounderIdRef.current[founderId] = nextVersion
+    return nextVersion
+  }
+
+  const validateFounderById = async (
+    founderId: string,
+    options?: {
+      inputOverride?: string
+      requestVersion?: number
+      setValidatingState?: boolean
+    }
+  ): Promise<FounderValidationResult> => {
+    const currentDraft = useDraftStore.getState().draft
+    const founder = currentDraft?.shareholders.find(
+      (candidate) => candidate.id === founderId
+    )
+
+    if (!founder) {
+      return { founderId, valid: false, resolvedAddress: null }
+    }
+
+    const founderInput = (options?.inputOverride ?? founder.walletAddress).trim()
+    if (!founderInput) {
+      setValidationByFounderId((previous) => ({
+        ...previous,
+        [founderId]: createIdleFounderValidation(founder.walletAddress),
+      }))
+      return { founderId, valid: false, resolvedAddress: null }
+    }
+
+    const requestVersion =
+      options?.requestVersion ?? validationVersionByFounderIdRef.current[founderId] ?? 0
+
+    if (options?.setValidatingState !== false) {
+      setValidationByFounderId((previous) => ({
+        ...previous,
+        [founderId]: {
+          status: 'validating',
+          input: founder.walletAddress,
+          resolvedAddress: null,
+          ensName: null,
+          source: null,
+          error: null,
+        },
+      }))
+    }
+
+    try {
+      const resolution = await resolveFounderIdentityAction(founderInput)
+      const latestDraft = useDraftStore.getState().draft
+      const latestFounder = latestDraft?.shareholders.find(
+        (candidate) => candidate.id === founderId
+      )
+
+      if (!latestFounder || latestFounder.walletAddress.trim() !== founderInput) {
+        return { founderId, valid: false, resolvedAddress: null }
+      }
+
+      const shouldApplyResult = shouldApplyFounderResolution({
+        requestVersion,
+        latestVersion: validationVersionByFounderIdRef.current[founderId] ?? 0,
+        requestInput: founderInput,
+        latestInput: latestFounder.walletAddress,
+      })
+      if (!shouldApplyResult) {
+        return { founderId, valid: false, resolvedAddress: null }
+      }
+
+      const nextValidation = applyFounderResolution(
+        latestFounder.walletAddress,
+        resolution
+      )
+
+      setValidationByFounderId((previous) => ({
+        ...previous,
+        [founderId]: nextValidation,
+      }))
+
+      return {
+        founderId,
+        valid:
+          nextValidation.status === 'valid' && !!nextValidation.resolvedAddress,
+        resolvedAddress: nextValidation.resolvedAddress,
+      }
+    } catch (error) {
+      const latestDraft = useDraftStore.getState().draft
+      const latestFounder = latestDraft?.shareholders.find(
+        (candidate) => candidate.id === founderId
+      )
+      if (!latestFounder) {
+        return { founderId, valid: false, resolvedAddress: null }
+      }
+
+      const shouldApplyError = shouldApplyFounderResolution({
+        requestVersion,
+        latestVersion: validationVersionByFounderIdRef.current[founderId] ?? 0,
+        requestInput: founderInput,
+        latestInput: latestFounder.walletAddress,
+      })
+      if (!shouldApplyError) {
+        return { founderId, valid: false, resolvedAddress: null }
+      }
+
+      setValidationByFounderId((previous) => ({
+        ...previous,
+        [founderId]: {
+          status: 'invalid',
+          input: latestFounder.walletAddress,
+          resolvedAddress: null,
+          ensName: null,
+          source: null,
+          error: 'Unable to resolve ENS right now. Try again or use a 0x address.',
+        },
+      }))
+
+      console.error(LOG_PREFIX, 'Founder validation failed:', error)
+      return { founderId, valid: false, resolvedAddress: null }
+    }
+  }
+
+  const queueFounderValidation = (founderId: string, input: string) => {
+    const requestVersion = getNextFounderValidationVersion(founderId)
+    scheduleFounderValidation({
+      founderId,
+      input,
+      delayMs: FOUNDER_VALIDATION_DEBOUNCE_MS,
+      timers: validationTimersRef.current,
+      onDebouncedValidate: (debouncedFounderId, debouncedInput) => {
+        setValidationByFounderId((previous) => ({
+          ...previous,
+          [debouncedFounderId]: {
+            status: 'validating',
+            input: debouncedInput,
+            resolvedAddress: null,
+            ensName: null,
+            source: null,
+            error: null,
+          },
+        }))
+        validateFounderById(debouncedFounderId, {
+          inputOverride: debouncedInput,
+          requestVersion,
+          setValidatingState: false,
+        }).catch((error) => {
+          console.error(LOG_PREFIX, 'Founder debounce validation failed:', error)
+        })
+      },
+    })
+  }
+
   const handleFounderModeChange = (isMultiple: boolean) => {
     setFounderMode(isMultiple)
   }
@@ -190,13 +460,28 @@ export function SetupWizard({ initialEnsName }: SetupWizardProps) {
     field: 'walletAddress' | 'equityPercentage',
     value: string
   ) => {
-    if (field === 'walletAddress') {
-      updateShareholder(id, { walletAddress: value })
-    } else if (field === 'equityPercentage') {
+    if (field === 'equityPercentage') {
       updateShareholder(id, { equityPercentage: Number.parseFloat(value) || 0 })
     }
   }
 
+  const handleFounderInputChange = (founderId: string, value: string) => {
+    updateShareholder(founderId, { walletAddress: value })
+    setValidationByFounderId((previous) => ({
+      ...previous,
+      [founderId]: createIdleFounderValidation(value),
+    }))
+
+    const trimmedValue = value.trim()
+    if (!trimmedValue) {
+      getNextFounderValidationVersion(founderId)
+      clearFounderValidationTimer(founderId, validationTimersRef.current)
+      return
+    }
+
+    queueFounderValidation(founderId, value)
+  }
+
   const handleCreateBusiness = async () => {
     console.log(LOG_PREFIX, '=== handleCreateBusiness START ===')
     console.log(LOG_PREFIX, 'authenticated:', authenticated)
@@ -218,9 +503,31 @@ export function SetupWizard({ initialEnsName }: SetupWizardProps) {
     setLocalError(null)
 
     try {
+      const validationResults = await Promise.all(
+        draft.shareholders.map((founder) => {
+          clearFounderValidationTimer(founder.id, validationTimersRef.current)
+          const requestVersion = getNextFounderValidationVersion(founder.id)
+          return validateFounderById(founder.id, { requestVersion })
+        })
+      )
+      const hasInvalidFounder = validationResults.some(
+        (result) => !result.valid || !result.resolvedAddress
+      )
+
+      if (hasInvalidFounder) {
+        return
+      }
+
+      const resolvedAddressByFounderId = new Map(
+        validationResults.map((result) => [
+          result.founderId,
+          result.resolvedAddress,
+        ])
+      )
+
       const founders = draft.shareholders.map(
-        ({ walletAddress, equityPercentage }) => ({
-          address: walletAddress,
+        ({ id, equityPercentage }) => ({
+          address: resolvedAddressByFounderId.get(id) || '',
           equity: equityPercentage.toString(),
         })
       )
@@ -277,11 +584,38 @@ export function SetupWizard({ initialEnsName }: SetupWizardProps) {
       failedPhase === 'startupchain')
   const showLaunchSurface = launchSteps.has(step) || showLaunchFailure
 
+  const hasUnresolvedFounderIdentity =
+    authenticated &&
+    draft.shareholders.some((founder) => {
+      const founderInput = founder.walletAddress.trim()
+      if (!founderInput) {
+        return true
+      }
+
+      const validation = validationByFounderId[founder.id]
+      if (!validation) {
+        return true
+      }
+
+      if (validation.status === 'validating' || validation.status === 'invalid') {
+        return true
+      }
+
+      if (validation.status === 'idle') {
+        return true
+      }
+
+      return (
+        validation.input.trim() !== founderInput || !validation.resolvedAddress
+      )
+    })
+
   const disableCreateButton =
     step !== 'idle' ||
     isLoadingCosts ||
     (!authenticated &&
       draft.shareholders.some((founder) => !founder.walletAddress.trim())) ||
+    hasUnresolvedFounderIdentity ||
     (draft.isMultipleFounders && Math.abs(totalEquity - 100) > 0.01) ||
     (draft.registerToDifferentAddress && !draft.customAddress.trim())
 
@@ -332,6 +666,8 @@ export function SetupWizard({ initialEnsName }: SetupWizardProps) {
               onAddFounder={handleAddFounder}
               onRemoveFounder={handleRemoveFounder}
               onUpdateFounder={handleUpdateFounder}
+              onFounderInputChange={handleFounderInputChange}
+              validationByFounderId={validationByFounderId}
               onRegisterToDifferentAddressChange={setRegisterToDifferentAddress}
               onCustomAddressChange={setCustomAddress}
             />