diff --git a/.gitignore b/.gitignore
index 26dd272055..0289daf5b5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,3 +37,5 @@ supabase/volumes/*
 !supabase/volumes/db/
 supabase/volumes/db/data
 !supabase/volumes/api/
+
+coverage/
diff --git a/src/analysis/individualStudy/summary/utils.test.ts b/src/analysis/individualStudy/summary/utils.test.ts
index 57a21812a7..32fb79a54a 100644
--- a/src/analysis/individualStudy/summary/utils.test.ts
+++ b/src/analysis/individualStudy/summary/utils.test.ts
@@ -99,12 +99,6 @@ function createMockAnswer(overrides: {
     incorrectAnswers: {},
     startTime: overrides.startTime,
     endTime: overrides.endTime,
-    provenanceGraph: {
-      sidebar: undefined,
-      aboveStimulus: undefined,
-      belowStimulus: undefined,
-      stimulus: undefined,
-    },
     windowEvents: [],
     timedOut: false,
     helpButtonClickedCount: 0,
diff --git a/src/analysis/individualStudy/thinkAloud/ThinkAloudFooter.tsx b/src/analysis/individualStudy/thinkAloud/ThinkAloudFooter.tsx
index 7dc7b78c1e..52d431e27b 100644
--- a/src/analysis/individualStudy/thinkAloud/ThinkAloudFooter.tsx
+++ b/src/analysis/individualStudy/thinkAloud/ThinkAloudFooter.tsx
@@ -36,6 +36,7 @@ import {
   buildProvenanceLegendEntries,
 } from '../../../components/audioAnalysis/provenanceColors';
 import { revisitPageId, syncChannel } from '../../../utils/syncReplay';
+import { getLegacyStoredAnswerProvenance } from '../../../store/provenance';
 import { buildTaskNavigationTarget } from './taskNavigation';
 
 const margin = {
@@ -50,6 +51,29 @@ function getParticipantData(trrackId: string | undefined, storageEngine: Storage
   return null;
 }
 
+function getLegacyProvenance(answer: unknown) {
+  return getLegacyStoredAnswerProvenance(answer);
+}
+
+async function getTaskProvenance(
+  storageEngine: StorageEngine | undefined,
+  participantId: string,
+  currentTrial: string,
+  answer: unknown,
+) {
+  const legacyProvenance = getLegacyProvenance(answer);
+
+  if (!storageEngine || !participantId || !currentTrial) {
+    return legacyProvenance;
+  }
+
+  try {
+    return await storageEngine.getProvenance(currentTrial, participantId) ?? legacyProvenance;
+  } catch {
+    return legacyProvenance;
+  }
+}
+
 async function getParticipantTags(authEmail: string, trrackId: string | undefined, studyId: string, storageEngine: StorageEngine | undefined) {
   if (storageEngine && trrackId) {
     return (await storageEngine.getAllParticipantAndTaskTags(authEmail, trrackId));
@@ -84,6 +108,7 @@ export function ThinkAloudFooter({
   const participantId = useMemo(() => searchParams.get('participantId') || '', [searchParams]);
 
   const { value: participant } = useAsync(getParticipantData, [participantId, storageEngine]);
+  const { value: provenanceGraph } = useAsync(getTaskProvenance, [storageEngine, participantId, currentTrial, participant?.answers[currentTrial]]);
 
   const { value: taskTags, execute: pullTags } = useAsync(getTags, [storageEngine, 'task']);
 
@@ -345,13 +370,12 @@ export function ThinkAloudFooter({
   const [timeString, setTimeString] = useState<string>('');
 
   const provenanceLegendEntries = useMemo(() => {
-    const answer = participant?.answers[currentTrial];
-    if (!answer?.provenanceGraph) {
+    if (!provenanceGraph) {
       return new Map<string, { label: string; color: string }>();
     }
 
-    return buildProvenanceLegendEntries(Object.values(answer.provenanceGraph));
-  }, [participant, currentTrial]);
+    return buildProvenanceLegendEntries(Object.values(provenanceGraph));
+  }, [provenanceGraph]);
 
   const tasksList = useMemo(() => orderedAnswers
     .filter((answer) => answer.identifier && answer.componentName)
diff --git a/src/components/audioAnalysis/AudioProvenanceVis.tsx b/src/components/audioAnalysis/AudioProvenanceVis.tsx
index 23586ee22b..456dbc281a 100644
--- a/src/components/audioAnalysis/AudioProvenanceVis.tsx
+++ b/src/components/audioAnalysis/AudioProvenanceVis.tsx
@@ -26,6 +26,8 @@ import { parseTrialOrder } from '../../utils/parseTrialOrder';
 import { useUpdateProvenance } from './useUpdateProvenance';
 import { useReplayContext } from '../../store/hooks/useReplay';
 import { syncChannel, syncEmitter } from '../../utils/syncReplay';
+import type { StoredProvenance } from '../../store/types';
+import { getLegacyStoredAnswerProvenance } from '../../store/provenance';
 
 const margin = {
   left: 20, top: 0, right: 20, bottom: 0,
@@ -62,6 +64,12 @@ export function AudioProvenanceVis({
   } = useReplayContext();
 
   const { storageEngine } = useStorageEngine();
+  const legacyProvenanceGraph = useMemo(
+    () => getLegacyStoredAnswerProvenance(answers[taskName]),
+    [answers, taskName],
+  );
+  const [storedProvenanceGraph, setStoredProvenanceGraph] = useState<StoredProvenance | null>(legacyProvenanceGraph);
+  const provenanceGraph = storedProvenanceGraph ?? legacyProvenanceGraph;
 
   const [analysisHasAudio, _setAnalysisHasAudio] = useState(true);
 
@@ -97,8 +105,36 @@ export function AudioProvenanceVis({
 
   const trrackForTrial = useRef<Trrack<object, string> | null>(null);
 
+  useEffect(() => {
+    let canceled = false;
+
+    async function fetchProvenance() {
+      if (!taskName || !participantId || !storageEngine) {
+        setStoredProvenanceGraph(legacyProvenanceGraph);
+        return;
+      }
+
+      try {
+        const storedProvenance = await storageEngine.getProvenance(taskName, participantId);
+        if (!canceled) {
+          setStoredProvenanceGraph(storedProvenance ?? legacyProvenanceGraph);
+        }
+      } catch {
+        if (!canceled) {
+          setStoredProvenanceGraph(legacyProvenanceGraph);
+        }
+      }
+    }
+
+    fetchProvenance();
+
+    return () => {
+      canceled = true;
+    };
+  }, [legacyProvenanceGraph, participantId, storageEngine, taskName]);
+
   const _setCurrentResponseNodes = useEvent((node: string | null, location: ResponseBlockLocation) => {
-    const graph = answers[taskName]?.provenanceGraph[location];
+    const graph = provenanceGraph?.[location];
     if (graph && node) {
       if (!currentGlobalNode || graph.nodes[node].createdOn > currentGlobalNode.time || playTime < currentGlobalNode.time) {
         setCurrentGlobalNode({ name: node || '', time: graph.nodes[node].createdOn });
@@ -176,26 +212,28 @@ export function AudioProvenanceVis({
     };
   }, [answers, context, navigate, participantId, routerLocation.search, setSearchParams, studyId]);
 
-  useUpdateProvenance('aboveStimulus', playTime, answers[taskName]?.provenanceGraph.aboveStimulus, currentResponseNodes.aboveStimulus, _setCurrentResponseNodes, saveProvenance);
+  useUpdateProvenance('aboveStimulus', playTime, provenanceGraph?.aboveStimulus, currentResponseNodes.aboveStimulus, _setCurrentResponseNodes, saveProvenance);
 
-  useUpdateProvenance('belowStimulus', playTime, answers[taskName]?.provenanceGraph.belowStimulus, currentResponseNodes.belowStimulus, _setCurrentResponseNodes, saveProvenance);
+  useUpdateProvenance('belowStimulus', playTime, provenanceGraph?.belowStimulus, currentResponseNodes.belowStimulus, _setCurrentResponseNodes, saveProvenance);
 
-  useUpdateProvenance('sidebar', playTime, answers[taskName]?.provenanceGraph.sidebar, currentResponseNodes.sidebar, _setCurrentResponseNodes, saveProvenance);
+  useUpdateProvenance('sidebar', playTime, provenanceGraph?.sidebar, currentResponseNodes.sidebar, _setCurrentResponseNodes, saveProvenance);
 
   // Create an instance of trrack to ensure getState works, incase the saved state is not a full state node.
   useEffect(() => {
-    if (taskName && answers[taskName]?.provenanceGraph) {
+    trrackForTrial.current = null;
+
+    if (taskName && provenanceGraph) {
       const reg = Registry.create();
 
       const trrack = initializeTrrack({ registry: reg, initialState: {} });
 
-      if (answers[taskName]?.provenanceGraph.stimulus) {
-        trrack.importObject(structuredClone(answers[taskName]?.provenanceGraph!.stimulus));
+      if (provenanceGraph.stimulus) {
+        trrack.importObject(structuredClone(provenanceGraph.stimulus));
 
         trrackForTrial.current = trrack;
       }
     }
-  }, [answers, taskName]);
+  }, [provenanceGraph, taskName]);
 
   const _setCurrentNode = useCallback((node: string | undefined) => {
     if (!node) {
@@ -203,21 +241,21 @@ export function AudioProvenanceVis({
     }
 
     if (taskName && trrackForTrial.current && context === 'provenanceVis' && saveProvenance) {
-      saveProvenance({ prov: trrackForTrial.current.getState(answers[taskName]?.provenanceGraph.stimulus?.nodes[node]), location: 'stimulus' });
+      saveProvenance({ prov: trrackForTrial.current.getState(provenanceGraph?.stimulus?.nodes[node]), location: 'stimulus' });
 
       trrackForTrial.current.to(node);
     }
 
     _setCurrentResponseNodes(node, 'stimulus');
     setCurrentNode(node);
-  }, [taskName, context, _setCurrentResponseNodes, saveProvenance, answers]);
+  }, [taskName, context, _setCurrentResponseNodes, saveProvenance, provenanceGraph]);
 
   // use effect to control the current provenance node based on the changing playtime.
   useEffect(() => {
-    if (!taskName || !trrackForTrial.current || !answers[taskName]?.provenanceGraph) {
+    if (!taskName || !trrackForTrial.current || !provenanceGraph) {
       return;
     }
-    const provGraph = answers[taskName]?.provenanceGraph;
+    const provGraph = provenanceGraph;
 
     if (!provGraph.stimulus) {
       return;
@@ -249,7 +287,7 @@ export function AudioProvenanceVis({
     if (tempNode.id !== currentNode) {
       _setCurrentNode(tempNode.id);
     }
-  }, [_setCurrentNode, currentNode, participantId, playTime, taskName, answers]);
+  }, [_setCurrentNode, currentNode, participantId, playTime, taskName, provenanceGraph]);
 
   useEffect(() => {
     if (duration === 0) {
@@ -353,13 +391,13 @@ export function AudioProvenanceVis({
             </Box>
           ) : null}
 
-        {xScale && taskName && answers[taskName]?.provenanceGraph
+        {xScale && taskName && provenanceGraph
           ? (
             <TaskProvenanceTimeline
               xScale={xScale}
               trialName={taskName}
               currentNode={currentGlobalNode?.name || ''}
-              answers={answers}
+              provenanceGraph={provenanceGraph}
               width={waveSurferWidth || (width - margin.left - margin.right)}
               height={25}
               margin={margin}
diff --git a/src/components/audioAnalysis/TaskProvenanceTimeline.tsx b/src/components/audioAnalysis/TaskProvenanceTimeline.tsx
index 4727cbf9d9..68f356ceac 100644
--- a/src/components/audioAnalysis/TaskProvenanceTimeline.tsx
+++ b/src/components/audioAnalysis/TaskProvenanceTimeline.tsx
@@ -1,11 +1,12 @@
 import { useMemo } from 'react';
 import * as d3 from 'd3';
-import { ParticipantData } from '../../storage/types';
 import { TaskProvenanceNodes } from './TaskProvenanceNodes';
+import type { StoredProvenance } from '../../store/types';
+import { PROVENANCE_LOCATIONS } from '../../store/provenance';
 
 export function TaskProvenanceTimeline({
   xScale,
-  answers,
+  provenanceGraph,
   width,
   height,
   currentNode,
@@ -14,7 +15,7 @@ export function TaskProvenanceTimeline({
   margin,
 }: {
   xScale: d3.ScaleLinear<number, number>;
-  answers: ParticipantData['answers'];
+  provenanceGraph: StoredProvenance;
   width: number;
   height: number;
   currentNode: string | null;
@@ -34,34 +35,22 @@ export function TaskProvenanceTimeline({
   );
 
   const provenanceNodes = useMemo(
-    () => Object.entries(answers)
-      .filter((entry) => (trialName ? trialName === entry[0] : true))
-      .map((entry) => {
-        const [name, answer] = entry;
-
-        const provenanceGraphComponents = Object.keys(answer.provenanceGraph).map(
-          (provenanceArea) => {
-            const graph = answer.provenanceGraph[
-                  provenanceArea as keyof typeof answer.provenanceGraph
-            ];
-            if (graph) {
-              return (
-                <TaskProvenanceNodes
-                  key={name + provenanceArea}
-                  height={height}
-                  currentNode={currentNode}
-                  xScale={newXScale}
-                  provenance={graph}
-                />
-              );
-            }
-            return null;
-          },
+    () => PROVENANCE_LOCATIONS.map((provenanceArea) => {
+      const graph = provenanceGraph[provenanceArea];
+      if (graph) {
+        return (
+          <TaskProvenanceNodes
+            key={`${trialName}-${provenanceArea}`}
+            height={height}
+            currentNode={currentNode}
+            xScale={newXScale}
+            provenance={graph}
+          />
         );
-
-        return provenanceGraphComponents;
-      }),
-    [currentNode, height, answers, trialName, newXScale],
+      }
+      return null;
+    }),
+    [currentNode, height, provenanceGraph, trialName, newXScale],
   );
 
   return (
diff --git a/src/components/downloader/DownloadButtons.tsx b/src/components/downloader/DownloadButtons.tsx
index 1de8c858b9..4899893715 100644
--- a/src/components/downloader/DownloadButtons.tsx
+++ b/src/components/downloader/DownloadButtons.tsx
@@ -2,14 +2,14 @@ import {
   Button, Group, Tooltip,
 } from '@mantine/core';
 import {
-  IconDatabaseExport, IconDeviceDesktopDown, IconMusicDown, IconTableExport,
+  IconDatabaseExport, IconDeviceDesktopDown, IconDownload, IconMusicDown, IconTableExport,
 } from '@tabler/icons-react';
 import { useState } from 'react';
 import { useDisclosure } from '@mantine/hooks';
 import { DownloadTidy, download } from './DownloadTidy';
 import { ParticipantDataWithStatus } from '../../storage/types';
 import { useStorageEngine } from '../../storage/storageEngineHooks';
-import { downloadParticipantsAudioZip, downloadParticipantsScreenRecordingZip } from '../../utils/handleDownloadFiles';
+import { downloadParticipantsAudioZip, downloadParticipantsProvenanceZip, downloadParticipantsScreenRecordingZip } from '../../utils/handleDownloadFiles';
 
 type ParticipantDataFetcher = ParticipantDataWithStatus[] | (() => Promise<ParticipantDataWithStatus[]>);
 
@@ -18,6 +18,7 @@ export function DownloadButtons({
 }: { visibleParticipants: ParticipantDataFetcher; studyId: string, gap?: string, fileName?: string | null; hasAudio?: boolean; hasScreenRecording?: boolean; }) {
   const [openDownload, { open, close }] = useDisclosure(false);
   const [participants, setParticipants] = useState<ParticipantDataWithStatus[]>([]);
+  const [loadingProvenance, setLoadingProvenance] = useState(false);
   const [loadingAudio, setLoadingAudio] = useState(false);
   const [loadingScreenRecording, setLoadingScreenRecording] = useState(false);
   const { storageEngine } = useStorageEngine();
@@ -56,6 +57,23 @@ export function DownloadButtons({
     }
   };
 
+  const handleDownloadProvenance = async () => {
+    setLoadingProvenance(true);
+
+    try {
+      const currParticipants = await fetchParticipants();
+      if (!storageEngine) return;
+      await downloadParticipantsProvenanceZip({
+        storageEngine,
+        participants: currParticipants,
+        studyId,
+        fileName,
+      });
+    } finally {
+      setLoadingProvenance(false);
+    }
+  };
+
   const handleDownloadScreenRecording = async () => {
     setLoadingScreenRecording(true);
 
@@ -98,6 +116,17 @@ export function DownloadButtons({
             <IconTableExport />
           </Button>
         </Tooltip>
+        <Tooltip label={`${tooltipText} provenance as ZIP`}>
+          <Button
+            variant="light"
+            disabled={visibleParticipants.length === 0 && typeof visibleParticipants !== 'function'}
+            onClick={handleDownloadProvenance}
+            px={4}
+            loading={loadingProvenance}
+          >
+            <IconDownload />
+          </Button>
+        </Tooltip>
         {hasAudio && (
           <Tooltip label={`${tooltipText} audio & transcripts as ZIP`}>
             <Button
diff --git a/src/storage/engines/types.ts b/src/storage/engines/types.ts
index eac08454d2..0e7acb10de 100644
--- a/src/storage/engines/types.ts
+++ b/src/storage/engines/types.ts
@@ -2,7 +2,7 @@ import localforage from 'localforage';
 import throttle from 'lodash.throttle';
 import { v4 as uuidv4 } from 'uuid';
 import { StudyConfig } from '../../parser/types';
-import { ParticipantMetadata, Sequence } from '../../store/types';
+import { ParticipantMetadata, Sequence, StoredProvenance } from '../../store/types';
 import { ParticipantData, ParticipantDataWithStatus } from '../types';
 import { hash, isParticipantData } from './utils/storageEngineHelpers';
 import { shouldPreferCachedParticipantData } from './utils/participantDataRecovery';
@@ -11,6 +11,10 @@ import { parseConditionParam } from '../../utils/handleConditionLogic';
 import {
   ParticipantTags, Tag, TaglessEditedText, TranscribedAudio,
 } from '../../analysis/individualStudy/thinkAloud/types';
+import {
+  normalizeStoredProvenance,
+  splitProvenanceFromAnswers,
+} from '../../store/provenance';
 
 export interface StoredUser {
   email: string | null,
@@ -1263,14 +1267,23 @@ export abstract class StorageEngine {
       return;
     }
 
+    const {
+      answers: answersWithoutProvenance,
+      provenanceByIdentifier,
+    } = splitProvenanceFromAnswers(answers);
+    const provenanceUploadPromises = Object.entries(provenanceByIdentifier).map(
+      ([taskName, provenanceGraph]) => this.saveProvenance(provenanceGraph, taskName),
+    );
+
     // Update the local copy of the participant data
     this.participantData = {
       ...this.participantData,
-      answers,
+      answers: answersWithoutProvenance,
     };
 
     await this.cacheParticipantDataSnapshot(this.participantData, this.currentParticipantId);
     this.scheduleParticipantDataWrite(this.participantData);
+    await Promise.all(provenanceUploadPromises);
   }
 
   // Updates the progress data in the sequence assignment
@@ -1411,6 +1424,82 @@ export abstract class StorageEngine {
     return url;
   }
 
+  private async parseProvenanceStorageObject(provenanceObject: unknown): Promise<StoredProvenance | null> {
+    if (typeof Blob !== 'undefined' && provenanceObject instanceof Blob) {
+      try {
+        return normalizeStoredProvenance(JSON.parse(await provenanceObject.text()));
+      } catch {
+        return null;
+      }
+    }
+
+    return normalizeStoredProvenance(provenanceObject);
+  }
+
+  async getProvenance(
+    task: string,
+    participantId?: string,
+  ) {
+    const targetParticipantId = participantId || this.currentParticipantId;
+    if (!targetParticipantId) {
+      throw new Error('Participant not initialized');
+    }
+
+    const provenanceObject = await this._getFromStorage(
+      `provenance/${targetParticipantId}`,
+      task,
+    );
+
+    return this.parseProvenanceStorageObject(provenanceObject);
+  }
+
+  async deleteProvenance(taskName: string) {
+    if (!this.currentParticipantId || !this.studyId) {
+      return;
+    }
+    try {
+      await this._deleteFromStorage(`provenance/${this.currentParticipantId}`, taskName);
+    } catch (error) {
+      console.warn(`Failed to delete provenance for task ${taskName}:`, error);
+    }
+  }
+
+  async saveProvenance(
+    provenanceGraph: StoredProvenance | null | undefined,
+    taskName: string,
+  ) {
+    const provenanceToSave = normalizeStoredProvenance(provenanceGraph);
+    if (!provenanceToSave) {
+      await this.deleteProvenance(taskName);
+      return undefined;
+    }
+
+    return this.trackAssetOperation(`provenance/${taskName}`, async () => {
+      if (this.studyId === undefined) {
+        throw new Error('Study ID is not set');
+      }
+      if (!this.currentParticipantId) {
+        throw new Error('Participant not initialized');
+      }
+      const modes = await this.getModes(this.studyId);
+      if (!modes.dataCollectionEnabled) {
+        throw new Error('Data collection is disabled for this study');
+      }
+
+      await this._pushToStorage(
+        `provenance/${this.currentParticipantId}`,
+        taskName,
+        provenanceToSave as unknown as StorageObject<typeof taskName>,
+      );
+
+      try {
+        await this._cacheStorageObject(`provenance/${this.currentParticipantId}`, taskName);
+      } catch (error) {
+        console.warn(`Failed to update cache headers for provenance ${taskName}:`, error);
+      }
+    });
+  }
+
   // Gets the transcript download URL (currently only supported by Firebase)
   async getTranscriptUrl(
     task: string,
@@ -1576,6 +1665,7 @@ export abstract class StorageEngine {
       await this._copyDirectory(`${sourceName}/participants`, `${targetName}/participants`);
       await this._copyDirectory(`${sourceName}/audio`, `${targetName}/audio`);
       await this._copyDirectory(`${sourceName}/screenRecording`, `${targetName}/screenRecording`);
+      await this._copyDirectory(`${sourceName}/provenance`, `${targetName}/provenance`);
       await this._copyDirectory(sourceName, targetName);
       await this._copyRealtimeData(sourceName, targetName);
     }
@@ -1623,6 +1713,7 @@ export abstract class StorageEngine {
         await this._deleteDirectory(`${deletionTarget}/participants`);
         await this._deleteDirectory(`${deletionTarget}/audio`);
         await this._deleteDirectory(`${deletionTarget}/screenRecording`);
+        await this._deleteDirectory(`${deletionTarget}/provenance`);
         await this._deleteDirectory(deletionTarget);
         await this._deleteRealtimeData(deletionTarget);
       }
@@ -1692,6 +1783,10 @@ export abstract class StorageEngine {
         `${snapshotName}/screenRecording`,
         `${originalName}/screenRecording`,
       );
+      await this._copyDirectory(
+        `${snapshotName}/provenance`,
+        `${originalName}/provenance`,
+      );
       await this._copyDirectory(snapshotName, originalName);
       await this._copyRealtimeData(snapshotName, originalName);
       successNotifications.push({
diff --git a/src/storage/engines/utils/participantDataRecovery.spec.ts b/src/storage/engines/utils/participantDataRecovery.spec.ts
index ee4770bf18..3bab7a74f2 100644
--- a/src/storage/engines/utils/participantDataRecovery.spec.ts
+++ b/src/storage/engines/utils/participantDataRecovery.spec.ts
@@ -24,12 +24,6 @@ function makeStoredAnswer(identifier: string, endTime: number): StoredAnswer {
     incorrectAnswers: {},
     startTime: endTime - 10,
     endTime,
-    provenanceGraph: {
-      aboveStimulus: undefined,
-      belowStimulus: undefined,
-      stimulus: undefined,
-      sidebar: undefined,
-    },
     windowEvents: [],
     timedOut: false,
     helpButtonClickedCount: 0,
diff --git a/src/storage/tests/highLevel.spec.ts b/src/storage/tests/highLevel.spec.ts
index 31b317b848..0441101516 100644
--- a/src/storage/tests/highLevel.spec.ts
+++ b/src/storage/tests/highLevel.spec.ts
@@ -8,7 +8,7 @@ import testConfigSimple from './testConfigSimple.json';
 import testConfigSimple2 from './testConfigSimple2.json';
 import { generateSequenceArray } from '../../utils/handleRandomSequences';
 import { hash } from '../engines/utils/storageEngineHelpers';
-import { Sequence, StoredAnswer } from '../../store/types';
+import { Sequence, StoredAnswer, TrrackedProvenance } from '../../store/types';
 import { LocalStorageEngine } from '../engines/LocalStorageEngine';
 import { StorageEngine, StorageObject, StorageObjectType } from '../engines/types';
 import { filterSequenceByCondition } from '../../utils/handleConditionLogic';
@@ -99,12 +99,6 @@ function makeStoredAnswer(identifier: string, endTime: number): StoredAnswer {
     incorrectAnswers: {},
     startTime: endTime - 10,
     endTime,
-    provenanceGraph: {
-      aboveStimulus: undefined,
-      belowStimulus: undefined,
-      stimulus: undefined,
-      sidebar: undefined,
-    },
     windowEvents: [],
     timedOut: false,
     helpButtonClickedCount: 0,
@@ -781,12 +775,6 @@ describe.each([
         incorrectAnswers: {},
         startTime: 10,
         endTime: 20,
-        provenanceGraph: {
-          sidebar: undefined,
-          aboveStimulus: undefined,
-          belowStimulus: undefined,
-          stimulus: undefined,
-        },
         windowEvents: [],
         timedOut: false,
         helpButtonClickedCount: 0,
@@ -811,6 +799,92 @@ describe.each([
     expect(participantData?.answers).toEqual(secondAnswers);
   });
 
+  test('saveAnswers strips inline provenance and stores it as a task asset', async () => {
+    const participantSession = await storageEngine.initializeParticipantSession({}, configSimple, participantMetadata);
+    const identifier = 'intro_0';
+    const provenanceGraph = {
+      root: 'root',
+      current: 'root',
+      nodes: {
+        root: {
+          id: 'root',
+          createdOn: 10,
+          children: [],
+        },
+      },
+    } as unknown as TrrackedProvenance;
+    const answerWithProvenance = {
+      ...makeStoredAnswer(identifier, 100),
+      provenanceGraph: {
+        aboveStimulus: undefined,
+        belowStimulus: undefined,
+        sidebar: undefined,
+        stimulus: provenanceGraph,
+      },
+    };
+
+    await storageEngine.saveAnswers({
+      [identifier]: answerWithProvenance,
+    });
+    await storageEngine.flushPendingParticipantData();
+
+    const participantData = await storageEngine.getParticipantData(participantSession.participantId);
+    expect(participantData).toBeDefined();
+    expect('provenanceGraph' in participantData!.answers[identifier]).toBe(false);
+
+    const storedProvenance = await storageEngine.getProvenance(identifier, participantSession.participantId);
+    expect(storedProvenance).toEqual({
+      aboveStimulus: undefined,
+      belowStimulus: undefined,
+      sidebar: undefined,
+      stimulus: provenanceGraph,
+    });
+  });
+
+  test('saveProvenance with null/undefined deletes existing provenance asset', async () => {
+    storageEngine = new LocalStorageEngine(true);
+    await storageEngine.connect();
+    await storageEngine.initializeStudyDb(studyId);
+    sequenceArray = await generateSequenceArray(configSimple);
+    const participantSession = await storageEngine.initializeParticipantSession({}, configSimple, participantMetadata);
+    const identifier = 'intro_0';
+
+    // First, save a provenance asset
+    const provenanceGraph = {
+      root: 'root',
+      current: 'root',
+      nodes: {
+        root: {
+          id: 'root',
+          createdOn: 10,
+          children: [],
+        },
+      },
+    } as unknown as TrrackedProvenance;
+    await storageEngine.saveProvenance({
+      aboveStimulus: undefined,
+      belowStimulus: undefined,
+      sidebar: undefined,
+      stimulus: provenanceGraph,
+    }, identifier);
+
+    // Verify it was saved
+    let storedProvenance = await storageEngine.getProvenance(identifier, participantSession.participantId);
+    expect(storedProvenance).toEqual({
+      aboveStimulus: undefined,
+      belowStimulus: undefined,
+      sidebar: undefined,
+      stimulus: provenanceGraph,
+    });
+
+    // Now save with null — should delete the existing asset
+    await storageEngine.saveProvenance(null, identifier);
+
+    // Verify it was deleted
+    storedProvenance = await storageEngine.getProvenance(identifier, participantSession.participantId);
+    expect(storedProvenance).toBeNull();
+  });
+
   test('saveAnswers coalesces to the latest answer and finalizeParticipant persists completion after delayed writes', async () => {
     storageEngine = new DelayedLocalStorageEngine(true);
     await storageEngine.connect();
diff --git a/src/storage/types.ts b/src/storage/types.ts
index 687deb27c4..48ff13e057 100644
--- a/src/storage/types.ts
+++ b/src/storage/types.ts
@@ -30,9 +30,6 @@ import { ParticipantMetadata, Sequence, StoredAnswer } from '../store/types';
  *   },
  *   "startTime": 1711641174858,
  *   "endTime": 1711641178836,
- *   "provenanceGraph":{
- *     ...
- *   },
  *   "windowEvents": [
  *     ...
  *   ]
@@ -40,9 +37,8 @@ import { ParticipantMetadata, Sequence, StoredAnswer } from '../store/types';
  * ```
  * The keys of this object are the names of the components with an additional underscore and number appended to the end. This is done so that the study creator can discern between not only the components but also between the various instances of the same component when necessary. All times are in **epoch milliseconds**.
  *
- * :::info
- * The `"provenanceGraph"` key will only exist if the component is a React component and if it is utilizing Trrack. See [here](../StoredAnswer) for more details.
- * :::
+ * Provenance graphs exported from Trrack are stored separately from the participant answer object, using the same per-participant, per-task asset storage pattern as audio and screen recordings.
+ *
  *
  * We can see at a high level that we are given the answer that the user submitted, the start time for the component, and the end time. In addition to this, we have a list of window events. You can find more information about the StoredAnswer object [here](../StoredAnswer).
  */
