Daily Systems Trends Report — October 18, 2026: The Second-Order Audit — Testing the Tests, Auditing the Auditors, Counting the Votes

Sunday deep-read edition. Source base: the unreported remainder of the arXiv October 15–16 announcement batch — cs.DC 16 / cs.SE 25 / cs.MA 22 new entries; items already covered in the October 16 and October 17 reports are excluded. Today the three categories converge on one move: pointing the instruments at each other.

BLUF — The Answer First

This weekend’s batch is a second-order audit: instead of proposing new mechanisms, most of the strongest papers measure, fault-inject, or stress-test the layers that were supposed to do the measuring. The single most striking number of the week comes from quantum software testing: after auditing four mutation tools and three curated bug benchmarks against 410 verified real-world bugs, only 13.7% of real faults belong to bug families those artifacts represent — the community has been testing the wrong bugs for years. Two independent papers break open the trust-in-the-instrument problem from opposite ends: mutation-based fault injection reveals 46 faults across six production Rust SAST tools, while a calibration study across seven code models finds that post-hoc calibrators improve calibration scores without consistently improving selective-prediction behavior — the metric and the mission have diverged.

On the systems side, the week’s "coordination budget" theme gets its counterpoint: a coordination-free data-loading policy (BCL) removes up to 82.8% of rank-local batch-cost variance and runs up to 1.343× faster than pooled scheduling with zero cross-rank metadata exchange. On the agentic side, two papers attack majority-vote ensembles from theory and practice: an EM-based jury model matches label-fitted weights with no statistically significant advantage from supervision, and a bias-injection framework turns an agent’s decision instability into a free reliability signal. And one paper demands a flag: four frontier agents autonomously post-trained a raw 4B model to match its official instruct version in a 104-hour campaign — impressive, but read the caveats before quoting it.

1. Systems Management & Distributed Computing

1.1 BCL: coordination-free workload regularization — the data-loader is the cheapest place to fix imbalance (arXiv:2610.21162)

Claim: most variable-cost imbalance in distributed training can be removed at the data-loader boundary, without any cross-rank coordination. Batch Cost Lookahead buffers a bounded rank-local window and repartitions it into fixed-cardinality packs with balanced estimated cost, preserving the trainer’s record-count contract. Foundation: traditional synchronous data-parallel training assigns every rank the same record count even when record costs vary by orders of magnitude, so each step waits for its most expensive rank-local batch — the straggler problem, classically attacked with pooled schedulers like MFFD that require cross-rank metadata exchange and runtime modification. Evidence: in simulation, BCL cuts per-rank estimated batch-cost variability by up to 82.8%; across 13 NeMo-RL SFT corpora on eight H200 GPUs it runs 1.050–1.167× faster than pooled MFFD; compiled H200 measurements on an internal sequence workload show 1.197–1.343× speedups from one to four nodes. The paper also maps a memory-feasibility boundary: a p99 cap bounds outliers before BCL balances the rest.

Trade-offs: the honest limits are stated in the abstract itself — results are partly simulation-based over public workload distributions, the 1.2–1.3× compiled numbers come from one internal sequence workload, and the authors explicitly clarify when data preparation or broader coordination is still necessary rather than claiming universality. Verdict: ready for evaluation in real training stacks. This is the strongest counterpoint yet to the coordination-heavy trend this report has tracked for a week: before you price, auction, or institutionalize coordination, check whether a boring data-loader heuristic makes the coordination unnecessary. Seven authors, credible measurement discipline, no heroics.

1.2 Probabilistic optical-layer surrogate: from fixed margins to runtime tail risk (arXiv:2610.21069)

Claim: optical-network control planes should query a conditional generative model over physical-layer metrics (OSNR, Q-margin, nonlinear penalty, feasibility) instead of relying on conservative fixed margins. Foundation: current control-plane decisions use analytical impairment models, deterministic learned predictors, or quantile-regression uncertainty estimates — all expose a limited, static summary, forcing operators to leave capacity underutilized to stay safe. Evidence: the surrogate is trained on traces from optical simulators with validated physical models and produces a full conditional distribution at runtime, so the controller can estimate violation probability and tail risk at arbitrary thresholds without retraining per decision. The single-author paper evaluates nine research questions covering prediction accuracy, inference latency, uncertainty quality, controller integration, cross-emulator generalization, dynamic reconfiguration under span degradation, topology scalability, GNPy-validated generalization, and latency on real live hardware traces; it is published at ACM CoNEXT 2026 (Proc. ACM Netw. 4).

