acceptodds
Under review as a conference paper at ICLR 2027

SEAM: Reproducibility, Auditability, and Stability for Agentic LLM Systems

Abstract

Agentic systems need reproducible executions and evidence explaining why fresh decisions disagree. We present SEAM (Seal, Explain, Abstain, Mechanize), a client-side architecture that normalizes execution order, replays recorded interactions, tests explanations of divergence, withholds unsupported stability claims, and selects deterministic replacements. Controlled studies connect each operation to measurable outcomes. On a 100-slide CAMELYON17 lymph-node subset, each processed six times per arm, ordered admission restores bitwise agreement in 500 of 500 reference-run heatmap comparisons; a separate two-run analysis removes 203 matched-lesion size-class changes. Across four recordings of a model-directed ledger loop, ordering reduces cases with varying decisions from 4–5 of 6 to 0–1. A diagnostic panel with 30 cases and eight repeats exposes the cost of treating repeated calls as independent: the sealed arm’s nominal one-sided 95% pair-risk upper bound is 0.068, while a finite-sample case-level bound for the same target is 0.262. On 300 three-factor attribution instances, sequential testing raises answer coverage from 51.0% to 85.3% with pruning held fixed; every returned sequential explanation matches the injected cause. A stricter procedure bounds erroneous returns under explicit sampling and separation assumptions. Greedy selection misses a beneficial joint replacement on one panel case. SEAM makes repeatability an execution property and stability claims accountable to recorded evidence.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
LLM agents, reproducibility, nondeterminism, record and replay, auditability, conformal risk control, selective prediction, delta debugging, fault localization, provenance

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_cTQ5OpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

SEAM combines execution ordering and record/replay (Seal), stochastic delta debugging (Explain), selective disagreement-risk control (Abstain), and deterministic component replacement (Mechanize). The experiments use an image pipeline, a ledger agent loop, a synthetic diagnostic panel, and attribution tasks with known injected causes. The paper separates repeatable execution, offline replay, agreement across fresh runs, and correctness. Its main findings are that ordering can remove client-side variation, repeated calls should not automatically count as independent samples, sequential tests can improve explanation coverage, and replacing one component with a deterministic rule does not always reduce disagreement in the full system.

Critical strengths
  1. The statistical analysis is useful. The paper shows how treating repeated calls as independent can give overly confident risk bounds. It also clearly separates pairwise disagreement, disagreement across eight runs, and stability on fresh runs.

  2. The controls help explain the gains. The experiments separate ordering from auditing and pruning from sequential testing. In Table 5, sequential testing raises D4 coverage from 0.510 to 0.853 with pruning held fixed.

Critical weaknesses
  1. The benefit of the full system is unclear. Ordering alone gives all the bitwise-agreement gains in the image study. The paper does not show whether SEAM reduces debugging cost compared with a simpler combination of logging, replay, and stochastic debugging.

  2. The main coverage results do not use the guaranteed procedure. Table 5 allows a fallback after timeout, while Proposition 3 covers strict mode. Strict-mode coverage is lower on difficult cases, and most attribution tests use synthetic faults. The guarantees still need validation on real agent failures.

Questions for authors
  1. On the same real fault set and execution budget, how much does SEAM reduce the number of debugging runs, manual checks, or total time compared with ordering + cassette + declaration-aware logging + stochastic ddmin? Could the existing records support a small comparison?

  2. For each main attribution experiment, please list the procedure used, whether it allows timeout fallback, whether it runs fresh terminal checks, the value of Ncap, total cost, and answer coverage. Could strict and non-strict versions be compared on the same workload with cost, coverage, and errors shown together?

  3. Is there at least one real disagreement from a fresh LLM agent where factor interventions can be repeated, strict mode returns an explanation, and the chosen replacement is then checked on fresh cases or recordings? If not, the paper should make clear that the full workflow has not yet been validated together.

1 comment
AuthorsOpenReview ↗

Response to Reviewer cTQ5

Thank you for the detailed and constructive review.

W1 / Q1 (debugging cost against simpler combinations) - We agree. The existing records cover the synthetic part - the fixed-repeat, pruning-off arm of our matched ablation is stochastic ddmin without SEAM's additions. We added the image-pipeline divergence and the new LLM case study, reporting executions, coverage, and errors per configuration. On the hardest separable synthetic tier, recovery rises 0.51 to 0.85 at matched cost from the sequential test alone, pruning adds approximately zero, and strict terminal checks show 0.64 at zero observed errors. Manual checks and wall-clock time are not comparable across these workloads, so we instead report executions and model calls.

