diff --git a/app/src/components/intelligence/IntelligenceOrchestrationTab.test.tsx b/app/src/components/intelligence/IntelligenceOrchestrationTab.test.tsx
new file mode 100644
index 000000000..25eabd51f
--- /dev/null
+++ b/app/src/components/intelligence/IntelligenceOrchestrationTab.test.tsx
@@ -0,0 +1,345 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  type WorkflowDefinition,
+  type WorkflowRun,
+  workflowRunsApi,
+} from '../../services/api/workflowRunsApi';
+import IntelligenceOrchestrationTab from './IntelligenceOrchestrationTab';
+
+vi.mock('../../services/api/workflowRunsApi', async importOriginal => {
+  // Keep the real assessWorkflowCost / thresholds; mock only the RPC client.
+  const actual = await importOriginal<typeof import('../../services/api/workflowRunsApi')>();
+  return {
+    ...actual,
+    workflowRunsApi: {
+      listDefinitions: vi.fn(),
+      listRuns: vi.fn(),
+      getRun: vi.fn(),
+      startRun: vi.fn(),
+      stopRun: vi.fn(),
+      resumeRun: vi.fn(),
+    },
+  };
+});
+
+// i18n → echo the key so assertions can target stable strings.
+vi.mock('../../lib/i18n/I18nContext', () => ({ useT: () => ({ t: (k: string) => k }) }));
+
+const api = vi.mocked(workflowRunsApi);
+
+function builtin(overrides: Partial<WorkflowDefinition> = {}): WorkflowDefinition {
+  return {
+    id: 'parallel_research_cross_check',
+    name: 'Parallel research',
+    description: 'desc',
+    phases: [{ name: 'decompose', description: '', agentIds: ['planner'], dependsOn: [] }],
+    defaultConcurrency: 2,
+    maxChildren: 8, // >= threshold → approval required
+    safetyTier: 'read_only',
+    ...overrides,
+  };
+}
+
+function startedRun(): WorkflowRun {
+  return {
+    id: 'wfrun-1',
+    definitionId: 'parallel_research_cross_check',
+    parentThreadId: null,
+    input: {},
+    phaseStates: { decompose: { status: 'running', outputs: [] } },
+    childRunIds: [],
+    status: 'running',
+    summary: null,
+    startedAt: '2026-01-01T00:00:00Z',
+    updatedAt: '2026-01-01T00:00:00Z',
+    completedAt: null,
+  };
+}
+
+describe('IntelligenceOrchestrationTab — approval gating', () => {
+  beforeEach(() => {
+    api.listDefinitions.mockReset();
+    api.listRuns.mockReset();
+    api.startRun.mockReset();
+    api.getRun.mockReset();
+    api.listRuns.mockResolvedValue([]);
+    api.getRun.mockResolvedValue(startedRun());
+  });
+
+  it('shows the approval card (not a direct start) for a high-cost definition', async () => {
+    api.listDefinitions.mockResolvedValue([builtin()]);
+    render(<IntelligenceOrchestrationTab />);
+
+    fireEvent.click(await screen.findByTestId('orchestration-start-parallel_research_cross_check'));
+
+    expect(screen.getByTestId('workflow-approval-card')).toBeInTheDocument();
+    // No direct "start run" button when approval is required.
+    expect(screen.queryByTestId('orchestration-confirm-start')).not.toBeInTheDocument();
+    // startRun must NOT have fired yet — approval is still pending.
+    expect(api.startRun).not.toHaveBeenCalled();
+  });
+
+  it('starts the run only after the approval is granted', async () => {
+    api.listDefinitions.mockResolvedValue([builtin()]);
+    api.startRun.mockResolvedValue(startedRun());
+    render(<IntelligenceOrchestrationTab />);
+
+    fireEvent.click(await screen.findByTestId('orchestration-start-parallel_research_cross_check'));
+    fireEvent.click(screen.getByTestId('workflow-approval-approve'));
+
+    await waitFor(() =>
+      expect(api.startRun).toHaveBeenCalledWith({
+        definitionId: 'parallel_research_cross_check',
+        input: undefined,
+      })
+    );
+  });
+
+  it('starts directly (no approval card) for a cheap read-only definition', async () => {
+    api.listDefinitions.mockResolvedValue([
+      builtin({ id: 'cheap', name: 'Cheap', maxChildren: 3, defaultConcurrency: 2 }),
+    ]);
+    api.startRun.mockResolvedValue(startedRun());
+    render(<IntelligenceOrchestrationTab />);
+
+    fireEvent.click(await screen.findByTestId('orchestration-start-cheap'));
+    expect(screen.queryByTestId('workflow-approval-card')).not.toBeInTheDocument();
+    expect(screen.getByTestId('orchestration-confirm-start')).toBeInTheDocument();
+  });
+});
+
+const cheap = () => builtin({ id: 'cheap', name: 'Cheap', maxChildren: 3, defaultConcurrency: 2 });
+
+describe('IntelligenceOrchestrationTab — load + empty states', () => {
+  beforeEach(() => {
+    api.listDefinitions.mockReset();
+    api.listRuns.mockReset();
+    api.startRun.mockReset();
+    api.getRun.mockReset();
+    api.stopRun.mockReset();
+    api.resumeRun.mockReset();
+  });
+
+  it('shows the error state when loading fails and retries on click', async () => {
+    api.listDefinitions.mockRejectedValueOnce(new Error('rpc boom'));
+    api.listRuns.mockResolvedValue([]);
+    render(<IntelligenceOrchestrationTab />);
+
+    // load() catch path (lines 79-81) + error render (224) + retry button (231-233).
+    expect(await screen.findByText(/orchestration.failedToLoad/)).toBeInTheDocument();
+    expect(screen.getByText(/rpc boom/)).toBeInTheDocument();
+
+    // Second attempt succeeds and clears the error.
+    api.listDefinitions.mockResolvedValueOnce([cheap()]);
+    fireEvent.click(screen.getByText('common.retry'));
+    expect(await screen.findByTestId('orchestration-start-cheap')).toBeInTheDocument();
+  });
+
+  it('renders the empty definitions + empty runs placeholders', async () => {
+    api.listDefinitions.mockResolvedValue([]);
+    api.listRuns.mockResolvedValue([]);
+    render(<IntelligenceOrchestrationTab />);
+
+    // noDefinitions (251) + noRuns placeholders.
+    expect(await screen.findByText('orchestration.noDefinitions')).toBeInTheDocument();
+    expect(screen.getByText('orchestration.noRuns')).toBeInTheDocument();
+  });
+});
+
+describe('IntelligenceOrchestrationTab — start flow + run list', () => {
+  beforeEach(() => {
+    api.listDefinitions.mockReset();
+    api.listRuns.mockReset();
+    api.startRun.mockReset();
+    api.getRun.mockReset();
+    api.stopRun.mockReset();
+    api.resumeRun.mockReset();
+    api.listRuns.mockResolvedValue([]);
+    api.getRun.mockResolvedValue(startedRun());
+  });
+
+  it('starts a cheap run with the typed question and opens its detail view', async () => {
+    api.listDefinitions.mockResolvedValue([cheap()]);
+    api.startRun.mockResolvedValue(startedRun());
+    render(<IntelligenceOrchestrationTab />);
+
+    fireEvent.click(await screen.findByTestId('orchestration-start-cheap'));
+    // Type a question (covers the controlled textarea onChange, line 305).
+    fireEvent.change(screen.getByTestId('orchestration-question'), {
+      target: { value: '  why is the sky blue?  ' },
+    });
+    // Direct confirm-start (lines 330, 332).
+    fireEvent.click(screen.getByTestId('orchestration-confirm-start'));
+
+    // doStart trims + forwards the question (line 161) and opens the run detail.
+    await waitFor(() =>
+      expect(api.startRun).toHaveBeenCalledWith({
+        definitionId: 'cheap',
+        input: { question: 'why is the sky blue?' },
+      })
+    );
+    expect(await screen.findByTestId('orchestration-selected-run')).toBeInTheDocument();
+    // The started run is upserted into the recent-runs list (lines 402-408).
+    expect(screen.getByTestId('orchestration-run-wfrun-1')).toBeInTheDocument();
+  });
+
+  it('surfaces a start error inline (doStart catch path)', async () => {
+    api.listDefinitions.mockResolvedValue([cheap()]);
+    api.startRun.mockRejectedValueOnce(new Error('start failed'));
+    render(<IntelligenceOrchestrationTab />);
+
+    fireEvent.click(await screen.findByTestId('orchestration-start-cheap'));
+    fireEvent.click(screen.getByTestId('orchestration-confirm-start'));
+
+    // doStart error branch (lines 169-171) renders the inline error.
+    expect(await screen.findByText(/start failed/)).toBeInTheDocument();
+    // The panel stays open (no selected run).
+    expect(screen.queryByTestId('orchestration-selected-run')).not.toBeInTheDocument();
+  });
+
+  it('cancels the start panel without starting a run', async () => {
+    api.listDefinitions.mockResolvedValue([cheap()]);
+    render(<IntelligenceOrchestrationTab />);
+
+    fireEvent.click(await screen.findByTestId('orchestration-start-cheap'));
+    expect(screen.getByTestId('orchestration-confirm-start')).toBeInTheDocument();
+    // cancelStart (lines 148-150) closes the panel.
+    fireEvent.click(screen.getByText('orchestration.approval.cancel'));
+    await waitFor(() =>
+      expect(screen.queryByTestId('orchestration-confirm-start')).not.toBeInTheDocument()
+    );
+    expect(api.startRun).not.toHaveBeenCalled();
+  });
+
+  it('opens a recent run, updates it via upsert, then closes it', async () => {
+    api.listDefinitions.mockResolvedValue([cheap()]);
+    // A pre-existing run in the recent list (drives the runs.map render, 402-408).
+    api.listRuns.mockResolvedValue([startedRun()]);
+    render(<IntelligenceOrchestrationTab />);
+
+    fireEvent.click(await screen.findByTestId('orchestration-run-wfrun-1'));
+    expect(await screen.findByTestId('orchestration-selected-run')).toBeInTheDocument();
+
+    // Close the drill-in (lines 364-366).
+    fireEvent.click(screen.getByTestId('orchestration-close-run'));
+    await waitFor(() =>
+      expect(screen.queryByTestId('orchestration-selected-run')).not.toBeInTheDocument()
+    );
+  });
+});
+
+describe('IntelligenceOrchestrationTab — stop / resume controls', () => {
+  beforeEach(() => {
+    api.listDefinitions.mockReset();
+    api.listRuns.mockReset();
+    api.getRun.mockReset();
+    api.stopRun.mockReset();
+    api.resumeRun.mockReset();
+    api.listDefinitions.mockResolvedValue([cheap()]);
+  });
+
+  it('stops a running run and reflects the interrupted snapshot', async () => {
+    api.listRuns.mockResolvedValue([startedRun()]);
+    // First poll snapshot is still running (Stop renders); once stopped the
+    // backend reports interrupted, so subsequent polls agree and don't race the
+    // stop result back to running (matches the serialized poll loop).
+    api.getRun
+      .mockResolvedValueOnce(startedRun())
+      .mockResolvedValue({ ...startedRun(), status: 'interrupted' });
+    api.stopRun.mockResolvedValue({ ...startedRun(), status: 'interrupted' });
+    render(<IntelligenceOrchestrationTab />);
+
+    fireEvent.click(await screen.findByTestId('orchestration-run-wfrun-1'));
+    fireEvent.click(await screen.findByTestId('workflow-run-stop'));
+
+    // handleStop (lines 179-185) calls stopRun and upserts the result.
+    await waitFor(() => expect(api.stopRun).toHaveBeenCalledWith('wfrun-1'));
+    await waitFor(() =>
+      expect(screen.getByTestId('workflow-run-status')).toHaveTextContent(
+        'orchestration.runStatus.interrupted'
+      )
+    );
+  });
+
+  it('resumes an interrupted run', async () => {
+    const interrupted = { ...startedRun(), status: 'interrupted' as const };
+    api.listRuns.mockResolvedValue([interrupted]);
+    api.getRun.mockResolvedValue(interrupted);
+    api.resumeRun.mockResolvedValue({ ...startedRun(), status: 'running' });
+    render(<IntelligenceOrchestrationTab />);
+
+    fireEvent.click(await screen.findByTestId('orchestration-run-wfrun-1'));
+    fireEvent.click(await screen.findByTestId('workflow-run-resume'));
+
+    // handleResume (lines 197-203) calls resumeRun and upserts the result.
+    await waitFor(() => expect(api.resumeRun).toHaveBeenCalledWith('wfrun-1'));
+    await waitFor(() =>
+      expect(screen.getByTestId('workflow-run-status')).toHaveTextContent(
+        'orchestration.runStatus.running'
+      )
+    );
+  });
+
+  it('swallows a stop RPC error without crashing', async () => {
+    api.listRuns.mockResolvedValue([startedRun()]);
+    api.getRun.mockResolvedValue(startedRun());
+    api.stopRun.mockRejectedValueOnce(new Error('stop boom'));
+    render(<IntelligenceOrchestrationTab />);
+
+    fireEvent.click(await screen.findByTestId('orchestration-run-wfrun-1'));
+    fireEvent.click(await screen.findByTestId('workflow-run-stop'));
+
+    // handleStop catch path (lines 188, 190): still mounted, button re-enabled.
+    await waitFor(() => expect(api.stopRun).toHaveBeenCalled());
+    expect(screen.getByTestId('orchestration-selected-run')).toBeInTheDocument();
+  });
+});
+
+describe('IntelligenceOrchestrationTab — polling loop', () => {
+  beforeEach(() => {
+    api.listDefinitions.mockReset();
+    api.listRuns.mockReset();
+    api.getRun.mockReset();
+    api.listDefinitions.mockResolvedValue([cheap()]);
+    api.listRuns.mockResolvedValue([startedRun()]);
+  });
+
+  it('polls getRun for a selected non-terminal run and upserts the fresh snapshot', async () => {
+    // First poll returns a completed snapshot.
+    api.getRun.mockResolvedValue({
+      ...startedRun(),
+      status: 'completed',
+      summary: 'done',
+      completedAt: '2026-01-01T00:05:00Z',
+    });
+    render(<IntelligenceOrchestrationTab />);
+
+    // Select the run; the parent then starts the real 2s poll interval. We wait
+    // (real timers) for the first tick rather than fight fake timers vs. the
+    // interval registered inside the post-select effect.
+    fireEvent.click(await screen.findByTestId('orchestration-run-wfrun-1'));
+    expect(await screen.findByTestId('orchestration-selected-run')).toBeInTheDocument();
+
+    // tick() runs after POLL_INTERVAL_MS (lines 117-121); upsert flips status.
+    await waitFor(() => expect(api.getRun).toHaveBeenCalledWith('wfrun-1'), { timeout: 4000 });
+    await waitFor(() =>
+      expect(screen.getByTestId('workflow-run-status')).toHaveTextContent(
+        'orchestration.runStatus.completed'
+      )
+    );
+  });
+
+  it('swallows a poll error (tick catch path)', async () => {
+    api.getRun.mockRejectedValue(new Error('poll boom'));
+    render(<IntelligenceOrchestrationTab />);
+
+    fireEvent.click(await screen.findByTestId('orchestration-run-wfrun-1'));
+    expect(await screen.findByTestId('orchestration-selected-run')).toBeInTheDocument();
+
+    // tick catch (line 123): poll rejects, the run stays open with no crash.
+    await waitFor(() => expect(api.getRun).toHaveBeenCalled(), { timeout: 4000 });
+    expect(screen.getByTestId('orchestration-selected-run')).toBeInTheDocument();
+  });
+});
diff --git a/app/src/components/intelligence/IntelligenceOrchestrationTab.tsx b/app/src/components/intelligence/IntelligenceOrchestrationTab.tsx
new file mode 100644
index 000000000..34d8644c7
--- /dev/null
+++ b/app/src/components/intelligence/IntelligenceOrchestrationTab.tsx
@@ -0,0 +1,437 @@
+/**
+ * IntelligenceOrchestrationTab (#3375)
+ * ------------------------------------
+ *
+ * The Workflows / multi-agent orchestration surface in the Intelligence command
+ * center. Lets the user:
+ *   - browse runnable workflow definitions (`workflow_run_list_definitions`),
+ *   - start the parallel-research workflow (`workflow_run_start`) — gated behind
+ *     an explicit approval card for high-cost / high-concurrency definitions,
+ *   - drill into a run's phase progress, child agent refs, and final synthesis,
+ *   - stop / resume a run.
+ *
+ * Progress is poll-based (the engine emits no socket events yet): once a run is
+ * selected and non-terminal, this tab polls `workflow_run_get` on an interval
+ * and feeds fresh snapshots to {@link WorkflowRunDetail}.
+ *
+ * This is a sibling of {@link WorkflowsTab} (which manages SKILL.md authoring) —
+ * the two are deliberately distinct primitives: that tab is reusable procedures,
+ * this tab is declarative multi-agent runs.
+ */
+import debug from 'debug';
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+import { useT } from '../../lib/i18n/I18nContext';
+import {
+  assessWorkflowCost,
+  type WorkflowDefinition,
+  type WorkflowRun,
+  workflowRunsApi,
+} from '../../services/api/workflowRunsApi';
+import { SAFETY_TIER_KEY, WorkflowRunApprovalCard } from './WorkflowRunApprovalCard';
+import WorkflowRunDetail from './WorkflowRunDetail';
+
+const log = debug('intelligence:orchestration');
+
+/** How often to poll a selected, non-terminal run for progress. */
+const POLL_INTERVAL_MS = 2000;
+
+const TERMINAL = new Set(['completed', 'failed', 'cancelled', 'interrupted']);
+
+function isTerminal(run: WorkflowRun | null): boolean {
+  return run !== null && TERMINAL.has(run.status);
+}
+
+export default function IntelligenceOrchestrationTab() {
+  const { t } = useT();
+
+  const [definitions, setDefinitions] = useState<WorkflowDefinition[]>([]);
+  const [runs, setRuns] = useState<WorkflowRun[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  // Start flow state.
+  const [startTarget, setStartTarget] = useState<WorkflowDefinition | null>(null);
+  const [question, setQuestion] = useState('');
+  const [starting, setStarting] = useState(false);
+  const [startError, setStartError] = useState<string | null>(null);
+
+  // Drill-in state.
+  const [selectedRunId, setSelectedRunId] = useState<string | null>(null);
+  const [selectedRun, setSelectedRun] = useState<WorkflowRun | null>(null);
+  const [controlBusy, setControlBusy] = useState(false);
+
+  const mountedRef = useRef(true);
+
+  const load = useCallback(async () => {
+    log('load: entry');
+    setError(null);
+    try {
+      const [defs, runList] = await Promise.all([
+        workflowRunsApi.listDefinitions(),
+        workflowRunsApi.listRuns({ limit: 50 }),
+      ]);
+      if (!mountedRef.current) return;
+      setDefinitions(defs);
+      setRuns(runList);
+      log('load: defs=%d runs=%d', defs.length, runList.length);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log('load: error %s', msg);
+      if (mountedRef.current) setError(msg);
+    } finally {
+      if (mountedRef.current) setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    // Defer the first fetch a tick so the loading state paints before `load`
+    // touches state (mirrors IntelligenceAgentWorkTab; avoids a synchronous
+    // setState inside the effect body).
+    const handle = window.setTimeout(() => void load(), 0);
+    return () => {
+      window.clearTimeout(handle);
+      mountedRef.current = false;
+    };
+  }, [load]);
+
+  // Merge a fresh run snapshot into the runs list (newest data wins).
+  const upsertRun = useCallback((run: WorkflowRun) => {
+    setRuns(prev => {
+      const idx = prev.findIndex(r => r.id === run.id);
+      if (idx === -1) return [run, ...prev];
+      const next = prev.slice();
+      next[idx] = run;
+      return next;
+    });
+  }, []);
+
+  // ---- Polling loop for the selected run -------------------------------
+  useEffect(() => {
+    if (!selectedRunId) return;
+    if (isTerminal(selectedRun)) return; // nothing left to poll
+
+    let cancelled = false;
+    let inFlight = false;
+    let handle: number | undefined;
+
+    const tick = async () => {
+      if (cancelled || inFlight) return;
+      inFlight = true;
+      try {
+        const run = await workflowRunsApi.getRun(selectedRunId);
+        if (cancelled || !mountedRef.current || !run) return;
+        setSelectedRun(run);
+        upsertRun(run);
+        if (!isTerminal(run)) {
+          handle = window.setTimeout(() => void tick(), POLL_INTERVAL_MS);
+        }
+      } catch (err) {
+        log('poll error %s', err instanceof Error ? err.message : String(err));
+      } finally {
+        inFlight = false;
+      }
+    };
+
+    void tick();
+    return () => {
+      cancelled = true;
+      if (handle !== undefined) window.clearTimeout(handle);
+    };
+  }, [selectedRunId, selectedRun, upsertRun]);
+
+  const openRun = useCallback((run: WorkflowRun) => {
+    log('openRun id=%s', run.id);
+    setSelectedRunId(run.id);
+    setSelectedRun(run);
+  }, []);
+
+  // ---- Start flow ------------------------------------------------------
+  const beginStart = useCallback((def: WorkflowDefinition) => {
+    log('beginStart definitionId=%s', def.id);
+    setStartTarget(def);
+    setQuestion('');
+    setStartError(null);
+  }, []);
+
+  const cancelStart = useCallback(() => {
+    setStartTarget(null);
+    setStarting(false);
+    setStartError(null);
+  }, []);
+
+  const doStart = useCallback(async () => {
+    if (!startTarget) return;
+    setStarting(true);
+    setStartError(null);
+    const trimmed = question.trim();
+    try {
+      const run = await workflowRunsApi.startRun({
+        definitionId: startTarget.id,
+        input: trimmed.length > 0 ? { question: trimmed } : undefined,
+      });
+      if (!mountedRef.current) return;
+      log('started runId=%s', run.id);
+      upsertRun(run);
+      setStartTarget(null);
+      openRun(run);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log('start error %s', msg);
+      if (mountedRef.current) setStartError(msg);
+    } finally {
+      if (mountedRef.current) setStarting(false);
+    }
+  }, [startTarget, question, upsertRun, openRun]);
+
+  // ---- Stop / Resume ---------------------------------------------------
+  const handleStop = useCallback(
+    async (id: string) => {
+      setControlBusy(true);
+      try {
+        const run = await workflowRunsApi.stopRun(id);
+        if (run && mountedRef.current) {
+          setSelectedRun(run);
+          upsertRun(run);
+        }
+      } catch (err) {
+        log('stop error %s', err instanceof Error ? err.message : String(err));
+      } finally {
+        if (mountedRef.current) setControlBusy(false);
+      }
+    },
+    [upsertRun]
+  );
+
+  const handleResume = useCallback(
+    async (id: string) => {
+      setControlBusy(true);
+      try {
+        const run = await workflowRunsApi.resumeRun(id);
+        if (mountedRef.current) {
+          setSelectedRun(run);
+          upsertRun(run);
+        }
+      } catch (err) {
+        log('resume error %s', err instanceof Error ? err.message : String(err));
+      } finally {
+        if (mountedRef.current) setControlBusy(false);
+      }
+    },
+    [upsertRun]
+  );
+
+  if (loading) {
+    return (
+      <div className="flex items-center justify-center py-10 text-stone-400 dark:text-neutral-500">
+        <div className="mr-2 h-4 w-4 animate-spin rounded-full border-2 border-ocean-500 border-t-transparent" />
+        <span className="text-sm">{t('orchestration.loading')}</span>
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <div className="space-y-3">
+        <div className="rounded-xl border border-coral-200 bg-coral-50 px-4 py-3 text-sm text-coral-700 dark:border-coral-500/30 dark:bg-coral-500/10 dark:text-coral-300">
+          {t('orchestration.failedToLoad')}: {error}
+        </div>
+        <button
+          type="button"
+          onClick={() => {
+            setLoading(true);
+            void load();
+          }}
+          className="rounded-lg border border-stone-300 bg-white px-3 py-1.5 text-xs font-medium text-stone-700 hover:bg-stone-50 dark:border-neutral-700 dark:bg-neutral-900 dark:text-neutral-300">
+          {t('common.retry')}
+        </button>
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-6" data-testid="orchestration-tab">
+      <p className="text-xs text-stone-400 dark:text-neutral-500">{t('orchestration.subtitle')}</p>
+
+      {/* Definitions catalog */}
+      <section className="space-y-2">
+        <h3 className="text-xs font-semibold uppercase tracking-wide text-stone-500 dark:text-neutral-400">
+          {t('orchestration.definitions')}
+        </h3>
+        {definitions.length === 0 ? (
+          <div className="rounded-xl border border-dashed border-stone-200 py-8 text-center text-sm text-stone-400 dark:border-neutral-800 dark:text-neutral-500">
+            {t('orchestration.noDefinitions')}
+          </div>
+        ) : (
+          <ul className="space-y-2" data-testid="orchestration-definitions">
+            {definitions.map(def => {
+              const assessment = assessWorkflowCost(def);
+              const isStarting = startTarget?.id === def.id;
+              return (
+                <li
+                  key={def.id}
+                  data-testid={`orchestration-definition-${def.id}`}
+                  className="rounded-xl border border-stone-200 bg-white p-3 dark:border-neutral-800 dark:bg-neutral-900">
+                  <div className="flex flex-wrap items-start justify-between gap-2">
+                    <div className="min-w-0">
+                      <div className="flex flex-wrap items-center gap-1.5">
+                        <span className="text-sm font-medium text-stone-800 dark:text-neutral-100">
+                          {def.name}
+                        </span>
+                        <span className="rounded-md border border-stone-200 px-1.5 py-0.5 text-[10px] font-medium text-stone-500 dark:border-neutral-700 dark:text-neutral-400">
+                          {t(SAFETY_TIER_KEY[def.safetyTier])}
+                        </span>
+                        {assessment.requiresApproval && (
+                          <span
+                            data-testid={`orchestration-approval-badge-${def.id}`}
+                            className="rounded-md border border-amber-300 bg-amber-50 px-1.5 py-0.5 text-[10px] font-medium text-amber-700 dark:border-amber-500/40 dark:bg-amber-500/10 dark:text-amber-300">
+                            {t('orchestration.approvalRequired')}
+                          </span>
+                        )}
+                      </div>
+                      <p className="mt-1 text-xs text-stone-500 dark:text-neutral-400">
+                        {def.description}
+                      </p>
+                    </div>
+                    {!isStarting && (
+                      <button
+                        type="button"
+                        data-testid={`orchestration-start-${def.id}`}
+                        onClick={() => beginStart(def)}
+                        className="flex-none rounded-lg bg-primary-500 px-3 py-1.5 text-xs font-semibold text-white shadow-soft hover:bg-primary-600 focus:outline-none focus:ring-2 focus:ring-primary-500">
+                        {t('orchestration.start')}
+                      </button>
+                    )}
+                  </div>
+
+                  {/* Inline start panel */}
+                  {isStarting && (
+                    <div className="mt-3 space-y-3 border-t border-stone-100 pt-3 dark:border-neutral-800">
+                      <label className="block text-xs font-medium text-stone-600 dark:text-neutral-300">
+                        {t('orchestration.questionLabel')}
+                        <textarea
+                          data-testid="orchestration-question"
+                          value={question}
+                          onChange={e => setQuestion(e.target.value)}
+                          rows={2}
+                          placeholder={t('orchestration.questionPlaceholder')}
+                          className="mt-1 w-full rounded-lg border border-stone-200 bg-white px-2 py-1.5 text-sm text-stone-800 focus:border-primary-500 focus:outline-none dark:border-neutral-700 dark:bg-neutral-800 dark:text-neutral-100"
+                        />
+                      </label>
+
+                      {startError && (
+                        <p className="text-xs text-coral-600 dark:text-coral-300">⚠ {startError}</p>
+                      )}
+
+                      {assessment.requiresApproval ? (
+                        <WorkflowRunApprovalCard
+                          definition={def}
+                          reasons={assessment.reasons}
+                          starting={starting}
+                          onApprove={() => void doStart()}
+                          onCancel={cancelStart}
+                        />
+                      ) : (
+                        <div className="flex items-center gap-2">
+                          <button
+                            type="button"
+                            data-testid="orchestration-confirm-start"
+                            disabled={starting}
+                            onClick={() => void doStart()}
+                            className="rounded-lg bg-primary-500 px-3 py-1.5 text-xs font-semibold text-white shadow-soft hover:bg-primary-600 disabled:opacity-50">
+                            {starting
+                              ? t('orchestration.starting')
+                              : t('orchestration.confirmStart')}
+                          </button>
+                          <button
+                            type="button"
+                            onClick={cancelStart}
+                            disabled={starting}
+                            className="rounded-lg border border-stone-300 bg-white px-3 py-1.5 text-xs font-medium text-stone-700 hover:bg-stone-50 disabled:opacity-50 dark:border-neutral-700 dark:bg-neutral-900 dark:text-neutral-300">
+                            {t('orchestration.approval.cancel')}
+                          </button>
+                        </div>
+                      )}
+                    </div>
+                  )}
+                </li>
+              );
+            })}
+          </ul>
+        )}
+      </section>
+
+      {/* Selected run drill-in */}
+      {selectedRun && (
+        <section className="space-y-2" data-testid="orchestration-selected-run">
+          <div className="flex items-center justify-between">
+            <h3 className="text-xs font-semibold uppercase tracking-wide text-stone-500 dark:text-neutral-400">
+              {t('orchestration.runProgress')}
+            </h3>
+            <button
+              type="button"
+              data-testid="orchestration-close-run"
+              onClick={() => {
+                setSelectedRunId(null);
+                setSelectedRun(null);
+              }}
+              className="text-[11px] text-stone-400 hover:text-stone-600 dark:text-neutral-500 dark:hover:text-neutral-300">
+              {t('orchestration.close')}
+            </button>
+          </div>
+          <WorkflowRunDetail
+            definition={definitions.find(d => d.id === selectedRun.definitionId)}
+            run={selectedRun}
+            busy={controlBusy}
+            onStop={id => void handleStop(id)}
+            onResume={id => void handleResume(id)}
+          />
+        </section>
+      )}
+
+      {/* Recent runs */}
+      <section className="space-y-2">
+        <h3 className="text-xs font-semibold uppercase tracking-wide text-stone-500 dark:text-neutral-400">
+          {t('orchestration.recentRuns')}
+        </h3>
+        {runs.length === 0 ? (
+          <div className="rounded-xl border border-dashed border-stone-200 py-8 text-center text-sm text-stone-400 dark:border-neutral-800 dark:text-neutral-500">
+            {t('orchestration.noRuns')}
+          </div>
+        ) : (
+          <ul
+            className="divide-y divide-stone-100 overflow-hidden rounded-xl border border-stone-200 bg-white dark:divide-neutral-800 dark:border-neutral-800 dark:bg-neutral-900"
+            data-testid="orchestration-runs">
+            {runs.map(run => {
+              const def = definitions.find(d => d.id === run.definitionId);
+              return (
+                <li key={run.id}>
+                  <button
+                    type="button"
+                    data-testid={`orchestration-run-${run.id}`}
+                    onClick={() => openRun(run)}
+                    className={`flex w-full items-center justify-between gap-2 p-3 text-left hover:bg-stone-50 dark:hover:bg-neutral-800/60 ${
+                      run.id === selectedRunId ? 'bg-stone-50 dark:bg-neutral-800/60' : ''
+                    }`}>
+                    <span className="min-w-0">
+                      <span className="block truncate text-sm font-medium text-stone-800 dark:text-neutral-100">
+                        {def?.name ?? run.definitionId}
+                      </span>
+                      <span className="font-mono text-[10px] text-stone-400 dark:text-neutral-500">
+                        {run.id}
+                      </span>
+                    </span>
+                    <span className="flex-none text-[11px] text-stone-400 dark:text-neutral-500">
+                      {t(`orchestration.runStatus.${run.status}`)}
+                    </span>
+                  </button>
+                </li>
+              );
+            })}
+          </ul>
+        )}
+      </section>
+    </div>
+  );
+}
diff --git a/app/src/components/intelligence/WorkflowRunApprovalCard.test.tsx b/app/src/components/intelligence/WorkflowRunApprovalCard.test.tsx
new file mode 100644
index 000000000..3534563e7
--- /dev/null
+++ b/app/src/components/intelligence/WorkflowRunApprovalCard.test.tsx
@@ -0,0 +1,95 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { type WorkflowDefinition } from '../../services/api/workflowRunsApi';
+import WorkflowRunApprovalCard from './WorkflowRunApprovalCard';
+
+// i18n → echo the key so assertions can target stable strings.
+vi.mock('../../lib/i18n/I18nContext', () => ({ useT: () => ({ t: (k: string) => k }) }));
+
+function def(overrides: Partial<WorkflowDefinition> = {}): WorkflowDefinition {
+  return {
+    id: 'parallel_research_cross_check',
+    name: 'Parallel research',
+    description: 'desc',
+    phases: [],
+    defaultConcurrency: 2,
+    maxChildren: 8,
+    safetyTier: 'read_only',
+    ...overrides,
+  };
+}
+
+describe('WorkflowRunApprovalCard', () => {
+  it('renders one localized line per reason', () => {
+    render(
+      <WorkflowRunApprovalCard
+        definition={def()}
+        reasons={['high_children', 'high_concurrency']}
+        onApprove={vi.fn()}
+        onCancel={vi.fn()}
+      />
+    );
+    const reasons = screen.getByTestId('workflow-approval-reasons');
+    expect(reasons.querySelectorAll('li')).toHaveLength(2);
+    expect(screen.getByText('orchestration.approval.reason.children')).toBeInTheDocument();
+    expect(screen.getByText('orchestration.approval.reason.concurrency')).toBeInTheDocument();
+  });
+
+  it('shows the concrete cost facts (tier / concurrency / max children)', () => {
+    render(
+      <WorkflowRunApprovalCard
+        definition={def({ defaultConcurrency: 3, maxChildren: 8 })}
+        reasons={['high_children']}
+        onApprove={vi.fn()}
+        onCancel={vi.fn()}
+      />
+    );
+    expect(screen.getByText('orchestration.tier.readOnly')).toBeInTheDocument();
+    expect(screen.getByText('3')).toBeInTheDocument();
+    expect(screen.getByText('8')).toBeInTheDocument();
+  });
+
+  it('fires onApprove when "Approve & start" is clicked', () => {
+    const onApprove = vi.fn();
+    render(
+      <WorkflowRunApprovalCard
+        definition={def()}
+        reasons={['high_children']}
+        onApprove={onApprove}
+        onCancel={vi.fn()}
+      />
+    );
+    fireEvent.click(screen.getByTestId('workflow-approval-approve'));
+    expect(onApprove).toHaveBeenCalledTimes(1);
+  });
+
+  it('fires onCancel when "Cancel" is clicked', () => {
+    const onCancel = vi.fn();
+    render(
+      <WorkflowRunApprovalCard
+        definition={def()}
+        reasons={['high_children']}
+        onApprove={vi.fn()}
+        onCancel={onCancel}
+      />
+    );
+    fireEvent.click(screen.getByTestId('workflow-approval-cancel'));
+    expect(onCancel).toHaveBeenCalledTimes(1);
+  });
+
+  it('disables both buttons and shows the starting label while a start is in flight', () => {
+    render(
+      <WorkflowRunApprovalCard
+        definition={def()}
+        reasons={['high_children']}
+        starting
+        onApprove={vi.fn()}
+        onCancel={vi.fn()}
+      />
+    );
+    expect(screen.getByTestId('workflow-approval-approve')).toBeDisabled();
+    expect(screen.getByTestId('workflow-approval-cancel')).toBeDisabled();
+    expect(screen.getByText('orchestration.approval.starting')).toBeInTheDocument();
+  });
+});
diff --git a/app/src/components/intelligence/WorkflowRunApprovalCard.tsx b/app/src/components/intelligence/WorkflowRunApprovalCard.tsx
new file mode 100644
index 000000000..9e8f9288a
--- /dev/null
+++ b/app/src/components/intelligence/WorkflowRunApprovalCard.tsx
@@ -0,0 +1,148 @@
+/**
+ * WorkflowRunApprovalCard (#3375)
+ * --------------------------------
+ *
+ * Confirmation surface shown before starting a high-cost / high-concurrency
+ * workflow run. The acceptance criterion "High-cost/high-concurrency runs
+ * require explicit approval" is enforced on the client: the Orchestration tab
+ * calls {@link assessWorkflowCost} and, when it returns `requiresApproval`,
+ * renders this card instead of starting immediately. The user must press
+ * "Approve & start" to proceed; "Cancel" aborts without touching the engine.
+ *
+ * Styling mirrors the chat ApprovalRequestCard (amber warning chrome) so the
+ * approval affordance is visually consistent across the app.
+ */
+import debug from 'debug';
+import React from 'react';
+
+import { useT } from '../../lib/i18n/I18nContext';
+import {
+  type WorkflowCostReason,
+  type WorkflowDefinition,
+  type WorkflowSafetyTier,
+} from '../../services/api/workflowRunsApi';
+import Button from '../ui/Button';
+
+const log = debug('intelligence:workflow-approval');
+
+/** i18n key for each cost reason code. */
+const REASON_KEY: Record<WorkflowCostReason, string> = {
+  non_read_only_tier: 'orchestration.approval.reason.tier',
+  high_concurrency: 'orchestration.approval.reason.concurrency',
+  high_children: 'orchestration.approval.reason.children',
+};
+
+/** i18n key for each safety tier label. */
+export const SAFETY_TIER_KEY: Record<WorkflowSafetyTier, string> = {
+  read_only: 'orchestration.tier.readOnly',
+  standard: 'orchestration.tier.standard',
+  edit_capable: 'orchestration.tier.editCapable',
+};
+
+interface Props {
+  definition: WorkflowDefinition;
+  reasons: WorkflowCostReason[];
+  /** Whether the start RPC is in flight (disables the buttons). */
+  starting?: boolean;
+  onApprove: () => void;
+  onCancel: () => void;
+}
+
+export const WorkflowRunApprovalCard: React.FC<Props> = ({
+  definition,
+  reasons,
+  starting = false,
+  onApprove,
+  onCancel,
+}) => {
+  const { t } = useT();
+
+  return (
+    <div
+      role="alertdialog"
+      aria-label={t('orchestration.approval.title')}
+      data-testid="workflow-approval-card"
+      className="rounded-xl border border-amber-300 bg-amber-50 p-4 text-sm dark:border-amber-500/40 dark:bg-amber-500/10">
+      <div className="flex items-start gap-2">
+        <span aria-hidden className="text-base leading-none">
+          ⚠️
+        </span>
+        <div className="min-w-0 flex-1">
+          <p className="font-semibold text-amber-900 dark:text-amber-200">
+            {t('orchestration.approval.title')}
+          </p>
+          <p className="mt-1 break-words text-amber-800/90 dark:text-amber-200/90">
+            {t('orchestration.approval.body')}{' '}
+            <span className="font-semibold">{definition.name}</span>
+          </p>
+
+          {/* Why approval is required — one localized line per reason code. */}
+          <ul
+            data-testid="workflow-approval-reasons"
+            className="mt-2 list-disc space-y-1 pl-5 text-xs text-amber-800/90 dark:text-amber-200/90">
+            {reasons.map(reason => (
+              <li key={reason}>{t(REASON_KEY[reason])}</li>
+            ))}
+          </ul>
+
+          {/* Concrete cost facts so the user knows what they're approving. */}
+          <dl className="mt-3 grid grid-cols-3 gap-2 text-xs">
+            <div className="rounded-md bg-amber-100/70 px-2 py-1.5 dark:bg-amber-500/15">
+              <dt className="text-amber-700/80 dark:text-amber-300/80">
+                {t('orchestration.approval.tier')}
+              </dt>
+              <dd className="font-medium text-amber-900 dark:text-amber-100">
+                {t(SAFETY_TIER_KEY[definition.safetyTier])}
+              </dd>
+            </div>
+            <div className="rounded-md bg-amber-100/70 px-2 py-1.5 dark:bg-amber-500/15">
+              <dt className="text-amber-700/80 dark:text-amber-300/80">
+                {t('orchestration.approval.concurrency')}
+              </dt>
+              <dd className="font-medium text-amber-900 dark:text-amber-100">
+                {definition.defaultConcurrency}
+              </dd>
+            </div>
+            <div className="rounded-md bg-amber-100/70 px-2 py-1.5 dark:bg-amber-500/15">
+              <dt className="text-amber-700/80 dark:text-amber-300/80">
+                {t('orchestration.approval.maxChildren')}
+              </dt>
+              <dd className="font-medium text-amber-900 dark:text-amber-100">
+                {definition.maxChildren}
+              </dd>
+            </div>
+          </dl>
+
+          <div className="mt-3 flex flex-wrap items-center gap-2">
+            <Button
+              variant="primary"
+              size="sm"
+              data-testid="workflow-approval-approve"
+              disabled={starting}
+              onClick={() => {
+                log('approve definitionId=%s', definition.id);
+                onApprove();
+              }}>
+              {starting
+                ? t('orchestration.approval.starting')
+                : t('orchestration.approval.approve')}
+            </Button>
+            <Button
+              variant="secondary"
+              size="sm"
+              data-testid="workflow-approval-cancel"
+              disabled={starting}
+              onClick={() => {
+                log('cancel definitionId=%s', definition.id);
+                onCancel();
+              }}>
+              {t('orchestration.approval.cancel')}
+            </Button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default WorkflowRunApprovalCard;
diff --git a/app/src/components/intelligence/WorkflowRunDetail.test.tsx b/app/src/components/intelligence/WorkflowRunDetail.test.tsx
new file mode 100644
index 000000000..6c42fb18e
--- /dev/null
+++ b/app/src/components/intelligence/WorkflowRunDetail.test.tsx
@@ -0,0 +1,200 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { type WorkflowDefinition, type WorkflowRun } from '../../services/api/workflowRunsApi';
+import WorkflowRunDetail from './WorkflowRunDetail';
+
+// i18n → echo the key so assertions can target stable strings.
+vi.mock('../../lib/i18n/I18nContext', () => ({ useT: () => ({ t: (k: string) => k }) }));
+
+function def(): WorkflowDefinition {
+  return {
+    id: 'parallel_research_cross_check',
+    name: 'Parallel research',
+    description: 'desc',
+    phases: [
+      {
+        name: 'decompose',
+        description: 'Break the question down.',
+        agentIds: ['planner'],
+        dependsOn: [],
+      },
+      {
+        name: 'research',
+        description: 'Research in parallel.',
+        agentIds: ['researcher', 'researcher'],
+        dependsOn: ['decompose'],
+      },
+      {
+        name: 'synthesize',
+        description: 'Synthesize.',
+        agentIds: ['summarizer'],
+        dependsOn: ['research'],
+      },
+    ],
+    defaultConcurrency: 2,
+    maxChildren: 8,
+    safetyTier: 'read_only',
+  };
+}
+
+function run(overrides: Partial<WorkflowRun> = {}): WorkflowRun {
+  return {
+    id: 'wfrun-1',
+    definitionId: 'parallel_research_cross_check',
+    parentThreadId: null,
+    input: { question: 'q' },
+    phaseStates: {
+      decompose: {
+        status: 'completed',
+        outputs: [{ orchestrationId: 'orch-1', agentId: 'planner', output: 'three angles' }],
+      },
+      research: { status: 'running', outputs: [] },
+      synthesize: { status: 'pending', outputs: [] },
+    },
+    childRunIds: ['orch-1'],
+    status: 'running',
+    summary: null,
+    startedAt: '2026-01-01T00:00:00Z',
+    updatedAt: '2026-01-01T00:01:00Z',
+    completedAt: null,
+    ...overrides,
+  };
+}
+
+describe('WorkflowRunDetail — progress rendering', () => {
+  it('renders the run status and every declared phase in order', () => {
+    render(
+      <WorkflowRunDetail definition={def()} run={run()} onStop={vi.fn()} onResume={vi.fn()} />
+    );
+
+    expect(screen.getByTestId('workflow-run-status')).toHaveTextContent(
+      'orchestration.runStatus.running'
+    );
+
+    const phases = screen.getByTestId('workflow-phase-list').querySelectorAll('li');
+    expect(phases).toHaveLength(3);
+    expect(screen.getByTestId('workflow-phase-decompose')).toBeInTheDocument();
+    expect(screen.getByTestId('workflow-phase-research')).toBeInTheDocument();
+    expect(screen.getByTestId('workflow-phase-synthesize')).toBeInTheDocument();
+  });
+
+  it('reflects per-phase status from phaseStates', () => {
+    render(
+      <WorkflowRunDetail definition={def()} run={run()} onStop={vi.fn()} onResume={vi.fn()} />
+    );
+    expect(screen.getByTestId('workflow-phase-status-decompose')).toHaveTextContent(
+      'orchestration.phaseStatus.completed'
+    );
+    expect(screen.getByTestId('workflow-phase-status-research')).toHaveTextContent(
+      'orchestration.phaseStatus.running'
+    );
+    expect(screen.getByTestId('workflow-phase-status-synthesize')).toHaveTextContent(
+      'orchestration.phaseStatus.pending'
+    );
+  });
+
+  it('shows child agent refs for a phase when expanded', () => {
+    render(
+      <WorkflowRunDetail definition={def()} run={run()} onStop={vi.fn()} onResume={vi.fn()} />
+    );
+    // Outputs are collapsed by default; expand the completed phase.
+    fireEvent.click(screen.getByTestId('workflow-phase-decompose').querySelector('button')!);
+    const outputs = screen.getByTestId('workflow-phase-outputs-decompose');
+    expect(outputs).toHaveTextContent('planner');
+    expect(outputs).toHaveTextContent('orch-1');
+    expect(outputs).toHaveTextContent('three angles');
+  });
+
+  it('renders the run-level child agent ref count', () => {
+    render(
+      <WorkflowRunDetail definition={def()} run={run()} onStop={vi.fn()} onResume={vi.fn()} />
+    );
+    expect(screen.getByTestId('workflow-child-refs')).toBeInTheDocument();
+  });
+
+  it('shows the final synthesis only once the run is terminal with a summary', () => {
+    const { rerender } = render(
+      <WorkflowRunDetail definition={def()} run={run()} onStop={vi.fn()} onResume={vi.fn()} />
+    );
+    expect(screen.queryByTestId('workflow-run-summary')).not.toBeInTheDocument();
+
+    rerender(
+      <WorkflowRunDetail
+        definition={def()}
+        run={run({
+          status: 'completed',
+          summary: 'A cited report.',
+          completedAt: '2026-01-01T00:05:00Z',
+        })}
+        onStop={vi.fn()}
+        onResume={vi.fn()}
+      />
+    );
+    expect(screen.getByTestId('workflow-run-summary')).toHaveTextContent('A cited report.');
+  });
+
+  it('offers Stop while running and wires it to onStop', () => {
+    const onStop = vi.fn();
+    render(<WorkflowRunDetail definition={def()} run={run()} onStop={onStop} onResume={vi.fn()} />);
+    expect(screen.queryByTestId('workflow-run-resume')).not.toBeInTheDocument();
+    fireEvent.click(screen.getByTestId('workflow-run-stop'));
+    expect(onStop).toHaveBeenCalledWith('wfrun-1');
+  });
+
+  it('offers Resume when interrupted and wires it to onResume', () => {
+    const onResume = vi.fn();
+    render(
+      <WorkflowRunDetail
+        definition={def()}
+        run={run({ status: 'interrupted' })}
+        onStop={vi.fn()}
+        onResume={onResume}
+      />
+    );
+    expect(screen.queryByTestId('workflow-run-stop')).not.toBeInTheDocument();
+    fireEvent.click(screen.getByTestId('workflow-run-resume'));
+    expect(onResume).toHaveBeenCalledWith('wfrun-1');
+  });
+
+  it('falls back to phaseStates keys + raw phase name when the definition is missing', () => {
+    render(
+      <WorkflowRunDetail
+        definition={undefined}
+        run={run({
+          phaseStates: { decompose: { status: 'running', outputs: [] } },
+          childRunIds: [],
+        })}
+        onStop={vi.fn()}
+        onResume={vi.fn()}
+      />
+    );
+    // With no definition, the phase order comes from run.phaseStates and the
+    // label falls back to the raw phase name (WorkflowRunDetail.tsx:173).
+    const phases = screen.getByTestId('workflow-phase-list').querySelectorAll('li');
+    expect(phases).toHaveLength(1);
+    expect(screen.getByTestId('workflow-phase-decompose')).toHaveTextContent('decompose');
+  });
+
+  it('renders the failure reason for a failed phase', () => {
+    render(
+      <WorkflowRunDetail
+        definition={def()}
+        run={run({
+          status: 'failed',
+          phaseStates: {
+            decompose: { status: 'failed', outputs: [], reason: 'planner agent errored out' },
+            research: { status: 'pending', outputs: [] },
+            synthesize: { status: 'pending', outputs: [] },
+          },
+        })}
+        onStop={vi.fn()}
+        onResume={vi.fn()}
+      />
+    );
+    // The failed-phase reason banner (WorkflowRunDetail.tsx:197).
+    expect(screen.getByTestId('workflow-phase-decompose')).toHaveTextContent(
+      'planner agent errored out'
+    );
+  });
+});
diff --git a/app/src/components/intelligence/WorkflowRunDetail.tsx b/app/src/components/intelligence/WorkflowRunDetail.tsx
new file mode 100644
index 000000000..f62b96c80
--- /dev/null
+++ b/app/src/components/intelligence/WorkflowRunDetail.tsx
@@ -0,0 +1,262 @@
+/**
+ * WorkflowRunDetail (#3375)
+ * -------------------------
+ *
+ * Drill-in view for a single workflow run. Given a definition (for phase
+ * ordering + labels) and the latest run snapshot, it renders:
+ *   - the run status header,
+ *   - an ordered phase timeline driven by `run.phaseStates`,
+ *   - each phase's child agent refs (orchestration id + agent id + output),
+ *   - Stop / Resume controls wired to the engine,
+ *   - the final synthesized report once the run completes.
+ *
+ * The component is presentational + control-only: the parent (Orchestration
+ * tab) owns the polling loop and passes a fresh `run` each tick. Stop / Resume
+ * delegate to callbacks so the parent can refresh its run list too.
+ */
+import debug from 'debug';
+import React, { useState } from 'react';
+
+import { useT } from '../../lib/i18n/I18nContext';
+import {
+  type WorkflowDefinition,
+  type WorkflowPhaseState,
+  type WorkflowPhaseStatus,
+  type WorkflowRun,
+  type WorkflowRunStatus,
+} from '../../services/api/workflowRunsApi';
+
+const log = debug('intelligence:workflow-detail');
+
+/** Accent classes per run status (semantic palette from tailwind.config.js). */
+const RUN_STATUS_ACCENT: Record<WorkflowRunStatus, string> = {
+  pending:
+    'border-stone-200 bg-stone-50 text-stone-600 dark:border-neutral-700 dark:bg-neutral-800/60 dark:text-neutral-300',
+  running:
+    'border-ocean-200 bg-ocean-50 text-ocean-700 dark:border-ocean-500/30 dark:bg-ocean-500/10 dark:text-ocean-300',
+  completed:
+    'border-sage-200 bg-sage-50 text-sage-700 dark:border-sage-500/30 dark:bg-sage-500/10 dark:text-sage-300',
+  failed:
+    'border-coral-200 bg-coral-50 text-coral-700 dark:border-coral-500/30 dark:bg-coral-500/10 dark:text-coral-300',
+  cancelled:
+    'border-stone-200 bg-stone-50 text-stone-600 dark:border-neutral-700 dark:bg-neutral-800/60 dark:text-neutral-300',
+  interrupted:
+    'border-amber-200 bg-amber-50 text-amber-700 dark:border-amber-500/30 dark:bg-amber-500/10 dark:text-amber-300',
+};
+
+const RUN_STATUS_KEY: Record<WorkflowRunStatus, string> = {
+  pending: 'orchestration.runStatus.pending',
+  running: 'orchestration.runStatus.running',
+  completed: 'orchestration.runStatus.completed',
+  failed: 'orchestration.runStatus.failed',
+  cancelled: 'orchestration.runStatus.cancelled',
+  interrupted: 'orchestration.runStatus.interrupted',
+};
+
+const PHASE_STATUS_KEY: Record<WorkflowPhaseStatus, string> = {
+  pending: 'orchestration.phaseStatus.pending',
+  running: 'orchestration.phaseStatus.running',
+  completed: 'orchestration.phaseStatus.completed',
+  failed: 'orchestration.phaseStatus.failed',
+};
+
+/** Glyph per phase status — color comes from the surrounding classes. */
+const PHASE_STATUS_DOT: Record<WorkflowPhaseStatus, string> = {
+  pending: 'bg-stone-300 dark:bg-neutral-600',
+  running: 'bg-ocean-500 animate-pulse',
+  completed: 'bg-sage-500',
+  failed: 'bg-coral-500',
+};
+
+const TERMINAL_STATUSES: WorkflowRunStatus[] = ['completed', 'failed', 'cancelled', 'interrupted'];
+
+interface Props {
+  definition: WorkflowDefinition | undefined;
+  run: WorkflowRun;
+  /** True while a stop/resume RPC is in flight. */
+  busy?: boolean;
+  onStop: (id: string) => void;
+  onResume: (id: string) => void;
+}
+
+export const WorkflowRunDetail: React.FC<Props> = ({
+  definition,
+  run,
+  busy = false,
+  onStop,
+  onResume,
+}) => {
+  const { t } = useT();
+  const [expanded, setExpanded] = useState<Record<string, boolean>>({});
+
+  // Phase order: lead with the definition's declared order, then append any
+  // runtime-only phases the run reports but the definition doesn't list (so a
+  // run still renders its full progress during definition/version drift).
+  const declaredPhaseNames = definition?.phases.map(p => p.name) ?? [];
+  const declaredSet = new Set(declaredPhaseNames);
+  const runtimeOnlyPhaseNames = Object.keys(run.phaseStates).filter(name => !declaredSet.has(name));
+  const phaseNames = [...declaredPhaseNames, ...runtimeOnlyPhaseNames];
+
+  const isRunning = run.status === 'running' || run.status === 'pending';
+  const canResume = run.status === 'interrupted';
+
+  const toggle = (name: string) => setExpanded(prev => ({ ...prev, [name]: !prev[name] }));
+
+  return (
+    <div className="space-y-4" data-testid="workflow-run-detail">
+      {/* Header: status + controls */}
+      <div className="flex flex-wrap items-center justify-between gap-2">
+        <div className="flex items-center gap-2">
+          <span
+            data-testid="workflow-run-status"
+            className={`inline-flex items-center gap-1.5 rounded-full border px-2.5 py-0.5 text-xs font-medium ${RUN_STATUS_ACCENT[run.status]}`}>
+            {run.status === 'running' && (
+              <span className="h-1.5 w-1.5 animate-pulse rounded-full bg-ocean-500" />
+            )}
+            {t(RUN_STATUS_KEY[run.status])}
+          </span>
+          <span className="font-mono text-[11px] text-stone-400 dark:text-neutral-500">
+            {run.id}
+          </span>
+        </div>
+
+        <div className="flex items-center gap-2">
+          {isRunning && (
+            <button
+              type="button"
+              data-testid="workflow-run-stop"
+              disabled={busy}
+              onClick={() => {
+                log('stop id=%s', run.id);
+                onStop(run.id);
+              }}
+              className="rounded-lg border border-coral-300 bg-white px-3 py-1.5 text-xs font-medium text-coral-700 hover:bg-coral-50 disabled:opacity-50 dark:border-coral-700 dark:bg-neutral-900 dark:text-coral-300 dark:hover:bg-coral-900/40">
+              {t('orchestration.detail.stop')}
+            </button>
+          )}
+          {canResume && (
+            <button
+              type="button"
+              data-testid="workflow-run-resume"
+              disabled={busy}
+              onClick={() => {
+                log('resume id=%s', run.id);
+                onResume(run.id);
+              }}
+              className="rounded-lg border border-ocean-300 bg-white px-3 py-1.5 text-xs font-medium text-ocean-700 hover:bg-ocean-50 disabled:opacity-50 dark:border-ocean-700 dark:bg-neutral-900 dark:text-ocean-300 dark:hover:bg-ocean-900/40">
+              {t('orchestration.detail.resume')}
+            </button>
+          )}
+        </div>
+      </div>
+
+      {/* Phase timeline */}
+      <ol className="space-y-2" data-testid="workflow-phase-list">
+        {phaseNames.map(name => {
+          const phaseDef = definition?.phases.find(p => p.name === name);
+          const state: WorkflowPhaseState = run.phaseStates[name] ?? {
+            status: 'pending',
+            outputs: [],
+          };
+          const isOpen = expanded[name] ?? false;
+          const hasOutputs = state.outputs.length > 0;
+          return (
+            <li
+              key={name}
+              data-testid={`workflow-phase-${name}`}
+              className="rounded-xl border border-stone-200 bg-white dark:border-neutral-800 dark:bg-neutral-900">
+              <button
+                type="button"
+                onClick={() => toggle(name)}
+                className="flex w-full items-center justify-between gap-2 px-3 py-2 text-left">
+                <span className="flex min-w-0 items-center gap-2">
+                  <span
+                    className={`h-2 w-2 flex-none rounded-full ${PHASE_STATUS_DOT[state.status]}`}
+                  />
+                  <span className="truncate text-sm font-medium text-stone-800 dark:text-neutral-100">
+                    {phaseDef?.name ?? name}
+                  </span>
+                  <span
+                    data-testid={`workflow-phase-status-${name}`}
+                    className="rounded-md border border-stone-200 px-1.5 py-0.5 text-[10px] font-medium text-stone-500 dark:border-neutral-700 dark:text-neutral-400">
+                    {t(PHASE_STATUS_KEY[state.status])}
+                  </span>
+                </span>
+                <span className="flex flex-none items-center gap-2 text-[11px] text-stone-400 dark:text-neutral-500">
+                  {hasOutputs && (
+                    <span data-testid={`workflow-phase-count-${name}`}>
+                      {state.outputs.length} {t('orchestration.detail.agents')}
+                    </span>
+                  )}
+                  <span aria-hidden>{isOpen ? '▾' : '▸'}</span>
+                </span>
+              </button>
+
+              {phaseDef?.description && (
+                <p className="px-3 pb-1 text-xs text-stone-500 dark:text-neutral-400">
+                  {phaseDef.description}
+                </p>
+              )}
+
+              {state.status === 'failed' && state.reason && (
+                <p className="mx-3 mb-2 rounded-md bg-coral-50 px-2 py-1 text-xs text-coral-700 dark:bg-coral-500/10 dark:text-coral-300">
+                  {state.reason}
+                </p>
+              )}
+
+              {/* Child agent refs for this phase */}
+              {isOpen && hasOutputs && (
+                <ul className="space-y-2 px-3 pb-3" data-testid={`workflow-phase-outputs-${name}`}>
+                  {state.outputs.map((out, idx) => (
+                    <li
+                      key={`${out.orchestrationId}-${idx}`}
+                      className="rounded-lg border border-stone-100 bg-stone-50 p-2 dark:border-neutral-800 dark:bg-neutral-800/40">
+                      <div className="flex flex-wrap items-center gap-1.5">
+                        <span className="text-xs font-medium text-stone-700 dark:text-neutral-200">
+                          {out.agentId}
+                        </span>
+                        <span className="font-mono text-[10px] text-stone-400 dark:text-neutral-500">
+                          {out.orchestrationId}
+                        </span>
+                      </div>
+                      {out.output && (
+                        <p className="mt-1 whitespace-pre-wrap break-words text-xs leading-snug text-stone-600 dark:text-neutral-300">
+                          {out.output}
+                        </p>
+                      )}
+                    </li>
+                  ))}
+                </ul>
+              )}
+            </li>
+          );
+        })}
+      </ol>
+
+      {/* Child agent refs summary (full run-level list) */}
+      {run.childRunIds.length > 0 && (
+        <div
+          className="text-[11px] text-stone-400 dark:text-neutral-500"
+          data-testid="workflow-child-refs">
+          {t('orchestration.detail.childRefs')}: {run.childRunIds.length}
+        </div>
+      )}
+
+      {/* Final synthesis */}
+      {run.summary && TERMINAL_STATUSES.includes(run.status) && (
+        <div
+          data-testid="workflow-run-summary"
+          className="rounded-xl border border-sage-200 bg-sage-50 p-3 dark:border-sage-500/30 dark:bg-sage-500/10">
+          <p className="mb-1 text-xs font-semibold text-sage-800 dark:text-sage-200">
+            {t('orchestration.detail.synthesis')}
+          </p>
+          <p className="whitespace-pre-wrap break-words text-sm leading-snug text-stone-700 dark:text-neutral-200">
+            {run.summary}
+          </p>
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default WorkflowRunDetail;
diff --git a/app/src/lib/i18n/ar.ts b/app/src/lib/i18n/ar.ts
index 91da680b6..5f79c3720 100644
--- a/app/src/lib/i18n/ar.ts
+++ b/app/src/lib/i18n/ar.ts
@@ -5360,6 +5360,55 @@ const messages: TranslationMap = {
   'notch.speaking': 'أتحدث…',
   'notch.transcribing': 'أفسّر…',
   'notch.executing': 'أنفّذ…',
+  'memory.tab.orchestration': 'التنسيق',
+  'memory.tab.orchestrationDescription':
+    'شغّل سير عمل متعدد الوكلاء — وزّع سؤالاً على وكلاء متوازين، وتحقّق من نتائجهم بشكل متبادل، وراقب اكتمال كل مرحلة لتتجمّع في إجابة واحدة مُركَّبة.',
+  'orchestration.subtitle':
+    'ابدأ سير عمل متعدد الوكلاء، وراقب تقدّم مراحله، واقرأ النتيجة المُركَّبة.',
+  'orchestration.loading': 'جارٍ تحميل سير العمل…',
+  'orchestration.failedToLoad': 'تعذّر تحميل سير العمل',
+  'orchestration.definitions': 'سير العمل المتاح',
+  'orchestration.noDefinitions': 'لا توجد تعريفات سير عمل متاحة.',
+  'orchestration.approvalRequired': 'الموافقة مطلوبة',
+  'orchestration.start': 'بدء',
+  'orchestration.confirmStart': 'بدء التشغيل',
+  'orchestration.starting': 'جارٍ البدء…',
+  'orchestration.questionLabel': 'سؤال البحث (اختياري)',
+  'orchestration.questionPlaceholder': 'ما الذي يجب أن يبحث فيه الوكلاء؟',
+  'orchestration.runProgress': 'تقدّم التشغيل',
+  'orchestration.recentRuns': 'عمليات التشغيل الأخيرة',
+  'orchestration.noRuns': 'لا توجد عمليات تشغيل لسير العمل بعد.',
+  'orchestration.close': 'إغلاق',
+  'orchestration.tier.readOnly': 'للقراءة فقط',
+  'orchestration.tier.standard': 'قياسي',
+  'orchestration.tier.editCapable': 'قادر على التحرير',
+  'orchestration.approval.title': 'الموافقة على تشغيل سير العمل هذا',
+  'orchestration.approval.body':
+    'هذا تشغيل عالي التكلفة أو عالي التزامن ويتطلّب موافقتك الصريحة قبل أن يبدأ:',
+  'orchestration.approval.reason.tier': 'يمكن لوكلائه تنفيذ إجراءات تتجاوز البحث للقراءة فقط.',
+  'orchestration.approval.reason.concurrency': 'يشغّل العديد من الوكلاء في الوقت نفسه.',
+  'orchestration.approval.reason.children': 'قد يُنشئ عدداً كبيراً جداً من الوكلاء إجمالاً.',
+  'orchestration.approval.tier': 'مستوى الأمان',
+  'orchestration.approval.concurrency': 'التزامن',
+  'orchestration.approval.maxChildren': 'الحد الأقصى للوكلاء',
+  'orchestration.approval.approve': 'الموافقة والبدء',
+  'orchestration.approval.starting': 'جارٍ البدء…',
+  'orchestration.approval.cancel': 'إلغاء',
+  'orchestration.runStatus.pending': 'قيد الانتظار',
+  'orchestration.runStatus.running': 'قيد التشغيل',
+  'orchestration.runStatus.completed': 'مكتمل',
+  'orchestration.runStatus.failed': 'فشل',
+  'orchestration.runStatus.cancelled': 'مُلغى',
+  'orchestration.runStatus.interrupted': 'مُقاطع',
+  'orchestration.phaseStatus.pending': 'قيد الانتظار',
+  'orchestration.phaseStatus.running': 'قيد التشغيل',
+  'orchestration.phaseStatus.completed': 'مكتملة',
+  'orchestration.phaseStatus.failed': 'فشلت',
+  'orchestration.detail.stop': 'إيقاف',
+  'orchestration.detail.resume': 'استئناف',
+  'orchestration.detail.agents': 'وكلاء',
+  'orchestration.detail.childRefs': 'الوكلاء الفرعيون',
+  'orchestration.detail.synthesis': 'التركيب النهائي',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': 'ملفات الوكيل',
   'settings.profiles.subtitle': 'وكلاء بطابع خاص — لكل منهم روحه وذاكرته وموصّلاته ومهاراته.',
diff --git a/app/src/lib/i18n/bn.ts b/app/src/lib/i18n/bn.ts
index 4c2b1c6e3..2e9401275 100644
--- a/app/src/lib/i18n/bn.ts
+++ b/app/src/lib/i18n/bn.ts
@@ -5470,6 +5470,55 @@ const messages: TranslationMap = {
   'notch.speaking': 'বলছি…',
   'notch.transcribing': 'ট্রান্সক্রাইব করছি…',
   'notch.executing': 'চালাচ্ছি…',
+  'memory.tab.orchestration': 'অর্কেস্ট্রেশন',
+  'memory.tab.orchestrationDescription':
+    'বহু-এজেন্ট ওয়ার্কফ্লো চালান — একটি প্রশ্নকে সমান্তরাল এজেন্টদের মধ্যে ছড়িয়ে দিন, তাদের ফলাফল পরস্পর যাচাই করুন, এবং দেখুন প্রতিটি ধাপ কীভাবে একটি সমন্বিত উত্তরে সম্পূর্ণ হয়।',
+  'orchestration.subtitle':
+    'একটি বহু-এজেন্ট ওয়ার্কফ্লো শুরু করুন, এর ধাপগুলোর অগ্রগতি দেখুন, এবং সমন্বিত ফলাফল পড়ুন।',
+  'orchestration.loading': 'ওয়ার্কফ্লো লোড হচ্ছে…',
+  'orchestration.failedToLoad': 'ওয়ার্কফ্লো লোড করতে ব্যর্থ',
+  'orchestration.definitions': 'উপলব্ধ ওয়ার্কফ্লো',
+  'orchestration.noDefinitions': 'কোনো ওয়ার্কফ্লো সংজ্ঞা উপলব্ধ নেই।',
+  'orchestration.approvalRequired': 'অনুমোদন প্রয়োজন',
+  'orchestration.start': 'শুরু করুন',
+  'orchestration.confirmStart': 'রান শুরু করুন',
+  'orchestration.starting': 'শুরু হচ্ছে…',
+  'orchestration.questionLabel': 'গবেষণা প্রশ্ন (ঐচ্ছিক)',
+  'orchestration.questionPlaceholder': 'এজেন্টদের কী গবেষণা করা উচিত?',
+  'orchestration.runProgress': 'রানের অগ্রগতি',
+  'orchestration.recentRuns': 'সাম্প্রতিক রান',
+  'orchestration.noRuns': 'এখনও কোনো ওয়ার্কফ্লো রান নেই।',
+  'orchestration.close': 'বন্ধ করুন',
+  'orchestration.tier.readOnly': 'শুধু-পড়া',
+  'orchestration.tier.standard': 'মানক',
+  'orchestration.tier.editCapable': 'সম্পাদনা-সক্ষম',
+  'orchestration.approval.title': 'এই ওয়ার্কফ্লো রান অনুমোদন করুন',
+  'orchestration.approval.body':
+    'এটি একটি উচ্চ-ব্যয় বা উচ্চ-সমান্তরালতার রান এবং শুরুর আগে এর জন্য আপনার স্পষ্ট অনুমোদন প্রয়োজন:',
+  'orchestration.approval.reason.tier': 'এর এজেন্টরা শুধু-পড়া গবেষণার বাইরেও পদক্ষেপ নিতে পারে।',
+  'orchestration.approval.reason.concurrency': 'এটি একই সময়ে অনেক এজেন্ট চালায়।',
+  'orchestration.approval.reason.children': 'এটি সর্বমোট বিপুল সংখ্যক এজেন্ট তৈরি করতে পারে।',
+  'orchestration.approval.tier': 'নিরাপত্তা স্তর',
+  'orchestration.approval.concurrency': 'সমান্তরালতা',
+  'orchestration.approval.maxChildren': 'সর্বোচ্চ এজেন্ট',
+  'orchestration.approval.approve': 'অনুমোদন ও শুরু করুন',
+  'orchestration.approval.starting': 'শুরু হচ্ছে…',
+  'orchestration.approval.cancel': 'বাতিল',
+  'orchestration.runStatus.pending': 'অপেক্ষমাণ',
+  'orchestration.runStatus.running': 'চলছে',
+  'orchestration.runStatus.completed': 'সম্পন্ন',
+  'orchestration.runStatus.failed': 'ব্যর্থ',
+  'orchestration.runStatus.cancelled': 'বাতিল',
+  'orchestration.runStatus.interrupted': 'বিঘ্নিত',
+  'orchestration.phaseStatus.pending': 'অপেক্ষমাণ',
+  'orchestration.phaseStatus.running': 'চলছে',
+  'orchestration.phaseStatus.completed': 'সম্পন্ন',
+  'orchestration.phaseStatus.failed': 'ব্যর্থ',
+  'orchestration.detail.stop': 'থামান',
+  'orchestration.detail.resume': 'পুনরায় শুরু করুন',
+  'orchestration.detail.agents': 'এজেন্ট',
+  'orchestration.detail.childRefs': 'চাইল্ড এজেন্ট',
+  'orchestration.detail.synthesis': 'চূড়ান্ত সংশ্লেষণ',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': 'এজেন্ট প্রোফাইল',
   'settings.profiles.subtitle':
diff --git a/app/src/lib/i18n/de.ts b/app/src/lib/i18n/de.ts
index 95ea68919..79e9a5920 100644
--- a/app/src/lib/i18n/de.ts
+++ b/app/src/lib/i18n/de.ts
@@ -5619,6 +5619,56 @@ const messages: TranslationMap = {
   'notch.speaking': 'Spreche…',
   'notch.transcribing': 'Transkribiere…',
   'notch.executing': 'Führe aus…',
+  'memory.tab.orchestration': 'Orchestrierung',
+  'memory.tab.orchestrationDescription':
+    'Führe Multi-Agenten-Workflows aus — verteile eine Frage auf parallele Agenten, gleiche ihre Ergebnisse ab und sieh zu, wie jede Phase zu einer zusammengeführten Antwort wird.',
+  'orchestration.subtitle':
+    'Starte einen Multi-Agenten-Workflow, verfolge seinen Phasenfortschritt und lies das zusammengeführte Ergebnis.',
+  'orchestration.loading': 'Lade Workflows…',
+  'orchestration.failedToLoad': 'Workflows konnten nicht geladen werden',
+  'orchestration.definitions': 'Verfügbare Workflows',
+  'orchestration.noDefinitions': 'Keine Workflow-Definitionen verfügbar.',
+  'orchestration.approvalRequired': 'Genehmigung erforderlich',
+  'orchestration.start': 'Starten',
+  'orchestration.confirmStart': 'Lauf starten',
+  'orchestration.starting': 'Wird gestartet…',
+  'orchestration.questionLabel': 'Forschungsfrage (optional)',
+  'orchestration.questionPlaceholder': 'Was sollen die Agenten erforschen?',
+  'orchestration.runProgress': 'Lauffortschritt',
+  'orchestration.recentRuns': 'Letzte Läufe',
+  'orchestration.noRuns': 'Noch keine Workflow-Läufe.',
+  'orchestration.close': 'Schließen',
+  'orchestration.tier.readOnly': 'Nur lesen',
+  'orchestration.tier.standard': 'Standard',
+  'orchestration.tier.editCapable': 'Bearbeitungsfähig',
+  'orchestration.approval.title': 'Diesen Workflow-Lauf genehmigen',
+  'orchestration.approval.body':
+    'Dies ist ein kosten- oder parallelitätsintensiver Lauf und benötigt vor dem Start deine ausdrückliche Genehmigung:',
+  'orchestration.approval.reason.tier':
+    'Seine Agenten können über reine Lese-Recherche hinaus Aktionen ausführen.',
+  'orchestration.approval.reason.concurrency': 'Er führt viele Agenten gleichzeitig aus.',
+  'orchestration.approval.reason.children': 'Er kann insgesamt sehr viele Agenten erzeugen.',
+  'orchestration.approval.tier': 'Sicherheitsstufe',
+  'orchestration.approval.concurrency': 'Parallelität',
+  'orchestration.approval.maxChildren': 'Max. Agenten',
+  'orchestration.approval.approve': 'Genehmigen & starten',
+  'orchestration.approval.starting': 'Wird gestartet…',
+  'orchestration.approval.cancel': 'Abbrechen',
+  'orchestration.runStatus.pending': 'Ausstehend',
+  'orchestration.runStatus.running': 'Läuft',
+  'orchestration.runStatus.completed': 'Abgeschlossen',
+  'orchestration.runStatus.failed': 'Fehlgeschlagen',
+  'orchestration.runStatus.cancelled': 'Abgebrochen',
+  'orchestration.runStatus.interrupted': 'Unterbrochen',
+  'orchestration.phaseStatus.pending': 'Ausstehend',
+  'orchestration.phaseStatus.running': 'Läuft',
+  'orchestration.phaseStatus.completed': 'Abgeschlossen',
+  'orchestration.phaseStatus.failed': 'Fehlgeschlagen',
+  'orchestration.detail.stop': 'Stoppen',
+  'orchestration.detail.resume': 'Fortsetzen',
+  'orchestration.detail.agents': 'Agenten',
+  'orchestration.detail.childRefs': 'Untergeordnete Agenten',
+  'orchestration.detail.synthesis': 'Endgültige Zusammenführung',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': 'Agentenprofile',
   'settings.profiles.subtitle':
diff --git a/app/src/lib/i18n/en.ts b/app/src/lib/i18n/en.ts
index 7a733c88a..6a1cfc82a 100644
--- a/app/src/lib/i18n/en.ts
+++ b/app/src/lib/i18n/en.ts
@@ -464,6 +464,9 @@ const en: TranslationMap = {
   'memory.tab.workflows': 'Workflows',
   'memory.tab.workflowsDescription':
     'Reusable, runnable procedures — a goal plus the steps to reach it. Create one, install from a URL, or open a workflow to run it.',
+  'memory.tab.orchestration': 'Orchestration',
+  'memory.tab.orchestrationDescription':
+    'Run multi-agent workflows — fan a question out across parallel agents, cross-check their findings, and watch each phase finish into one synthesized answer.',
   'memory.tab.dreams': 'Dreams',
   'memory.tab.calls': 'Calls',
   'memory.tab.diagram': 'Diagram',
@@ -3557,6 +3560,53 @@ const en: TranslationMap = {
   'intelligence.agentWork.action.continuePlaceholder': 'Reply to unblock this agent…',
   'intelligence.agentWork.action.followUpPlaceholder': 'Send a follow-up instruction…',
   'intelligence.agentWork.action.failed': 'Action failed',
+  // Orchestration tab (#3375) — multi-agent workflow runs.
+  'orchestration.subtitle':
+    'Start a multi-agent workflow, watch its phases progress, and read the synthesized result.',
+  'orchestration.loading': 'Loading workflows…',
+  'orchestration.failedToLoad': 'Failed to load workflows',
+  'orchestration.definitions': 'Available workflows',
+  'orchestration.noDefinitions': 'No workflow definitions are available.',
+  'orchestration.approvalRequired': 'Approval required',
+  'orchestration.start': 'Start',
+  'orchestration.confirmStart': 'Start run',
+  'orchestration.starting': 'Starting…',
+  'orchestration.questionLabel': 'Research question (optional)',
+  'orchestration.questionPlaceholder': 'What should the agents research?',
+  'orchestration.runProgress': 'Run progress',
+  'orchestration.recentRuns': 'Recent runs',
+  'orchestration.noRuns': 'No workflow runs yet.',
+  'orchestration.close': 'Close',
+  'orchestration.tier.readOnly': 'Read-only',
+  'orchestration.tier.standard': 'Standard',
+  'orchestration.tier.editCapable': 'Edit-capable',
+  'orchestration.approval.title': 'Approve this workflow run',
+  'orchestration.approval.body':
+    'This is a high-cost or high-concurrency run and needs your explicit approval before it starts:',
+  'orchestration.approval.reason.tier': 'Its agents can take actions beyond read-only research.',
+  'orchestration.approval.reason.concurrency': 'It runs many agents at the same time.',
+  'orchestration.approval.reason.children': 'It can spawn a large number of agents in total.',
+  'orchestration.approval.tier': 'Safety tier',
+  'orchestration.approval.concurrency': 'Concurrency',
+  'orchestration.approval.maxChildren': 'Max agents',
+  'orchestration.approval.approve': 'Approve & start',
+  'orchestration.approval.starting': 'Starting…',
+  'orchestration.approval.cancel': 'Cancel',
+  'orchestration.runStatus.pending': 'Pending',
+  'orchestration.runStatus.running': 'Running',
+  'orchestration.runStatus.completed': 'Completed',
+  'orchestration.runStatus.failed': 'Failed',
+  'orchestration.runStatus.cancelled': 'Cancelled',
+  'orchestration.runStatus.interrupted': 'Interrupted',
+  'orchestration.phaseStatus.pending': 'Pending',
+  'orchestration.phaseStatus.running': 'Running',
+  'orchestration.phaseStatus.completed': 'Completed',
+  'orchestration.phaseStatus.failed': 'Failed',
+  'orchestration.detail.stop': 'Stop',
+  'orchestration.detail.resume': 'Resume',
+  'orchestration.detail.agents': 'agents',
+  'orchestration.detail.childRefs': 'Child agents',
+  'orchestration.detail.synthesis': 'Final synthesis',
   'intelligence.teams.subtitle': 'Coordinated agent teams and the tasks they share.',
   'intelligence.teams.loading': 'Loading teams…',
   'intelligence.teams.failedToLoad': 'Failed to load teams',
diff --git a/app/src/lib/i18n/es.ts b/app/src/lib/i18n/es.ts
index 3b59ab9b4..125292a62 100644
--- a/app/src/lib/i18n/es.ts
+++ b/app/src/lib/i18n/es.ts
@@ -5584,6 +5584,56 @@ const messages: TranslationMap = {
   'notch.speaking': 'Hablando…',
   'notch.transcribing': 'Transcribiendo…',
   'notch.executing': 'Ejecutando…',
+  'memory.tab.orchestration': 'Orquestación',
+  'memory.tab.orchestrationDescription':
+    'Ejecuta flujos de trabajo con múltiples agentes: distribuye una pregunta entre agentes paralelos, contrasta sus hallazgos y observa cómo cada fase culmina en una única respuesta sintetizada.',
+  'orchestration.subtitle':
+    'Inicia un flujo de trabajo con múltiples agentes, observa el avance de sus fases y lee el resultado sintetizado.',
+  'orchestration.loading': 'Cargando flujos de trabajo…',
+  'orchestration.failedToLoad': 'No se pudieron cargar los flujos de trabajo',
+  'orchestration.definitions': 'Flujos de trabajo disponibles',
+  'orchestration.noDefinitions': 'No hay definiciones de flujos de trabajo disponibles.',
+  'orchestration.approvalRequired': 'Aprobación requerida',
+  'orchestration.start': 'Iniciar',
+  'orchestration.confirmStart': 'Iniciar ejecución',
+  'orchestration.starting': 'Iniciando…',
+  'orchestration.questionLabel': 'Pregunta de investigación (opcional)',
+  'orchestration.questionPlaceholder': '¿Qué deben investigar los agentes?',
+  'orchestration.runProgress': 'Progreso de la ejecución',
+  'orchestration.recentRuns': 'Ejecuciones recientes',
+  'orchestration.noRuns': 'Aún no hay ejecuciones de flujos de trabajo.',
+  'orchestration.close': 'Cerrar',
+  'orchestration.tier.readOnly': 'Solo lectura',
+  'orchestration.tier.standard': 'Estándar',
+  'orchestration.tier.editCapable': 'Con capacidad de edición',
+  'orchestration.approval.title': 'Aprobar esta ejecución del flujo de trabajo',
+  'orchestration.approval.body':
+    'Esta es una ejecución de alto costo o alta concurrencia y necesita tu aprobación explícita antes de iniciar:',
+  'orchestration.approval.reason.tier':
+    'Sus agentes pueden realizar acciones más allá de la investigación de solo lectura.',
+  'orchestration.approval.reason.concurrency': 'Ejecuta muchos agentes al mismo tiempo.',
+  'orchestration.approval.reason.children': 'Puede generar una gran cantidad de agentes en total.',
+  'orchestration.approval.tier': 'Nivel de seguridad',
+  'orchestration.approval.concurrency': 'Concurrencia',
+  'orchestration.approval.maxChildren': 'Máx. de agentes',
+  'orchestration.approval.approve': 'Aprobar e iniciar',
+  'orchestration.approval.starting': 'Iniciando…',
+  'orchestration.approval.cancel': 'Cancelar',
+  'orchestration.runStatus.pending': 'Pendiente',
+  'orchestration.runStatus.running': 'En ejecución',
+  'orchestration.runStatus.completed': 'Completada',
+  'orchestration.runStatus.failed': 'Fallida',
+  'orchestration.runStatus.cancelled': 'Cancelada',
+  'orchestration.runStatus.interrupted': 'Interrumpida',
+  'orchestration.phaseStatus.pending': 'Pendiente',
+  'orchestration.phaseStatus.running': 'En ejecución',
+  'orchestration.phaseStatus.completed': 'Completada',
+  'orchestration.phaseStatus.failed': 'Fallida',
+  'orchestration.detail.stop': 'Detener',
+  'orchestration.detail.resume': 'Reanudar',
+  'orchestration.detail.agents': 'agentes',
+  'orchestration.detail.childRefs': 'Agentes secundarios',
+  'orchestration.detail.synthesis': 'Síntesis final',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': 'Perfiles de agente',
   'settings.profiles.subtitle':
diff --git a/app/src/lib/i18n/fr.ts b/app/src/lib/i18n/fr.ts
index c5a8740c0..5c396f9db 100644
--- a/app/src/lib/i18n/fr.ts
+++ b/app/src/lib/i18n/fr.ts
@@ -5604,6 +5604,57 @@ const messages: TranslationMap = {
   'notch.speaking': 'Je parle…',
   'notch.transcribing': 'Transcription…',
   'notch.executing': "J'exécute…",
+  'memory.tab.orchestration': 'Orchestration',
+  'memory.tab.orchestrationDescription':
+    'Exécutez des workflows multi-agents — répartissez une question entre des agents parallèles, recoupez leurs résultats et regardez chaque phase aboutir à une réponse synthétisée unique.',
+  'orchestration.subtitle':
+    'Démarrez un workflow multi-agents, suivez la progression de ses phases et lisez le résultat synthétisé.',
+  'orchestration.loading': 'Chargement des workflows…',
+  'orchestration.failedToLoad': 'Échec du chargement des workflows',
+  'orchestration.definitions': 'Workflows disponibles',
+  'orchestration.noDefinitions': 'Aucune définition de workflow disponible.',
+  'orchestration.approvalRequired': 'Approbation requise',
+  'orchestration.start': 'Démarrer',
+  'orchestration.confirmStart': "Démarrer l'exécution",
+  'orchestration.starting': 'Démarrage…',
+  'orchestration.questionLabel': 'Question de recherche (facultatif)',
+  'orchestration.questionPlaceholder': 'Que doivent rechercher les agents ?',
+  'orchestration.runProgress': "Progression de l'exécution",
+  'orchestration.recentRuns': 'Exécutions récentes',
+  'orchestration.noRuns': 'Aucune exécution de workflow pour le moment.',
+  'orchestration.close': 'Fermer',
+  'orchestration.tier.readOnly': 'Lecture seule',
+  'orchestration.tier.standard': 'Standard',
+  'orchestration.tier.editCapable': "Capable d'édition",
+  'orchestration.approval.title': 'Approuver cette exécution de workflow',
+  'orchestration.approval.body':
+    "Il s'agit d'une exécution coûteuse ou très concurrente qui nécessite votre approbation explicite avant de démarrer :",
+  'orchestration.approval.reason.tier':
+    'Ses agents peuvent effectuer des actions au-delà de la recherche en lecture seule.',
+  'orchestration.approval.reason.concurrency': 'Il exécute de nombreux agents en même temps.',
+  'orchestration.approval.reason.children':
+    "Il peut générer un très grand nombre d'agents au total.",
+  'orchestration.approval.tier': 'Niveau de sécurité',
+  'orchestration.approval.concurrency': 'Concurrence',
+  'orchestration.approval.maxChildren': "Nombre max d'agents",
+  'orchestration.approval.approve': 'Approuver et démarrer',
+  'orchestration.approval.starting': 'Démarrage…',
+  'orchestration.approval.cancel': 'Annuler',
+  'orchestration.runStatus.pending': 'En attente',
+  'orchestration.runStatus.running': 'En cours',
+  'orchestration.runStatus.completed': 'Terminée',
+  'orchestration.runStatus.failed': 'Échouée',
+  'orchestration.runStatus.cancelled': 'Annulée',
+  'orchestration.runStatus.interrupted': 'Interrompue',
+  'orchestration.phaseStatus.pending': 'En attente',
+  'orchestration.phaseStatus.running': 'En cours',
+  'orchestration.phaseStatus.completed': 'Terminée',
+  'orchestration.phaseStatus.failed': 'Échouée',
+  'orchestration.detail.stop': 'Arrêter',
+  'orchestration.detail.resume': 'Reprendre',
+  'orchestration.detail.agents': 'agents',
+  'orchestration.detail.childRefs': 'Agents enfants',
+  'orchestration.detail.synthesis': 'Synthèse finale',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': "Profils d'agent",
   'settings.profiles.subtitle':
diff --git a/app/src/lib/i18n/hi.ts b/app/src/lib/i18n/hi.ts
index a126f59ad..9ea4416b3 100644
--- a/app/src/lib/i18n/hi.ts
+++ b/app/src/lib/i18n/hi.ts
@@ -5471,6 +5471,56 @@ const messages: TranslationMap = {
   'notch.speaking': 'बोल रहा हूं…',
   'notch.transcribing': 'ट्रांसक्राइब कर रहा हूं…',
   'notch.executing': 'चला रहा हूं…',
+  'memory.tab.orchestration': 'ऑर्केस्ट्रेशन',
+  'memory.tab.orchestrationDescription':
+    'बहु-एजेंट वर्कफ़्लो चलाएं — एक प्रश्न को समानांतर एजेंटों में बाँटें, उनके निष्कर्षों की परस्पर जाँच करें, और देखें कि हर चरण एक संयोजित उत्तर में पूरा होता है।',
+  'orchestration.subtitle':
+    'बहु-एजेंट वर्कफ़्लो शुरू करें, उसके चरणों की प्रगति देखें, और संयोजित परिणाम पढ़ें।',
+  'orchestration.loading': 'वर्कफ़्लो लोड हो रहे हैं…',
+  'orchestration.failedToLoad': 'वर्कफ़्लो लोड करने में विफल',
+  'orchestration.definitions': 'उपलब्ध वर्कफ़्लो',
+  'orchestration.noDefinitions': 'कोई वर्कफ़्लो परिभाषा उपलब्ध नहीं है।',
+  'orchestration.approvalRequired': 'अनुमोदन आवश्यक',
+  'orchestration.start': 'शुरू करें',
+  'orchestration.confirmStart': 'रन शुरू करें',
+  'orchestration.starting': 'शुरू हो रहा है…',
+  'orchestration.questionLabel': 'शोध प्रश्न (वैकल्पिक)',
+  'orchestration.questionPlaceholder': 'एजेंटों को क्या शोध करना चाहिए?',
+  'orchestration.runProgress': 'रन प्रगति',
+  'orchestration.recentRuns': 'हाल के रन',
+  'orchestration.noRuns': 'अभी तक कोई वर्कफ़्लो रन नहीं।',
+  'orchestration.close': 'बंद करें',
+  'orchestration.tier.readOnly': 'केवल-पढ़ने योग्य',
+  'orchestration.tier.standard': 'मानक',
+  'orchestration.tier.editCapable': 'संपादन-सक्षम',
+  'orchestration.approval.title': 'इस वर्कफ़्लो रन को अनुमोदित करें',
+  'orchestration.approval.body':
+    'यह एक उच्च-लागत या उच्च-समवर्ती रन है और शुरू होने से पहले इसे आपके स्पष्ट अनुमोदन की आवश्यकता है:',
+  'orchestration.approval.reason.tier': 'इसके एजेंट केवल-पढ़ने योग्य शोध से परे कार्य कर सकते हैं।',
+  'orchestration.approval.reason.concurrency': 'यह एक साथ कई एजेंट चलाता है।',
+  'orchestration.approval.reason.children':
+    'यह कुल मिलाकर बहुत बड़ी संख्या में एजेंट उत्पन्न कर सकता है।',
+  'orchestration.approval.tier': 'सुरक्षा स्तर',
+  'orchestration.approval.concurrency': 'समवर्तीता',
+  'orchestration.approval.maxChildren': 'अधिकतम एजेंट',
+  'orchestration.approval.approve': 'अनुमोदित करें और शुरू करें',
+  'orchestration.approval.starting': 'शुरू हो रहा है…',
+  'orchestration.approval.cancel': 'रद्द करें',
+  'orchestration.runStatus.pending': 'लंबित',
+  'orchestration.runStatus.running': 'चल रहा है',
+  'orchestration.runStatus.completed': 'पूर्ण',
+  'orchestration.runStatus.failed': 'विफल',
+  'orchestration.runStatus.cancelled': 'रद्द',
+  'orchestration.runStatus.interrupted': 'बाधित',
+  'orchestration.phaseStatus.pending': 'लंबित',
+  'orchestration.phaseStatus.running': 'चल रहा है',
+  'orchestration.phaseStatus.completed': 'पूर्ण',
+  'orchestration.phaseStatus.failed': 'विफल',
+  'orchestration.detail.stop': 'रोकें',
+  'orchestration.detail.resume': 'पुनः आरंभ करें',
+  'orchestration.detail.agents': 'एजेंट',
+  'orchestration.detail.childRefs': 'चाइल्ड एजेंट',
+  'orchestration.detail.synthesis': 'अंतिम संश्लेषण',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': 'एजेंट प्रोफ़ाइल',
   'settings.profiles.subtitle': 'विशिष्ट एजेंट — हर एक की अपनी आत्मा, स्मृति, कनेक्टर और कौशल।',
diff --git a/app/src/lib/i18n/id.ts b/app/src/lib/i18n/id.ts
index 23354d746..6cb8dab05 100644
--- a/app/src/lib/i18n/id.ts
+++ b/app/src/lib/i18n/id.ts
@@ -5488,6 +5488,57 @@ const messages: TranslationMap = {
   'notch.speaking': 'Berbicara…',
   'notch.transcribing': 'Mentranskrip…',
   'notch.executing': 'Mengeksekusi…',
+  'memory.tab.orchestration': 'Orkestrasi',
+  'memory.tab.orchestrationDescription':
+    'Jalankan alur kerja multi-agen — sebarkan satu pertanyaan ke agen-agen paralel, periksa silang temuan mereka, dan saksikan setiap fase berakhir menjadi satu jawaban tersintesis.',
+  'orchestration.subtitle':
+    'Mulai alur kerja multi-agen, pantau kemajuan fasenya, dan baca hasil tersintesisnya.',
+  'orchestration.loading': 'Memuat alur kerja…',
+  'orchestration.failedToLoad': 'Gagal memuat alur kerja',
+  'orchestration.definitions': 'Alur kerja tersedia',
+  'orchestration.noDefinitions': 'Tidak ada definisi alur kerja yang tersedia.',
+  'orchestration.approvalRequired': 'Persetujuan diperlukan',
+  'orchestration.start': 'Mulai',
+  'orchestration.confirmStart': 'Mulai jalankan',
+  'orchestration.starting': 'Memulai…',
+  'orchestration.questionLabel': 'Pertanyaan riset (opsional)',
+  'orchestration.questionPlaceholder': 'Apa yang harus diteliti para agen?',
+  'orchestration.runProgress': 'Kemajuan eksekusi',
+  'orchestration.recentRuns': 'Eksekusi terbaru',
+  'orchestration.noRuns': 'Belum ada eksekusi alur kerja.',
+  'orchestration.close': 'Tutup',
+  'orchestration.tier.readOnly': 'Hanya-baca',
+  'orchestration.tier.standard': 'Standar',
+  'orchestration.tier.editCapable': 'Mampu menyunting',
+  'orchestration.approval.title': 'Setujui eksekusi alur kerja ini',
+  'orchestration.approval.body':
+    'Ini adalah eksekusi berbiaya tinggi atau berkonkurensi tinggi dan memerlukan persetujuan eksplisit Anda sebelum dimulai:',
+  'orchestration.approval.reason.tier':
+    'Agen-agennya dapat melakukan tindakan di luar riset hanya-baca.',
+  'orchestration.approval.reason.concurrency': 'Ini menjalankan banyak agen pada saat yang sama.',
+  'orchestration.approval.reason.children':
+    'Ini dapat memunculkan agen dalam jumlah sangat besar secara total.',
+  'orchestration.approval.tier': 'Tingkat keamanan',
+  'orchestration.approval.concurrency': 'Konkurensi',
+  'orchestration.approval.maxChildren': 'Maks. agen',
+  'orchestration.approval.approve': 'Setujui & mulai',
+  'orchestration.approval.starting': 'Memulai…',
+  'orchestration.approval.cancel': 'Batal',
+  'orchestration.runStatus.pending': 'Menunggu',
+  'orchestration.runStatus.running': 'Berjalan',
+  'orchestration.runStatus.completed': 'Selesai',
+  'orchestration.runStatus.failed': 'Gagal',
+  'orchestration.runStatus.cancelled': 'Dibatalkan',
+  'orchestration.runStatus.interrupted': 'Terputus',
+  'orchestration.phaseStatus.pending': 'Menunggu',
+  'orchestration.phaseStatus.running': 'Berjalan',
+  'orchestration.phaseStatus.completed': 'Selesai',
+  'orchestration.phaseStatus.failed': 'Gagal',
+  'orchestration.detail.stop': 'Hentikan',
+  'orchestration.detail.resume': 'Lanjutkan',
+  'orchestration.detail.agents': 'agen',
+  'orchestration.detail.childRefs': 'Agen anak',
+  'orchestration.detail.synthesis': 'Sintesis akhir',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': 'Profil Agen',
   'settings.profiles.subtitle':
diff --git a/app/src/lib/i18n/it.ts b/app/src/lib/i18n/it.ts
index cb956f7ee..f7107889b 100644
--- a/app/src/lib/i18n/it.ts
+++ b/app/src/lib/i18n/it.ts
@@ -5574,6 +5574,56 @@ const messages: TranslationMap = {
   'notch.speaking': 'Parlo…',
   'notch.transcribing': 'Trascrizione…',
   'notch.executing': 'Eseguendo…',
+  'memory.tab.orchestration': 'Orchestrazione',
+  'memory.tab.orchestrationDescription':
+    'Esegui flussi di lavoro multi-agente — distribuisci una domanda tra agenti paralleli, confronta i loro risultati e osserva ogni fase concludersi in un’unica risposta sintetizzata.',
+  'orchestration.subtitle':
+    'Avvia un flusso di lavoro multi-agente, osserva l’avanzamento delle sue fasi e leggi il risultato sintetizzato.',
+  'orchestration.loading': 'Caricamento dei flussi di lavoro…',
+  'orchestration.failedToLoad': 'Impossibile caricare i flussi di lavoro',
+  'orchestration.definitions': 'Flussi di lavoro disponibili',
+  'orchestration.noDefinitions': 'Nessuna definizione di flusso di lavoro disponibile.',
+  'orchestration.approvalRequired': 'Approvazione richiesta',
+  'orchestration.start': 'Avvia',
+  'orchestration.confirmStart': 'Avvia esecuzione',
+  'orchestration.starting': 'Avvio in corso…',
+  'orchestration.questionLabel': 'Domanda di ricerca (facoltativa)',
+  'orchestration.questionPlaceholder': 'Cosa devono ricercare gli agenti?',
+  'orchestration.runProgress': 'Avanzamento esecuzione',
+  'orchestration.recentRuns': 'Esecuzioni recenti',
+  'orchestration.noRuns': 'Ancora nessuna esecuzione di flussi di lavoro.',
+  'orchestration.close': 'Chiudi',
+  'orchestration.tier.readOnly': 'Sola lettura',
+  'orchestration.tier.standard': 'Standard',
+  'orchestration.tier.editCapable': 'Con capacità di modifica',
+  'orchestration.approval.title': 'Approva questa esecuzione del flusso di lavoro',
+  'orchestration.approval.body':
+    'Questa è un’esecuzione ad alto costo o ad alta concorrenza e richiede la tua approvazione esplicita prima di iniziare:',
+  'orchestration.approval.reason.tier':
+    'I suoi agenti possono compiere azioni oltre la ricerca in sola lettura.',
+  'orchestration.approval.reason.concurrency': 'Esegue molti agenti contemporaneamente.',
+  'orchestration.approval.reason.children': 'Può generare un gran numero di agenti in totale.',
+  'orchestration.approval.tier': 'Livello di sicurezza',
+  'orchestration.approval.concurrency': 'Concorrenza',
+  'orchestration.approval.maxChildren': 'Numero massimo di agenti',
+  'orchestration.approval.approve': 'Approva e avvia',
+  'orchestration.approval.starting': 'Avvio in corso…',
+  'orchestration.approval.cancel': 'Annulla',
+  'orchestration.runStatus.pending': 'In attesa',
+  'orchestration.runStatus.running': 'In esecuzione',
+  'orchestration.runStatus.completed': 'Completata',
+  'orchestration.runStatus.failed': 'Non riuscita',
+  'orchestration.runStatus.cancelled': 'Annullata',
+  'orchestration.runStatus.interrupted': 'Interrotta',
+  'orchestration.phaseStatus.pending': 'In attesa',
+  'orchestration.phaseStatus.running': 'In esecuzione',
+  'orchestration.phaseStatus.completed': 'Completata',
+  'orchestration.phaseStatus.failed': 'Non riuscita',
+  'orchestration.detail.stop': 'Arresta',
+  'orchestration.detail.resume': 'Riprendi',
+  'orchestration.detail.agents': 'agenti',
+  'orchestration.detail.childRefs': 'Agenti figli',
+  'orchestration.detail.synthesis': 'Sintesi finale',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': 'Profili agente',
   'settings.profiles.subtitle':
diff --git a/app/src/lib/i18n/ko.ts b/app/src/lib/i18n/ko.ts
index 70ad2a82a..2d226f6b8 100644
--- a/app/src/lib/i18n/ko.ts
+++ b/app/src/lib/i18n/ko.ts
@@ -5416,6 +5416,57 @@ const messages: TranslationMap = {
   'notch.speaking': '말하는 중…',
   'notch.transcribing': '변환 중…',
   'notch.executing': '실행 중…',
+  'memory.tab.orchestration': '오케스트레이션',
+  'memory.tab.orchestrationDescription':
+    '다중 에이전트 워크플로를 실행하세요. 하나의 질문을 병렬 에이전트들에 분산하고, 그 결과를 교차 검증하며, 각 단계가 하나의 종합된 답변으로 완성되는 과정을 지켜보세요.',
+  'orchestration.subtitle':
+    '다중 에이전트 워크플로를 시작하고, 단계 진행 상황을 지켜보며, 종합된 결과를 확인하세요.',
+  'orchestration.loading': '워크플로 불러오는 중…',
+  'orchestration.failedToLoad': '워크플로를 불러오지 못했습니다',
+  'orchestration.definitions': '사용 가능한 워크플로',
+  'orchestration.noDefinitions': '사용 가능한 워크플로 정의가 없습니다.',
+  'orchestration.approvalRequired': '승인 필요',
+  'orchestration.start': '시작',
+  'orchestration.confirmStart': '실행 시작',
+  'orchestration.starting': '시작 중…',
+  'orchestration.questionLabel': '연구 질문 (선택 사항)',
+  'orchestration.questionPlaceholder': '에이전트가 무엇을 조사해야 하나요?',
+  'orchestration.runProgress': '실행 진행 상황',
+  'orchestration.recentRuns': '최근 실행',
+  'orchestration.noRuns': '아직 워크플로 실행이 없습니다.',
+  'orchestration.close': '닫기',
+  'orchestration.tier.readOnly': '읽기 전용',
+  'orchestration.tier.standard': '표준',
+  'orchestration.tier.editCapable': '편집 가능',
+  'orchestration.approval.title': '이 워크플로 실행 승인',
+  'orchestration.approval.body':
+    '이것은 고비용 또는 고동시성 실행으로, 시작하기 전에 명시적인 승인이 필요합니다:',
+  'orchestration.approval.reason.tier':
+    '해당 에이전트는 읽기 전용 조사를 넘어서는 작업을 수행할 수 있습니다.',
+  'orchestration.approval.reason.concurrency': '동시에 많은 에이전트를 실행합니다.',
+  'orchestration.approval.reason.children':
+    '전체적으로 매우 많은 수의 에이전트를 생성할 수 있습니다.',
+  'orchestration.approval.tier': '보안 등급',
+  'orchestration.approval.concurrency': '동시성',
+  'orchestration.approval.maxChildren': '최대 에이전트 수',
+  'orchestration.approval.approve': '승인 및 시작',
+  'orchestration.approval.starting': '시작 중…',
+  'orchestration.approval.cancel': '취소',
+  'orchestration.runStatus.pending': '대기 중',
+  'orchestration.runStatus.running': '실행 중',
+  'orchestration.runStatus.completed': '완료됨',
+  'orchestration.runStatus.failed': '실패함',
+  'orchestration.runStatus.cancelled': '취소됨',
+  'orchestration.runStatus.interrupted': '중단됨',
+  'orchestration.phaseStatus.pending': '대기 중',
+  'orchestration.phaseStatus.running': '실행 중',
+  'orchestration.phaseStatus.completed': '완료됨',
+  'orchestration.phaseStatus.failed': '실패함',
+  'orchestration.detail.stop': '중지',
+  'orchestration.detail.resume': '재개',
+  'orchestration.detail.agents': '에이전트',
+  'orchestration.detail.childRefs': '하위 에이전트',
+  'orchestration.detail.synthesis': '최종 종합',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': '에이전트 프로필',
   'settings.profiles.subtitle':
diff --git a/app/src/lib/i18n/pl.ts b/app/src/lib/i18n/pl.ts
index 5773cf662..e77500e7b 100644
--- a/app/src/lib/i18n/pl.ts
+++ b/app/src/lib/i18n/pl.ts
@@ -5557,6 +5557,56 @@ const messages: TranslationMap = {
   'notch.speaking': 'Mówię…',
   'notch.transcribing': 'Transkrybuję…',
   'notch.executing': 'Wykonuję…',
+  'memory.tab.orchestration': 'Orkiestracja',
+  'memory.tab.orchestrationDescription':
+    'Uruchamiaj przepływy pracy z wieloma agentami — rozdziel pytanie między równoległych agentów, porównaj ich ustalenia i obserwuj, jak każda faza kończy się jedną zsyntetyzowaną odpowiedzią.',
+  'orchestration.subtitle':
+    'Uruchom przepływ pracy z wieloma agentami, obserwuj postęp jego faz i przeczytaj zsyntetyzowany wynik.',
+  'orchestration.loading': 'Ładowanie przepływów pracy…',
+  'orchestration.failedToLoad': 'Nie udało się załadować przepływów pracy',
+  'orchestration.definitions': 'Dostępne przepływy pracy',
+  'orchestration.noDefinitions': 'Brak dostępnych definicji przepływów pracy.',
+  'orchestration.approvalRequired': 'Wymagane zatwierdzenie',
+  'orchestration.start': 'Uruchom',
+  'orchestration.confirmStart': 'Uruchom wykonanie',
+  'orchestration.starting': 'Uruchamianie…',
+  'orchestration.questionLabel': 'Pytanie badawcze (opcjonalne)',
+  'orchestration.questionPlaceholder': 'Co agenci mają zbadać?',
+  'orchestration.runProgress': 'Postęp wykonania',
+  'orchestration.recentRuns': 'Ostatnie wykonania',
+  'orchestration.noRuns': 'Brak wykonań przepływów pracy.',
+  'orchestration.close': 'Zamknij',
+  'orchestration.tier.readOnly': 'Tylko do odczytu',
+  'orchestration.tier.standard': 'Standardowy',
+  'orchestration.tier.editCapable': 'Z możliwością edycji',
+  'orchestration.approval.title': 'Zatwierdź to wykonanie przepływu pracy',
+  'orchestration.approval.body':
+    'To kosztowne lub silnie współbieżne wykonanie wymaga Twojego wyraźnego zatwierdzenia przed rozpoczęciem:',
+  'orchestration.approval.reason.tier':
+    'Jego agenci mogą wykonywać działania wykraczające poza badania tylko do odczytu.',
+  'orchestration.approval.reason.concurrency': 'Uruchamia wielu agentów jednocześnie.',
+  'orchestration.approval.reason.children': 'Może łącznie utworzyć bardzo dużą liczbę agentów.',
+  'orchestration.approval.tier': 'Poziom bezpieczeństwa',
+  'orchestration.approval.concurrency': 'Współbieżność',
+  'orchestration.approval.maxChildren': 'Maks. agentów',
+  'orchestration.approval.approve': 'Zatwierdź i uruchom',
+  'orchestration.approval.starting': 'Uruchamianie…',
+  'orchestration.approval.cancel': 'Anuluj',
+  'orchestration.runStatus.pending': 'Oczekujące',
+  'orchestration.runStatus.running': 'W trakcie',
+  'orchestration.runStatus.completed': 'Zakończone',
+  'orchestration.runStatus.failed': 'Nieudane',
+  'orchestration.runStatus.cancelled': 'Anulowane',
+  'orchestration.runStatus.interrupted': 'Przerwane',
+  'orchestration.phaseStatus.pending': 'Oczekująca',
+  'orchestration.phaseStatus.running': 'W trakcie',
+  'orchestration.phaseStatus.completed': 'Zakończona',
+  'orchestration.phaseStatus.failed': 'Nieudana',
+  'orchestration.detail.stop': 'Zatrzymaj',
+  'orchestration.detail.resume': 'Wznów',
+  'orchestration.detail.agents': 'agenci',
+  'orchestration.detail.childRefs': 'Agenci podrzędni',
+  'orchestration.detail.synthesis': 'Synteza końcowa',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': 'Profile agenta',
   'settings.profiles.subtitle':
diff --git a/app/src/lib/i18n/pt.ts b/app/src/lib/i18n/pt.ts
index 97f2bd386..4f794d016 100644
--- a/app/src/lib/i18n/pt.ts
+++ b/app/src/lib/i18n/pt.ts
@@ -5567,6 +5567,56 @@ const messages: TranslationMap = {
   'notch.speaking': 'Falando…',
   'notch.transcribing': 'Transcrevendo…',
   'notch.executing': 'Executando…',
+  'memory.tab.orchestration': 'Orquestração',
+  'memory.tab.orchestrationDescription':
+    'Execute fluxos de trabalho com múltiplos agentes — distribua uma pergunta entre agentes paralelos, confronte seus resultados e veja cada fase culminar em uma única resposta sintetizada.',
+  'orchestration.subtitle':
+    'Inicie um fluxo de trabalho com múltiplos agentes, acompanhe o progresso de suas fases e leia o resultado sintetizado.',
+  'orchestration.loading': 'Carregando fluxos de trabalho…',
+  'orchestration.failedToLoad': 'Falha ao carregar os fluxos de trabalho',
+  'orchestration.definitions': 'Fluxos de trabalho disponíveis',
+  'orchestration.noDefinitions': 'Nenhuma definição de fluxo de trabalho disponível.',
+  'orchestration.approvalRequired': 'Aprovação necessária',
+  'orchestration.start': 'Iniciar',
+  'orchestration.confirmStart': 'Iniciar execução',
+  'orchestration.starting': 'Iniciando…',
+  'orchestration.questionLabel': 'Pergunta de pesquisa (opcional)',
+  'orchestration.questionPlaceholder': 'O que os agentes devem pesquisar?',
+  'orchestration.runProgress': 'Progresso da execução',
+  'orchestration.recentRuns': 'Execuções recentes',
+  'orchestration.noRuns': 'Ainda não há execuções de fluxos de trabalho.',
+  'orchestration.close': 'Fechar',
+  'orchestration.tier.readOnly': 'Somente leitura',
+  'orchestration.tier.standard': 'Padrão',
+  'orchestration.tier.editCapable': 'Com capacidade de edição',
+  'orchestration.approval.title': 'Aprovar esta execução do fluxo de trabalho',
+  'orchestration.approval.body':
+    'Esta é uma execução de alto custo ou alta concorrência e precisa da sua aprovação explícita antes de iniciar:',
+  'orchestration.approval.reason.tier':
+    'Seus agentes podem realizar ações além da pesquisa somente leitura.',
+  'orchestration.approval.reason.concurrency': 'Ela executa muitos agentes ao mesmo tempo.',
+  'orchestration.approval.reason.children': 'Ela pode gerar um grande número de agentes no total.',
+  'orchestration.approval.tier': 'Nível de segurança',
+  'orchestration.approval.concurrency': 'Concorrência',
+  'orchestration.approval.maxChildren': 'Máx. de agentes',
+  'orchestration.approval.approve': 'Aprovar e iniciar',
+  'orchestration.approval.starting': 'Iniciando…',
+  'orchestration.approval.cancel': 'Cancelar',
+  'orchestration.runStatus.pending': 'Pendente',
+  'orchestration.runStatus.running': 'Em execução',
+  'orchestration.runStatus.completed': 'Concluída',
+  'orchestration.runStatus.failed': 'Falhou',
+  'orchestration.runStatus.cancelled': 'Cancelada',
+  'orchestration.runStatus.interrupted': 'Interrompida',
+  'orchestration.phaseStatus.pending': 'Pendente',
+  'orchestration.phaseStatus.running': 'Em execução',
+  'orchestration.phaseStatus.completed': 'Concluída',
+  'orchestration.phaseStatus.failed': 'Falhou',
+  'orchestration.detail.stop': 'Parar',
+  'orchestration.detail.resume': 'Retomar',
+  'orchestration.detail.agents': 'agentes',
+  'orchestration.detail.childRefs': 'Agentes filhos',
+  'orchestration.detail.synthesis': 'Síntese final',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': 'Perfis de agente',
   'settings.profiles.subtitle':
diff --git a/app/src/lib/i18n/ru.ts b/app/src/lib/i18n/ru.ts
index 0865a619a..e00abec8e 100644
--- a/app/src/lib/i18n/ru.ts
+++ b/app/src/lib/i18n/ru.ts
@@ -5527,6 +5527,57 @@ const messages: TranslationMap = {
   'notch.speaking': 'Говорю…',
   'notch.transcribing': 'Транскрибирую…',
   'notch.executing': 'Выполняю…',
+  'memory.tab.orchestration': 'Оркестрация',
+  'memory.tab.orchestrationDescription':
+    'Запускайте мультиагентные рабочие процессы — распределяйте вопрос между параллельными агентами, перепроверяйте их выводы и наблюдайте, как каждая фаза сходится в единый синтезированный ответ.',
+  'orchestration.subtitle':
+    'Запустите мультиагентный рабочий процесс, следите за ходом его фаз и читайте синтезированный результат.',
+  'orchestration.loading': 'Загрузка рабочих процессов…',
+  'orchestration.failedToLoad': 'Не удалось загрузить рабочие процессы',
+  'orchestration.definitions': 'Доступные рабочие процессы',
+  'orchestration.noDefinitions': 'Нет доступных определений рабочих процессов.',
+  'orchestration.approvalRequired': 'Требуется подтверждение',
+  'orchestration.start': 'Запустить',
+  'orchestration.confirmStart': 'Запустить выполнение',
+  'orchestration.starting': 'Запуск…',
+  'orchestration.questionLabel': 'Исследовательский вопрос (необязательно)',
+  'orchestration.questionPlaceholder': 'Что должны исследовать агенты?',
+  'orchestration.runProgress': 'Ход выполнения',
+  'orchestration.recentRuns': 'Недавние выполнения',
+  'orchestration.noRuns': 'Пока нет выполнений рабочих процессов.',
+  'orchestration.close': 'Закрыть',
+  'orchestration.tier.readOnly': 'Только чтение',
+  'orchestration.tier.standard': 'Стандартный',
+  'orchestration.tier.editCapable': 'С правом изменения',
+  'orchestration.approval.title': 'Подтвердить это выполнение рабочего процесса',
+  'orchestration.approval.body':
+    'Это дорогостоящее или высокопараллельное выполнение, требующее вашего явного подтверждения перед запуском:',
+  'orchestration.approval.reason.tier':
+    'Его агенты могут выполнять действия за пределами исследования только для чтения.',
+  'orchestration.approval.reason.concurrency': 'Он одновременно запускает множество агентов.',
+  'orchestration.approval.reason.children':
+    'Он может в совокупности порождать очень большое число агентов.',
+  'orchestration.approval.tier': 'Уровень безопасности',
+  'orchestration.approval.concurrency': 'Параллелизм',
+  'orchestration.approval.maxChildren': 'Макс. агентов',
+  'orchestration.approval.approve': 'Подтвердить и запустить',
+  'orchestration.approval.starting': 'Запуск…',
+  'orchestration.approval.cancel': 'Отмена',
+  'orchestration.runStatus.pending': 'В ожидании',
+  'orchestration.runStatus.running': 'Выполняется',
+  'orchestration.runStatus.completed': 'Завершено',
+  'orchestration.runStatus.failed': 'Не удалось',
+  'orchestration.runStatus.cancelled': 'Отменено',
+  'orchestration.runStatus.interrupted': 'Прервано',
+  'orchestration.phaseStatus.pending': 'В ожидании',
+  'orchestration.phaseStatus.running': 'Выполняется',
+  'orchestration.phaseStatus.completed': 'Завершена',
+  'orchestration.phaseStatus.failed': 'Не удалась',
+  'orchestration.detail.stop': 'Остановить',
+  'orchestration.detail.resume': 'Возобновить',
+  'orchestration.detail.agents': 'агенты',
+  'orchestration.detail.childRefs': 'Дочерние агенты',
+  'orchestration.detail.synthesis': 'Итоговый синтез',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': 'Профили агента',
   'settings.profiles.subtitle':
diff --git a/app/src/lib/i18n/zh-CN.ts b/app/src/lib/i18n/zh-CN.ts
index 1c3cfc1e5..127cf59f3 100644
--- a/app/src/lib/i18n/zh-CN.ts
+++ b/app/src/lib/i18n/zh-CN.ts
@@ -5194,6 +5194,53 @@ const messages: TranslationMap = {
   'notch.speaking': '说话中…',
   'notch.transcribing': '转录中…',
   'notch.executing': '执行中…',
+  'memory.tab.orchestration': '编排',
+  'memory.tab.orchestrationDescription':
+    '运行多智能体工作流——将一个问题分发给多个并行智能体，交叉核对它们的发现，并观察每个阶段汇聚成一个综合答案。',
+  'orchestration.subtitle': '启动多智能体工作流，观察其各阶段进展，并阅读综合结果。',
+  'orchestration.loading': '正在加载工作流…',
+  'orchestration.failedToLoad': '加载工作流失败',
+  'orchestration.definitions': '可用工作流',
+  'orchestration.noDefinitions': '没有可用的工作流定义。',
+  'orchestration.approvalRequired': '需要批准',
+  'orchestration.start': '启动',
+  'orchestration.confirmStart': '启动运行',
+  'orchestration.starting': '正在启动…',
+  'orchestration.questionLabel': '研究问题（可选）',
+  'orchestration.questionPlaceholder': '智能体应研究什么？',
+  'orchestration.runProgress': '运行进度',
+  'orchestration.recentRuns': '近期运行',
+  'orchestration.noRuns': '尚无工作流运行。',
+  'orchestration.close': '关闭',
+  'orchestration.tier.readOnly': '只读',
+  'orchestration.tier.standard': '标准',
+  'orchestration.tier.editCapable': '可编辑',
+  'orchestration.approval.title': '批准此工作流运行',
+  'orchestration.approval.body': '这是一次高成本或高并发的运行，启动前需要您明确批准：',
+  'orchestration.approval.reason.tier': '其智能体可执行超出只读研究范围的操作。',
+  'orchestration.approval.reason.concurrency': '它会同时运行许多智能体。',
+  'orchestration.approval.reason.children': '它总共可能生成大量智能体。',
+  'orchestration.approval.tier': '安全级别',
+  'orchestration.approval.concurrency': '并发数',
+  'orchestration.approval.maxChildren': '最大智能体数',
+  'orchestration.approval.approve': '批准并启动',
+  'orchestration.approval.starting': '正在启动…',
+  'orchestration.approval.cancel': '取消',
+  'orchestration.runStatus.pending': '等待中',
+  'orchestration.runStatus.running': '运行中',
+  'orchestration.runStatus.completed': '已完成',
+  'orchestration.runStatus.failed': '已失败',
+  'orchestration.runStatus.cancelled': '已取消',
+  'orchestration.runStatus.interrupted': '已中断',
+  'orchestration.phaseStatus.pending': '等待中',
+  'orchestration.phaseStatus.running': '运行中',
+  'orchestration.phaseStatus.completed': '已完成',
+  'orchestration.phaseStatus.failed': '已失败',
+  'orchestration.detail.stop': '停止',
+  'orchestration.detail.resume': '继续',
+  'orchestration.detail.agents': '个智能体',
+  'orchestration.detail.childRefs': '子智能体',
+  'orchestration.detail.synthesis': '最终综合',
   // ── Agent Profiles ───────────────────────────────────────────────────────
   'settings.profiles.title': '智能体配置',
   'settings.profiles.subtitle': '风格化智能体——每个都有自己的灵魂、记忆、连接器和技能。',
diff --git a/app/src/pages/Intelligence.tsx b/app/src/pages/Intelligence.tsx
index a1d7fcb4e..ca8508d9e 100644
--- a/app/src/pages/Intelligence.tsx
+++ b/app/src/pages/Intelligence.tsx
@@ -5,6 +5,7 @@ import { useSearchParams } from 'react-router-dom';
 import { ConfirmationModal } from '../components/intelligence/ConfirmationModal';
 import IntelligenceAgentsTab from '../components/intelligence/IntelligenceAgentsTab';
 import IntelligenceAgentWorkTab from '../components/intelligence/IntelligenceAgentWorkTab';
+import IntelligenceOrchestrationTab from '../components/intelligence/IntelligenceOrchestrationTab';
 import IntelligenceSubconsciousTab from '../components/intelligence/IntelligenceSubconsciousTab';
 import IntelligenceTasksTab from '../components/intelligence/IntelligenceTasksTab';
 import IntelligenceTeamsTab from '../components/intelligence/IntelligenceTeamsTab';
@@ -37,6 +38,7 @@ type IntelligenceTab =
   | 'teams'
   | 'agents'
   | 'workflows'
+  | 'orchestration'
   | 'council';
 
 const INTELLIGENCE_TABS: IntelligenceTab[] = [
@@ -47,6 +49,7 @@ const INTELLIGENCE_TABS: IntelligenceTab[] = [
   'teams',
   'agents',
   'workflows',
+  'orchestration',
   'council',
 ];
 
@@ -178,6 +181,11 @@ export default function Intelligence({ tabParamKey = 'tab' }: IntelligenceProps
       label: t('memory.tab.workflows'),
       description: t('memory.tab.workflowsDescription'),
     },
+    {
+      id: 'orchestration',
+      label: t('memory.tab.orchestration'),
+      description: t('memory.tab.orchestrationDescription'),
+    },
     { id: 'council', label: t('memory.tab.council'), devOnly: true },
     { id: 'agents', label: t('memory.tab.agents'), description: t('memory.tab.agentsDescription') },
   ];
@@ -273,6 +281,8 @@ export default function Intelligence({ tabParamKey = 'tab' }: IntelligenceProps
 
             {activeTab === 'workflows' && <WorkflowsTab />}
 
+            {activeTab === 'orchestration' && <IntelligenceOrchestrationTab />}
+
             {activeTab === 'council' && <ModelCouncilTab />}
           </div>
         </div>
diff --git a/app/src/services/api/workflowRunsApi.test.ts b/app/src/services/api/workflowRunsApi.test.ts
new file mode 100644
index 000000000..28e3900b9
--- /dev/null
+++ b/app/src/services/api/workflowRunsApi.test.ts
@@ -0,0 +1,166 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { callCoreRpc } from '../coreRpcClient';
+import {
+  assessWorkflowCost,
+  type WorkflowDefinition,
+  type WorkflowRun,
+  workflowRunsApi,
+} from './workflowRunsApi';
+
+vi.mock('../coreRpcClient', () => ({ callCoreRpc: vi.fn() }));
+
+const mockRpc = vi.mocked(callCoreRpc);
+
+function def(overrides: Partial<WorkflowDefinition> = {}): WorkflowDefinition {
+  return {
+    id: 'parallel_research_cross_check',
+    name: 'Parallel research with cross-checking',
+    description: 'Decompose, research in parallel, cross-check, synthesize.',
+    phases: [
+      { name: 'decompose', description: '', agentIds: ['planner'], dependsOn: [] },
+      {
+        name: 'research',
+        description: '',
+        agentIds: ['researcher', 'researcher'],
+        dependsOn: ['decompose'],
+      },
+    ],
+    defaultConcurrency: 2,
+    maxChildren: 8,
+    safetyTier: 'read_only',
+    ...overrides,
+  };
+}
+
+function run(overrides: Partial<WorkflowRun> = {}): WorkflowRun {
+  return {
+    id: 'wfrun-1',
+    definitionId: 'parallel_research_cross_check',
+    parentThreadId: null,
+    input: { question: 'why is the sky blue?' },
+    phaseStates: {},
+    childRunIds: [],
+    status: 'running',
+    summary: null,
+    startedAt: '2026-01-01T00:00:00Z',
+    updatedAt: '2026-01-01T00:00:00Z',
+    completedAt: null,
+    ...overrides,
+  };
+}
+
+describe('assessWorkflowCost', () => {
+  it('requires approval for the builtin (maxChildren >= 8)', () => {
+    const result = assessWorkflowCost(def({ maxChildren: 8, defaultConcurrency: 2 }));
+    expect(result.requiresApproval).toBe(true);
+    expect(result.reasons).toContain('high_children');
+  });
+
+  it('does not require approval for a small read-only fan-out', () => {
+    const result = assessWorkflowCost(
+      def({ maxChildren: 4, defaultConcurrency: 2, safetyTier: 'read_only' })
+    );
+    expect(result.requiresApproval).toBe(false);
+    expect(result.reasons).toHaveLength(0);
+  });
+
+  it('flags non-read-only tiers', () => {
+    const result = assessWorkflowCost(
+      def({ maxChildren: 2, defaultConcurrency: 1, safetyTier: 'edit_capable' })
+    );
+    expect(result.requiresApproval).toBe(true);
+    expect(result.reasons).toContain('non_read_only_tier');
+  });
+
+  it('flags high concurrency', () => {
+    const result = assessWorkflowCost(
+      def({ maxChildren: 2, defaultConcurrency: 4, safetyTier: 'read_only' })
+    );
+    expect(result.requiresApproval).toBe(true);
+    expect(result.reasons).toContain('high_concurrency');
+  });
+});
+
+describe('workflowRunsApi', () => {
+  beforeEach(() => mockRpc.mockReset());
+
+  it('listDefinitions calls the RPC and returns the array', async () => {
+    mockRpc.mockResolvedValueOnce({ definitions: [def()], count: 1 });
+    const defs = await workflowRunsApi.listDefinitions();
+    expect(mockRpc).toHaveBeenCalledWith({ method: 'openhuman.workflow_run_list_definitions' });
+    expect(defs).toHaveLength(1);
+    expect(defs[0].id).toBe('parallel_research_cross_check');
+  });
+
+  it('listDefinitions tolerates a missing array', async () => {
+    mockRpc.mockResolvedValueOnce({});
+    expect(await workflowRunsApi.listDefinitions()).toEqual([]);
+  });
+
+  it('listRuns forwards filters and returns the runs array', async () => {
+    mockRpc.mockResolvedValueOnce({ runs: [run()], count: 1 });
+    const runs = await workflowRunsApi.listRuns({ limit: 50, status: 'running' });
+    expect(mockRpc).toHaveBeenCalledWith({
+      method: 'openhuman.workflow_run_list',
+      params: { limit: 50, status: 'running' },
+    });
+    expect(runs).toHaveLength(1);
+    expect(runs[0].id).toBe('wfrun-1');
+  });
+
+  it('listRuns defaults params and tolerates a missing array', async () => {
+    mockRpc.mockResolvedValueOnce({});
+    const runs = await workflowRunsApi.listRuns();
+    expect(mockRpc).toHaveBeenCalledWith({ method: 'openhuman.workflow_run_list', params: {} });
+    expect(runs).toEqual([]);
+  });
+
+  it('getRun returns the run when present', async () => {
+    mockRpc.mockResolvedValueOnce({ workflowRun: run() });
+    const fetched = await workflowRunsApi.getRun('wfrun-1');
+    expect(mockRpc).toHaveBeenCalledWith({
+      method: 'openhuman.workflow_run_get',
+      params: { id: 'wfrun-1' },
+    });
+    expect(fetched?.id).toBe('wfrun-1');
+  });
+
+  it('startRun forwards definitionId + input and returns the run', async () => {
+    mockRpc.mockResolvedValueOnce({ workflowRun: run() });
+    const started = await workflowRunsApi.startRun({
+      definitionId: 'parallel_research_cross_check',
+      input: { question: 'q' },
+    });
+    expect(mockRpc).toHaveBeenCalledWith({
+      method: 'openhuman.workflow_run_start',
+      params: { definitionId: 'parallel_research_cross_check', input: { question: 'q' } },
+    });
+    expect(started.id).toBe('wfrun-1');
+  });
+
+  it('getRun returns null when the run is absent', async () => {
+    mockRpc.mockResolvedValueOnce({ workflowRun: null });
+    expect(await workflowRunsApi.getRun('nope')).toBeNull();
+  });
+
+  it('stopRun returns the updated run', async () => {
+    mockRpc.mockResolvedValueOnce({ workflowRun: run({ status: 'interrupted' }) });
+    const stopped = await workflowRunsApi.stopRun('wfrun-1');
+    expect(mockRpc).toHaveBeenCalledWith({
+      method: 'openhuman.workflow_run_stop',
+      params: { id: 'wfrun-1' },
+    });
+    expect(stopped?.status).toBe('interrupted');
+  });
+
+  it('resumeRun returns the resumed run', async () => {
+    mockRpc.mockResolvedValueOnce({ workflowRun: run({ status: 'running' }) });
+    const resumed = await workflowRunsApi.resumeRun('wfrun-1');
+    expect(mockRpc).toHaveBeenCalledWith({
+      method: 'openhuman.workflow_run_resume',
+      params: { id: 'wfrun-1' },
+    });
+    expect(resumed.status).toBe('running');
+  });
+});
diff --git a/app/src/services/api/workflowRunsApi.ts b/app/src/services/api/workflowRunsApi.ts
new file mode 100644
index 000000000..ecf50a22c
--- /dev/null
+++ b/app/src/services/api/workflowRunsApi.ts
@@ -0,0 +1,260 @@
+/**
+ * Frontend client for the declarative workflow-runs engine (#3375).
+ *
+ * Wraps the six `openhuman.workflow_run_*` JSON-RPC controllers exposed by the
+ * Rust `workflow_runs` domain:
+ *   - `workflow_run_list_definitions` — catalog of runnable workflow definitions
+ *   - `workflow_run_list`             — durable runs (with filters / paging)
+ *   - `workflow_run_get`              — single run (poll target for progress)
+ *   - `workflow_run_start`            — start a run from a definition id
+ *   - `workflow_run_stop`             — interrupt a running workflow
+ *   - `workflow_run_resume`           — resume an interrupted workflow
+ *
+ * The Rust controllers serialize structs with `rename_all = "camelCase"` and
+ * the status / safety-tier enums with `rename_all = "snake_case"`, so the wire
+ * payload already matches these TypeScript shapes — no snake/camel transform is
+ * needed. Progress is poll-based in this engine (no socket events yet): start a
+ * run, then poll `getRun(id)` until `status` is terminal.
+ */
+import debug from 'debug';
+
+import { callCoreRpc } from '../coreRpcClient';
+
+const log = debug('workflowRunsApi');
+
+// ---------------------------------------------------------------------------
+// Wire types — mirror `src/openhuman/workflow_runs/types.rs`.
+// ---------------------------------------------------------------------------
+
+/** What a workflow's child agents are permitted to do. (`snake_case` on wire.) */
+export type WorkflowSafetyTier = 'read_only' | 'standard' | 'edit_capable';
+
+/** Lifecycle status of a durable run. (`snake_case` on wire.) */
+export type WorkflowRunStatus =
+  | 'pending'
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+  | 'interrupted';
+
+/** Per-phase progress status inside `WorkflowRun.phaseStates`. */
+export type WorkflowPhaseStatus = 'pending' | 'running' | 'completed' | 'failed';
+
+/** One ordered phase of a workflow definition. */
+export interface WorkflowPhase {
+  /** Unique within the definition (e.g. "decompose", "research"). */
+  name: string;
+  /** Human-readable purpose. */
+  description: string;
+  /** Agent definition ids fanned out (in parallel) for this phase. */
+  agentIds: string[];
+  /** Phase names that must complete before this one runs. */
+  dependsOn: string[];
+}
+
+/** A runnable workflow definition (builtin or, later, user-authored). */
+export interface WorkflowDefinition {
+  id: string;
+  name: string;
+  description: string;
+  phases: WorkflowPhase[];
+  /** Max agents run concurrently within a single phase. */
+  defaultConcurrency: number;
+  /** Hard cap on child agents spawned across the whole run. */
+  maxChildren: number;
+  safetyTier: WorkflowSafetyTier;
+}
+
+/** One child agent's result within a phase. */
+export interface WorkflowPhaseOutput {
+  /** Orchestration id of the spawned child agent. */
+  orchestrationId: string;
+  /** Agent definition id (e.g. "researcher"). */
+  agentId: string;
+  /** The child's result summary. */
+  output: string;
+}
+
+/** Progress record for a single phase, keyed by phase name in `phaseStates`. */
+export interface WorkflowPhaseState {
+  status: WorkflowPhaseStatus;
+  outputs: WorkflowPhaseOutput[];
+  /** Present only when `status === 'failed'`. */
+  reason?: string;
+}
+
+/** A durable workflow run. Mirrors the Rust `WorkflowRun`. */
+export interface WorkflowRun {
+  id: string;
+  definitionId: string;
+  parentThreadId: string | null;
+  /** Run input object (e.g. `{ question: "..." }`). */
+  input: unknown;
+  /** Per-phase progress, keyed by phase name. */
+  phaseStates: Record<string, WorkflowPhaseState>;
+  /** Orchestration ids of every spawned child agent. */
+  childRunIds: string[];
+  status: WorkflowRunStatus;
+  /** Final synthesized output — present once `status === 'completed'`. */
+  summary: string | null;
+  startedAt: string;
+  updatedAt: string;
+  completedAt: string | null;
+}
+
+interface ListDefinitionsResult {
+  definitions: WorkflowDefinition[];
+  count: number;
+}
+
+interface ListRunsResult {
+  runs: WorkflowRun[];
+  count: number;
+}
+
+interface RunResult {
+  workflowRun: WorkflowRun;
+}
+
+interface MaybeRunResult {
+  workflowRun: WorkflowRun | null;
+}
+
+/** Filters accepted by `workflow_run_list`. */
+export interface ListRunsParams {
+  definitionId?: string;
+  status?: WorkflowRunStatus;
+  parentThreadId?: string;
+  limit?: number;
+  offset?: number;
+}
+
+/** Parameters accepted by `workflow_run_start`. */
+export interface StartRunParams {
+  definitionId: string;
+  /** Run input, e.g. `{ question: "..." }` or `{ modelOverride: "..." }`. */
+  input?: Record<string, unknown>;
+  /** Originating thread id, for lineage. */
+  parentThreadId?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Cost / concurrency safety gate (#3375 AC: high-cost runs require approval).
+// ---------------------------------------------------------------------------
+
+/**
+ * Why a run is considered high-cost / high-concurrency and therefore gated
+ * behind explicit approval. Stable codes — the UI maps each to a localized
+ * sentence so the user understands what they're approving.
+ */
+export type WorkflowCostReason = 'non_read_only_tier' | 'high_concurrency' | 'high_children';
+
+export interface WorkflowCostAssessment {
+  /** True when the definition must be explicitly approved before starting. */
+  requiresApproval: boolean;
+  /** Machine-readable reasons (empty when no approval required). */
+  reasons: WorkflowCostReason[];
+}
+
+/**
+ * Per-phase concurrency at or above this is treated as high-concurrency.
+ * The builtin parallel-research workflow runs at 2, so routine read-only
+ * fan-outs stay frictionless; only unusually wide phases trip the gate.
+ */
+export const HIGH_CONCURRENCY_THRESHOLD = 4;
+
+/**
+ * Total child-agent budget at or above this is treated as high-cost — every
+ * child is a full agent turn (tokens + wall-clock), so a large cap is the
+ * clearest proxy for spend in the absence of an explicit cost field.
+ */
+export const HIGH_CHILDREN_THRESHOLD = 8;
+
+/**
+ * Decide whether starting `def` needs explicit user approval.
+ *
+ * The Rust safety tiers exist on the definition but the engine does not yet
+ * gate on them, so the approval decision lives here on the client: any
+ * non-`read_only` tier (child agents may take actions / edit files), or a
+ * wide/expensive fan-out, requires the user to confirm before we call
+ * `startRun`. Read-only, low-fan-out definitions start immediately.
+ */
+export function assessWorkflowCost(def: WorkflowDefinition): WorkflowCostAssessment {
+  const reasons: WorkflowCostReason[] = [];
+  if (def.safetyTier !== 'read_only') reasons.push('non_read_only_tier');
+  if (def.defaultConcurrency >= HIGH_CONCURRENCY_THRESHOLD) reasons.push('high_concurrency');
+  if (def.maxChildren >= HIGH_CHILDREN_THRESHOLD) reasons.push('high_children');
+  return { requiresApproval: reasons.length > 0, reasons };
+}
+
+// ---------------------------------------------------------------------------
+// RPC client.
+// ---------------------------------------------------------------------------
+
+export const workflowRunsApi = {
+  /** List available declarative workflow definitions (builtins, currently). */
+  listDefinitions: async (): Promise<WorkflowDefinition[]> => {
+    log('listDefinitions: request');
+    const result = await callCoreRpc<ListDefinitionsResult>({
+      method: 'openhuman.workflow_run_list_definitions',
+    });
+    const definitions = result?.definitions ?? [];
+    log('listDefinitions: count=%d', definitions.length);
+    return definitions;
+  },
+
+  /** List durable workflow runs, newest first, with optional filters. */
+  listRuns: async (params: ListRunsParams = {}): Promise<WorkflowRun[]> => {
+    log('listRuns: request %o', params);
+    const result = await callCoreRpc<ListRunsResult>({
+      method: 'openhuman.workflow_run_list',
+      params,
+    });
+    const runs = result?.runs ?? [];
+    log('listRuns: count=%d', runs.length);
+    return runs;
+  },
+
+  /** Fetch a single run by id. Returns null when no such run exists. */
+  getRun: async (id: string): Promise<WorkflowRun | null> => {
+    log('getRun: request id=%s', id);
+    const result = await callCoreRpc<MaybeRunResult>({
+      method: 'openhuman.workflow_run_get',
+      params: { id },
+    });
+    const run = result?.workflowRun ?? null;
+    log('getRun: status=%s', run?.status ?? 'null');
+    return run;
+  },
+
+  /** Start a run from a definition id; returns the created Running run. */
+  startRun: async (params: StartRunParams): Promise<WorkflowRun> => {
+    log('startRun: request definitionId=%s', params.definitionId);
+    const result = await callCoreRpc<RunResult>({ method: 'openhuman.workflow_run_start', params });
+    log('startRun: id=%s status=%s', result.workflowRun.id, result.workflowRun.status);
+    return result.workflowRun;
+  },
+
+  /** Stop a running workflow after its current phase. Null if id unknown. */
+  stopRun: async (id: string): Promise<WorkflowRun | null> => {
+    log('stopRun: request id=%s', id);
+    const result = await callCoreRpc<MaybeRunResult>({
+      method: 'openhuman.workflow_run_stop',
+      params: { id },
+    });
+    log('stopRun: status=%s', result?.workflowRun?.status ?? 'null');
+    return result?.workflowRun ?? null;
+  },
+
+  /** Resume an interrupted workflow from the first incomplete phase. */
+  resumeRun: async (id: string): Promise<WorkflowRun> => {
+    log('resumeRun: request id=%s', id);
+    const result = await callCoreRpc<RunResult>({
+      method: 'openhuman.workflow_run_resume',
+      params: { id },
+    });
+    log('resumeRun: status=%s', result.workflowRun.status);
+    return result.workflowRun;
+  },
+};
diff --git a/src/openhuman/about_app/catalog_data.rs b/src/openhuman/about_app/catalog_data.rs
index 52b06f2a1..866163098 100644
--- a/src/openhuman/about_app/catalog_data.rs
+++ b/src/openhuman/about_app/catalog_data.rs
@@ -503,6 +503,16 @@ pub(super) const CAPABILITIES: &[Capability] = &[
         status: CapabilityStatus::Beta,
         privacy: DERIVED_TO_BACKEND,
     },
+    Capability {
+        id: "intelligence.workflow_orchestration",
+        name: "Workflow Orchestration",
+        domain: "workflow_runs",
+        category: CapabilityCategory::Intelligence,
+        description: "Run declarative multi-agent workflows such as parallel research with cross-checking: a question is decomposed into angles, researched in parallel, adversarially cross-checked, and synthesized into one cited report. Watch each phase progress with its child agent results, stop or resume a run, and read the final synthesis. High-cost / high-concurrency runs require explicit approval before starting.",
+        how_to: "Intelligence > Orchestration > pick a workflow and Start",
+        status: CapabilityStatus::Beta,
+        privacy: DERIVED_TO_BACKEND,
+    },
     Capability {
         id: "intelligence.agent_library",
         name: "Agents Library",