Trade-offs: a generative surrogate inherits its simulator’s physical-model assumptions — if the validated models are wrong, the tail probabilities are confidently wrong; and single-author provenance, despite peer review, means less adversarial scrutiny than a team effort. Verdict: the abstraction is the contribution: physical-layer behavior as a fast probabilistic query mechanism rather than an offline simulation output. The same shift — static summary → runtime distribution — is exactly what SRE teams want from chaos engineering and capacity planning. Watch this pattern migrate into cloud capacity control within a year.

1.3 Cyclotron: recurrences as a language for interprocessor communication (arXiv:2610.20981)

Claim: streaming dataflow algorithms can be expressed as recurrence equations over logical iteration spaces and compiled to distributed processor topologies, with communication patterns (nearest-neighbor systolic exchange, broadcast, bidirectional split ring, asymmetric piecewise broadcast) that standard distributed linear algebra libraries do not support. Foundation: hand-optimized libraries — ScaLAPACK, SLATE, cuSolverMp — encode one communication strategy per routine; changing problem size or architecture historically meant rewriting the program. Evidence: from the Stanford group of Kunle Olukotun and Fredrik Kjolstad: the compiler lowers recurrences into per-processor sends/receives/computes with data able to live on the iteration space itself; users choose which dimensions map to processors and which to time, and the compiler places communication correctly per the chosen space–time mapping. Evaluated on distributed matmul, TRSM, Cholesky, and fused Cholesky–TRSM across up to 16 CPU nodes and 16 GPUs — competitive with and often outperforming the hand-tuned libraries; notably, the best communication strategy for Cholesky changes with problem size and architecture, which is precisely what a compiler can automate and a library cannot.

Trade-offs: recurrences are a niche programming model — expressive for dense linear algebra and stencil-like streaming, but the paper does not claim generality across arbitrary distributed workloads; and compiler correctness for user-specified communication patterns is only as good as its placement analysis. Verdict: a serious systems-language contribution from a lineage (Spartan/tensor-compiler group) that has shipped before. Not production-ready, but the direction — separate the algorithm and communication from the hardware mapping — is how every successful abstraction layer in HPC history started. Watch whether a follow-up covers sparse or irregular workloads.

1.4 ReFlow: experience replay as the missing amortization in RL post-training (arXiv:2610.21640)

Claim: RL systems consume each rollout trajectory once; replaying recent trajectories amortizes the high cost of rollout generation without excessive policy staleness. Foundation: standard RL post-training pipelines overlap rollout generation with policy optimization via asynchronous execution — but mild asynchrony gives limited gains while aggressive asynchrony degrades model quality, and static resource allocation fails as multi-turn agentic workloads shift demands over time. Evidence: from the Alibaba AAU lineage (Zhengping Qian, Wenchao Zhou, Chuan Wu): ReFlow co-designs system and algorithm with three components — a dual replay data cycle balancing throughput and optimization stability, an elastic resource pool for dynamic placement, and an adaptive scheduler coordinating generation strategies. Across single-turn reasoning and multi-turn agentic RL tasks, up to 2.06× training throughput over state-of-the-art synchronous and asynchronous systems at comparable or better model performance.

Trade-offs: replay introduces staleness risk by design — the dual cycle is the mitigation, but the paper’s own framing concedes the efficiency–staleness trade-off is the whole game; replay also changes the optimization distribution, so comparable final performance is claimed, not universally guaranteed across reward models. Verdict: this is the rare RL-infra paper that attacks the cost driver (rollout generation) instead of the scheduler. Given that RL post-training is where the money burns, a 2× throughput claim at equal quality is worth replicating. The Alibaba production lineage and the co-design framing make it credible; the replay-distribution side effects deserve an independent audit.

2. Software Development

2.1 The quantum-testing fault gap: 86.3% of real bugs are unrepresented (arXiv:2610.22089)

Claim: quantum software testing techniques are evaluated against fault models that barely overlap with real-world quantum bugs. Foundation: the traditional evaluation regime — mutation-generated faults and curated bug benchmarks — inherited from classical software testing research. Evidence: the authors audited four quantum mutation-testing tools and three curated bug benchmarks, then collected 410 verified bugs from ten quantum software repositories over two years and classified all three sources into a common taxonomy of 56 bug families. Mutation tools support 20 families; curated benchmarks add 15 more; yet only 56 of the 410 real bugs (13.7%) fall in families either source represents — 354 bugs (86.3%) are in families absent from both. The largest unrepresented families: compiler transformations (66 bugs), type handling (53), input validation (47) — faults living in compilers, intermediate representations, and framework interfaces, not in circuits and statements.

