@@ -55,8 +55,8 @@ def evaluate(
     config_id: UUID = Body(..., description="Stored config ID"),
     config_version: int = Body(..., ge=1, description="Stored config version"),
     run_mode: RunModeEnum = Body(
-        default=RunModeEnum.BATCH,
-        description="Execution mode: 'batch' (default) or 'fast'",
+        default=RunModeEnum.FAST,
+        description="Execution mode: 'batch' or 'fast'. Omit to default to 'fast'.",
     ),
 ) -> APIResponse[EvaluationRunPublic]:
     """Start an evaluation run."""
 
@@ -4,7 +4,7 @@
 ordered by the per-task `priority`:
 
     9  LLM call + LLM chain (run_llm_job, run_llm_chain_job, run_response_job)
-    6  Fast evaluation (run_evaluation_fast)
+    6  Fast evaluation (run_evaluation_fast_chunk, run_evaluation_fast_aggregate)
     2  Everything else (doctransform, collections, STT/TTS evaluation, assessment)
     1  Notifications (send_eval_completion_notification)
 
@@ -352,32 +352,57 @@ def run_tts_result_processing(
 
 
 @celery_app.task(bind=True, queue="default", priority=6)
-@gevent_timeout(settings.CELERY_TASK_SOFT_TIME_LIMIT, "run_evaluation_fast")
-def run_evaluation_fast(
-    self: Task, eval_run_id: int, trace_id: str = DEFAULT_TRACE_ID
+@gevent_timeout(settings.CELERY_TASK_SOFT_TIME_LIMIT, "run_evaluation_fast_chunk")
+def run_evaluation_fast_chunk(
+    self: Task,
+    eval_run_id: int,
+    chunk_index: int,
+    trace_id: str = DEFAULT_TRACE_ID,
 ) -> None:
-    """Run the fast evaluation pipeline for one EvaluationRun.
+    """Run one responses chunk of a fast EvaluationRun.
+
+    Idempotent: the chunk is skipped when its (eval_run, chunk_index) batch_job
+    already has a raw_output_url, so Celery redelivery never re-charges OpenAI.
+    """
+    from app.services.evaluations.fast import execute_fast_evaluation_chunk
+
+    _set_trace(trace_id)
+    logger.info(
+        f"[run_evaluation_fast_chunk] Starting fast eval chunk | "
+        f"eval_run_id={eval_run_id} | chunk_index={chunk_index} | "
+        f"task_id={current_task.request.id}"
+    )
+
+    return _run_with_otel_parent(
+        self,
+        lambda: execute_fast_evaluation_chunk(
+            eval_run_id=eval_run_id, chunk_index=chunk_index
+        ),
+    )
 
-    Idempotency: each stage is skipped on retry when its `batch_job` marker is
-    already set on the EvaluationRun, so Celery redelivery never re-calls
-    OpenAI for work that already succeeded.
 
-    Args:
-        eval_run_id: ID of the EvaluationRun (run_mode="fast").
-        trace_id: Correlation id from the enqueueing request, propagated into
-            the worker for log correlation.
+@celery_app.task(bind=True, queue="default", priority=6)
+@gevent_timeout(settings.CELERY_TASK_SOFT_TIME_LIMIT, "run_evaluation_fast_aggregate")
+def run_evaluation_fast_aggregate(
+    self: Task, eval_run_id: int, trace_id: str = DEFAULT_TRACE_ID
+) -> None:
+    """Fan-in: merge the response chunks then run embeddings + scoring.
+
+    Enqueued once by the cron barrier after every chunk has completed.
+    Idempotent: each stage is skipped on retry when its `batch_job` marker is
+    set, so redelivery never re-does completed work.
     """
-    from app.services.evaluations.fast import execute_fast_evaluation
+    from app.services.evaluations.fast import execute_fast_evaluation_aggregate
 
     _set_trace(trace_id)
     logger.info(
-        f"[run_evaluation_fast] Starting fast evaluation task | "
+        f"[run_evaluation_fast_aggregate] Starting fast eval aggregate | "
         f"eval_run_id={eval_run_id} | task_id={current_task.request.id}"
     )
 
     return _run_with_otel_parent(
         self,
-        lambda: execute_fast_evaluation(eval_run_id=eval_run_id),
+        lambda: execute_fast_evaluation_aggregate(eval_run_id=eval_run_id),
     )
 
 
 
@@ -252,17 +252,36 @@ def start_tts_result_processing(
     return task_id
 
 
-def start_fast_evaluation(eval_run_id: int, trace_id: str = "N/A") -> str:
-    """Enqueue the run_evaluation_fast orchestrator task for one EvaluationRun."""
-    from app.celery.tasks.job_execution import run_evaluation_fast
+def start_fast_evaluation_chunk(
+    eval_run_id: int, chunk_index: int, trace_id: str = "N/A"
+) -> str:
+    """Enqueue one parallel responses-chunk task for a fast EvaluationRun."""
+    from app.celery.tasks.job_execution import run_evaluation_fast_chunk
+
+    task_id = _enqueue_with_trace_context(
+        run_evaluation_fast_chunk,
+        eval_run_id=eval_run_id,
+        chunk_index=chunk_index,
+        trace_id=trace_id,
+    )
+    logger.info(
+        f"[start_fast_evaluation_chunk] Enqueued fast eval chunk | "
+        f"eval_run_id={eval_run_id} | chunk_index={chunk_index} | task_id={task_id}"
+    )
+    return task_id
+
+
+def start_fast_evaluation_aggregate(eval_run_id: int, trace_id: str = "N/A") -> str:
+    """Enqueue the fan-in aggregate task once a fast run's chunks are all done."""
+    from app.celery.tasks.job_execution import run_evaluation_fast_aggregate
 
     task_id = _enqueue_with_trace_context(
-        run_evaluation_fast,
+        run_evaluation_fast_aggregate,
         eval_run_id=eval_run_id,
         trace_id=trace_id,
     )
     logger.info(
-        f"[start_fast_evaluation] Enqueued fast eval | "
+        f"[start_fast_evaluation_aggregate] Enqueued fast eval aggregate | "
         f"eval_run_id={eval_run_id} | task_id={task_id}"
     )
     return task_id
 
@@ -186,6 +186,9 @@ def AWS_S3_BUCKET(self) -> str:
     LLM_PENDING_THRESHOLD_MINUTES: int = 30
     COLLECTION_PENDING_THRESHOLD_MINUTES: int = 30
     DOC_TRANSFORMATION_PENDING_THRESHOLD_MINUTES: int = 30
+    # A fast run stuck in `processing` past this with no chunk progress is stalled;
+    # the cron healer re-enqueues its missing chunk tasks.
+    EVAL_FAST_STALL_THRESHOLD_MINUTES: int = 15
     PENDING_JOB_QUERY_TIMEOUT_MS: int = 1000
 
     # AI-assisted prompt improvement settings.
@@ -197,11 +200,14 @@ def AWS_S3_BUCKET(self) -> str:
 
     # Fast evaluation (run_mode="fast") configuration.
     # See "Fast Evaluation SRD.md" for the full design rationale.
-    EVAL_FAST_MAX_UNIQUE_ROWS: int = 10
+    EVAL_FAST_MAX_UNIQUE_ROWS: int = 100
     EVAL_FAST_FAILURE_THRESHOLD: float = 0.5
     # Capped at 4 by default: higher values (8-10) across multiple Celery
     # workers can cause memory pressure on smaller EC2 instances.
     EVAL_FAST_API_CONCURRENCY: int = 4
+    # Items per responses chunk task; smaller = more parallel workers and each
+    # task well under CELERY_TASK_SOFT_TIME_LIMIT.
+    EVAL_FAST_CHUNK_SIZE: int = 50
 
     @computed_field  # type: ignore[prop-decorator]
     @property