Reproducible agents require controlled boundaries, not deterministic models

The demand for reproducibility in agent systems starts from a category error: the assumption that deterministic sampling (temperature at zero, seed locked) is the path to reliable behavior. It isn't. Determinism guarantees identity — run it twice and you get the same output — but not correctness. An agent can deterministically produce the wrong answer every time. Reproducibility is useful for agents when you need to debug or audit a specific decision; it is not a fidelity guarantee.

The real lever is boundary control. The research on agent nondeterminism shows that non-determinism enters at three independent points: model inference (the stochastic sampling itself), tool availability (what tools are present and their outputs), and scheduling (the order in which concurrent tasks execute). You can lock the seed, but you cannot lock tool output from an external API or a live data store. Reproducibility therefore comes not from making the model deterministic but from making the context deterministic: pinned versions of every dependency, frozen snapshots of retrieved documents, immutable copies of tool outputs, and ordered serialization of concurrent actions.

The envelope, not the point estimate

Consider what FlashDecoding and Split-KV tell us about determinism in practice. The attention-specific analogue of split-reduction over the key/value sequence dimension introduces non-deterministic reduction order — the same inputs, different outputs depending on GPU parallelism level. This is not a bug in CUDA; it is an inherent property of hardware acceleration with unordered accumulations. The point: even locking temperature to zero does not produce bit-exact reproducibility when the compute substrate has non-deterministic arithmetic. You need batch-invariant grouping operations, deterministic reduction order, and control over the batch size.

The lesson scales up. The "determinism envelope" in agent systems extends beyond the model call to every material input: pinned tool versions, frozen retrieval results, serialized execution order, and controlled environment state. A seed value is a single control point inside a much larger boundary problem. Teams that focus on the seed are solving for the wrong variable.

Batch invariance over bit-exact reproducibility

The deeper insight from research on replay fidelity is that you do not need bit-exact determinism — you need batch invariance. Same inputs, same decision class. Two runs may differ in token-level output but agree on the critical classification: approve or deny this loan, escalate or close this ticket. That is a much weaker requirement than bit-exact reproducibility and something you can actually measure.

This reframes evaluation. Instead of testing determinism (which is expensive and narrow), test invariance under perturbation: vary timing by 50ms, change the order of retrieved document chunks, shuffle tool call order — does the decision class hold? This is a property you can assert with bounded coverage. Determinism checks at scale are expensive because they require pinning every source of variation.

The practical rule: design systems where the output is invariant to harmless variations rather than identical under fixed seeds. The former survives deployment; the latter does not.