Trade-offs: mutation tools are not useless — they exercise what they model well; the finding is about coverage of the fault universe, not tool quality per se. The fix is expensive: testing semantic preservation across compiler transformations and correctness at representation boundaries is far harder than mutating gates. Verdict: a field-realigning empirical result, and a template any maturing subfield should steal: build the real-bug corpus first, then ask whether your evaluation artifacts cover it. The same critique could be aimed at classical mutation testing for LLM-generated code — nobody has done the 410-bug audit there yet.

2.2 MPI mutations as a benchmark for AI error detection (arXiv:2610.20616)

Claim: LLM-based error detection for HPC MPI code can be benchmarked properly using a mutated dataset built from real open-source programs, and compact specialized models beat general LLM prompting on specific error classes. Foundation: dynamic verification tools (ITAC and friends) are accurate but computationally expensive; static analysis is cheap but inaccurate; existing AI methods were "difficult to benchmark, too general, and poorly adapted" to HPC specifics. Evidence: peer-reviewed at ICS 2026. The MPI Mutated Dataset (MMD) is built from thousands of GitHub MPI programs with errors injected via mutations emulating real developer mistakes, aligned to the MPI-BugBench classification. Compact MLPs with AST-T5 embeddings reach up to 92.0% detection accuracy on classes like CallOrdering and InvalidParameter; engineered prompts lift Claude Sonnet 4.5 InvalidParam detection from 84.8% to 93.6%, surpassing the dynamic tool ITAC (87.0%); the full agentic pipeline achieves 73.9% overall multi-class accuracy and 87.6% bug-detection recall.

Trade-offs: mutation-generated faults are exactly what paper 2.1 warns about — they may not represent real MPI bugs (the authors partially mitigate this by emulating developer mistakes and grounding in MBB classes). 73.9% overall accuracy is not deployment-grade. Verdict: the value is the benchmark and the finding that prompt engineering beats a dynamic tool on a specific class — cheap static AI screening ahead of expensive dynamic verification is a sensible pipeline. A measured, useful step; not a revolution.

2.3 TRUST: mutation-testing the Rust security tools themselves (arXiv:2610.21373)

Claim: production Rust SAST tools miss real vulnerabilities and contain their own faults; LLM-assisted semantics-preserving mutation can find them. Foundation: Rust’s memory-safety guarantees are widely (over-)trusted as making SAST redundant — the traditional position being that unsafe blocks and complex concurrency mechanisms still require static analysis. Evidence: a two-part study from a seven-author group (Pei, Pan, Tan lineage). First, an empirical evaluation of mainstream Rust SAST tools against real-world vulnerabilities, uncovering common weaknesses and root causes. Then TRUST, an LLM-assisted framework that derives semantics-preserving transformations from the official Rust reference and uses them to generate mutants for evaluating the tools: 46 faults revealed across six popular SAST tools, 17 confirmed, plus ten empirical findings and four practical lessons.

Trade-offs: mutants derived from the official reference are a proxy for the vulnerability space, not the space itself (the recurring lesson of this batch); LLM-generated transformations need their own correctness argument, though anchoring in the official reference is the strongest available anchor. Verdict: the second concrete instance this month of "audit the auditors" (after October 1’s permission-minimality testing). The 17 confirmed faults in shipped security tools is the headline: security tooling has a supply chain too, and it is uninspected. Rust teams should not treat SAST output as ground truth — the paper shows it is a fallible instrument.

2.4 Calibration of deep code models: the score improves, the decision does not (arXiv:2610.21248)

Claim: confidence and uncertainty metrics for code models are poor guides for selective prediction, and standard post-hoc calibration does not reliably fix that. Foundation: the traditional reliability recipe — calibrate confidence scores, then defer to humans when the score is low — imported from classification ML into code tasks with strict accuracy requirements. Evidence: a systematic study across defect prediction and vulnerability detection using seven code models, thirteen uncertainty signals, and three widely used post-hoc calibration methods. Three findings: (1) even strong uncertainty signals remain poorly calibrated with limited separation at the high-confidence end; (2) standard post-hoc calibrators often improve calibration scores but do not consistently translate into better selective prediction; (3) commonly used calibration metrics can disagree with selective-prediction performance outright. The authors argue for a decision-oriented view: calibrated scores must be evaluated jointly with selective-prediction quality and retained-region risk before supporting accept–defer deployment.

