diff --git a/packages/gooddata-eval/src/gooddata_eval/cli/agentic_runner.py b/packages/gooddata-eval/src/gooddata_eval/cli/agentic_runner.py
index e8feb992e..6a430db88 100644
--- a/packages/gooddata-eval/src/gooddata_eval/cli/agentic_runner.py
+++ b/packages/gooddata-eval/src/gooddata_eval/cli/agentic_runner.py
@@ -404,6 +404,18 @@ def _apply_timings(item_report: ItemReport, timings: Any) -> None:
     item_report.simulated_user_latency_s = timings.simulated_user_s
 
 
+def _apply_best_run_latency(item_report: ItemReport, source: Any) -> None:
+    """Copy the rank-selected run's own wall time, mirroring the single-shot path's
+    ``ItemReport.best_run_latency_s`` (see ``core/runner.py``'s ``_run_one_item``).
+
+    Kinds not yet wired to measure it pass None and keep the field at its own None
+    default rather than reporting an invented number.
+    """
+    best_run_latency_s = getattr(source, "best_run_latency_s", None)
+    if best_run_latency_s is not None:
+        item_report.best_run_latency_s = best_run_latency_s
+
+
 def run_agentic_items(
     items: list[DatasetItem],
     host: str,
@@ -501,6 +513,7 @@ def _process_item(index: int, item: DatasetItem) -> ItemReport:
             item_report.response_id = response_id
             item_report.best_detail = detail or {}
             _apply_timings(item_report, getattr(outcome, "timings", None))
+            _apply_best_run_latency(item_report, outcome)
             _apply_run_counts(item_report, outcome)
             _apply_failed_runs(item_report, outcome)
             _apply_run_latencies(item_report, outcome)
@@ -512,6 +525,7 @@ def _process_item(index: int, item: DatasetItem) -> ItemReport:
             item_report.response_id = getattr(exc, "response_id", None)
             item_report.best_detail = getattr(exc, "detail", None) or {}
             _apply_timings(item_report, getattr(exc, "timings", None))
+            _apply_best_run_latency(item_report, exc)
             _apply_run_counts(item_report, exc)
             _apply_failed_runs(item_report, exc)
             _apply_run_latencies(item_report, exc)
@@ -555,6 +569,7 @@ def _process_item(index: int, item: DatasetItem) -> ItemReport:
             # runs and then raised would otherwise show up in the per-response table and not in
             # the per-conversation one.
             traces.discard()
+            _apply_best_run_latency(item_report, exc)
         finally:
             item_report.latency_s = time.perf_counter() - t0
             item_report.trace_latencies_s = traces.stop()
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/_outcome.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/_outcome.py
new file mode 100644
index 000000000..576aee838
--- /dev/null
+++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/_outcome.py
@@ -0,0 +1,123 @@
+# (C) 2026 GoodData Corporation
+"""The common tail of every ``evaluate_agentic_*`` function.
+
+Before this module, each of the agentic evaluators hand-wrote the same block: copy
+``reasoning_steps``/``conversation_id``/``response_id``/``detail``/``runs_passed``/
+``runs_effective``/``best_run_latency_s`` (and sometimes ``timings``) either onto a
+raised exception or into the returned ``AgenticEvalOutcome``. Eleven independent copies
+of the same ~7 lines meant a new universal field needed eleven edits, not one, and
+nothing failed loudly when a copy was missed -- exactly what happened to ``timings``
+(see ``AgenticAssertionError``'s docstring: "while it lived in eight copies, two
+declared timings and six did not") and again to ``best_run_latency_s`` (every agentic
+kind silently reported it as ``null`` until this was noticed and fixed kind-by-kind).
+
+``agentic_detail`` has the same motivation for the ``detail`` dict's timeline fields:
+``timeline_detail`` builds both ``latency_breakdown`` and ``tool_calls`` from the same
+events so they stay index-aligned, but roughly half the evaluators called
+``build_latency_breakdown`` directly and silently never got a ``tool_calls`` key.
+"""
+
+from __future__ import annotations
+
+from typing import Any, NoReturn
+
+from gooddata_eval.core.models import (
+    AgenticAssertionError,
+    AgenticEvalOutcome,
+    ReasoningStepEvent,
+    ToolCallEvent,
+    timeline_detail,
+)
+from gooddata_eval.core.timing import PhaseTimings
+
+__all__ = ["agentic_detail", "agentic_success", "raise_agentic_failure"]
+
+
+def agentic_detail(
+    tool_call_events: list[ToolCallEvent],
+    reasoning_step_events: list[ReasoningStepEvent] | None,
+    **kind_specific: Any,
+) -> dict:
+    """A kind's full ``detail`` dict: its own fields plus the universal timeline ones.
+
+    ``kind_specific`` comes first in the merge so a kind can never accidentally shadow
+    ``latency_breakdown``/``tool_calls`` with a same-named field of its own.
+    """
+    return {**kind_specific, **timeline_detail(tool_call_events, reasoning_step_events)}
+
+
+def raise_agentic_failure(
+    exception_cls: type[AgenticAssertionError],
+    message: str,
+    *,
+    reasoning_steps: list[str],
+    conversation_id: str,
+    response_id: str | None,
+    detail: dict,
+    runs_passed: int,
+    runs_effective: int,
+    best_run_latency_s: float | None,
+    timings: PhaseTimings | None = None,
+    failed_runs: list[dict] | None = None,
+    run_latencies_s: list[float] | None = None,
+) -> NoReturn:
+    """Build ``exception_cls(message)`` with every common field attached, and raise it.
+
+    ``exception_cls`` must be an ``AgenticAssertionError`` subclass -- that base class is
+    what declares these fields as legal targets (see its docstring). A kind whose own
+    "no verdict at all" branch raises a bare ``JudgeResponseError`` instead (not a subclass)
+    does not go through this helper for that branch.
+
+    ``timings`` stays optional: only the three kinds that track per-run ``PhaseTimings``
+    (general_question, metric_skill, dashboard_skill) pass one -- the rest keep their
+    own ``PhaseTimings()`` zero default, same as before this helper existed. ``failed_runs``
+    and ``run_latencies_s`` are likewise optional: not every kind has built them by the
+    time it raises.
+    """
+    exc = exception_cls(message)
+    exc.reasoning_steps = reasoning_steps
+    exc.conversation_id = conversation_id
+    exc.response_id = response_id
+    exc.detail = detail
+    exc.runs_passed = runs_passed
+    exc.runs_effective = runs_effective
+    exc.best_run_latency_s = best_run_latency_s
+    if timings is not None:
+        exc.timings = timings
+    if failed_runs is not None:
+        exc.failed_runs = failed_runs
+    if run_latencies_s is not None:
+        exc.run_latencies_s = run_latencies_s
+    raise exc
+
+
+def agentic_success(
+    *,
+    reasoning_steps: list[str],
+    conversation_id: str | None,
+    response_id: str | None,
+    detail: dict,
+    runs_passed: int,
+    runs_effective: int,
+    best_run_latency_s: float | None,
+    timings: PhaseTimings | None = None,
+    failed_runs: list[dict] | None = None,
+    run_latencies_s: list[float] | None = None,
+) -> AgenticEvalOutcome:
+    """The success-path mirror of ``raise_agentic_failure`` -- same fields, same shape."""
+    kwargs: dict[str, Any] = {
+        "reasoning_steps": reasoning_steps,
+        "conversation_id": conversation_id,
+        "response_id": response_id,
+        "detail": detail,
+        "runs_passed": runs_passed,
+        "runs_effective": runs_effective,
+        "best_run_latency_s": best_run_latency_s,
+    }
+    if timings is not None:
+        kwargs["timings"] = timings
+    if failed_runs is not None:
+        kwargs["failed_runs"] = failed_runs
+    if run_latencies_s is not None:
+        kwargs["run_latencies_s"] = run_latencies_s
+    return AgenticEvalOutcome(**kwargs)
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/alert_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/alert_skill.py
index 6c5a55d67..f1f532af3 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/alert_skill.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/alert_skill.py
@@ -23,6 +23,7 @@
     log_gate_scores,
     stamp_gate_metadata,
 )