W2 / Q2 (strict vs non-strict) - Acknowledged, and the revision now reports strict mode as the primary result. Table 5 contains the updated values and the full factorial, D1-D2, and the image-pipeline row are now located in the SDD-calibration appendix of the revised PDF. All arms share instances and random streams, 300 per tier. Fixed-repeat and sequential are cost-matched at alpha = beta = 0.02, and strict uses the bound-valid alpha = beta = 0.1/(334+0.1), at which the 334-test cap gives a 0.1 error bound (only strict runs fresh terminal checks and enforces Ncap = 334; the fallback arms vote at a threshold at timeout). On D4 the three arms are comparable in cost, so sequential nearly doubling the fixed-repeat coverage (0.51 to 0.85) with no observed errors is a legitimate gain. Strict trades coverage for the bound (0.64) and does not return any wrong answers on any tier. The full per-tier coverage, executions and error rates are also found in Table 5.

Q3 (full workflow on a real disagreement) - Not before the current revision. Explain and Mechanize had been validated on different workloads, and the provider endpoint does not let us repeat interventions on its sampling. We added an open-weights case study (Qwen2.5-14B, sampling on) allowing for repeatable interventions, modeling each decision step as a factor whose intervention is sampled decode against a greedy baseline. Over 100 cases, 10 produced a fresh decision disagreement; 5 saw strict mode return a single-step cause that was confirmed by an intervention (holding that step at the deterministic baseline drops the disagreement rate to 0), and the other 5 saw strict mode refuse (sample cap or an invalid pilot band) rather than guess. Replacing the attributed step with a deterministic rule reduced decision pair-disagreement on held-out cases from 0.35 to 0, at a decision-change cost of about 0.10 against the greedy reference. Thus, the full workflow runs end to end on a real disagreement, and strict mode refuses where separation is insufficient.

Reviewer_rxWWOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces SEAM, a framework for improving the reproducibility and auditability of AI agents via deterministic execution ordering, record & replay, divergence attribution, statistical risk control, and component replacement. The paper also evaluate these components using an image-processing pipeline, a ledger agent, and synthetic diagnostic tasks.

Critical strengths
  1. The authors addresses a practical problem. I appreciate the distinction between reproducible execution and reliable decisions, as well as the careful treatment of statistical dependence across repeated runs.

  2. The authors provide detailed experiments and discuss cases where their methods fail or cannot support a statistical guarantee. This makes the results easier to assess.

Critical weaknesses
  1. The image-processing experiment does not involve an LLM, the ledger study uses only six constructed cases, and most attribution experiments rely on synthetic data. It remains unclear how well SEAM works on realistic, long-running agents.

  2. Simple execution ordering already accounts for the main reproducibility gains, while existing replay tools achieve similar recording fidelity. The attribution and repair components have limited validation on real agent failures, making it difficult to assess what SEAM offers beyond combining existing techniques.

Questions for authors
  1. Can the authors conduct SEAM on a more realistic agent benchmark with longer trajectories and naturally occurring failures?

  2. What measurable debugging benefit does SEAM provide over deterministic ordering and existing record-and-replay tools when compared under similar conditions?

2 comments
AuthorsOpenReview ↗

Response to Reviewer rxWW

Thank you for the thorough review.

Realistic agents (W1, Q1) - We agree this is the main limitation. We added an end-to-end case study on a model-directed tool loop with an open-weights model (Qwen2.5-14B) and sampling enabled, expanded from 6 to 100 cases, in which the disagreements arise from the model rather than from injection. The loop was decision-stable on 90 cases, and of the 10 fresh disagreements strict attribution returned an intervention-confirmed single-step cause on 5 and refused on the other 5, with a deterministic replacement of the attributed step removing the disagreement on held-out cases. A longer-horizon public benchmark could not be run within the discussion period and is listed as future work.

Ordering and existing replay (W2) - Both observations are correct, as reported in the paper under the ordered-only arm and the cassette baseline. The layers have different jobs. Ordering removes client-side variation while recording makes a run reconstructable, but a cassette alone does not fix the order in which responses are consumed. In the ledger loop, the in-process race still produces 71 distinct tool sequences in 72 episodes under cassette replay. In the ledger loop, decisions still vary after sealing despite ordering and recording because of model choices, and that residual variance is addressed by attribution and abstention.

Q2 (measurable debugging benefit) - We added the comparison you described of ordering + cassette + fixed-repeat stochastic ddmin, adding declarations/pruning, sequential testing and strict terminal checks. These were run on synthetic faults, the image-pipeline divergence, and the new LLM case study. On the hardest separable synthetic tier the sequential test comprises the entire measured gain (recovery 0.51 to 0.85 at matched cost), dependency pruning adds approximately zero (0.51 to 0.51), and strict terminal checks trade recovery for the error bound (0.64 at zero observed errors). In summary, the measured gain originates from sequential testing. Dependency-based pruning adds little on these workloads, and that is now directly stated.

Thank you for the response. The new LLM case study is helpful, and the comparison makes it clearer where the debugging gains come from. I’m still unsure how well SEAM works on longer agent tasks, so I’m keeping my score.

Reviewer_GZFCOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