Trade-offs: negative-result papers trade hope for clarity — this one gives no new technique that fixes calibration; it removes an excuse. The study covers defect prediction and vulnerability detection, not code generation itself, so the transfer to agentic coding is plausible but unproven. Verdict: a two-author, unreviewed-but-methodical study that lands a genuinely important blow: if your CI gate defers on low confidence, verify the deferral actually improves outcomes — the metric you tuned may not be the decision you made. This converges with the October 3 verifier-audit and October 17 test-trust findings: score quality — decision quality is emerging as 2026’s recurring measured disappointment.

2.5 ContribAlign: repository evidence for CONTRIBUTING files (arXiv:2610.21316) — and WEAVE: dependency-structured multi-PR tasks (arXiv:22039)

ContribAlign claim: OSS contribution guidelines are incomplete and outdated; an agent can revise them from project-specific evidence. Foundation: static, hand-maintained CONTRIBUTING.md files that drift from actual review practice. Evidence: a taxonomy of 30 fine-grained guidance types across six categories; a classifier diagnosing category coverage at weighted F1 0.764 (+0.156 over the existing baseline); a verifier detecting factual conflicts at 97.3% precision and 91.5% estimated recall; human evaluation ranks ContribAlign highest for usefulness, beginner-friendliness, and completeness. Trade-off: auto-revising governance documents risks laundering the very drift it detects — the 97.3% precision conflict filter is the load-bearing component. Verdict: modest, useful, peer-track work; the precision figure is the part to copy.

WEAVE claim: real software work is multi-PR, but benchmarks treat tasks as single issues. WEAVE transforms verified PR histories into dependency-structured DAGs of executable tasks, and introduces Graph Credit, a deterministic, test-grounded metric measuring dependency-consistent partial progress, enabling dense verifiable rewards for RL. Foundation: flat single-issue benchmarks (SWE-bench lineage) and coarse multi-PR aggregations with structure-agnostic evaluation. Trade-off: dependency-structured tasks from PR histories inherit the biases of what maintainers chose to merge; Graph Credit’s determinism depends on test-grounding quality. Verdict: the supervision-side infrastructure agentic RL has been missing; alongside October 17’s SWE-at-Scale radar entry, task-construction quality is becoming a first-class research object.

3. Agentic AI Frameworks

3.1 A jury, not an electorate: EM-estimated reliability without labels (arXiv:2610.21085)

Claim: ensemble reliability can be estimated label-free from the pattern of agreement and disagreement among experts, and the result matches supervised weighting. Foundation: majority voting and fixed-reputation weighting — the electorate model, where headcount decides. The paper’s reframing is the contribution: "the answers are testimony from witnesses of unknown reliability, and the question is not what the majority said but who is credible." Evidence: modeling each question as having a latent true answer with experts reporting at unknown reliabilities, estimated by Expectation Maximisation from unlabelled answer configurations; the decision rule reduces to a log-odds weighted linear score. On a 1,560-question benchmark with nine experts of up to 3B parameters, the jury performs comparably to the same fusion rule with label-fitted weights — no statistically significant advantage from supervision — while outperforming the best single model with matched self-consistency and the strongest label-free alternative.

Trade-offs: EM on agreement patterns has known pathologies when experts are correlated through shared training data — correlated errors look like consensus, which is exactly the failure mode October 2’s consensus work and the October 16 coordination-budget arc documented; the paper does not claim to solve correlation, only to match supervised weighting without labels. Verdict: theoretically clean, empirically modest (3B-class experts, QA-style benchmark), conceptually important: for agent-ensemble gating, supervision buys you nothing. For anyone building multi-agent verification (the October 16–17 convergence), this is the cheapest credible upgrade to naive majority vote.

3.2 Bias control and injection: instability as a reliability signal (arXiv:2610.21290)

