diff --git a/packages/core/src/evaluation/orchestrator.ts b/packages/core/src/evaluation/orchestrator.ts
index 11a36ab3..e03ab967 100644
--- a/packages/core/src/evaluation/orchestrator.ts
+++ b/packages/core/src/evaluation/orchestrator.ts
@@ -1593,6 +1593,8 @@ export async function runEvalCase(options: RunEvalCaseOptions): Promise<Evaluati
   let attempt = 0;
   let providerResponse: ProviderResponse | undefined = cachedResponse;
   let lastError: unknown;
+  /** Set when a fallback target actually served the response. */
+  let targetUsed: string | undefined;
 
   while (!providerResponse && attempt < attemptBudget) {
     try {
@@ -1616,25 +1618,36 @@ export async function runEvalCase(options: RunEvalCaseOptions): Promise<Evaluati
         attempt += 1;
         continue;
       }
-      // On error, keep workspace for debugging (unless forceCleanup is set)
-      const errorResult = buildErrorResult(
-        evalCase,
-        target.name,
-        nowFn(),
-        error,
-        promptInputs,
-        provider,
-        'agent',
-        'provider_error',
-        verbose,
-      );
-      if (workspacePath) {
-        if (forceCleanup) {
-          await cleanupWorkspace(workspacePath).catch(() => {});
-        }
-        return { ...errorResult, workspacePath };
+      break; // Exhausted retries on primary — try fallback targets below
+    }
+  }
+
+  // Try fallback targets in order after exhausting retries on the primary
+  if (!providerResponse && target.fallbackTargets?.length && targetResolver) {
+    for (const fallbackName of target.fallbackTargets) {
+      const fallbackProvider = targetResolver(fallbackName);
+      if (!fallbackProvider) {
+        continue;
+      }
+      try {
+        providerResponse = await invokeProvider(fallbackProvider, {
+          evalCase: evalCase,
+          target,
+          promptInputs,
+          attempt: 0,
+          agentTimeoutMs,
+          signal,
+          cwd: workspacePath,
+          workspaceFile: caseWorkspaceFile ?? suiteWorkspaceFile,
+          captureFileChanges: !!baselineCommit,
+          streamCallbacks: options.streamCallbacks,
+        });
+        targetUsed = fallbackName;
+        break; // Fallback succeeded
+      } catch (error) {
+        lastError = error;
+        // Continue to next fallback
       }
-      return errorResult;
     }
   }
 
@@ -1812,9 +1825,13 @@ export async function runEvalCase(options: RunEvalCaseOptions): Promise<Evaluati
         ? 'execution_error'
         : classifyQualityStatus(result.score, caseThreshold);
 
+    // Include targetUsed only when a fallback target served the response
+    const targetUsedField = targetUsed ? { targetUsed } : {};
+
     const finalResult = providerError
       ? {
           ...result,
+          ...targetUsedField,
           evalRun,
           error: providerError,
           executionStatus,
@@ -1828,6 +1845,7 @@ export async function runEvalCase(options: RunEvalCaseOptions): Promise<Evaluati
       : skippedEvaluatorError
         ? {
             ...result,
+            ...targetUsedField,
             score: 0,
             evalRun,
             error: skippedEvaluatorError,
@@ -1841,6 +1859,7 @@ export async function runEvalCase(options: RunEvalCaseOptions): Promise<Evaluati
           }
         : {
             ...result,
+            ...targetUsedField,
             evalRun,
             executionStatus,
             beforeAllOutput,
diff --git a/packages/core/src/evaluation/providers/targets.ts b/packages/core/src/evaluation/providers/targets.ts
index 2d6562a8..dd1df2d0 100644
--- a/packages/core/src/evaluation/providers/targets.ts
+++ b/packages/core/src/evaluation/providers/targets.ts
@@ -592,6 +592,11 @@ interface ResolvedTargetBase {
    * to force CLI invocation even in subagent mode.
    */
   readonly subagentModeAllowed?: boolean;
+  /**
+   * Ordered list of target names to try when the primary target fails after
+   * exhausting retries. Each fallback is attempted in order.
+   */
+  readonly fallbackTargets?: readonly string[];
 }
 
 export type ResolvedTarget =
@@ -642,6 +647,8 @@ export const COMMON_TARGET_SETTINGS = [
   'providerBatching',
   'subagent_mode_allowed',
   'subagentModeAllowed',
+  'fallback_targets',
+  'fallbackTargets',
 ] as const;
 
 const BASE_TARGET_SCHEMA = z
@@ -654,6 +661,8 @@ const BASE_TARGET_SCHEMA = z
     workspace_template: z.string().optional(),
     workspaceTemplate: z.string().optional(),
     subagent_mode_allowed: z.boolean().optional(),
+    fallback_targets: z.array(z.string().min(1)).optional(),
+    fallbackTargets: z.array(z.string().min(1)).optional(),
   })
   .passthrough();
 