This paper addresses disagreement across repeated executions of agentic LLM systems by proposing a client-side architecture called SEAM with four modules: Seal fixes client execution order and records calls for offline replay; Explain combines ddmin with SPRT to find which factors cause a divergence; Abstain bounds selective pair-disagreement risk while accounting for within-case clustering; and Mechanize jointly replaces unstable model nodes with deterministic rules. These mechanisms are evaluated on an image pipeline, a ledger loop, a diagnostic panel, and a synthetic benchmark.

Critical strengths

The proposed framework offers a helpful perspective on auditing agentic LLM systems. Its four-module design organizes the audit process into a coherent workflow, while clearly distinguishing replay fidelity, agreement across fresh executions, and decision correctness.

The experiments are reported in considerable detail, including configurations, controls, and limitations. This transparency helps readers interpret the findings and supports reproducibility.

Critical weaknesses
  1. The text is filled with file paths, hash digests, and notes on historical code revisions, making the presentation overly fragmented and defensive, much like a raw engineering log rather than a coherent scientific paper. While AI-assisted research is reasonable, these issues, together with many poorly organized tables that are difficult to read, give the impression that the manuscript was largely generated by AI with minimal human curation and review. Overall, the presentation quality falls well below the standard expected at this conference.

  2. The incremental contribution of the integrated framework remains unclear. The four modules mainly combine existing mechanisms such as record-replay, hash chains, and ddmin. While such integration can be valuable, the paper does not sufficiently demonstrate what additional capabilities or practical benefits the full framework provides over a simpler combination of existing tools. Moreover, the contribution also appears more closely aligned with software engineering and systems research, rather than machine learning.

  3. The applicability of the framework to real LLM agents is not yet sufficiently validated. Some major experiments do not involve language models, while the LLM-based experiments use relatively few independent cases and simplified task setups. In particular, for the Explain module, the paper does not demonstrate its attribution effectiveness on LLM tasks, and each attribution instance often requires thousands of workflow executions (Table 5).

Questions for authors
  1. The paper mainly evaluates fixed node graphs and a short tool loop. For more complex and dynamic agent architectures, how would Seal's ordering normalization and read/write dependency declarations be extended and applied?

  2. In multi-step LLM agents, each full execution incurs high latency and API cost. Could the authors clarify how the sampling overhead of Explain (SDD) can be controlled in practice? For example, does the architecture support partial replay to avoid re-running the entire workflow from scratch during each intervention?

  3. To improve readability, it is recommended to reorganize the presentation, streamline the tables, and move low-level engineering details as well as discussions of flawed historical configurations to the appendix, making the main narrative more coherent and focused.

2 comments
AuthorsOpenReview ↗

Response to Reviewer GZFC

Thank you for the careful review.

Presentation - we agree, and have restructured the paper accordingly (see general comment). The main text no longer contains hashes, file paths or descriptions of superseded configurations, which have been moved to the appendix. The attribution results now report the procedure covered by our guarantee, with the earlier procedure as a comparison only. Tables 1, 2 and 5 have been rewritten for readability.

Contribution beyond existing tools - the primitives (record/replay, hash chains, ddmin) are not claimed as new. What we contribute is (i) a sequential stochastic test for ddmin, which raises cause recovery on the hardest separable tier from 0.51 to 0.85 at similar cost on matched instances; (ii) a strict variant of that test with a bound on returning a non-minimal explanation; (iii) the finding that repeated-call bounds can overstate confidence (0.068 nominal vs 0.262 case-level for the same target); and (iv) the finding that replacing one component can increase system-level disagreement. The new component ablation isolates the test layers and demonstrates that dependency pruning adds approximately zero (0.51 to 0.51 on D4) and strict terminal checks trade recovery for the error bound (0.64 at zero observed errors). The null pruning result is stated directly.

Real LLM agents and Explain on LLM tasks - Explain now runs on the end-to-end LLM case study (see general comment), with strict, intervention-confirmed attribution. On cost, the synthetic tiers are deliberately hard, while the real image-pipeline divergence took 363 executions and the LLM case study averaged 598.

Q1 (dynamic architectures) - Seal does not require a fixed graph. Declarations attach to each model or tool call when they happen, and ordering is fixed at concurrency points (parallel tool results, admission under a budget, memory commits). Two cases are already demonstrated - the ledger loop is model-directed with the model picking the next call at runtime, and the three-agent diagnostic panel is sealed as a multi-agent composition. Dynamically spawned sub-agents and run-time fan-out are not evaluated and remain future work.

Q2 (cost control, partial replay) - A good suggestion that we have now implemented. Because sealing makes the execution before an intervention point identical across runs, recorded responses can be served up to the first step impacted by the perturbed factor, and only the remainder of the execution is run live. In the new case study this served 27% of the model calls in an attribution from the recorded prefix, with the returned cause and its certification unchanged.

Q3. Done; see above.

Thank you for the revisions and additional experiments. However, the new study is still limited in scope, and I think the presentation could be improved and the experimental evidence strengthened. I therefore maintain my rating of 2.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.