Claim: non-semantic biases in LLM agents (majority pressure, response-style preferences) can be both mitigated and exploited: bias control improves initial answer selection, while deliberately injected bias elicits decision instability that serves as a reliability signal. Foundation: multi-agent debate and Mixture-of-Agents aggregation, which treat agent outputs as semantically meaningful votes and typically need validation data or known model strengths to weight them. Evidence: from POSTECH’s Jungseul Ok group: a test-time aggregation framework requiring neither validation data nor prior knowledge of relative model strength. Bias control = presenting one style-normalized reasoning trace per distinct answer; bias injection = placing each aggregating agent’s initially selected answer in the minority and watching whether it flips. Higher average accuracy and better token efficiency than competing non-oracle aggregation methods across three mathematical reasoning benchmarks and four heterogeneous LLM combinations; also improves final-answer accuracy when applied to debate and MoA without modifying their interaction or synthesis processes.

Trade-offs: bias injection doubles (or more) inference cost per decision — every candidate answer gets re-queried under adversarial placement; the stability signal is empirical, and math-reasoning benchmarks are the friendliest possible domain for style-normalization experiments. Verdict: one of the more original aggregation mechanisms this quarter: it treats consistency under perturbation as the reliability test — the same epistemics as differential testing and chaos engineering, applied to agents. Pairs beautifully with 3.1: EM learns who is credible from natural disagreement; bias injection manufactures informative disagreement. Both are label-free. That convergence is not an accident — it is the maturation of the aggregation layer.

3.3 RCM: responsibility-centered coordination for decentralized agents (arXiv:2610.21243)

Claim: decentralized multi-agent coordination fails because delegated responsibility is untracked; coupling task delegation with explicit commitments preserves accountability across delegation chains. Foundation: centralized orchestration (scalability bottleneck, single point of failure) versus decentralized coordination (bottlenecks removed, but "responsibility for delegated dependencies and failure recovery unclear"). Evidence: from Deakin’s Dinh Phung group: RCM uses commitments to bind delegation with explicit responsibilities; through recursive delegation, agents retain upstream responsibilities while locally orchestrating downstream commitments, forming a network of local orchestration whose commitment graph evolves as agents act in parallel. Operationalized via responsibility-constrained decision-making and a responsibility-oriented communication protocol (RCP). Across reasoning, coding, and executable agent environments: up to +18.7 points task performance and +10.2 points on Responsibility metrics over strong centralized and decentralized baselines, with improved failure and harm detection, no task-specific training.

Trade-offs: commitment-bookkeeping is itself coordination overhead — the paper does not report the accounting cost of maintaining the commitment graph, which October 16’s coordination-budget lens demands; and "Responsibility" as a scored metric is defined by the authors’ own rubric. Verdict: the constructive answer to the week’s arc: October 16 priced coordination, October 17 questioned who holds the pen, and RCM proposes that responsibility graphs — who owes what to whom, surviving delegation — are the substrate both governance and recovery need. The mechanism is classical (commitment protocols from multi-agent literature circa 2000s) married to LLM agents; the +18.7 needs independent replication before adoption.

3.4 Athanor: frontier agents autonomously post-train a base model — flagged, read the caveats (arXiv:2610.21055)

Claim: a team of four frontier agents (Claude Opus 5.5), each on an eight-GPU node, autonomously post-trained Qwen3-4B-Base from 15.9 to 67.3 on a six-task development suite and from 9.2 to 48.2 on a held-out suite — against 66.5 and 47.9 for the official Qwen3-4B-Instruct-2507 — in a 104-hour campaign, with no external teacher models and no research advice. Foundation: recursive self-improvement rhetoric, brought down to a measurable, weaker form: agents doing post-training research on real GPUs. Evidence: an open agent-native system with frozen evaluation, managed jobs, decontaminated data, a persistent research record, and a held-out suite the agents were unaware of (the strongest single design choice here). The record shows the agents reached the level by recombining known methods: SFT on public reasoning data, RL with one agent’s rollout change, weight merges across agents, and self-distillation rounds.

Trade-offs: this is a self-reported campaign by the system’s builders; the development-suite improvement (15.9→67.3) includes picking the suite context, and "matches or surpasses the official instruct version on average" rests on averaging choices across six tasks; 104 GPU-hours per eight-GPU node × four nodes is a nontrivial budget that most labs cannot casually replicate; and the authors’ own framing concedes the agents recombined known methods — this is automation of a known recipe, not novel research discovery. Verdict: significant and worth watching, but treat as a well-instrumented demonstration, not a proof of autonomous research ability. The held-out-suite discipline and full campaign record are genuinely good practice; the superintelligence-adjacent framing in the abstract outruns the evidence. This report has flagged over-claimed agent-autonomy results before (October 8’s Society of Researchers compute claim) — same rule applies: admire the instrumentation, discount the narrative.