diff --git a/src/store/hooks/useNextStep.spec.tsx b/src/store/hooks/useNextStep.spec.tsx
index 31118c741d..81fc77ff5e 100644
--- a/src/store/hooks/useNextStep.spec.tsx
+++ b/src/store/hooks/useNextStep.spec.tsx
@@ -12,6 +12,7 @@ import { useNextStep } from './useNextStep';
 const mockNavigate = vi.fn();
 const mockShowNotification = vi.fn();
 const mockSaveAnswers = vi.fn();
+const mockSaveProvenance = vi.fn(() => Promise.resolve());
 const mockSaveTrialAnswer = vi.fn((payload) => ({ type: 'saveTrialAnswer', payload }));
 const mockSetReactiveAnswers = vi.fn((payload) => ({ type: 'setReactiveAnswers', payload }));
 const mockSetMatrixAnswersCheckbox = vi.fn((payload) => ({ type: 'setMatrixAnswersCheckbox', payload }));
@@ -26,12 +27,6 @@ let mockStoredAnswer: {
   incorrectAnswers: Record<string, string>;
   startTime: number;
   endTime: number;
-  provenanceGraph: {
-    aboveStimulus: undefined;
-    belowStimulus: undefined;
-    stimulus: undefined;
-    sidebar: undefined;
-  };
   windowEvents: never[];
   timedOut: boolean;
   helpButtonClickedCount: number;
@@ -101,6 +96,7 @@ vi.mock('../../storage/storageEngineHooks', () => ({
   useStorageEngine: () => ({
     storageEngine: {
       saveAnswers: mockSaveAnswers,
+      saveProvenance: mockSaveProvenance,
     },
   }),
 }));
@@ -141,6 +137,7 @@ describe('useNextStep', () => {
     mockNavigate.mockReset();
     mockShowNotification.mockReset();
     mockSaveAnswers.mockReset();
+    mockSaveProvenance.mockClear();
     mockSaveTrialAnswer.mockClear();
     mockSetReactiveAnswers.mockClear();
     mockSetMatrixAnswersCheckbox.mockClear();
@@ -178,12 +175,6 @@ describe('useNextStep', () => {
       incorrectAnswers: {},
       startTime: 0,
       endTime: -1,
-      provenanceGraph: {
-        aboveStimulus: undefined,
-        belowStimulus: undefined,
-        stimulus: undefined,
-        sidebar: undefined,
-      },
       windowEvents: [],
       timedOut: false,
       helpButtonClickedCount: 0,
diff --git a/src/store/hooks/useNextStep.ts b/src/store/hooks/useNextStep.ts
index ca5dd0c28c..ba73f3d1fa 100644
--- a/src/store/hooks/useNextStep.ts
+++ b/src/store/hooks/useNextStep.ts
@@ -86,7 +86,6 @@ export function useNextStep() {
           answer: answerToPersist,
           startTime,
           endTime,
-          provenanceGraph,
           windowEvents: currentWindowEvents,
           timedOut: !collectData,
         };
@@ -94,13 +93,23 @@ export function useNextStep() {
 
         if (storageEngine) {
           storageEngine.saveAnswers(answersToPersist).catch((error) => {
-            console.error('Failed to save participant answers', error);
+            console.error('Failed to save participant response data', error);
             showNotification({
               title: 'Failed to Save Response',
               message: 'Your response could not be saved. Please check your connection and try again.',
               color: 'red',
             });
           });
+          if (provenanceGraph) {
+            storageEngine.saveProvenance(provenanceGraph, identifier).catch((error) => {
+              console.error('Failed to save participant response data', error);
+              showNotification({
+                title: 'Failed to Save Response',
+                message: 'Your response could not be saved. Please check your connection and try again.',
+                color: 'red',
+              });
+            });
+          }
         }
 
         storeDispatch(
@@ -129,7 +138,6 @@ export function useNextStep() {
           answer: answerToPersist,
           startTime,
           endTime,
-          provenanceGraph,
           windowEvents: currentWindowEvents,
           timedOut: !collectData,
         },
diff --git a/src/store/provenance.spec.ts b/src/store/provenance.spec.ts
new file mode 100644
index 0000000000..dae7e77998
--- /dev/null
+++ b/src/store/provenance.spec.ts
@@ -0,0 +1,51 @@
+import { describe, expect, test } from 'vitest';
+import { StoredAnswer } from './types';
+import {
+  getLegacyStoredAnswerProvenance,
+  splitProvenanceFromAnswers,
+} from './provenance';
+
+function makeStoredAnswer(identifier: string): StoredAnswer {
+  return {
+    answer: {},
+    identifier,
+    componentName: 'intro',
+    trialOrder: '0',
+    incorrectAnswers: {},
+    startTime: 1,
+    endTime: 2,
+    windowEvents: [],
+    timedOut: false,
+    helpButtonClickedCount: 0,
+    parameters: {},
+    correctAnswer: [],
+    optionOrders: {},
+    questionOrders: {},
+  };
+}
+
+describe('provenance helpers', () => {
+  test('legacy answer provenance reads tolerate null and non-object answers', () => {
+    expect(getLegacyStoredAnswerProvenance(null)).toBeNull();
+    expect(getLegacyStoredAnswerProvenance(undefined)).toBeNull();
+    expect(getLegacyStoredAnswerProvenance('not-an-answer')).toBeNull();
+    expect(getLegacyStoredAnswerProvenance({
+      ...makeStoredAnswer('intro_0'),
+      provenanceGraph: null,
+    })).toBeNull();
+  });
+
+  test('splitProvenanceFromAnswers strips null inline provenance without saving a provenance asset', () => {
+    const answerWithNullProvenance = {
+      ...makeStoredAnswer('intro_0'),
+      provenanceGraph: null,
+    };
+
+    const { answers, provenanceByIdentifier } = splitProvenanceFromAnswers({
+      intro_0: answerWithNullProvenance,
+    });
+
+    expect(provenanceByIdentifier).toEqual({});
+    expect('provenanceGraph' in answers.intro_0).toBe(false);
+  });
+});
diff --git a/src/store/provenance.ts b/src/store/provenance.ts
new file mode 100644
index 0000000000..cffff528d1
--- /dev/null
+++ b/src/store/provenance.ts
@@ -0,0 +1,82 @@
+import type { ResponseBlockLocation } from '../parser/types';
+import type { StoredAnswer, StoredProvenance } from './types';
+
+export const PROVENANCE_LOCATIONS: ResponseBlockLocation[] = [
+  'aboveStimulus',
+  'belowStimulus',
+  'sidebar',
+  'stimulus',
+];
+
+export type LegacyStoredAnswerWithProvenance = StoredAnswer & {
+  provenanceGraph?: unknown;
+};
+
+export function createEmptyProvenance(): StoredProvenance {
+  return {
+    aboveStimulus: undefined,
+    belowStimulus: undefined,
+    sidebar: undefined,
+    stimulus: undefined,
+  };
+}
+
+export function normalizeStoredProvenance(provenanceGraph: unknown): StoredProvenance | null {
+  if (!provenanceGraph || typeof provenanceGraph !== 'object') {
+    return null;
+  }
+
+  const provenanceCandidate = provenanceGraph as Partial<StoredProvenance>;
+  const provenance = createEmptyProvenance();
+  let hasProvenance = false;
+
+  PROVENANCE_LOCATIONS.forEach((location) => {
+    if (provenanceCandidate[location]) {
+      provenance[location] = provenanceCandidate[location];
+      hasProvenance = true;
+    }
+  });
+
+  return hasProvenance ? provenance : null;
+}
+
+export function hasStoredProvenance(provenanceGraph: unknown) {
+  return normalizeStoredProvenance(provenanceGraph) !== null;
+}
+
+export function getLegacyStoredAnswerProvenance(answer: unknown) {
+  if (!answer || typeof answer !== 'object') {
+    return null;
+  }
+
+  return normalizeStoredProvenance(
+    (answer as LegacyStoredAnswerWithProvenance).provenanceGraph,
+  );
+}
+
+export function stripProvenanceFromStoredAnswer(
+  answer: StoredAnswer | LegacyStoredAnswerWithProvenance,
+): StoredAnswer {
+  const { provenanceGraph: _provenanceGraph, ...answerWithoutProvenance } = answer as LegacyStoredAnswerWithProvenance;
+  return answerWithoutProvenance;
+}
+
+export function splitProvenanceFromAnswers(answers: Record<string, StoredAnswer>) {
+  const provenanceByIdentifier: Record<string, StoredProvenance> = {};
+  const answersWithoutProvenance: Record<string, StoredAnswer> = {};
+
+  Object.entries(answers).forEach(([identifier, answer]) => {
+    const provenanceGraph = getLegacyStoredAnswerProvenance(answer);
+
+    if (provenanceGraph) {
+      provenanceByIdentifier[identifier] = provenanceGraph;
+    }
+
+    answersWithoutProvenance[identifier] = stripProvenanceFromStoredAnswer(answer);
+  });
+
+  return {
+    answers: answersWithoutProvenance,
+    provenanceByIdentifier,
+  };
+}
diff --git a/src/store/store.tsx b/src/store/store.tsx
index 735d8017d0..b6356a3333 100644
--- a/src/store/store.tsx
+++ b/src/store/store.tsx
@@ -48,12 +48,6 @@ export async function studyStoreCreator(
           incorrectAnswers: {},
           startTime: 0,
           endTime: -1,
-          provenanceGraph: {
-            aboveStimulus: undefined,
-            belowStimulus: undefined,
-            stimulus: undefined,
-            sidebar: undefined,
-          },
           windowEvents: [],
           timedOut: false,
           helpButtonClickedCount: 0,
@@ -173,12 +167,6 @@ export async function studyStoreCreator(
           trialOrder: `${payload.index}_${payload.funcIndex}`,
           startTime: 0,
           endTime: -1,
-          provenanceGraph: {
-            aboveStimulus: undefined,
-            belowStimulus: undefined,
-            stimulus: undefined,
-            sidebar: undefined,
-          },
           windowEvents: [],
           timedOut: false,
           helpButtonClickedCount: 0,
diff --git a/src/store/types.ts b/src/store/types.ts
index e1af906dd7..27e114ff43 100644
--- a/src/store/types.ts
+++ b/src/store/types.ts
@@ -21,6 +21,7 @@ export interface ParticipantMetadata {
 }
 
 export type TrrackedProvenance = ProvenanceGraph<any, any>;
+export type StoredProvenance = Record<ResponseBlockLocation, TrrackedProvenance | undefined>;
 
 // timestamp, event type, event data
 type FocusEvent = [number, 'focus', string];
@@ -43,7 +44,7 @@ export type TrialValidation = Record<
     belowStimulus: ValidationStatus;
     sidebar: ValidationStatus;
     stimulus: ValidationStatus;
-    provenanceGraph: Record<ResponseBlockLocation, TrrackedProvenance | undefined>;
+    provenanceGraph: StoredProvenance;
   }
 >;
 
@@ -81,8 +82,6 @@ export interface StoredAnswer {
   startTime: number;
   /** Time that the user ended interaction with the component in epoch milliseconds. */
   endTime: number;
-  /** The entire provenance graph exported from a Trrack instance from a React component. This will only be present if you are using React components and you're utilizing [Trrack](https://apps.vdl.sci.utah.edu/trrack) */
-  provenanceGraph: Record<ResponseBlockLocation, TrrackedProvenance | undefined>;
   /**
    * A list containing the time (in epoch milliseconds), the action (focus, input, keypress, mousedown, mouseup, mousemove, resize, scroll or visibility), and then either a coordinate pertaining to where the event took place on the screen or string related to such event. Below is an example of the windowEvents list.
    *
diff --git a/src/utils/handleDownloadFiles.provenance.spec.ts b/src/utils/handleDownloadFiles.provenance.spec.ts
new file mode 100644
index 0000000000..eda803a5ae
--- /dev/null
+++ b/src/utils/handleDownloadFiles.provenance.spec.ts
@@ -0,0 +1,122 @@
+import {
+  afterEach, describe, expect, test, vi,
+} from 'vitest';
+import { downloadParticipantsProvenanceZip } from './handleDownloadFiles';
+import type { StorageEngine } from '../storage/engines/types';
+import type { StoredAnswer } from '../store/types';
+
+const mockZipState = vi.hoisted(() => {
+  const instances: Array<{
+    files: Record<string, unknown>;
+    file: (name: string, content: unknown) => unknown;
+  }> = [];
+
+  class MockJSZip {
+    files: Record<string, unknown> = {};
+
+    file = vi.fn((name: string, content: unknown) => {
+      this.files[name] = content;
+      return this;
+    });
+
+    generateAsync = vi.fn(async () => new Blob(['zip']));
+
+    constructor() {
+      instances.push(this);
+    }
+  }
+
+  return { instances, MockJSZip };
+});
+
+vi.mock('jszip', () => ({
+  default: mockZipState.MockJSZip,
+}));
+
+function makeStoredAnswer(overrides: Partial<StoredAnswer> = {}): StoredAnswer {
+  return {
+    answer: {},
+    identifier: 'intro_0',
+    componentName: 'intro',
+    trialOrder: '0',
+    correctAnswer: [],
+    incorrectAnswers: {},
+    startTime: 10,
+    endTime: 20,
+    windowEvents: [],
+    timedOut: false,
+    helpButtonClickedCount: 0,
+    parameters: {},
+    optionOrders: {},
+    questionOrders: {},
+    ...overrides,
+  };
+}
+
+describe('provenance downloads', () => {
+  afterEach(() => {
+    mockZipState.instances.splice(0, mockZipState.instances.length);
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  test('downloads provenance as a zip alongside the expected per-answer file name', async () => {
+    const anchor = {
+      href: '',
+      download: '',
+      click: vi.fn(),
+      remove: vi.fn(),
+    } as unknown as HTMLAnchorElement;
+    const createElement = vi.fn().mockReturnValue(anchor);
+    const appendChild = vi.fn();
+    vi.stubGlobal('document', {
+      createElement,
+      body: {
+        appendChild,
+      },
+    });
+    vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:zip');
+    vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => undefined);
+
+    const provenanceGraph = {
+      aboveStimulus: undefined,
+      belowStimulus: undefined,
+      sidebar: undefined,
+      stimulus: {
+        root: 'root',
+        nodes: {
+          root: {
+            id: 'root',
+            createdOn: 10,
+            children: [],
+          },
+        },
+      },
+    };
+
+    const storageEngine = {
+      getProvenance: vi.fn().mockResolvedValue(provenanceGraph),
+    } as unknown as StorageEngine;
+
+    await downloadParticipantsProvenanceZip({
+      storageEngine,
+      participants: [
+        {
+          participantId: 'p1',
+          answers: {
+            intro_0: makeStoredAnswer(),
+          },
+        },
+      ],
+      studyId: 'study-1',
+    });
+
+    expect(storageEngine.getProvenance).toHaveBeenCalledWith('intro_0', 'p1');
+    expect(mockZipState.instances).toHaveLength(1);
+    expect(mockZipState.instances[0].files['study-1_p1_intro_0_provenance.json']).toBe(
+      JSON.stringify(provenanceGraph, null, 2),
+    );
+    expect(anchor.download).toBe('study-1_provenance.zip');
+    expect(anchor.click).toHaveBeenCalled();
+  });
+});
diff --git a/src/utils/handleDownloadFiles.ts b/src/utils/handleDownloadFiles.ts
index a6e96d1541..8bcac482b7 100644
--- a/src/utils/handleDownloadFiles.ts
+++ b/src/utils/handleDownloadFiles.ts
@@ -1,6 +1,8 @@
 import JSZip from 'jszip';
 import { StorageEngine } from '../storage/engines/types';
 import { StudyConfig } from '../parser/types';
+import { getLegacyStoredAnswerProvenance } from '../store/provenance';
+import type { StoredAnswer } from '../store/types';
 
 export async function handleTaskAudio({
   storageEngine,
@@ -86,6 +88,42 @@ async function downloadZip(zip: JSZip, fileName: string) {
   URL.revokeObjectURL(url);
 }
 
+async function downloadParticipantsProvenance({
+  storageEngine,
+  participantId,
+  identifier,
+  namePrefix,
+  zip,
+  answer,
+}: {
+  storageEngine: StorageEngine;
+  participantId: string;
+  identifier: string;
+  namePrefix: string;
+  zip?: JSZip;
+  answer?: StoredAnswer;
+}) {
+  const provenanceZip = zip || new JSZip();
+
+  try {
+    const legacyProvenance = answer ? getLegacyStoredAnswerProvenance(answer) : null;
+    const provenance = legacyProvenance || await storageEngine.getProvenance(identifier, participantId);
+
+    if (provenance) {
+      provenanceZip.file(
+        `${namePrefix}_${participantId}_${identifier}_provenance.json`,
+        JSON.stringify(provenance, null, 2),
+      );
+    }
+
+    if (!zip) {
+      downloadZip(provenanceZip, `${namePrefix}_${participantId}_${identifier}_provenance.zip`);
+    }
+  } catch (error) {
+    console.warn(`Failed to fetch provenance for ${identifier}:`, error);
+  }
+}
+
 async function downloadParticipantsAudio({
   storageEngine,
   participantId,
@@ -217,6 +255,45 @@ export async function downloadParticipantsScreenRecordingZip({
   await downloadZip(zip, `${namePrefix}_screenRecording.zip`);
 }
 
+export async function downloadParticipantsProvenanceZip({
+  storageEngine,
+  participants,
+  studyId,
+  fileName,
+}: {
+  storageEngine: StorageEngine;
+  participants: Array<{
+    participantId: string;
+    answers: Record<string, StoredAnswer>;
+  }>;
+  studyId: string;
+  fileName?: string | null;
+}) {
+  const namePrefix = fileName || studyId;
+  const zip = new JSZip();
+
+  const provenancePromises = participants.flatMap((participant) => {
+    const entries = Object.entries(participant.answers)
+      .filter(([, ans]) => ans.endTime > 0)
+      .sort(([, a], [, b]) => a.startTime - b.startTime);
+
+    return entries.map(async ([identifier, ans]) => {
+      await downloadParticipantsProvenance({
+        storageEngine,
+        participantId: participant.participantId,
+        identifier: ans.identifier || identifier,
+        namePrefix,
+        zip,
+        answer: ans,
+      });
+    });
+  });
+
+  await Promise.all(provenancePromises);
+
+  await downloadZip(zip, `${namePrefix}_provenance.zip`);
+}
+
 export async function downloadConfigFile({
   studyId,
   hash,