diff --git a/src/app/models/task-execution.ts b/src/app/models/task-execution.ts
index ccb6506..6b1a82e 100644
--- a/src/app/models/task-execution.ts
+++ b/src/app/models/task-execution.ts
@@ -173,6 +173,8 @@ export type TaskExecutionStep = {
   outputs?: TaskExecutionStepOutput[];
   result?: Record<string, unknown>;
   status: StepStatus;
+  /** Which round of its loop the step is on; 1, or absent from older servers, for a step in no loop. */
+  iteration?: number;
   started?: boolean;
   skipReason?: string | null;
   simulated: boolean;
diff --git a/src/app/services/task-executions/task-executions-call.base.ts b/src/app/services/task-executions/task-executions-call.base.ts
index 9256ddc..7dc2baf 100644
--- a/src/app/services/task-executions/task-executions-call.base.ts
+++ b/src/app/services/task-executions/task-executions-call.base.ts
@@ -97,11 +97,16 @@ export abstract class TaskExecutionsCallServiceBase {
     inputName: string,
     files: File[]
   ): Observable<TaskExecution>;
+  /**
+   * `iteration`, when given, is the round of its loop the answer is for: the server refuses it if
+   * the node has moved on to another, rather than taking it as the answer to a question not seen.
+   */
   abstract submitInteractionText(
     executionId: string,
     nodeId: string,
     fieldName: string,
-    value: string
+    value: string,
+    iteration?: number
   ): Observable<TaskExecution>;
   /**
    * Submits a human evaluation whole - every criterion and the notes in one call - because the
@@ -111,17 +116,20 @@ export abstract class TaskExecutionsCallServiceBase {
     executionId: string,
     nodeId: string,
     verdict: Record<string, string>,
-    notes: string
+    notes: string,
+    iteration?: number
   ): Observable<TaskExecution>;
   abstract attachEvaluationEvidence(
     executionId: string,
     nodeId: string,
-    files: File[]
+    files: File[],
+    iteration?: number
   ): Observable<TaskExecution>;
   /** Asks to see the reference verdict; the execution records that it was seen before judging. */
   abstract revealEvaluationReference(
     executionId: string,
-    nodeId: string
+    nodeId: string,
+    iteration?: number
   ): Observable<TaskExecution>;
   abstract provideAuthorization(
     executionId: string,
diff --git a/src/app/services/task-executions/task-executions-call.ts b/src/app/services/task-executions/task-executions-call.ts
index b3c86de..51da7b6 100644
--- a/src/app/services/task-executions/task-executions-call.ts
+++ b/src/app/services/task-executions/task-executions-call.ts
@@ -269,11 +269,13 @@ export class TaskExecutionsCallService extends TaskExecutionsCallServiceBase {
     executionId: string,
     nodeId: string,
     fieldName: string,
-    value: string
+    value: string,
+    iteration?: number
   ): Observable<TaskExecution> {
     const url = `${environment.apiUrl}/executions/${encodeURIComponent(executionId)}/node/${encodeURIComponent(nodeId)}/interaction/${encodeURIComponent(fieldName)}/text`;
     return this.http.put<unknown>(url, value, {
-      headers: { 'Content-Type': 'text/plain' }
+      headers: { 'Content-Type': 'text/plain' },
+      params: roundParams(iteration)
     }).pipe(map((raw) => this.mapExecution(raw)));
   }
 
@@ -281,28 +283,33 @@ export class TaskExecutionsCallService extends TaskExecutionsCallServiceBase {
     executionId: string,
     nodeId: string,
     verdict: Record<string, string>,
-    notes: string
+    notes: string,
+    iteration?: number
   ): Observable<TaskExecution> {
     const url = `${environment.apiUrl}/executions/${encodeURIComponent(executionId)}/node/${encodeURIComponent(nodeId)}/evaluation`;
-    return this.http.put<unknown>(url, { verdict, notes }).pipe(map((raw) => this.mapExecution(raw)));
+    return this.http.put<unknown>(url, { verdict, notes }, { params: roundParams(iteration) })
+      .pipe(map((raw) => this.mapExecution(raw)));
   }
 
   override attachEvaluationEvidence(
     executionId: string,
     nodeId: string,
-    files: File[]
+    files: File[],
+    iteration?: number
   ): Observable<TaskExecution> {
     const url = `${environment.apiUrl}/executions/${encodeURIComponent(executionId)}/node/${encodeURIComponent(nodeId)}/evaluation/evidence`;
     const formData = new FormData();
     for (const file of files) {
       formData.append('files', file);
     }
-    return this.http.put<unknown>(url, formData).pipe(map((raw) => this.mapExecution(raw)));
+    return this.http.put<unknown>(url, formData, { params: roundParams(iteration) })
+      .pipe(map((raw) => this.mapExecution(raw)));
   }
 
-  override revealEvaluationReference(executionId: string, nodeId: string): Observable<TaskExecution> {
+  override revealEvaluationReference(executionId: string, nodeId: string, iteration?: number): Observable<TaskExecution> {
     const url = `${environment.apiUrl}/executions/${encodeURIComponent(executionId)}/node/${encodeURIComponent(nodeId)}/evaluation/reveal`;
-    return this.http.put<unknown>(url, {}).pipe(map((raw) => this.mapExecution(raw)));
+    return this.http.put<unknown>(url, {}, { params: roundParams(iteration) })
+      .pipe(map((raw) => this.mapExecution(raw)));
   }
 
   override provideAuthorization(
@@ -777,3 +784,8 @@ export class TaskExecutionsCallService extends TaskExecutionsCallServiceBase {
     return Number.isFinite(number) ? number : fallback;
   }
 }
+
+/** The round an answer is for, as the endpoint's optional `iteration` parameter. */
+function roundParams(iteration?: number): Record<string, string> {
+  return typeof iteration === 'number' ? { iteration: String(iteration) } : {};
+}
diff --git a/src/app/services/task-executions/task-executions.ts b/src/app/services/task-executions/task-executions.ts
index 1f27902..23eaabf 100644
--- a/src/app/services/task-executions/task-executions.ts
+++ b/src/app/services/task-executions/task-executions.ts
@@ -347,14 +347,14 @@ export class TaskExecutionsService {
     );
   }
 
-  submitInteractionText(executionId: string, nodeId: string, fieldName: string, value: string) {
+  submitInteractionText(executionId: string, nodeId: string, fieldName: string, value: string, iteration?: number) {
     const execution = this._taskExecutions().find((item) => item.id === executionId);
     if (execution?.interactionSimulationEnabled === true) {
       return throwError(() => new Error('Manual interaction is disabled for simulated executions.'));
     }
 
     return this.withRefreshAndErrorHandling(
-      this.taskExecutionsCallService.submitInteractionText(executionId, nodeId, fieldName, value).pipe(
+      this.taskExecutionsCallService.submitInteractionText(executionId, nodeId, fieldName, value, iteration).pipe(
         tap((updatedExecution) => {
           if (updatedExecution.executionKind === 'SUBFLOW') {
             this.cacheFollowedExecution(updatedExecution);
@@ -367,14 +367,14 @@ export class TaskExecutionsService {
     );
   }
 
-  submitEvaluation(executionId: string, nodeId: string, verdict: Record<string, string>, notes: string) {
+  submitEvaluation(executionId: string, nodeId: string, verdict: Record<string, string>, notes: string, iteration?: number) {
     const execution = this._taskExecutions().find((item) => item.id === executionId);
     if (execution?.interactionSimulationEnabled === true) {
       return throwError(() => new Error('Manual interaction is disabled for simulated executions.'));
     }
 
     return this.withRefreshAndErrorHandling(
-      this.taskExecutionsCallService.submitEvaluation(executionId, nodeId, verdict, notes).pipe(
+      this.taskExecutionsCallService.submitEvaluation(executionId, nodeId, verdict, notes, iteration).pipe(
         tap((updatedExecution) => {
           if (updatedExecution.executionKind === 'SUBFLOW') {
             this.cacheFollowedExecution(updatedExecution);
@@ -387,9 +387,9 @@ export class TaskExecutionsService {
     );
   }
 
-  attachEvaluationEvidence(executionId: string, nodeId: string, files: File[]) {
+  attachEvaluationEvidence(executionId: string, nodeId: string, files: File[], iteration?: number) {
     return this.withRefreshAndErrorHandling(
-      this.taskExecutionsCallService.attachEvaluationEvidence(executionId, nodeId, files).pipe(
+      this.taskExecutionsCallService.attachEvaluationEvidence(executionId, nodeId, files, iteration).pipe(
         tap((execution) => this.replaceExecution(execution))
       ),
       'Attach evaluation evidence failed',
@@ -397,9 +397,9 @@ export class TaskExecutionsService {
     );
   }
 
-  revealEvaluationReference(executionId: string, nodeId: string) {
+  revealEvaluationReference(executionId: string, nodeId: string, iteration?: number) {
     return this.withRefreshAndErrorHandling(
-      this.taskExecutionsCallService.revealEvaluationReference(executionId, nodeId).pipe(
+      this.taskExecutionsCallService.revealEvaluationReference(executionId, nodeId, iteration).pipe(
         tap((execution) => this.replaceExecution(execution))
       ),
       'Reveal reference verdict failed',
diff --git a/src/app/shared/nodes/task-step-node/task-step-node.css b/src/app/shared/nodes/task-step-node/task-step-node.css
index 7e9ee6d..0127a8e 100644
--- a/src/app/shared/nodes/task-step-node/task-step-node.css
+++ b/src/app/shared/nodes/task-step-node/task-step-node.css
@@ -393,6 +393,18 @@ button.llm-node-bias-summary:focus-visible {
   font-size: 11px;
 }
 
+/* A loop's round sits at the other corner, so it does not cover a container's subflow badge. */
+.llm-subflow-badge-wrap:has(.llm-loop-round-badge) {
+  left: auto;
+  right: 12px;
+}
+
+.llm-loop-round-badge {
+  border-color: #c4b5fd;
+  background: #f5f3ff;
+  color: #5b21b6;
+}
+
 .llm-header {
   display: flex;
   align-items: center;
diff --git a/src/app/shared/nodes/task-step-node/task-step-node.html b/src/app/shared/nodes/task-step-node/task-step-node.html
index dcdbf5a..17b7f3a 100644
--- a/src/app/shared/nodes/task-step-node/task-step-node.html
+++ b/src/app/shared/nodes/task-step-node/task-step-node.html
@@ -44,6 +44,15 @@
     </span>
   </div>
   }
+  @if (loopRound()) {
+  <div class="llm-subflow-badge-wrap">
+    <span class="llm-subflow-badge llm-loop-round-badge"
+          [title]="'Round ' + loopRound() + ' of its loop - earlier rounds are kept in the execution history'">
+      <i class="bi bi-arrow-repeat"></i>
+      <span>Round {{ loopRound() }}</span>
+    </span>
+  </div>
+  }
   @if (needsAttention() && isHumanNode()) {
   <div class="llm-attention-wrap" (pointerdown)="$event.stopPropagation()" (click)="$event.stopPropagation()">
     <button
diff --git a/src/app/shared/nodes/task-step-node/task-step-node.spec.ts b/src/app/shared/nodes/task-step-node/task-step-node.spec.ts
index 0cb01ce..a73ab00 100644
--- a/src/app/shared/nodes/task-step-node/task-step-node.spec.ts
+++ b/src/app/shared/nodes/task-step-node/task-step-node.spec.ts
@@ -373,6 +373,7 @@ describe('TaskStepNodeComponent bias canvas highlighting', () => {
         __executionNodeId: 'node-1',
         __executionStatus: 'WAITING',
         __stepStatus: 'WAITING_FOR_INTERACTION',
+        __stepIteration: 1,
         question: 'Should the candidate proceed?',
         options: [
           { name: 'approve', label: 'Approve' },
@@ -449,11 +450,28 @@ describe('TaskStepNodeComponent bias canvas highlighting', () => {
       });
 
       expect(executions.submitInteractionText.mock.calls).toEqual([
-        ['execution-1', 'node-1', 'rationale', 'Documented evidence'],
-        ['execution-1', 'node-1', 'choice', 'approve']
+        ['execution-1', 'node-1', 'rationale', 'Documented evidence', 1],
+        ['execution-1', 'node-1', 'choice', 'approve', 1]
       ]);
     });
 
+    it('answers for the round of the loop the person saw, even if the page has moved on since', () => {
+      // Polling may refresh the node to the next round while the dialog is still open. The answer
+      // is to the question that was asked, so it carries that question's round - and the server
+      // refuses it rather than applying it to a draft the person never saw.
+      configureInteraction('human-decision');
+      component.data.data.specificConfiguration = { ...component.data.data.specificConfiguration, __stepIteration: 3 };
+      const dialog = TestBed.inject(HumanInteractionDialogService) as any;
+      const executions = TestBed.inject(TaskExecutionsService) as any;
+      component.openInteractionModal();
+      const input = dialog.open.mock.calls.at(-1)[0];
+      component.data.data.specificConfiguration = { ...component.data.data.specificConfiguration, __stepIteration: 4 };
+
+      input.onSubmit({ mode: 'decision', choice: 'approve', rationale: 'Looks right' });
+
+      expect(executions.submitInteractionText.mock.calls.map((call: unknown[]) => call[4])).toEqual([3, 3]);
+    });
+
     it('uses the single-response completion field and never confirms the runtime input', () => {
       configureInteraction('single-response');
       const dialog = TestBed.inject(HumanInteractionDialogService) as any;
@@ -467,7 +485,8 @@ describe('TaskStepNodeComponent bias canvas highlighting', () => {
         'execution-1',
         'node-1',
         'output',
-        'Human response'
+        'Human response',
+        1
       );
     });
 
diff --git a/src/app/shared/nodes/task-step-node/task-step-node.ts b/src/app/shared/nodes/task-step-node/task-step-node.ts
index cadaa23..bbc4dec 100644
--- a/src/app/shared/nodes/task-step-node/task-step-node.ts
+++ b/src/app/shared/nodes/task-step-node/task-step-node.ts
@@ -132,6 +132,12 @@ export class TaskStepNodeComponent {
   name = 'Step';
   mainContentFields: MainContentView[] = [];
   interactionSubmitting = false;
+  /**
+   * The round of its loop the open question belongs to, fixed when the person opened it. Read at
+   * submit time instead, a page refreshed by polling would send the new round's number with an
+   * answer to the old round's question - exactly what the round is sent to catch.
+   */
+  private interactionRound: number | undefined;
   /** Per dialog session: the step holds the truth, these only drive what the form shows. */
   private evaluationEvidenceCount = 0;
   private evaluationReferenceRevealed = false;
@@ -610,6 +616,12 @@ export class TaskStepNodeComponent {
     return this.stepStatus() === 'SKIPPED';
   }
 
+  /** The round of its loop this step is on, or null for a step on its first - or in no loop. */
+  loopRound(): number | null {
+    const iteration = this.blockConfiguration?.['__stepIteration'];
+    return typeof iteration === 'number' && iteration > 1 ? iteration : null;
+  }
+
   stepStatus(): string {
     const status = this.blockConfiguration?.['__stepStatus'];
     return typeof status === 'string' ? status.toUpperCase() : '';
@@ -632,6 +644,8 @@ export class TaskStepNodeComponent {
     const executionNodeId = this.executionNodeId();
     const contract = this.interactionContract();
     if (!executionId || !executionNodeId || !contract) return;
+    const iteration = this.blockConfiguration?.['__stepIteration'];
+    this.interactionRound = typeof iteration === 'number' ? iteration : undefined;
 
     this.humanInteractionDialog.open({
       ...this.buildInteractionDialogState(executionId, executionNodeId, contract),
@@ -1072,7 +1086,7 @@ export class TaskStepNodeComponent {
   }
 
   private revealEvaluationReference(executionId: string, executionNodeId: string) {
-    this.taskExecutionsService.revealEvaluationReference(executionId, executionNodeId).subscribe({
+    this.taskExecutionsService.revealEvaluationReference(executionId, executionNodeId, this.interactionRound).subscribe({
       next: () => {
         this.evaluationReferenceRevealed = true;
         this.humanInteractionDialog.update({
@@ -1089,7 +1103,7 @@ export class TaskStepNodeComponent {
   }
 
   private attachEvaluationEvidence(executionId: string, executionNodeId: string, files: File[]) {
-    this.taskExecutionsService.attachEvaluationEvidence(executionId, executionNodeId, files).subscribe({
+    this.taskExecutionsService.attachEvaluationEvidence(executionId, executionNodeId, files, this.interactionRound).subscribe({
       next: () => {
         this.evaluationEvidenceCount += files.length;
         this.humanInteractionDialog.update({
@@ -1142,7 +1156,8 @@ export class TaskStepNodeComponent {
       executionId,
       executionNodeId,
       interactionFieldName,
-      result.value
+      result.value,
+      this.interactionRound
     ).subscribe({
       next: () => {
         this.interactionSubmitting = false;
@@ -1185,7 +1200,8 @@ export class TaskStepNodeComponent {
       executionId,
       executionNodeId,
       result.verdict,
-      result.notes
+      result.notes,
+      this.interactionRound
     ).subscribe({
       next: () => {
         this.interactionSubmitting = false;
@@ -1249,7 +1265,8 @@ export class TaskStepNodeComponent {
         executionId,
         executionNodeId,
         choiceField,
-        result.choice
+        result.choice,
+        this.interactionRound
       ).subscribe({
         next: () => {
           this.interactionSubmitting = false;
@@ -1267,7 +1284,8 @@ export class TaskStepNodeComponent {
         executionId,
         executionNodeId,
         rationaleField,
-        rationale
+        rationale,
+        this.interactionRound
       ).subscribe({
         next: submitChoice,
         error: (error) => this.handleDecisionSubmitError(error)
diff --git a/src/app/shared/task-execution-viewer/task-execution-viewer.ts b/src/app/shared/task-execution-viewer/task-execution-viewer.ts
index 1ea3db7..a9a58ef 100644
--- a/src/app/shared/task-execution-viewer/task-execution-viewer.ts
+++ b/src/app/shared/task-execution-viewer/task-execution-viewer.ts
@@ -537,6 +537,7 @@ export class TaskExecutionViewerComponent implements OnDestroy {
           __executionStatus: this.execution()?.context.status ?? null,
           __interactionSimulationEnabled: this.execution()?.interactionSimulationEnabled === true,
           __stepStatus: step.status,
+          __stepIteration: typeof step.iteration === 'number' ? step.iteration : 1,
           // Which iteration a container is on, so a node that is visibly working can say what it
           // is working on rather than only that it is.
           __containerIterationIndex: typeof step.containerIterationIndex === 'number'