4. Critical Analysis: New vs. Traditional

The audit-of-instruments pattern is now the dominant intellectual move. Traditional software engineering trusted its instruments: mutation tools defined fault reality, SAST output defined security truth, calibration scores defined reliability, majority votes defined ensemble answers. This batch measures the instruments against ground truth assembled the hard way (410 verified bugs, 46 confirmed tool faults, seven models by thirteen signals) and finds the instruments wanting: 86.3% of quantum bugs unrepresented, 46 faults in security tools, calibration metrics disagreeing with decisions. The trade is classic engineering: give up the comfort of a trusted meter, gain the ability to bound your actual risk.

Label-free beats label-fitted, again. The jury paper (3.1) and bias-injection (3.2) both show supervision buying nothing over agreement-pattern inference in their settings — converging with October 16’s score-gating result (a threshold at or below the smallest weight makes scores and gates equivalent) and October 3’s Groundability (weak reviewers audit strong agents when decisive checks exist). The direction of travel across three weeks is consistent: replace learned trust scores with structural checks on observable behavior — agreement patterns, stability under perturbation, evidence-before-effect. Traditional sound foundations survive; learned surrogates of those foundations keep failing their audits.

Coordination keeps having to justify itself. BCL (1.1) is the week’s cleanest result: remove 82.8% of imbalance with a bounded rank-local buffer and zero metadata exchange, beating pooled coordination on real corpora. This does not refute October 16’s coordination budget — it sharpens it: the budget question is not "how much coordination" but "does any coordination beat its cheapest local alternative." Cyclotron (1.3) is the same lesson in reverse: where communication genuinely must be coordinated, express it as a first-class language object and let a compiler place it, rather than freezing it in hand-tuned libraries. Both point at the same engineering virtue: pay for coordination exactly when, and only when, the local alternative measurably fails.

What to discount. Athanor (3.4) — admire the instrumentation, discount the recursive-self-improvement narrative until independent replication. RCM (3.3) — +18.7 on an author-defined Responsibility rubric is a claim, not a fact. And the calibration paper’s finding cuts both ways: if calibration scores do not track decisions, then every 2026 agent-harness that gates on model confidence has an unaudited deferral policy running in production.

Sources & Glossary

Primary sources (arXiv, October 15–16, 2026 announcements): 2610.21162 (BCL, coordination-free workload regularization); 2610.21069 (probabilistic optical-layer surrogate, CoNEXT 2026); 2610.20981 (Cyclotron, Stanford); 2610.21640 (ReFlow, RL post-training); 2610.21457 (post-quantum S3 benchmarking); 2610.22089 (quantum software testing fault-representation gaps); 2610.20616 (MPI mutations, ICS 2026); 2610.21373 (TRUST, Rust SAST evaluation); 2610.21309 (companion: LLM + dynamic analysis for universal SAST testing); 2610.21248 (uncertainty calibration in deep code models); 2610.21316 (ContribAlign); 2610.22039 (WEAVE); 2610.21098 (ToolBottleneckBench); 2610.21421 (agentic instruction categories, APSEC 2026); 2610.21372 (Flask dependency transformations, APSEC 2026); 2610.21085 (a jury, not an electorate); 2610.21290 (bias control and injection, POSTECH); 2610.21243 (RCM, Deakin); 2610.21055 (Athanor); 2610.21938 (Agentic-Priors, Southampton); 2610.21570 (RTL coverage-closure agent).

Glossary: mutation testing — injecting small artificial faults to evaluate a detector; SAST — static application security testing; selective prediction — model defers on inputs it expects to fail; EM — Expectation Maximisation, iterative estimation of latent parameters; MNL — multinomial logit, discrete-choice model; ML-KEM — post-quantum key encapsulation mechanism (NIST standard); OSNR/Q-margin — optical signal quality metrics; commitment protocol — multi-agent coordination formalism where agents bind themselves to obligations.

Method note: all items from the unreported remainder of the October 15–16 arXiv batch; prior coverage in the October 16 and 17 reports is excluded. No claims are quoted from paper abstracts beyond what the abstracts themselves state; replication status and peer-review venue are flagged per item.