@@ -741,12 +750,14 @@ export function resolveTargetDefinition(
   );
 
   // Shared base fields for all resolved targets
+  const fallbackTargets = parsed.fallback_targets ?? parsed.fallbackTargets;
   const base = {
     name: parsed.name,
     graderTarget: parsed.grader_target ?? parsed.judge_target,
     workers: parsed.workers,
     providerBatching,
     subagentModeAllowed,
+    ...(fallbackTargets ? { fallbackTargets } : {}),
   } as const;
 
   switch (provider) {
diff --git a/packages/core/src/evaluation/providers/types.ts b/packages/core/src/evaluation/providers/types.ts
index 33cf09d9..9b12dce7 100644
--- a/packages/core/src/evaluation/providers/types.ts
+++ b/packages/core/src/evaluation/providers/types.ts
@@ -382,4 +382,7 @@ export interface TargetDefinition {
   readonly retryBackoffFactor?: number | unknown | undefined;
   readonly retry_status_codes?: unknown | undefined;
   readonly retryStatusCodes?: unknown | undefined;
+  // Fallback targets for provider errors
+  readonly fallback_targets?: readonly string[] | unknown | undefined;
+  readonly fallbackTargets?: readonly string[] | unknown | undefined;
 }
diff --git a/packages/core/src/evaluation/types.ts b/packages/core/src/evaluation/types.ts
index 3d26498c..a554ac85 100644
--- a/packages/core/src/evaluation/types.ts
+++ b/packages/core/src/evaluation/types.ts
@@ -900,6 +900,11 @@ export interface EvaluationResult {
   readonly score: number;
   readonly assertions: readonly AssertionEntry[];
   readonly target: string;
+  /**
+   * The target that actually served the response, when different from the
+   * primary target. Present only when a fallback target was used.
+   */
+  readonly targetUsed?: string;
   /** Token usage metrics from provider (optional) */
   readonly tokenUsage?: TokenUsage;
   /** Total cost in USD (optional, from provider) */
diff --git a/packages/core/test/evaluation/providers/fallback-targets.test.ts b/packages/core/test/evaluation/providers/fallback-targets.test.ts
new file mode 100644
index 00000000..cd4b2b24
--- /dev/null
+++ b/packages/core/test/evaluation/providers/fallback-targets.test.ts
@@ -0,0 +1,342 @@
+/**
+ * Tests for fallback_targets feature.
+ *
+ * When a primary target fails with provider errors after exhausting retries,
+ * the runner tries fallback targets in order. The result records which target
+ * actually served the response via the `targetUsed` field.
+ */
+import { describe, expect, it } from 'bun:test';
+
+import { runEvalCase } from '../../../src/evaluation/orchestrator.js';
+import { resolveTargetDefinition } from '../../../src/evaluation/providers/targets.js';
+import type { ResolvedTarget } from '../../../src/evaluation/providers/targets.js';
+import type { Provider, ProviderResponse } from '../../../src/evaluation/providers/types.js';
+import type { EvalTest } from '../../../src/evaluation/types.js';
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+function makeResponse(content: string): ProviderResponse {
+  return {
+    output: [{ role: 'assistant', content }],
+  };
+}
+
+class FailingProvider implements Provider {
+  readonly id: string;
+  readonly kind = 'mock' as const;
+  readonly targetName: string;
+
+  constructor(targetName: string) {
+    this.id = `failing:${targetName}`;
+    this.targetName = targetName;
+  }
+
+  async invoke(): Promise<ProviderResponse> {
+    const error = new Error('Service Unavailable') as Error & { status: number };
+    error.status = 503;
+    throw error;
+  }
+}
+
+class SuccessProvider implements Provider {
+  readonly id: string;
+  readonly kind = 'mock' as const;
+  readonly targetName: string;
+  private readonly response: ProviderResponse;
+  invoked = false;
+
+  constructor(targetName: string, content = 'ok') {
+    this.id = `success:${targetName}`;
+    this.targetName = targetName;
+    this.response = makeResponse(content);
+  }
+
+  async invoke(): Promise<ProviderResponse> {
+    this.invoked = true;
+    return this.response;
+  }
+}
+
+const MOCK_EVAL_CASE: EvalTest = {
+  id: 'test-1',
+  question: 'What is 1+1?',
+  input: [{ role: 'user', content: 'What is 1+1?' }],
+  expected_output: [],
+  file_paths: [],
+  criteria: 'Answer correctly',
+};
+
+const MOCK_TARGET: ResolvedTarget = {
+  kind: 'mock',
+  name: 'primary',
+  config: { response: 'ok' },
+  fallbackTargets: ['fallback-a', 'fallback-b'],
+};
+
+const MOCK_TARGET_NO_FALLBACK: ResolvedTarget = {
+  kind: 'mock',
+  name: 'primary',
+  config: { response: 'ok' },
+};
+
+function makeGraderResponse(): ProviderResponse {
+  return {
+    output: [
+      {
+        role: 'assistant',
+        content: JSON.stringify({
+          score: 10,
+          pass: true,
+          criteria: [{ id: 'main', score: 10, satisfied: true }],
+        }),
+      },
+    ],
+  };
+}
+
+class StubGrader implements Provider {
+  readonly id = 'grader:stub';
+  readonly kind = 'mock' as const;
+  readonly targetName = 'grader';
+
+  async invoke(): Promise<ProviderResponse> {
+    return makeGraderResponse();
+  }
+}
+
+// Minimal evaluator map required by runEvalCase
+const evaluators = {
+  'llm-grader': {
+    kind: 'llm-grader',
+    async evaluate() {
+      return {
+        score: 1.0,
+        verdict: 'pass' as const,
+        assertions: [{ text: 'Passed', passed: true }],
+        expectedAspectCount: 1,
+      };
+    },
+  },
+};
+
+// ---------------------------------------------------------------------------
+// resolveTargetDefinition tests
+// ---------------------------------------------------------------------------
+
+describe('resolveTargetDefinition - fallback_targets', () => {
+  const env = {
+    TEST_KEY: 'sk-test-key',
+    TEST_MODEL: 'gpt-4o-mini',
+  };
+
+  it('resolves fallback_targets from snake_case YAML field', () => {
+    const definition = {
+      name: 'test-openai',
+      provider: 'openai',
+      api_key: '${{ TEST_KEY }}',
+      model: '${{ TEST_MODEL }}',
+      fallback_targets: ['azure-llm', 'gemini-flash'],
+    };
+
+    const resolved = resolveTargetDefinition(definition, env);
+    expect(resolved.fallbackTargets).toEqual(['azure-llm', 'gemini-flash']);
+  });
+
+  it('resolves fallbackTargets from camelCase field', () => {
+    const definition = {
+      name: 'test-openai',
+      provider: 'openai',
+      api_key: '${{ TEST_KEY }}',
+      model: '${{ TEST_MODEL }}',
+      fallbackTargets: ['backup-1'],
+    };
+
+    const resolved = resolveTargetDefinition(definition, env);
+    expect(resolved.fallbackTargets).toEqual(['backup-1']);
+  });
+
+  it('snake_case takes priority over camelCase', () => {
+    const definition = {
+      name: 'test-openai',
+      provider: 'openai',
+      api_key: '${{ TEST_KEY }}',
+      model: '${{ TEST_MODEL }}',
+      fallback_targets: ['snake-wins'],
+      fallbackTargets: ['camel-loses'],
+    };
+
+    const resolved = resolveTargetDefinition(definition, env);
+    expect(resolved.fallbackTargets).toEqual(['snake-wins']);
+  });
+
+  it('omits fallbackTargets when not specified', () => {
+    const definition = {
+      name: 'test-openai',
+      provider: 'openai',
+      api_key: '${{ TEST_KEY }}',
+      model: '${{ TEST_MODEL }}',
+    };
+
+    const resolved = resolveTargetDefinition(definition, env);
+    expect(resolved.fallbackTargets).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Orchestrator fallback tests
+// ---------------------------------------------------------------------------
+
+describe('runEvalCase - fallback targets', () => {
+  it('uses fallback provider when primary fails', async () => {
+    const primary = new FailingProvider('primary');
+    const fallbackA = new SuccessProvider('fallback-a', 'from fallback-a');
+
+    const result = await runEvalCase({
+      evalCase: MOCK_EVAL_CASE,
+      provider: primary,
+      target: MOCK_TARGET,
+      evaluators,
+      maxRetries: 0, // No retries on primary, go straight to fallback
+      targetResolver: (name: string) => {
+        if (name === 'fallback-a') return fallbackA;
+        return undefined;
+      },
+      availableTargets: ['primary', 'fallback-a', 'fallback-b'],
+    });
+
+    expect(result.targetUsed).toBe('fallback-a');
+    expect(fallbackA.invoked).toBe(true);
+    // Should not be an error result — fallback succeeded
+    expect(result.error).toBeUndefined();
+  });
+
+  it('skips unavailable fallback and uses next one', async () => {
+    const primary = new FailingProvider('primary');
+    const fallbackB = new SuccessProvider('fallback-b', 'from fallback-b');
+
+    const result = await runEvalCase({
+      evalCase: MOCK_EVAL_CASE,
+      provider: primary,
+      target: MOCK_TARGET,
+      evaluators,
+      maxRetries: 0,
+      targetResolver: (name: string) => {
+        // fallback-a is not resolvable
+        if (name === 'fallback-b') return fallbackB;
+        return undefined;
+      },
+      availableTargets: ['primary', 'fallback-b'],
+    });
+
+    expect(result.targetUsed).toBe('fallback-b');
+    expect(fallbackB.invoked).toBe(true);
+    expect(result.error).toBeUndefined();
+  });
+
+  it('returns error when primary and all fallbacks fail', async () => {
+    const primary = new FailingProvider('primary');
+    const fallbackA = new FailingProvider('fallback-a');
+    const fallbackB = new FailingProvider('fallback-b');
+
+    const result = await runEvalCase({
+      evalCase: MOCK_EVAL_CASE,
+      provider: primary,
+      target: MOCK_TARGET,
+      evaluators,
+      maxRetries: 0,
+      targetResolver: (name: string) => {
+        if (name === 'fallback-a') return fallbackA;
+        if (name === 'fallback-b') return fallbackB;
+        return undefined;
+      },
+      availableTargets: ['primary', 'fallback-a', 'fallback-b'],
+    });
+
+    expect(result.error).toBeDefined();
+    expect(result.executionStatus).toBe('execution_error');
+  });
+
+  it('does not use fallback when primary succeeds', async () => {
+    const primary = new SuccessProvider('primary', 'from primary');
+    const fallbackA = new SuccessProvider('fallback-a', 'from fallback-a');
+
+    const result = await runEvalCase({
+      evalCase: MOCK_EVAL_CASE,
+      provider: primary,
+      target: MOCK_TARGET,
+      evaluators,
+      maxRetries: 0,
+      targetResolver: (name: string) => {
+        if (name === 'fallback-a') return fallbackA;
+        return undefined;
+      },
+      availableTargets: ['primary', 'fallback-a'],
+    });
+
+    expect(result.targetUsed).toBeUndefined();
+    expect(fallbackA.invoked).toBe(false);
+    expect(result.target).toBe('primary');
+  });
+
+  it('target field always shows primary target name', async () => {
+    const primary = new FailingProvider('primary');
+    const fallbackA = new SuccessProvider('fallback-a', 'from fallback-a');
+
+    const result = await runEvalCase({
+      evalCase: MOCK_EVAL_CASE,
+      provider: primary,
+      target: MOCK_TARGET,
+      evaluators,
+      maxRetries: 0,
+      targetResolver: (name: string) => {
+        if (name === 'fallback-a') return fallbackA;
+        return undefined;
+      },
+      availableTargets: ['primary', 'fallback-a'],
+    });
+
+    // target always shows the primary target name
+    expect(result.target).toBe('primary');
+    // targetUsed shows which fallback actually served the response
+    expect(result.targetUsed).toBe('fallback-a');
+  });
+
+  it('does not attempt fallback when no fallback_targets configured', async () => {
+    const primary = new FailingProvider('primary');
+    const fallbackA = new SuccessProvider('fallback-a', 'from fallback-a');
+
+    const result = await runEvalCase({
+      evalCase: MOCK_EVAL_CASE,
+      provider: primary,
+      target: MOCK_TARGET_NO_FALLBACK,
+      evaluators,
+      maxRetries: 0,
+      targetResolver: (name: string) => {
+        if (name === 'fallback-a') return fallbackA;
+        return undefined;
+      },
+      availableTargets: ['primary', 'fallback-a'],
+    });
+
+    expect(result.error).toBeDefined();
+    expect(fallbackA.invoked).toBe(false);
+  });
+
+  it('does not attempt fallback when targetResolver is not provided', async () => {
+    const primary = new FailingProvider('primary');
+
+    const result = await runEvalCase({
+      evalCase: MOCK_EVAL_CASE,
+      provider: primary,
+      target: MOCK_TARGET,
+      evaluators,
+      maxRetries: 0,
+      // No targetResolver — cannot resolve fallback names
+    });
+
+    expect(result.error).toBeDefined();
+    expect(result.executionStatus).toBe('execution_error');
+  });
+});