+from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure
 from gooddata_eval.core.agentic._trace_linker import (
     RunIdentity,
     RunTraceContext,
@@ -700,7 +701,8 @@ class AlertRunResult:
     # also report operator/threshold/metric/recipients as False.
     exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED
     turns_used: int = 0
-    # This run's own wall time, from just before its chat call to the end of its scoring.
+    # This run's own wall time, across all its turns -- mirrors the single-shot
+    # path's best_run_latency_s (see core/runner.py's _run_one_item).
     run_latency_s: float = 0.0
 
 
@@ -975,6 +977,7 @@ def run_agentic_alert_skill(
 
     def _run_once(conv_id: str) -> AlertRunResult:
         alert_id_to_delete: str | None = None
+        run_started = time.monotonic()
         try:
             alert_id: str | None = None
             actual_args: dict = {}
@@ -1260,9 +1263,25 @@ def _write_scores(ctx: RunTraceContext) -> None:
 
     best = summary.best
     ev = best.eval
-    # max_iterations is the same for every run, so it stays at the item level rather than
-    # being repeated into each failing run's detail.
-    detail = {**_run_detail(best), "max_iterations": max_iterations}
+    detail = agentic_detail(
+        best.tool_call_events,
+        best.reasoning_step_events,
+        alert_created=ev.alert_created,
+        operator_correct=ev.operator_correct,
+        threshold_correct=ev.threshold_correct,
+        trigger_correct=ev.trigger_correct,
+        filters_correct=ev.filters_correct,
+        metric_correct=ev.metric_correct,
+        recipients_correct=ev.recipients_correct,
+        attributes_correct=ev.attributes_correct,
+        granularity_correct=ev.granularity_correct,
+        actual_alert_arguments=best.actual_alert_arguments,
+        # Why the loop stopped. alert_created=False alone cannot tell a refusal from a run
+        # that hit max_iterations while still on track -- see LoopExit.
+        exit_reason=best.exit_reason.value,
+        turns_used=best.turns_used,
+        max_iterations=max_iterations,
+    )
     # Same predicate runs_passed is taken over, so an item's failed_runs and its counts
     # cannot disagree about which runs failed.
     failed_runs = build_failed_runs(
@@ -1273,29 +1292,34 @@ def _write_scores(ctx: RunTraceContext) -> None:
 
     if not gate_passed(gate, pass_at_k=summary.pass_at_k, pass_power_k=summary.pass_power_k):
         gate_note = gate_failure_note(gate, runs_passed, runs_effective)
-        exc = AlertSkillAssertionError(
+        raise_agentic_failure(
+            AlertSkillAssertionError,
             f"Alert skill assertion failed. {gate_note} strict_pass={ev.strict_pass}. "
-            + ", ".join(f"{name}={value}" for name, value in ev.checks().items())
-            + f". Actual args: {best.actual_alert_arguments}"
+            f"alert_created={ev.alert_created}, operator_correct={ev.operator_correct}, "
+            f"threshold_correct={ev.threshold_correct}, trigger_correct={ev.trigger_correct}, "
+            f"filters_correct={ev.filters_correct}, metric_correct={ev.metric_correct}, "
+            f"recipients_correct={ev.recipients_correct}, "
+            f"attributes_correct={ev.attributes_correct}, "
+            f"granularity_correct={ev.granularity_correct}. "
+            f"Actual args: {best.actual_alert_arguments}",
+            reasoning_steps=best.reasoning_steps,
+            conversation_id=best.conversation_id,
+            response_id=best.response_id,
+            detail=detail,
+            runs_passed=runs_passed,
+            runs_effective=runs_effective,
+            failed_runs=failed_runs,
+            run_latencies_s=[r.run_latency_s for r in summary.run_results],
+            best_run_latency_s=best.run_latency_s,
         )
-        exc.reasoning_steps = best.reasoning_steps
-        exc.conversation_id = best.conversation_id
-        exc.response_id = best.response_id
-        exc.detail = detail
-        exc.runs_passed = runs_passed
-        exc.runs_effective = runs_effective
-        exc.failed_runs = failed_runs
-        exc.run_latencies_s = [r.run_latency_s for r in summary.run_results]
-        raise exc
-    return AgenticEvalOutcome(
-        runs_passed=runs_passed,
-        runs_effective=runs_effective,
+    return agentic_success(
         reasoning_steps=best.reasoning_steps,
         conversation_id=best.conversation_id,
         response_id=best.response_id,
         detail=detail,
-        # Also on the success path: pass@K clears the gate with one passing run, so a
-        # 1/3 item reports success while two of its runs failed for reasons worth reading.
+        runs_passed=runs_passed,
+        runs_effective=runs_effective,
         failed_runs=failed_runs,
         run_latencies_s=[r.run_latency_s for r in summary.run_results],
+        best_run_latency_s=best.run_latency_s,
     )
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/anomaly_detection.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/anomaly_detection.py
index 1a4238983..25f2281a0 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/anomaly_detection.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/anomaly_detection.py
@@ -41,6 +41,7 @@
     log_gate_scores,
     stamp_gate_metadata,
 )
+from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure
 from gooddata_eval.core.agentic._trace_linker import (
     RunIdentity,
     RunTraceContext,
@@ -58,9 +59,9 @@
     AgenticAssertionError,
     AgenticEvalOutcome,
     ChatResult,
+    LoopExit,
     ReasoningStepEvent,
     ToolCallEvent,
-    build_latency_breakdown,
     shift_and_index_events,
 )
 
@@ -285,8 +286,14 @@ class AnomalyRunResult:
     response_id: str | None = None
     tool_call_events: list[ToolCallEvent] = field(default_factory=list)
     reasoning_step_events: list[ReasoningStepEvent] = field(default_factory=list)
-    # This run's own wall time, from just before its chat call to the end of its scoring.
+    # This run's own wall time, across all its turns -- mirrors the single-shot
+    # path's best_run_latency_s (see core/runner.py's _run_one_item). Distinct from
+    # turn_wall_clock_sec above, which is only the final triggering turn.
     run_latency_s: float = 0.0
+    # Why the simulated-user loop stopped -- see LoopExit. `triggered=False` alone cannot
+    # separate a refusal from a run that hit max_iterations while still on track (matches
+    # kda_skill.py/alert_skill.py).
+    exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED
 
 
 @dataclass
@@ -371,6 +378,7 @@ def run_agentic_anomaly_detection(
     )
 
     def _run_once(conv_id: str) -> AnomalyRunResult:
+        run_started = time.monotonic()
         viz_args: dict | None = None
         execute_result: dict | None = None
         turn_wall_clock_sec: float | None = None
@@ -397,6 +405,10 @@ def _accumulate(result: ChatResult) -> None:
             all_reasoning_step_events.extend(result.reasoning_step_events or [])
 
         run_started = time.monotonic()
+        # Defaults to BUDGET_EXHAUSTED: every other exit assigns explicitly, so a loop that
+        # simply runs out of range() is labelled correctly with no trailing else.
+        exit_reason = LoopExit.BUDGET_EXHAUSTED
+
         for iteration in range(max_iterations):
             try:
                 chat_result = client.send_message(conv_id, current_question)
@@ -409,6 +421,7 @@ def _accumulate(result: ChatResult) -> None:
                     _accumulate(partial)
                     viz_args, execute_result = _extract_anomaly_calls(all_tool_call_events)
                 turn_completed = False
+                exit_reason = LoopExit.CHAT_ERROR
                 break
             reasoning_steps.extend(chat_result.reasoning_steps or [])
             response_id = chat_result.response_id or response_id
@@ -422,8 +435,10 @@ def _accumulate(result: ChatResult) -> None:
             if execute_result is not None:
                 # The turn that ran the detection, not an earlier disambiguation turn.
                 turn_wall_clock_sec = chat_result.turn_wall_clock_sec
+                exit_reason = LoopExit.SUCCESS
                 break
             if not response_text:
+                exit_reason = LoopExit.AGENT_SILENT
                 break
             if iteration >= max_iterations - 1:
                 break
@@ -432,6 +447,7 @@ def _accumulate(result: ChatResult) -> None:
                 disambiguated = True
             except Exception as exc:  # noqa: BLE001 -- harness-side fault; end only this run
                 _log.warning("Simulated anomaly user reply failed for conversation %s: %s", conv_id, exc)
+                exit_reason = LoopExit.SIMULATED_USER_FAILED
                 break
 
         return AnomalyRunResult(
@@ -440,6 +456,7 @@ def _accumulate(result: ChatResult) -> None:
             actual_visualization=viz_args,
             actual_execute_result=execute_result,
             turn_wall_clock_sec=turn_wall_clock_sec,
+            exit_reason=exit_reason,
             reasoning_steps=reasoning_steps,
             response_id=response_id,
             tool_call_events=all_tool_call_events,
@@ -493,25 +510,29 @@ class AnomalyDetectionAssertionError(AgenticAssertionError):
 
 def _detail(best: AnomalyRunResult) -> dict[str, Any]:
     ev = best.evaluation
-    return {
-        "triggered": ev.triggered,
-        "executed": ev.executed,
-        "success": ev.success,
-        "turn_completed": ev.turn_completed,
-        "metric_correct": ev.metric_correct,
-        "granularity_correct": ev.granularity_correct,
+    return agentic_detail(
+        best.tool_call_events,
+        best.reasoning_step_events,
+        triggered=ev.triggered,
+        executed=ev.executed,
+        success=ev.success,
+        turn_completed=ev.turn_completed,
+        metric_correct=ev.metric_correct,
+        granularity_correct=ev.granularity_correct,
         # Which content checks the fixture pinned -- without it a run that verified nothing
         # reads the same as one where everything matched.
-        "asserted": ev.asserted,
-        "disambiguated": ev.disambiguated,
-        "actual_metrics": sorted(_metric_uris(best.actual_visualization)),
-        "actual_granularity": _inferred_granularity(best.actual_visualization),
+        asserted=ev.asserted,
+        disambiguated=ev.disambiguated,
+        actual_metrics=sorted(_metric_uris(best.actual_visualization)),
+        actual_granularity=_inferred_granularity(best.actual_visualization),
         # Reported, never asserted: whether a real series contains anomalies is a property
         # of the data, so a fixture demanding some would fail on the next warehouse refresh.
-        "anomaly_point_count": _point_count(best.actual_execute_result),
-        "actual_execute_result": best.actual_execute_result,
-        "latency_breakdown": build_latency_breakdown(best.tool_call_events, best.reasoning_step_events),
-    }
+        anomaly_point_count=_point_count(best.actual_execute_result),
+        actual_execute_result=best.actual_execute_result,
+        # Why the loop stopped. triggered=False alone cannot tell a refusal from a run
+        # that hit max_iterations while still on track -- see LoopExit.
+        exit_reason=best.exit_reason.value,
+    )
 
 
 def evaluate_agentic_anomaly_detection(
@@ -648,24 +669,28 @@ def _write_scores(ctx: RunTraceContext) -> None:
             f"Analysed {detail['actual_metrics']} at {detail['actual_granularity']}. "
             f"Actual execute result: {best.actual_execute_result}."
         )
-        exc = AnomalyDetectionAssertionError(message)
-        exc.reasoning_steps = best.reasoning_steps
-        exc.conversation_id = best.conversation_id
-        exc.response_id = best.response_id
-        exc.detail = detail
-        exc.runs_passed = runs_passed
-        exc.runs_effective = len(summary.run_results)
-        exc.failed_runs = failed_runs
-        exc.run_latencies_s = [r.run_latency_s for r in summary.run_results]
-        raise exc
-
-    return AgenticEvalOutcome(
-        runs_passed=runs_passed,
-        runs_effective=len(summary.run_results),
+        raise_agentic_failure(
+            AnomalyDetectionAssertionError,
+            message,
+            reasoning_steps=best.reasoning_steps,
+            conversation_id=best.conversation_id,
+            response_id=best.response_id,
+            detail=detail,
+            runs_passed=runs_passed,
+            runs_effective=len(summary.run_results),
+            failed_runs=failed_runs,
+            run_latencies_s=[r.run_latency_s for r in summary.run_results],
+            best_run_latency_s=best.run_latency_s,
+        )
+
+    return agentic_success(
         reasoning_steps=best.reasoning_steps,
         conversation_id=best.conversation_id,
         response_id=best.response_id,
         detail=detail,
+        runs_passed=runs_passed,
+        runs_effective=len(summary.run_results),
         failed_runs=failed_runs,
         run_latencies_s=[r.run_latency_s for r in summary.run_results],
+        best_run_latency_s=best.run_latency_s,
     )
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/conversation.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/conversation.py
index e980958bc..92f106340 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/conversation.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/conversation.py
@@ -56,6 +56,7 @@
     summarize_visualizations,
 )
 from gooddata_eval.core.agentic._gate import log_gate_scores
+from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure
 from gooddata_eval.core.agentic._trace_linker import (
     RunIdentity,
     RunTraceContext,
@@ -82,7 +83,6 @@
     ReasoningStepEvent,
     ToolCallEvent,
     shift_and_index_events,
-    timeline_detail,
 )
 from gooddata_eval.core.scoring import (
     check_filters,
@@ -729,8 +729,10 @@ class ConversationResult:
     stalled_turns: int = 0
     mode: ConversationMode = "legacy"
     judge_model: str | None = None
-    # The whole conversation's wall time, from just before its first message to the end of its
-    # last turn's scoring; conversation create/delete is not part of it.
+    # This conversation's own wall time, across every turn -- mirrors the single-shot
+    # path's best_run_latency_s (see core/runner.py's _run_one_item). There is no
+    # K-of-N selection for this kind (see run_agentic_conversation's docstring), so
+    # this is simply the one conversation's own time, not a "best of" pick.
     run_latency_s: float = 0.0
 
 
@@ -857,6 +859,7 @@ def run_agentic_conversation(
     A fixture with ``expects_clarification`` needs ``context`` mode: legacy mode neither sends
     ``clarifying_answers`` nor lets the clarification checks fail the item, so it raises ``ValueError``.
     """
+    run_started = time.monotonic()
     resolved_mode = resolve_conversation_mode(mode)
     graded = [t.turn_id for t in fixture.turns if t.expects_clarification is not None]
     if resolved_mode == "legacy" and graded:
@@ -1307,21 +1310,22 @@ def run_agentic_conversation(
 
 
 def _conversation_detail(result: ConversationResult) -> dict:
-    return {
-        "mode": result.mode,
-        "full_skill_coverage": result.full_skill_coverage,
-        "conversation_success": result.conversation_success,
-        "context_success": result.context_success,
-        "context_kept_rate": result.context_kept_rate,
-        "turns_before_first_break": result.turns_before_first_break,
-        "lost_context_clarifications": result.lost_context_clarifications,
-        "stalled_turns": result.stalled_turns,
-        "total_clarification_turns": result.total_clarification_turns,
-        "max_clarification_turns": result.max_clarification_turns,
-        "judge_model": result.judge_model,
-        "turns": [tr.detail() for tr in result.turn_results],
-        **timeline_detail(result.tool_call_events, result.reasoning_step_events),
-    }
+    return agentic_detail(
+        result.tool_call_events,
+        result.reasoning_step_events,
+        mode=result.mode,
+        full_skill_coverage=result.full_skill_coverage,
+        conversation_success=result.conversation_success,
+        context_success=result.context_success,
+        context_kept_rate=result.context_kept_rate,
+        turns_before_first_break=result.turns_before_first_break,
+        lost_context_clarifications=result.lost_context_clarifications,
+        stalled_turns=result.stalled_turns,
+        total_clarification_turns=result.total_clarification_turns,
+        max_clarification_turns=result.max_clarification_turns,
+        judge_model=result.judge_model,
+        turns=[tr.detail() for tr in result.turn_results],
+    )
 
 
 class ConversationAssertionError(AgenticAssertionError):
@@ -1508,18 +1512,21 @@ def _write_scores(ctx: RunTraceContext) -> None:
                 f"full_skill_coverage={result.full_skill_coverage}. "
                 f"Failed turns: {legacy_failed}"
             )
-        exc = ConversationAssertionError(message)
-        exc.reasoning_steps = result.reasoning_steps
-        exc.conversation_id = result.conversation_id
-        exc.response_id = result.response_id
-        exc.detail = detail
         # This kind takes no k and drives its fixture exactly once, whatever --runs asks
         # for. Saying so explicitly stops the report claiming K runs that never happened.
-        exc.runs_passed = 0
-        exc.runs_effective = 1
-        exc.run_latencies_s = [result.run_latency_s]
-        raise exc
-    return AgenticEvalOutcome(
+        raise_agentic_failure(
+            ConversationAssertionError,
+            message,
+            reasoning_steps=result.reasoning_steps,
+            conversation_id=result.conversation_id,
+            response_id=result.response_id,
+            detail=detail,
+            runs_passed=0,
+            runs_effective=1,
+            run_latencies_s=[result.run_latency_s],
+            best_run_latency_s=result.run_latency_s,
+        )
+    return agentic_success(
         reasoning_steps=result.reasoning_steps,
         conversation_id=result.conversation_id,
         response_id=result.response_id,
@@ -1527,4 +1534,5 @@ def _write_scores(ctx: RunTraceContext) -> None:
         runs_passed=1,
         runs_effective=1,
         run_latencies_s=[result.run_latency_s],
+        best_run_latency_s=result.run_latency_s,
     )
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py
index fdb797c09..35de92558 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py
@@ -18,6 +18,7 @@
     log_gate_scores,
     stamp_gate_metadata,
 )
+from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure
 from gooddata_eval.core.agentic._trace_linker import (
     RunIdentity,
     RunTraceContext,
@@ -28,20 +29,21 @@
     utc_now,
 )
 from gooddata_eval.core.chat.render import render_answer_text
-from gooddata_eval.core.chat.sse_client import ChatClient
+from gooddata_eval.core.chat.sse_client import ChatClient, ChatError
 from gooddata_eval.core.config import ReasoningEffort
 from gooddata_eval.core.langfuse.item_scope import item_scope
 from gooddata_eval.core.models import (
     AgenticAssertionError,
     AgenticEvalOutcome,
     ChatResult,
+    LoopExit,
     ReasoningStepEvent,
     ToolCallEvent,
     build_latency_breakdown,
     shift_and_index_events,
 )
 from gooddata_eval.core.scoring import AAC_VISUALIZATION_TYPES, same_viz_type
-from gooddata_eval.core.timing import PhaseTimings, log_timer, sum_timings
+from gooddata_eval.core.timing import PhaseTimings, log_timer, run_latency_s, sum_timings
 
 _DEFAULT_K = 1
 # Matches kda_skill and visualization. The reply this loop sends is built from the expectation
@@ -1492,6 +1494,12 @@ class DashboardRunResult:
     timings: PhaseTimings = field(default_factory=PhaseTimings)
     # This run's own wall time, from just before its chat call to the end of its scoring.
     run_latency_s: float = 0.0
+    # Why the loop stopped -- see LoopExit. A dashboard not produced alone cannot tell a
+    # refusal from a run that hit max_iterations while still on track (matches
+    # kda_skill.py/alert_skill.py). CHAT_ERROR is reachable; SIMULATED_USER_FAILED is not --
+    # this loop's follow-up is built from the expectation by build_simulated_reply, with no
+    # judge call that could fail.
+    exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED
 
 
 @dataclass
@@ -1738,12 +1746,43 @@ def _execute_single_dashboard_run(
     turn_offset = 0.0
     tool_index_offset = 0
     reasoning_index_offset = 0
+    # Defaults to BUDGET_EXHAUSTED: every other exit assigns explicitly, so a loop that
+    # simply runs out of range() (or the is_edit "no reply of its own" branch below, which
+    # is the same shape of outcome -- the agent answered, just not with the dashboard tool)
+    # is labelled correctly with no trailing else.
+    exit_reason = LoopExit.BUDGET_EXHAUSTED
 
     run_started = time.monotonic()
     for iteration in range(max_iterations):
         turns += 1
         agent_started = time.monotonic()
-        chat_result = client.send_message(conversation_id, current_question)
+        try:
+            chat_result = client.send_message(conversation_id, current_question)
+        except ChatError as exc:
+            # Recorded rather than left to escape: this runs inside one of K runs, so an
+            # uncaught ChatError discarded every run already completed along with this one's
+            # exit_reason, and the item surfaced as a bare error with no per-run diagnosis.
+            # Matches metric_skill.py and conversation.py, which record it the same way.
+            timings.agent_s += time.monotonic() - agent_started
+            print(f"[CHAT] send_message failed for conversation {conversation_id}: {exc}")
+            partial = exc.partial_result
+            if partial is not None:
+                # Shifted and indexed exactly as a completed turn is, before anything reads
+                # the events: left raw, a late turn's call_ts restarts near zero and
+                # timeline_detail reports it as overlapping the first one.
+                reasoning_steps.extend(partial.reasoning_steps or [])
+                response_id = partial.response_id or response_id
+                turn_offset, tool_index_offset, reasoning_index_offset = shift_and_index_events(
+                    partial,
+                    turn_offset=turn_offset,
+                    tool_index_offset=tool_index_offset,
+                    reasoning_index_offset=reasoning_index_offset,
+                )
+                all_tool_call_events.extend(partial.tool_call_events or [])
+                all_reasoning_step_events.extend(partial.reasoning_step_events or [])
+                steps += partial.reasoning_step_count
+            exit_reason = LoopExit.CHAT_ERROR
+            break
         agent_elapsed = time.monotonic() - agent_started
         timings.agent_s += agent_elapsed
         reasoning_steps.extend(chat_result.reasoning_steps or [])
@@ -1778,10 +1817,12 @@ def _execute_single_dashboard_run(
             dashboard_part = _extract_dashboard_part(chat_result, "dashboard")
             if is_edit:
                 patch_part = _extract_dashboard_part(chat_result, _PATCH_TYPE)
+            exit_reason = LoopExit.SUCCESS
             break
 
         response_text = (chat_result.text_response or "").strip() or render_answer_text(chat_result)
         if not response_text and not chat_result.tool_call_events:
+            exit_reason = LoopExit.AGENT_SILENT
             break
         if iteration >= max_iterations - 1:
             break
@@ -1817,6 +1858,7 @@ def _execute_single_dashboard_run(
         reasoning_step_events=all_reasoning_step_events,
         timings=timings,
         run_latency_s=time.monotonic() - run_started,
+        exit_reason=exit_reason,
     )
 
 
@@ -2003,7 +2045,17 @@ def _write_scores(ctx: RunTraceContext) -> None:
     runs_effective = len(summary.run_results)
 
     best = summary.best
-    detail: dict[str, Any] = _run_detail(best)
+    detail: dict[str, Any] = agentic_detail(
+        best.tool_call_events,
+        best.reasoning_step_events,
+        **best.evaluation.strict_checks,
+        **best.evaluation.diagnostics,
+        failures=best.evaluation.failures,
+        notes=best.evaluation.notes,
+        # Why the loop stopped. A dashboard not produced alone cannot tell a refusal from
+        # a run that hit max_iterations while still on track -- see LoopExit.
+        exit_reason=best.exit_reason.value,
+    )
     # Same predicate runs_passed is taken over, so an item's failed_runs and its counts
     # cannot disagree about which runs failed.
     failed_runs = build_failed_runs(
@@ -2031,30 +2083,32 @@ def _write_scores(ctx: RunTraceContext) -> None:
                 " one feature flag registers both, so check that before the model."
             )
         notes = "; ".join(best.evaluation.notes)
-        exc = DashboardSkillAssertionError(
+        raise_agentic_failure(
+            DashboardSkillAssertionError,
             f"Dashboard skill assertion failed. {gate_note}{skill_note} "
             f"Checks: {best.evaluation.strict_checks}. "
             f"Failures: {'; '.join(best.evaluation.failures) or 'none reported'}."
-            + (f" Notes (not scored): {notes}." if notes else "")
+            + (f" Notes (not scored): {notes}." if notes else ""),
+            reasoning_steps=best.reasoning_steps,
+            conversation_id=best.conversation_id,
+            response_id=best.response_id,
+            detail=detail,
+            runs_passed=runs_passed,
+            runs_effective=runs_effective,
+            best_run_latency_s=run_latency_s(best.timings),
+            timings=item_timings,
+            failed_runs=failed_runs,
+            run_latencies_s=[r.run_latency_s for r in summary.run_results],
         )
-        exc.reasoning_steps = best.reasoning_steps
-        exc.conversation_id = best.conversation_id
-        exc.response_id = best.response_id
-        exc.timings = item_timings
-        exc.detail = detail
-        exc.runs_passed = runs_passed
-        exc.runs_effective = runs_effective
-        exc.failed_runs = failed_runs
-        exc.run_latencies_s = [r.run_latency_s for r in summary.run_results]
-        raise exc
-    return AgenticEvalOutcome(
-        runs_passed=runs_passed,
-        runs_effective=runs_effective,
+    return agentic_success(
         reasoning_steps=best.reasoning_steps,
         conversation_id=best.conversation_id,
         response_id=best.response_id,
         detail=detail,
-        timings=item_timings,
+        runs_passed=runs_passed,
+        runs_effective=runs_effective,
         failed_runs=failed_runs,
         run_latencies_s=[r.run_latency_s for r in summary.run_results],
+        best_run_latency_s=run_latency_s(best.timings),
+        timings=item_timings,
     )
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/general_question.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/general_question.py
index 5de9512d5..3190d7754 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/general_question.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/general_question.py
@@ -15,6 +15,7 @@
     log_gate_scores,
     stamp_gate_metadata,
 )
+from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure
 from gooddata_eval.core.agentic._trace_linker import (
     RunIdentity,
     RunTraceContext,
@@ -37,7 +38,7 @@
     ToolCallEvent,
     build_latency_breakdown,
 )
-from gooddata_eval.core.timing import PhaseTimings, log_timer, sum_timings
+from gooddata_eval.core.timing import PhaseTimings, log_timer, run_latency_s, sum_timings
 
 _DEFAULT_K = 1
 
@@ -230,6 +231,7 @@ def _attach_diagnostics(
     runs_passed: int,
     runs_effective: int,
     run_latencies_s: list[float],
+    best_run_latency_s: float | None,
 ) -> None:
     """Hang the report payload on a raised error, whichever error it is.
 
@@ -245,6 +247,7 @@ def _attach_diagnostics(
     error.runs_effective = runs_effective
     error.failed_runs = failed_runs
     error.run_latencies_s = run_latencies_s
+    error.best_run_latency_s = best_run_latency_s
 
 
 def _run_detail(run: GeneralQuestionResult) -> dict:
@@ -373,13 +376,17 @@ def _write_scores(ctx: RunTraceContext) -> None:
     run_latencies_s = [r.run_latency_s for r in summary.run_results]
 
     best = summary.best
-    detail = {
-        **_run_detail(best),
+    detail = agentic_detail(
+        best.tool_call_events,
+        best.reasoning_step_events,
+        judge_passed=best.passed,
+        judge_reasoning=best.reasoning,
+        actual_output=best.actual_output,
         # Only present when it happened, so the usual JSON shape is unchanged. A
         # pass@K computed over fewer runs than --runs asked for is a weaker result and
         # the report has to say so.
         **({"unscored_runs": len(unscored), "judge_errors": unscored} if unscored else {}),
-    }
+    )
     # An ungraded run has no verdict, so `r.passed` is not a claim about it -- treat it as
     # non-passing here so it is recorded with its judge_error rather than silently dropped.
     failed_runs = build_failed_runs(
@@ -397,28 +404,37 @@ def _write_scores(ctx: RunTraceContext) -> None:
             f"judge returned no readable verdict for any of the {len(summary.run_results)} run(s): "
             + " | ".join(unscored)
         )
-        _attach_diagnostics(error, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s)
+        _attach_diagnostics(
+            error, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s, run_latency_s(best.timings)
+        )
         error.timings = item_timings
         raise error
 
     if not gate_passed(gate, pass_at_k=summary.pass_at_k, pass_power_k=summary.pass_power_k):
         gate_note = gate_failure_note(gate, runs_passed, runs_effective, len(unscored))
-        exc = GeneralQuestionAssertionError(
-            f"General question assertion failed. {gate_note} passed={best.passed}. Reasoning: {best.reasoning}"
+        raise_agentic_failure(
+            GeneralQuestionAssertionError,
+            f"General question assertion failed. {gate_note} passed={best.passed}. Reasoning: {best.reasoning}",
+            reasoning_steps=best.reasoning_steps,
+            conversation_id=best.conversation_id,
+            response_id=best.response_id,
+            detail=detail,
+            runs_passed=runs_passed,
+            runs_effective=runs_effective,
+            failed_runs=failed_runs,
+            run_latencies_s=run_latencies_s,
+            best_run_latency_s=run_latency_s(best.timings),
+            timings=item_timings,
         )
-        _attach_diagnostics(exc, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s)
-        exc.timings = item_timings
-        raise exc
-    return AgenticEvalOutcome(
-        runs_passed=runs_passed,
-        runs_effective=runs_effective,
+    return agentic_success(
         reasoning_steps=best.reasoning_steps,
         conversation_id=best.conversation_id,
         response_id=best.response_id,
         detail=detail,
-        timings=item_timings,
-        # Also on the success path: pass@K clears the gate with one passing run, so a
-        # 1/3 item reports success while two of its runs failed for reasons worth reading.
+        runs_passed=runs_passed,
+        runs_effective=runs_effective,
         failed_runs=failed_runs,
         run_latencies_s=run_latencies_s,
+        best_run_latency_s=run_latency_s(best.timings),
+        timings=item_timings,
     )
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/guardrail.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/guardrail.py
index 81f9cb1ad..f9e281c2d 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/guardrail.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/guardrail.py
@@ -15,6 +15,7 @@
     log_gate_scores,
     stamp_gate_metadata,
 )
+from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure
 from gooddata_eval.core.agentic._trace_linker import (
     RunIdentity,
     RunTraceContext,
@@ -87,7 +88,8 @@ class GuardrailResult:
     # Set when the judge returned something unreadable for THIS run. Excluded from pass@K
     # and from Langfuse scoring rather than counted as a failure -- see score_run.
     judge_error: str | None = None
-    # This run's own wall time, from just before its chat call to the end of its scoring.
+    # This run's own wall time (agent call + its grading) -- mirrors the single-shot
+    # path's best_run_latency_s (see core/runner.py's _run_one_item).
     run_latency_s: float = 0.0
 
 
@@ -211,6 +213,7 @@ def _attach_diagnostics(
     runs_passed: int,
     runs_effective: int,
     run_latencies_s: list[float],
+    best_run_latency_s: float | None,
 ) -> None:
     """Hang the report payload on a raised error, whichever error it is.
 
@@ -226,6 +229,7 @@ def _attach_diagnostics(
     error.runs_effective = runs_effective
     error.failed_runs = failed_runs
     error.run_latencies_s = run_latencies_s
+    error.best_run_latency_s = best_run_latency_s
 
 
 def _run_detail(run: GuardrailResult) -> dict:
@@ -354,12 +358,16 @@ def _write_scores(ctx: RunTraceContext) -> None:
     run_latencies_s = [r.run_latency_s for r in summary.run_results]
 
     best = summary.best
-    detail = {
-        **_run_detail(best),
+    detail = agentic_detail(
+        best.tool_call_events,
+        best.reasoning_step_events,
+        judge_passed=best.passed,
+        judge_reasoning=best.reasoning,
+        actual_output=best.actual_output,
         # Only present when it happened, so the usual JSON shape is unchanged. A
         # pass@K over fewer runs than --runs asked for is a weaker result.
         **({"unscored_runs": len(unscored), "judge_errors": unscored} if unscored else {}),
-    }
+    )
     # An ungraded run has no verdict, so `r.passed` is not a claim about it -- treat it as
     # non-passing here so it is recorded with its judge_error rather than silently dropped.
     failed_runs = build_failed_runs(
@@ -375,25 +383,34 @@ def _write_scores(ctx: RunTraceContext) -> None:
             f"judge returned no readable verdict for any of the {len(summary.run_results)} run(s): "
             + " | ".join(unscored)
         )
-        _attach_diagnostics(error, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s)
+        _attach_diagnostics(
+            error, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s, best.run_latency_s
+        )
         raise error
 
     if not gate_passed(gate, pass_at_k=summary.pass_at_k, pass_power_k=summary.pass_power_k):
         gate_note = gate_failure_note(gate, runs_passed, runs_effective, len(unscored))
-        exc = GuardrailAssertionError(
-            f"Guardrail assertion failed. {gate_note} passed={best.passed}. Reasoning: {best.reasoning}"
+        raise_agentic_failure(
+            GuardrailAssertionError,
+            f"Guardrail assertion failed. {gate_note} passed={best.passed}. Reasoning: {best.reasoning}",
+            reasoning_steps=best.reasoning_steps,
+            conversation_id=best.conversation_id,
+            response_id=best.response_id,
+            detail=detail,
+            runs_passed=runs_passed,
+            runs_effective=runs_effective,
+            failed_runs=failed_runs,
+            run_latencies_s=run_latencies_s,
+            best_run_latency_s=best.run_latency_s,
         )
-        _attach_diagnostics(exc, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s)
-        raise exc
-    return AgenticEvalOutcome(
-        runs_passed=runs_passed,
-        runs_effective=runs_effective,
+    return agentic_success(
         reasoning_steps=best.reasoning_steps,
         conversation_id=best.conversation_id,
         response_id=best.response_id,
         detail=detail,
-        # Also on the success path: pass@K clears the gate with one passing run, so a
-        # 1/3 item reports success while two of its runs failed for reasons worth reading.
+        runs_passed=runs_passed,
+        runs_effective=runs_effective,
         failed_runs=failed_runs,
         run_latencies_s=run_latencies_s,
+        best_run_latency_s=best.run_latency_s,
     )
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/kda_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/kda_skill.py
index 7ab93c40a..683f8d42d 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/kda_skill.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/kda_skill.py
@@ -19,6 +19,7 @@
     log_gate_scores,
     stamp_gate_metadata,
 )
+from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure
 from gooddata_eval.core.agentic._trace_linker import (
     RunIdentity,
     RunTraceContext,
@@ -201,7 +202,9 @@ class KdaRunResult:
     # separate a refusal from a run that hit max_iterations while still on track.
     exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED
     turns_used: int = 0
-    # This run's own wall time, from just before its chat call to the end of its scoring.
+    # This run's own wall time, across all its turns -- mirrors the single-shot
+    # path's best_run_latency_s (see core/runner.py's _run_one_item). Distinct from
+    # turn_wall_clock_sec above, which is only the final create-triggering turn.
     run_latency_s: float = 0.0
 
 
@@ -271,6 +274,7 @@ def run_agentic_kda_skill(
     )
 
     def _run_once(conv_id: str) -> KdaRunResult:
+        run_started = time.monotonic()
         create_args: dict | None = None
         execute_result: dict | None = None
         turn_wall_clock_sec: float | None = None
@@ -562,9 +566,21 @@ def _write_scores(ctx: RunTraceContext) -> None:
 
     best = summary.best
     ev = best.evaluation
-    # max_iterations is the same for every run, so it stays at the item level rather than
-    # being repeated into each failing run's detail.
-    detail = {**_run_detail(best), "max_iterations": max_iterations}
+    detail = agentic_detail(
+        best.tool_call_events,
+        best.reasoning_step_events,
+        triggered=ev.triggered,
+        executed=ev.executed,
+        success=ev.success,
+        turn_completed=ev.turn_completed,
+        disambiguated=ev.disambiguated,
+        actual_create_args=best.actual_create_args,
+        actual_execute_result=best.actual_execute_result,
+        # Why the loop stopped -- see LoopExit.
+        exit_reason=best.exit_reason.value,
+        turns_used=best.turns_used,
+        max_iterations=max_iterations,
+    )
     # Same predicate runs_passed is taken over, so an item's failed_runs and its counts
     # cannot disagree about which runs failed.
     failed_runs = build_failed_runs(
@@ -582,25 +598,27 @@ def _write_scores(ctx: RunTraceContext) -> None:
             f"Actual create args: {best.actual_create_args}. "
             f"Actual execute result: {best.actual_execute_result}."
         )
-        exc = KdaSkillAssertionError(message)
-        exc.reasoning_steps = best.reasoning_steps
-        exc.conversation_id = best.conversation_id
-        exc.response_id = best.response_id
-        exc.detail = detail
-        exc.runs_passed = runs_passed
-        exc.runs_effective = runs_effective
-        exc.failed_runs = failed_runs
-        exc.run_latencies_s = [r.run_latency_s for r in summary.run_results]
-        raise exc
-    return AgenticEvalOutcome(
-        runs_passed=runs_passed,
-        runs_effective=runs_effective,
+        raise_agentic_failure(
+            KdaSkillAssertionError,
+            message,
+            reasoning_steps=best.reasoning_steps,
+            conversation_id=best.conversation_id,
+            response_id=best.response_id,
+            detail=detail,
+            runs_passed=runs_passed,
+            runs_effective=runs_effective,
+            failed_runs=failed_runs,
+            run_latencies_s=[r.run_latency_s for r in summary.run_results],
+            best_run_latency_s=best.run_latency_s,
+        )
+    return agentic_success(
         reasoning_steps=best.reasoning_steps,
         conversation_id=best.conversation_id,
         response_id=best.response_id,
         detail=detail,
-        # Also on the success path: pass@K clears the gate with one passing run, so a
-        # 1/3 item reports success while two of its runs failed for reasons worth reading.
+        runs_passed=runs_passed,
+        runs_effective=runs_effective,
         failed_runs=failed_runs,
         run_latencies_s=[r.run_latency_s for r in summary.run_results],
+        best_run_latency_s=best.run_latency_s,
     )
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/metric_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/metric_skill.py
index 464cf592e..f662b205b 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/metric_skill.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/metric_skill.py
@@ -21,6 +21,7 @@
     log_gate_scores,
     stamp_gate_metadata,
 )
+from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure
 from gooddata_eval.core.agentic._trace_linker import (
     RunIdentity,
     RunTraceContext,
@@ -44,7 +45,7 @@
     shift_and_index_events,
     timeline_detail,
 )
-from gooddata_eval.core.timing import PhaseTimings, log_timer, sum_timings
+from gooddata_eval.core.timing import PhaseTimings, log_timer, run_latency_s, sum_timings
 
 try:
     from openai import OpenAI as _OpenAI
@@ -630,9 +631,19 @@ def _run_detail(run: MetricRunResult) -> dict:
             **timeline_detail(run.tool_call_events, run.reasoning_step_events),
         }
 
-    # max_iterations is the same for every run, so it stays at the item level rather than
-    # being repeated into each failing run's detail.
-    detail = {**_run_detail(best), "max_iterations": max_iterations}
+    detail = agentic_detail(
+        best.tool_call_events,
+        best.reasoning_step_events,
+        metric_created=best.metric_created,
+        maql_correct=best.maql_correct,
+        expected_maql_candidates=[c.get("maql", "") for c in expected_outputs_list],
+        actual_maql=best.actual_maql,
+        # Why the loop stopped. metric_created=False alone cannot tell a refusal from a run
+        # that hit max_iterations while still on track -- see LoopExit.
+        exit_reason=best.exit_reason.value,
+        turns_used=best.turns_used,
+        max_iterations=max_iterations,
+    )
     # Same predicate runs_passed is taken over, so an item's failed_runs and its counts
     # cannot disagree about which runs failed.
     failed_runs = build_failed_runs(
@@ -644,32 +655,32 @@ def _run_detail(run: MetricRunResult) -> dict:
     if not gate_passed(gate, pass_at_k=summary.pass_at_k, pass_power_k=summary.pass_power_k):
         gate_note = gate_failure_note(gate, runs_passed, runs_effective)
         candidates_str = "; ".join(repr(c.get("maql", "")) for c in expected_outputs_list)
-        exc = MetricSkillAssertionError(
+        raise_agentic_failure(
+            MetricSkillAssertionError,
             f"Metric skill assertion failed. {gate_note} "
             f"metric_created={best.metric_created}, maql_correct={best.maql_correct}. "
             f"Expected MAQL (candidates): {candidates_str}. "
-            f"Actual MAQL: {best.actual_maql}."
+            f"Actual MAQL: {best.actual_maql}.",
+            reasoning_steps=best.reasoning_steps,
+            conversation_id=best.conversation_id,
+            response_id=best.response_id,
+            detail=detail,
+            runs_passed=runs_passed,
+            runs_effective=runs_effective,
+            best_run_latency_s=run_latency_s(best.timings),
+            timings=item_timings,
+            failed_runs=failed_runs,
+            run_latencies_s=run_latencies_s,
         )
-        exc.reasoning_steps = best.reasoning_steps
-        exc.conversation_id = best.conversation_id
-        exc.response_id = best.response_id
-        exc.timings = item_timings
-        exc.detail = detail
-        exc.runs_passed = runs_passed
-        exc.runs_effective = runs_effective
-        exc.failed_runs = failed_runs
-        exc.run_latencies_s = run_latencies_s
-        raise exc
-    return AgenticEvalOutcome(
-        runs_passed=runs_passed,
-        runs_effective=runs_effective,
+    return agentic_success(
         reasoning_steps=best.reasoning_steps,
         conversation_id=best.conversation_id,
         response_id=best.response_id,
         detail=detail,
-        timings=item_timings,
-        # Also on the success path: pass@K clears the gate with one passing run, so a
-        # 1/3 item reports success while two of its runs failed for reasons worth reading.
+        runs_passed=runs_passed,
+        runs_effective=runs_effective,
         failed_runs=failed_runs,
         run_latencies_s=run_latencies_s,
+        best_run_latency_s=run_latency_s(best.timings),
+        timings=item_timings,
     )
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/search_tool.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/search_tool.py
index 1d19c2e89..51100349a 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/search_tool.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/search_tool.py
@@ -15,6 +15,7 @@
     log_gate_scores,
     stamp_gate_metadata,
 )
+from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure
 from gooddata_eval.core.agentic._trace_linker import (
     RunIdentity,
     RunTraceContext,
@@ -78,7 +79,8 @@ class SearchResult:
     response_id: str | None = None
     tool_call_events: list[ToolCallEvent] = field(default_factory=list)
     reasoning_step_events: list[ReasoningStepEvent] = field(default_factory=list)
-    # This run's own wall time, from just before its chat call to the end of its scoring.
+    # This run's own wall time -- mirrors the single-shot path's best_run_latency_s
+    # (see core/runner.py's _run_one_item).
     run_latency_s: float = 0.0
 
 
@@ -290,7 +292,13 @@ def _write_scores(ctx: RunTraceContext) -> None:
     runs_effective = len(summary.run_results)
 
     best = summary.best
-    detail = _run_detail(best)
+    detail = agentic_detail(
+        best.tool_call_events,
+        best.reasoning_step_events,
+        tool_selected=best.tool_selected,
+        tool_correct=best.tool_correct,
+        tool_call_names=best.tool_call_names,
+    )
     # Same predicate pass@K and runs_passed are taken over, so an item's failed_runs and its
     # counts cannot disagree about which runs failed.
     failed_runs = build_failed_runs(
@@ -301,29 +309,29 @@ def _write_scores(ctx: RunTraceContext) -> None:
 
     if not gate_passed(gate, pass_at_k=summary.pass_at_k, pass_power_k=summary.pass_power_k):
         gate_note = gate_failure_note(gate, runs_passed, runs_effective)
-        exc = SearchToolAssertionError(
+        raise_agentic_failure(
+            SearchToolAssertionError,
             f"Search tool assertion failed. {gate_note} "
             f"tool_selected={best.tool_selected}, tool_correct={best.tool_correct}. "
-            f"Tool calls made: {best.tool_call_names}"
+            f"Tool calls made: {best.tool_call_names}",
+            reasoning_steps=best.reasoning_steps,
+            conversation_id=best.conversation_id,
+            response_id=best.response_id,
+            detail=detail,
+            runs_passed=runs_passed,
+            runs_effective=runs_effective,
+            best_run_latency_s=best.run_latency_s,
+            failed_runs=failed_runs,
+            run_latencies_s=[r.run_latency_s for r in summary.run_results],
         )
-        exc.reasoning_steps = best.reasoning_steps
-        exc.conversation_id = best.conversation_id
-        exc.response_id = best.response_id
-        exc.detail = detail
-        exc.runs_passed = runs_passed
-        exc.runs_effective = runs_effective
-        exc.failed_runs = failed_runs
-        exc.run_latencies_s = [r.run_latency_s for r in summary.run_results]
-        raise exc
-    return AgenticEvalOutcome(
-        runs_passed=runs_passed,
-        runs_effective=runs_effective,
+    return agentic_success(
         reasoning_steps=best.reasoning_steps,
         conversation_id=best.conversation_id,
         response_id=best.response_id,
         detail=detail,
-        # Also on the success path: pass@K clears the gate with one passing run, so a
-        # 1/3 item reports success while two of its runs failed for reasons worth reading.
+        runs_passed=runs_passed,
+        runs_effective=runs_effective,
         failed_runs=failed_runs,
         run_latencies_s=[r.run_latency_s for r in summary.run_results],
+        best_run_latency_s=best.run_latency_s,
     )
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/visualization.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/visualization.py
index 6b1523ae2..b06821452 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/visualization.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/visualization.py
@@ -20,6 +20,7 @@
     log_gate_scores,
     stamp_gate_metadata,
 )
+from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure
 from gooddata_eval.core.agentic._trace_linker import (
     RunIdentity,
     RunTraceContext,
@@ -77,7 +78,8 @@ class RunResult:
     # Why the simulated-user loop stopped. visualization_created=False alone cannot separate
     # a refusal from a run that hit max_iterations while still on track -- see LoopExit.
     exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED
-    # This run's own wall time, from just before its first chat call to the end of its scoring.
+    # This run's own wall time, across all its turns -- mirrors the single-shot
+    # path's best_run_latency_s (see core/runner.py's _run_one_item).
     run_latency_s: float = 0.0
     # Everything the final turn said, which the answer patterns are matched against.
     answer_text: str = ""
@@ -208,6 +210,7 @@ def _execute_single_run(
     one_turn = not options.expects_visualization or options.visualization_optional
     if one_turn:
         max_iterations = min(max_iterations, 1)
+    run_started = time.monotonic()
     total_turns = 0
     total_steps = 0
     all_tool_call_events: list[ToolCallEvent] = []
@@ -643,9 +646,16 @@ def _write_scores(ctx: RunTraceContext) -> None:
 
     best = summary.best
     ev = best.eval_result
-    # max_iterations is the same for every run, so it stays at the item level rather than
-    # being repeated into each failing run's detail.
-    detail = {**_run_detail(best), "max_iterations": max_iterations}
+    detail = agentic_detail(
+        best.tool_call_events,
+        best.reasoning_step_events,
+        **evaluation_result_detail(ev),
+        # Why the loop stopped -- see LoopExit. total_turns is already the turn count for
+        # this run, so it doubles as turns_used.
+        exit_reason=best.exit_reason.value,
+        turns_used=int(best.total_turns),
+        max_iterations=max_iterations,
+    )
     # Same predicate runs_passed is taken over, so an item's failed_runs and its counts
     # cannot disagree about which runs failed. Every failing run keeps its own
     # expected/actual check breakdown -- for this kind that is the whole diagnosis, and
@@ -667,7 +677,8 @@ def _write_scores(ctx: RunTraceContext) -> None:
             else {"expects_visualization": False}
         )
         actual_dump = best.actual_output.model_dump(exclude_none=True) if best.actual_output else None
-        exc = VisualizationAssertionError(
+        raise_agentic_failure(
+            VisualizationAssertionError,
             "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
             "Agentic Visualization Assertion Failed! (Critical Mode)\n"
             f"{gate_note}\n"
@@ -699,26 +710,25 @@ def _write_scores(ctx: RunTraceContext) -> None:
             f"  Executed              : {ev.executed}{' (required)' if ev.requires_execution else ''}\n"
             f"{_options_lines(ev, best.answer_text)}"
             f"  Stated Value Matches  : {ev.stated_value_matches} (reported only)\n"
-            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
+            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n",
+            reasoning_steps=best.reasoning_steps,
+            conversation_id=best.conversation_id,
+            response_id=best.response_id,
+            detail=detail,
+            runs_passed=runs_passed,
+            runs_effective=runs_effective,
+            failed_runs=failed_runs,
+            run_latencies_s=run_latencies_s,
+            best_run_latency_s=best.run_latency_s,
         )
-        exc.reasoning_steps = best.reasoning_steps
-        exc.conversation_id = best.conversation_id
-        exc.response_id = best.response_id
-        exc.detail = detail
-        exc.runs_passed = runs_passed
-        exc.runs_effective = runs_effective
-        exc.failed_runs = failed_runs
-        exc.run_latencies_s = run_latencies_s
-        raise exc
-    return AgenticEvalOutcome(
-        runs_passed=runs_passed,
-        runs_effective=runs_effective,
+    return agentic_success(
         reasoning_steps=best.reasoning_steps,
         conversation_id=best.conversation_id,
         response_id=best.response_id,
         detail=detail,
-        # Also on the success path: pass@K clears the gate with one passing run, so a
-        # 1/3 item reports success while two of its runs failed for reasons worth reading.
+        runs_passed=runs_passed,
+        runs_effective=runs_effective,
         failed_runs=failed_runs,
         run_latencies_s=run_latencies_s,
+        best_run_latency_s=best.run_latency_s,
     )
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/what_if.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/what_if.py
index baaeb201d..de124ceed 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/what_if.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/what_if.py
@@ -35,6 +35,7 @@
     log_gate_scores,
     stamp_gate_metadata,
 )
+from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure
 from gooddata_eval.core.agentic._trace_linker import (
     RunIdentity,
     RunTraceContext,
@@ -53,9 +54,9 @@
     AgenticAssertionError,
     AgenticEvalOutcome,
     ChatResult,
+    LoopExit,
     ReasoningStepEvent,
     ToolCallEvent,
-    build_latency_breakdown,
     shift_and_index_events,
 )
 
@@ -212,8 +213,14 @@ class WhatIfRunResult:
     response_id: str | None = None
     tool_call_events: list[ToolCallEvent] = field(default_factory=list)
     reasoning_step_events: list[ReasoningStepEvent] = field(default_factory=list)
-    # This run's own wall time, from just before its chat call to the end of its scoring.
+    # This run's own wall time, across all its turns -- mirrors the single-shot
+    # path's best_run_latency_s (see core/runner.py's _run_one_item). Distinct from
+    # turn_wall_clock_sec above, which is only the scenario-execution turn.
     run_latency_s: float = 0.0
+    # Why the simulated-user loop stopped -- see LoopExit. `triggered=False` alone cannot
+    # separate a refusal from a run that hit max_iterations while still on track (matches
+    # kda_skill.py/alert_skill.py).
+    exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED
 
 
 @dataclass
@@ -328,6 +335,7 @@ def run_agentic_what_if(
     )
 
     def _run_once(conv_id: str) -> WhatIfRunResult:
+        run_started = time.monotonic()
         create_args: dict | None = None
         execute_result: dict | None = None
         turn_wall_clock_sec: float | None = None
@@ -354,6 +362,10 @@ def _accumulate(result: ChatResult) -> None:
             all_reasoning_step_events.extend(result.reasoning_step_events or [])
 
         run_started = time.monotonic()
+        # Defaults to BUDGET_EXHAUSTED: every other exit assigns explicitly, so a loop that
+        # simply runs out of range() is labelled correctly with no trailing else.
+        exit_reason = LoopExit.BUDGET_EXHAUSTED
+
         for iteration in range(max_iterations):
             try:
                 chat_result = client.send_message(conv_id, current_question)
@@ -366,6 +378,7 @@ def _accumulate(result: ChatResult) -> None:
                     _accumulate(partial)
                     create_args, execute_result = _extract_what_if_calls(all_tool_call_events)
                 turn_completed = False
+                exit_reason = LoopExit.CHAT_ERROR
                 break
             reasoning_steps.extend(chat_result.reasoning_steps or [])
             response_id = chat_result.response_id or response_id
@@ -379,8 +392,10 @@ def _accumulate(result: ChatResult) -> None:
             if execute_result is not None:
                 # The turn that ran the scenario, not an earlier disambiguation turn.
                 turn_wall_clock_sec = chat_result.turn_wall_clock_sec
+                exit_reason = LoopExit.SUCCESS
                 break
             if not response_text:
+                exit_reason = LoopExit.AGENT_SILENT
                 break
             if iteration >= max_iterations - 1:
                 break
@@ -389,6 +404,7 @@ def _accumulate(result: ChatResult) -> None:
                 disambiguated = True
             except Exception as exc:  # noqa: BLE001 -- harness-side fault; end only this run
                 _log.warning("Simulated what-if user reply failed for conversation %s: %s", conv_id, exc)
+                exit_reason = LoopExit.SIMULATED_USER_FAILED
                 break
 
         return WhatIfRunResult(
@@ -396,6 +412,7 @@ def _accumulate(result: ChatResult) -> None:
             evaluation=_evaluate_run(create_args, execute_result, expected_output, turn_completed, disambiguated),
             actual_create_args=create_args,
             actual_execute_result=execute_result,
+            exit_reason=exit_reason,
             turn_wall_clock_sec=turn_wall_clock_sec,
             reasoning_steps=reasoning_steps,
             response_id=response_id,
@@ -453,26 +470,30 @@ class WhatIfAssertionError(AgenticAssertionError):
 def _detail(best: WhatIfRunResult) -> dict[str, Any]:
     ev = best.evaluation
     adjustments = _adjustments(best.actual_create_args)
-    return {
-        "triggered": ev.triggered,
-        "executed": ev.executed,
-        "success": ev.success,
-        "turn_completed": ev.turn_completed,
-        "metric_correct": ev.metric_correct,
-        "maql_correct": ev.maql_correct,
-        "scenario_count_correct": ev.scenario_count_correct,
-        "baseline_correct": ev.baseline_correct,
+    return agentic_detail(
+        best.tool_call_events,
+        best.reasoning_step_events,
+        triggered=ev.triggered,
+        executed=ev.executed,
+        success=ev.success,
+        turn_completed=ev.turn_completed,
+        metric_correct=ev.metric_correct,
+        maql_correct=ev.maql_correct,
+        scenario_count_correct=ev.scenario_count_correct,
+        baseline_correct=ev.baseline_correct,
         # Which content checks the fixture pinned -- without it a run that verified nothing
         # reads the same as one where everything matched.
-        "asserted": ev.asserted,
-        "disambiguated": ev.disambiguated,
-        "actual_adjustments": adjustments,
-        "actual_scenario_labels": [
+        asserted=ev.asserted,
+        disambiguated=ev.disambiguated,
+        actual_adjustments=adjustments,
+        actual_scenario_labels=[
             s.get("label") for s in ((best.actual_create_args or {}).get("scenarios") or []) if isinstance(s, dict)
         ],
-        "actual_execute_result": best.actual_execute_result,
-        "latency_breakdown": build_latency_breakdown(best.tool_call_events, best.reasoning_step_events),
-    }
+        actual_execute_result=best.actual_execute_result,
+        # Why the loop stopped. triggered=False alone cannot tell a refusal from a run
+        # that hit max_iterations while still on track -- see LoopExit.
+        exit_reason=best.exit_reason.value,
+    )
 
 
 def evaluate_agentic_what_if(
@@ -613,24 +634,28 @@ def _write_scores(ctx: RunTraceContext) -> None:
             f"Actual adjustments: {detail['actual_adjustments']}. "
             f"Actual execute result: {best.actual_execute_result}."
         )
-        exc = WhatIfAssertionError(message)
-        exc.reasoning_steps = best.reasoning_steps
-        exc.conversation_id = best.conversation_id
-        exc.response_id = best.response_id
-        exc.detail = detail
-        exc.runs_passed = runs_passed
-        exc.runs_effective = len(summary.run_results)
-        exc.failed_runs = failed_runs
-        exc.run_latencies_s = [r.run_latency_s for r in summary.run_results]
-        raise exc
-
-    return AgenticEvalOutcome(
-        runs_passed=runs_passed,
-        runs_effective=len(summary.run_results),
+        raise_agentic_failure(
+            WhatIfAssertionError,
+            message,
+            reasoning_steps=best.reasoning_steps,
+            conversation_id=best.conversation_id,
+            response_id=best.response_id,
+            detail=detail,
+            runs_passed=runs_passed,
+            runs_effective=len(summary.run_results),
+            failed_runs=failed_runs,
+            run_latencies_s=[r.run_latency_s for r in summary.run_results],
+            best_run_latency_s=best.run_latency_s,
+        )
+
+    return agentic_success(
         reasoning_steps=best.reasoning_steps,
         conversation_id=best.conversation_id,
         response_id=best.response_id,
         detail=detail,
+        runs_passed=runs_passed,
+        runs_effective=len(summary.run_results),
         failed_runs=failed_runs,
         run_latencies_s=[r.run_latency_s for r in summary.run_results],
+        best_run_latency_s=best.run_latency_s,
     )
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/evaluators/_llm_judge.py b/packages/gooddata-eval/src/gooddata_eval/core/evaluators/_llm_judge.py
index c32cb3f40..6bb4b9e62 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/evaluators/_llm_judge.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/evaluators/_llm_judge.py
@@ -62,6 +62,7 @@ class JudgeResponseError(RuntimeError):
     runs_effective: int
     failed_runs: list[dict]
     run_latencies_s: list[float]
+    best_run_latency_s: float | None
 
 
 def _message_content(response: Any) -> str | None:
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/models.py b/packages/gooddata-eval/src/gooddata_eval/core/models.py
index 85f92e74c..435ac811a 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/models.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/models.py
@@ -434,6 +434,7 @@ class AgenticAssertionError(AssertionError):
     runs_effective: int
     failed_runs: list[dict]
     run_latencies_s: list[float]
+    best_run_latency_s: float | None
 
 
 class AgenticEvalOutcome(BaseModel):
@@ -470,6 +471,12 @@ class AgenticEvalOutcome(BaseModel):
     # needs one per run. Empty means the kind recorded none, which the report reads as "no
     # sample", not as zero-second runs.
     run_latencies_s: list[float] = Field(default_factory=list)
+    # The rank-selected run's own wall time -- mirrors the single-shot path's
+    # ItemReport.best_run_latency_s (see core/runner.py's _run_one_item), which the
+    # agentic path never populated because its K runs happen inside the evaluator,
+    # not in a loop the runner itself can time. None for a kind that has not yet been
+    # wired to measure it (see AgenticAssertionError.best_run_latency_s, same default).
+    best_run_latency_s: float | None = None
 
 
 class SummaryInput(BaseModel):
diff --git a/packages/gooddata-eval/src/gooddata_eval/core/timing.py b/packages/gooddata-eval/src/gooddata_eval/core/timing.py
index b2d203d7b..2c7b9992f 100644
--- a/packages/gooddata-eval/src/gooddata_eval/core/timing.py
+++ b/packages/gooddata-eval/src/gooddata_eval/core/timing.py
@@ -182,3 +182,13 @@ def note_trace_latency(seconds: float | None) -> None:
     sink = _trace_latencies.get()
     if sink is not None and seconds is not None:
         sink.append(seconds)
+
+
+def run_latency_s(timings: PhaseTimings) -> float:
+    """One run's own wall time, for a single run's ``PhaseTimings``.
+
+    Excludes ``langfuse_s`` (deliberately off the critical path -- see
+    ``PhaseTimings.langfuse_s``) so this stays comparable to the single-shot path's
+    ``best_run_latency_s``, which times only the agent call and its grading.
+    """
+    return timings.agent_s + timings.judge_s + timings.simulated_user_s
diff --git a/packages/gooddata-eval/tests/test_agentic_anomaly_detection.py b/packages/gooddata-eval/tests/test_agentic_anomaly_detection.py
index d7fef2965..5c1e25d8b 100644
--- a/packages/gooddata-eval/tests/test_agentic_anomaly_detection.py
+++ b/packages/gooddata-eval/tests/test_agentic_anomaly_detection.py
@@ -16,7 +16,7 @@
     evaluate_agentic_anomaly_detection,
     run_agentic_anomaly_detection,
 )
-from gooddata_eval.core.models import ChatResult
+from gooddata_eval.core.models import ChatResult, LoopExit
 
 _MODULE = "gooddata_eval.core.agentic.anomaly_detection"
 
@@ -254,18 +254,22 @@ def test_a_single_turn_detection_passes():
     summary = _run([_chat(_pair())])
     assert summary.pass_at_k is True
     assert summary.best.evaluation.disambiguated is False
+    assert summary.best.exit_reason is LoopExit.SUCCESS
 
 
 def test_a_clarifying_question_is_answered_and_the_run_continues():
     summary = _run([_chat([], text="Which Spend metric did you mean?"), _chat(_pair())])
     assert summary.pass_at_k is True
     assert summary.best.evaluation.disambiguated is True
+    assert summary.best.exit_reason is LoopExit.SUCCESS
 
 
 def test_the_loop_stops_at_max_iterations_without_a_detection():
+    # executed=False alone cannot tell this apart from a refusal -- exit_reason can.
     summary = _run([_chat([], text="Still thinking")] * 4, max_iterations=4)
     assert summary.pass_at_k is False
     assert summary.best.evaluation.executed is False
+    assert summary.best.exit_reason is LoopExit.BUDGET_EXHAUSTED
 
 
 def test_an_empty_response_ends_the_run_immediately():
@@ -276,17 +280,19 @@ def test_an_empty_response_ends_the_run_immediately():
         patch(f"{_MODULE}.ChatClient", return_value=client),
         patch(f"{_MODULE}.generate_simulated_anomaly_response") as sim,
     ):
-        run_agentic_anomaly_detection(
+        summary = run_agentic_anomaly_detection(
             host="http://h", token="tok", workspace_id="ws1", question="q", expected_output=_EXPECTED
         )
     assert client.send_message.call_count == 1
     sim.assert_not_called()
+    assert summary.best.exit_reason is LoopExit.AGENT_SILENT
 
 
 def test_a_chat_error_on_a_later_run_does_not_discard_the_earlier_one():
     summary = _run([_chat(_pair()), RuntimeError("boom")], k=2)
     assert len(summary.run_results) == 2
     assert summary.pass_at_k is True
+    assert summary.run_results[1].exit_reason is LoopExit.CHAT_ERROR
 
 
 def test_k_must_be_at_least_one():
@@ -318,6 +324,8 @@ def test_detail_reports_the_series_analysed_and_the_flag_count():
     assert outcome.detail["anomaly_point_count"] == 0
     assert outcome.detail["asserted"] == ["metric", "granularity"]
     assert "latency_breakdown" in outcome.detail
+    assert "tool_calls" in outcome.detail
+    assert outcome.detail["exit_reason"] == "success"
     assert outcome.runs_passed == 1
     assert len(outcome.run_latencies_s) == outcome.runs_effective == 1
     assert all(latency >= 0 for latency in outcome.run_latencies_s)
diff --git a/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py b/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py
index 94a39a970..c4cfb7e23 100644
--- a/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py
+++ b/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py
@@ -17,7 +17,8 @@
     evaluate_dashboard_response,
     run_agentic_dashboard_skill,
 )
-from gooddata_eval.core.models import ChatResult, ToolCallEvent
+from gooddata_eval.core.chat.sse_client import ChatError
+from gooddata_eval.core.models import ChatResult, LoopExit, ToolCallEvent
 
 # Ids and titles are the ones the eval layout seeds; shapes are trimmed from real runs of
 # `agent_dashboard_skill` against ecommerce_demo.
@@ -2343,6 +2344,8 @@ def test_the_loop_is_capped(self):
         assert client.send_message.call_count == 2
         assert not summary.pass_at_k
         assert not summary.best.evaluation.drafted
+        # drafted=False alone cannot tell this apart from a refusal -- exit_reason can.
+        assert summary.best.exit_reason is LoopExit.BUDGET_EXHAUSTED
 
     def test_an_empty_turn_stops_the_loop(self):
         client = MagicMock()
@@ -2350,6 +2353,7 @@ def test_an_empty_turn_stops_the_loop(self):
         summary = _run_with(client, _DC05_EXPECTED, max_iterations=5)
         assert client.send_message.call_count == 1
         assert not summary.pass_at_k
+        assert summary.best.exit_reason is LoopExit.AGENT_SILENT
 
     def test_a_caller_supplied_conversation_is_not_deleted(self):
         client = MagicMock()
@@ -2358,6 +2362,54 @@ def test_a_caller_supplied_conversation_is_not_deleted(self):
         client.create_conversation.assert_not_called()
         client.delete_conversation.assert_not_called()
 
+    def test_a_chat_error_is_recorded_rather_than_left_to_escape(self) -> None:
+        """It used to escape run_agentic_dashboard_skill, taking every completed K-run with
+        it: no DashboardRunResult, no exit_reason, just a bare error on the item. Recorded
+        the way metric_skill.py and conversation.py record it, so an infrastructure fault
+        stays distinguishable from the agent failing to draft."""
+        client = MagicMock()
+        client.send_message.side_effect = ChatError("gen-ai fell over")
+
+        summary = _run_with(client, _DC05_EXPECTED)
+
+        assert summary.run_results[0].exit_reason is LoopExit.CHAT_ERROR
+        assert summary.run_results[0].evaluation.strict_pass is False
+        assert summary.pass_at_k is False
+
+    def test_a_chat_error_keeps_the_partial_turn_s_work(self) -> None:
+        """A bare catch would discard ChatError.partial_result. What the stream delivered
+        before it died is still this turn's work -- the steps were taken and the tools ran."""
+        partial = _chat_result(
+            tool_calls=[{"functionName": "search_objects", "functionArguments": "{}", "callTs": 1, "durationMs": 10}],
+            text="Here is the draft.",
+        )
+        partial.reasoning_steps = ["looked for the charts"]
+        partial.reasoning_step_count = 1
+        client = MagicMock()
+        client.send_message.side_effect = ChatError("stream died mid-answer", partial_result=partial)
+
+        summary = _run_with(client, _DC05_EXPECTED)
+        run = summary.run_results[0]
+
+        assert run.exit_reason is LoopExit.CHAT_ERROR
+        assert run.reasoning_steps == ["looked for the charts"]
+        assert run.total_steps == 1
+        assert [tc.function_name for tc in run.tool_call_events] == ["search_objects"]
+
+    def test_a_chat_error_on_a_later_turn_keeps_the_earlier_ones(self) -> None:
+        """The whole point of recording it: turns already completed survive the fault."""
+        client = MagicMock()
+        client.send_message.side_effect = [
+            _chat_result(text="Which charts did you have in mind?"),
+            ChatError("gen-ai fell over"),
+        ]
+
+        summary = _run_with(client, _DC05_EXPECTED)
+        run = summary.run_results[0]
+
+        assert run.exit_reason is LoopExit.CHAT_ERROR
+        assert run.total_turns == 2
+
 
 class TestEvaluateEntryPoint:
     def test_a_failing_run_raises_with_the_failures_attached(self):
@@ -2421,6 +2473,8 @@ def test_a_passing_run_returns_the_outcome(self):
         assert outcome.detail["charts_matched"] is True
         assert len(outcome.run_latencies_s) == outcome.runs_effective
         assert all(latency >= 0 for latency in outcome.run_latencies_s)
+        assert outcome.detail["exit_reason"] == "success"
+        assert "tool_calls" in outcome.detail
 
 
 def _as_events(raw: list[dict]) -> list[ToolCallEvent]:
diff --git a/packages/gooddata-eval/tests/test_agentic_general_question.py b/packages/gooddata-eval/tests/test_agentic_general_question.py
index cdfc683b8..64fca9012 100644
--- a/packages/gooddata-eval/tests/test_agentic_general_question.py
+++ b/packages/gooddata-eval/tests/test_agentic_general_question.py
@@ -257,6 +257,7 @@ def test_evaluate_agentic_general_question_returns_reasoning_steps_on_pass():
         "judge_reasoning": "Correct answer",
         "actual_output": "42",
         "latency_breakdown": [],
+        "tool_calls": [],
     }
     # One wall-clock sample per run, passing runs included -- the latency distribution is over
     # these, and a kind that forgot to report them would silently drop out of it.
@@ -288,6 +289,7 @@ def test_evaluate_agentic_general_question_attaches_reasoning_steps_to_exception
         "judge_reasoning": "Wrong answer",
         "actual_output": "I don't know",
         "latency_breakdown": [],
+        "tool_calls": [],
     }
     assert len(exc_info.value.run_latencies_s) == exc_info.value.runs_effective == 1
 
@@ -407,6 +409,9 @@ def test_evaluate_general_question_aggregates_timings_across_k_runs():
     assert outcome.timings.judge_s == 1.5  # 1.0 + 0.5
     # Each run's own span, agent and judge both inside it -- not their sum across runs.
     assert outcome.run_latencies_s == [3.0, 3.5]
+    # best_run_latency_s is the rank-selected run's own time (agent_s=2.0 + judge_s=1.0
+    # from the first, tied-best run), not the item total above (both runs summed).
+    assert outcome.best_run_latency_s == 3.0
 
 
 def test_evaluate_general_question_attaches_timings_to_the_failure_exception():
@@ -430,6 +435,7 @@ def test_evaluate_general_question_attaches_timings_to_the_failure_exception():
 
     assert exc_info.value.timings.agent_s == 4.0
     assert exc_info.value.timings.judge_s == 2.0
+    assert exc_info.value.best_run_latency_s == 6.0
 
 
 def test_trace_link_window_is_pinned_at_submit_time_not_when_the_task_runs():
diff --git a/packages/gooddata-eval/tests/test_agentic_kda_skill.py b/packages/gooddata-eval/tests/test_agentic_kda_skill.py
index 07f8bcb64..6a1690ebb 100644
--- a/packages/gooddata-eval/tests/test_agentic_kda_skill.py
+++ b/packages/gooddata-eval/tests/test_agentic_kda_skill.py
@@ -1134,6 +1134,7 @@ def test_evaluate_agentic_kda_skill_returns_reasoning_steps_on_pass():
         "turns_used": 1,
         "max_iterations": 1,
         "latency_breakdown": [],
+        "tool_calls": [],
     }
     assert len(outcome.run_latencies_s) == outcome.runs_effective == 1
     assert all(latency >= 0 for latency in outcome.run_latencies_s)
@@ -1174,6 +1175,7 @@ def test_evaluate_agentic_kda_skill_attaches_reasoning_steps_to_exception_on_fai
         "turns_used": 1,
         "max_iterations": 1,
         "latency_breakdown": [],
+        "tool_calls": [],
     }
     assert len(exc_info.value.run_latencies_s) == exc_info.value.runs_effective == 1
 
diff --git a/packages/gooddata-eval/tests/test_agentic_metric_skill.py b/packages/gooddata-eval/tests/test_agentic_metric_skill.py
index a86a2e9c3..5efcbb0bb 100644
--- a/packages/gooddata-eval/tests/test_agentic_metric_skill.py
+++ b/packages/gooddata-eval/tests/test_agentic_metric_skill.py
@@ -855,6 +855,7 @@ def test_evaluate_metric_skill_surfaces_timings_on_the_outcome():
 
     assert outcome.timings.agent_s == 3.0
     assert outcome.timings.simulated_user_s == 0.0
+    assert outcome.best_run_latency_s == 3.0
 
 
 def test_no_timer_output_by_default(monkeypatch, capsys):
diff --git a/packages/gooddata-eval/tests/test_agentic_runner.py b/packages/gooddata-eval/tests/test_agentic_runner.py
index f28c0fae6..67d3513b0 100644
--- a/packages/gooddata-eval/tests/test_agentic_runner.py
+++ b/packages/gooddata-eval/tests/test_agentic_runner.py
@@ -405,6 +405,54 @@ def test_run_agentic_items_records_phase_timings_when_the_item_fails():
     assert report.items[0].judge_latency_s == 2.0
 
 
+def test_run_agentic_items_records_best_run_latency_on_success():
+    # best_run_latency_s was never populated on the agentic path -- the K-run loop and
+    # best-of-K selection happen inside the evaluator, not in a loop the runner itself
+    # times (unlike _run_one_item on the single-shot path).
+    outcome = AgenticEvalOutcome(
+        conversation_id="c1",
+        detail={"alert_created": True},
+        best_run_latency_s=4.25,
+    )
+    with patch("gooddata_eval.cli.agentic_runner.evaluate_agentic_alert_skill", return_value=outcome):
+        report = run_agentic_items(
+            [_timed_item()],
+            host="http://host",
+            token="tok",
+            workspace_id="ws1",
+            run_ts="2026-01-01",
+        )
+
+    assert report.items[0].best_run_latency_s == 4.25
+
+
+def test_run_agentic_items_records_best_run_latency_when_the_item_fails():
+    exc = AlertSkillAssertionError("nope")
+    exc.detail = {"alert_created": False}
+    exc.best_run_latency_s = 9.5
+
+    with patch("gooddata_eval.cli.agentic_runner.evaluate_agentic_alert_skill", side_effect=exc):
+        report = run_agentic_items(
+            [_timed_item()],
+            host="http://host",
+            token="tok",
+            workspace_id="ws1",
+            run_ts="2026-01-01",
+        )
+
+    assert report.items[0].pass_at_k is False
+    assert report.items[0].best_run_latency_s == 9.5
+
+
+def test_an_errored_item_without_best_run_latency_keeps_the_none_default():
+    # Kinds not yet wired to measure it (or any exception with no such attribute) must
+    # not report an invented number -- None stays None, not 0.0.
+    with patch("gooddata_eval.cli.agentic_runner.evaluate_agentic_alert_skill", side_effect=RuntimeError("boom")):
+        report = run_agentic_items([_timed_item()], host="h", token="t", workspace_id="ws1", run_ts="2026-01-01")
+
+    assert report.items[0].best_run_latency_s is None
+
+
 def test_a_pending_trace_link_does_not_block_the_next_item():
     """The overlap claim, proved by construction rather than by a stopwatch.
 
@@ -991,9 +1039,15 @@ def test_every_multi_run_kind_s_evaluator_builds_failed_runs(kind, expected_outp
         pytest.skip(f"{kind} runs its fixture once; no K to fail within")
     assert "build_failed_runs(" in source, f"{module.__name__} never builds per-run failure records"
     assert "failed_runs=failed_runs" in source, f"{module.__name__} never returns them on the success path"
-    # Either set directly on the raised error, or via the kind's own _attach_diagnostics
-    # helper -- the judge-based kinds raise from two places and set the payload in one.
-    attaches = "failed_runs = failed_runs" in source or "_attach_diagnostics(" in source
+    # Either set directly on the raised error, via the kind's own _attach_diagnostics
+    # helper (the judge-based kinds raise from two places and set the payload in one), or
+    # passed to raise_agentic_failure -- the shared tail every other kind's failure raise
+    # goes through, alongside its agentic_success mirror, so the keyword appears twice.
+    attaches = (
+        "failed_runs = failed_runs" in source
+        or "_attach_diagnostics(" in source
+        or ("raise_agentic_failure(" in source and source.count("failed_runs=failed_runs") >= 2)
+    )
     assert attaches, f"{module.__name__} never attaches them to its failure"
 
 
@@ -1135,7 +1189,13 @@ def test_every_evaluator_hands_out_its_run_latencies(kind, expected_output, targ
     module = importlib.import_module(getattr(agentic_runner, target).__module__)
     source = inspect.getsource(module)
     assert "run_latencies_s=" in source, f"{module.__name__} never returns its run latencies on the success path"
-    assert ".run_latencies_s = " in source, f"{module.__name__} never attaches them to its failure"
+    # Either set directly on the raised error (the two judge-based kinds' all-ungraded
+    # path), or passed to raise_agentic_failure alongside its agentic_success mirror, so
+    # the keyword appears at least twice.
+    attaches = ".run_latencies_s = " in source or (
+        "raise_agentic_failure(" in source and source.count("run_latencies_s=") >= 2
+    )
+    assert attaches, f"{module.__name__} never attaches them to its failure"
 
 
 @pytest.mark.parametrize(("kind", "expected_output", "target"), _ALL_AGENTIC_KIND_CASES)
diff --git a/packages/gooddata-eval/tests/test_agentic_search_tool.py b/packages/gooddata-eval/tests/test_agentic_search_tool.py
index e188e7b99..d103fb389 100644
--- a/packages/gooddata-eval/tests/test_agentic_search_tool.py
+++ b/packages/gooddata-eval/tests/test_agentic_search_tool.py
@@ -208,6 +208,7 @@ def test_evaluate_agentic_search_tool_returns_reasoning_steps_on_pass():
         "tool_correct": True,
         "tool_call_names": ["search_objects"],
         "latency_breakdown": [],
+        "tool_calls": [],
     }
     # One wall-clock sample per run, passing runs included -- the latency distribution is over
     # these, and a kind that forgot to report them would silently drop out of it.
@@ -248,5 +249,6 @@ def test_evaluate_agentic_search_tool_attaches_reasoning_steps_to_exception_on_f
         "tool_correct": False,
         "tool_call_names": [],
         "latency_breakdown": [],
+        "tool_calls": [],
     }
     assert len(exc_info.value.run_latencies_s) == exc_info.value.runs_effective == 1
diff --git a/packages/gooddata-eval/tests/test_agentic_what_if.py b/packages/gooddata-eval/tests/test_agentic_what_if.py
index 67a3cc84c..38b04ebf3 100644
--- a/packages/gooddata-eval/tests/test_agentic_what_if.py
+++ b/packages/gooddata-eval/tests/test_agentic_what_if.py
@@ -13,7 +13,7 @@
     evaluate_agentic_what_if,
     run_agentic_what_if,
 )
-from gooddata_eval.core.models import ChatResult
+from gooddata_eval.core.models import ChatResult, LoopExit
 
 _MODULE = "gooddata_eval.core.agentic.what_if"
 
@@ -215,6 +215,7 @@ def test_a_single_turn_scenario_passes():
     summary = _run([_chat(_pair())])
     assert summary.pass_at_k is True
     assert summary.best.evaluation.disambiguated is False
+    assert summary.best.exit_reason is LoopExit.SUCCESS
 
 
 def test_a_clarifying_question_is_answered_and_the_run_continues():
@@ -222,12 +223,15 @@ def test_a_clarifying_question_is_answered_and_the_run_continues():
     summary = _run([_chat([], text="Which Spend metric did you mean?"), _chat(_pair())])
     assert summary.pass_at_k is True
     assert summary.best.evaluation.disambiguated is True
+    assert summary.best.exit_reason is LoopExit.SUCCESS
 
 
 def test_the_loop_stops_at_max_iterations_without_a_scenario():
+    # triggered=False alone cannot tell this apart from a refusal -- exit_reason can.
     summary = _run([_chat([], text="Still thinking")] * 4, max_iterations=4)
     assert summary.pass_at_k is False
     assert summary.best.evaluation.triggered is False
+    assert summary.best.exit_reason is LoopExit.BUDGET_EXHAUSTED
 
 
 def test_an_empty_response_ends_the_run_immediately():
@@ -238,15 +242,19 @@ def test_an_empty_response_ends_the_run_immediately():
         patch(f"{_MODULE}.ChatClient", return_value=client),
         patch(f"{_MODULE}.generate_simulated_what_if_response") as sim,
     ):
-        run_agentic_what_if(host="http://h", token="tok", workspace_id="ws1", question="q", expected_output=_EXPECTED)
+        summary = run_agentic_what_if(
+            host="http://h", token="tok", workspace_id="ws1", question="q", expected_output=_EXPECTED
+        )
     assert client.send_message.call_count == 1
     sim.assert_not_called()
+    assert summary.best.exit_reason is LoopExit.AGENT_SILENT
 
 
 def test_a_chat_error_on_a_later_run_does_not_discard_the_earlier_one():
     summary = _run([_chat(_pair()), RuntimeError("boom")], k=2)
     assert len(summary.run_results) == 2
     assert summary.pass_at_k is True
+    assert summary.run_results[1].exit_reason is LoopExit.CHAT_ERROR
 
 
 def test_k_must_be_at_least_one():
@@ -277,6 +285,8 @@ def test_detail_reports_the_adjustments_the_agent_asked_for():
     assert outcome.detail["actual_scenario_labels"] == ["Scenario A"]
     assert outcome.detail["asserted"] == ["metric_id", "scenario_maql"]
     assert "latency_breakdown" in outcome.detail
+    assert "tool_calls" in outcome.detail
+    assert outcome.detail["exit_reason"] == "success"
     assert outcome.runs_passed == 1
     assert len(outcome.run_latencies_s) == outcome.runs_effective == 1
     assert all(latency >= 0 for latency in outcome.run_latencies_s)
diff --git a/packages/gooddata-eval/tests/test_timing.py b/packages/gooddata-eval/tests/test_timing.py
index b2de2e19b..527ce7be5 100644
--- a/packages/gooddata-eval/tests/test_timing.py
+++ b/packages/gooddata-eval/tests/test_timing.py
@@ -15,6 +15,7 @@
     log_timer,
     note_trace_latency,
     percentile,
+    run_latency_s,
     sum_timings,
     timers_enabled,
     trimmed_mean,
@@ -268,3 +269,10 @@ def item(base: float) -> list[float]:
         results = list(pool.map(item, [0.0, 100.0, 200.0, 300.0]))
 
     assert results == [[b + s for s in range(5)] for b in (0.0, 100.0, 200.0, 300.0)]
+
+
+def test_run_latency_s_excludes_langfuse():
+    # langfuse_s is deliberately off the critical path (see PhaseTimings docstring), so a
+    # trace-link slowdown must not inflate the run latency a worst-case table sorts on.
+    timings = PhaseTimings(agent_s=2.0, judge_s=1.0, simulated_user_s=0.5, langfuse_s=100.0)
+    assert run_latency_s(timings) == 3.5