acceptodds
Under review as a conference paper at ICLR 2027

StateBundle: Cause-Centered Evidence Selection for Agentic Data-Center Operations

Abstract

Autonomous data-center operations require agents to interpret heterogeneous telemetry and manage faults that propagate across physical facilities and the IT stack. In modern operational environments, redundant and fragmented telemetry complicates reasoning while increasing context and computational costs. We propose Statebundle, a hierarchical, cause-centered evidence-selection method that constructs compact observation bundles for operational agents. Statebundle selects nonredundant evidence anchors and retrieves corroborating observations through contrastive cross-modal alignment, hierarchical root-cause and propagation supervision, and task-oriented evidence-selection objectives. To enable controlled cross-layer evaluation, we further introduce DC-Bench, a deterministic simulator-backed benchmark that couples physical facility with compute, storage, network, control-plane, and application dynamics. DC-Bench contains 72 task instances spanning 18 fault mechanisms and four operational objectives: detection, localization, root-cause analysis, and mitigation. Across ten evaluated agent systems, Statebundle reduces total model-token usage per episode by 37.4–80.9% relative to full-canonical observations, while improving task success for evaluated agents.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Agentic data-center operations, AI for infrastructure, LLM agents, AIOps

Reviews

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

StateBundle selects compact telemetry bundles for operational agents using hierarchical representations, root-cause supervision, and complementary evidence retrieval. The paper also introduces DC-Bench, a deterministic simulator coupling facility and IT dynamics, with 72 tasks spanning 18 fault mechanisms. Experiments across agent systems report substantial token savings and improved aggregate success, although some individual task results decline.

Critical strengths
  • Organizing fragmented telemetry while controlling context costs is practically relevant to autonomous data-center operations.
  • DC-Bench and its generated dataset extend evaluation to interactions between facility infrastructure and the IT stack.
  • StateBundle reduces token consumption across all evaluated agents while improving observed aggregate success.
Critical weaknesses

-The introduction describes telemetry fragmentation broadly but lacks a clear incident walkthrough demonstrating why existing representations fail and how StateBundle resolves that failure.

  • Figures 1 and 2 contain small labels and densely packed components, making the operational scenario and training-to-inference relationships difficult to follow.
  • Evaluation relies on deterministic dynamics and single injected faults. The 72-task suite provides limited evidence of robustness to concurrent incidents, stochastic behavior, and production telemetry imperfections.
  • Root-cause labels, propagation supervision, and embedding similarity can support predictive relevance, but do not establish that selected observations identify causal mechanisms. Interventions or tests that disrupt spurious associations would strengthen the cause-centered claim.
  • Despite aggregate gains, GPT-5.6 Sol’s localization success falls from 98.1% to 92.6%, and Claude Opus 5’s from 92.6% to 88.9%. These regressions warrant uncertainty estimates and analysis of whether selection removes evidence useful to capable models.
Questions for authors

Please refer to the Weakness section above.

3 comments
AuthorsOpenReview ↗

Response to Reviewer 1eQk. Q1 and Q2

Response to Reviewer 1eQk

[W1&Q1]

Concern Summarization Figures 1 and 2 contain small labels and densely packed components, making the operational scenario and training-to-inference relationships difficult to follow.

Response:

We thank the reviewer for this helpful feedback. We have revised both figures to improve readability by enlarging all labels and reducing the number of components in each panel.

Manuscript revision:

Figures 1 and 2 in the revised manuscript have been replaced with the redrawn versions.

[W2&Q2]

Concern Summarization Evaluation relies on deterministic dynamics and single injected faults. The 72-task suite provides limited evidence of robustness to concurrent incidents, stochastic behavior, and production telemetry imperfections.

Response:

We thank the reviewer for this important point. We agree that the original suite does not test these conditions, so we added three stress-test suites (i.e. stochastic behavior, telemetry imperfections, and concurrent incidents), with the original StateBundle weight to evaluate its robustness to stress conditions. All experiments use Codex (GPT-5.6 Luna), the agent from our ablation studies.

Stochastic dynamics. We rerun the 72 original tasks with temporally correlated workload fluctuations. A disturbance is sampled at every simulator tick of the healthy, fault-active, and recovery phases and propagates through the existing utilization, power, thermal, and service-performance dependencies:

Dt=max⁡(0,Dˉt(1+ϵt)),ϵt=ρϵt−1+σ1−ρ2ξt,ξt∼N(0,1),D_t=\max(0,\bar{D}_t(1+\epsilon_t)),\qquad\epsilon_t=\rho\epsilon_{t-1}+\sigma\sqrt{1-\rho^2}\xi_t,\qquad\xi_t\sim\mathcal{N}(0,1),

where Dˉt\bar{D}_t is the original demand, ρ=0.95\rho=0.95, and σ=0.05\sigma=0.05.

Telemetry imperfections. We rerun the 72 original tasks with random observation loss and delayed delivery. Each eligible canonical observation is independently dropped with probability pdrop=0.05p_{\mathrm{drop}}=0.05 and independently delayed with probability pdelay=0.05p_{\mathrm{delay}}=0.05, in which case it reaches the agent 1–10 ticks late.

Concurrent incidents. We build 72 new tasks with each contains two injected faults from the original 18 fault mechanisms. To ensure balanced coverage, we randomly permute the 18 mechanisms using a specific seed and pair each mechanism with its successor in the permutation. Success requires handling both faults: identifying both mechanisms with evidence (detection), both targets (localization), each mechanism with its target and evidence (RCA), and recovery from both faults over the stability window (mitigation). The agent is told that one or two faults may be present, but not how many.

Table 1. Success rates (%) over 72 tasks × 3 trials and average model tokens per episode:

ConditionMethodDetectLocalizeRCAMitigateOverallTokens
OriginalFull-Canonical92.685.268.535.270.4181,200
StateBundle90.792.672.250.076.4113,484
StochasticFull-Canonical88.985.263.031.567.1233,323
StateBundle87.090.775.942.674.1157,372
Imperfect telemetryFull-Canonical87.088.964.833.368.5179,937
StateBundle90.792.670.451.976.4113,105
ConcurrentFull-Canonical81.585.250.031.562.0402,993
StateBundle75.987.053.738.963.9240,364

Stochastic dynamics and imperfect telemetry. StateBundle maintains its performance advantage over Full-Canonical under both stochastic system dynamics and telemetry imperfections, suggesting robustness to these perturbations. Notably, under telemetry imperfections, both methods exhibit only minor performance changes, with Full-Canonical declining by 1.9 percentage points and StateBundle maintaining its original success rate. A plausible reason for it is that a fault usually leaves evidence in several channels, allowing agents to retain sufficient diagnostic information even when a small proportion of observations is missing or delayed.

Concurrent incidents. For this setting, the gap between StateBundle and full-canonical observations narrows to 1.9 points. A likely reason is that StateBundle is trained only on single-fault incidents, which can concentrate the bundle on one root cause. Nevertheless, StateBundle maintains a higher task success rate than Full-Canonical while consuming fewer model tokens, suggesting that its evidence-selection strategy remains beneficial under concurrent-fault conditions.

Manuscript revision:

We added the appendix subsection "Robustness Stress Tests", which describes the three suites and reports the results in Table R1.

AuthorsOpenReview ↗

Response to Reviewer 1eQk. Q3

Response to Reviewer 1eQk

[W3&Q3]

Concern Summarization Root-cause labels, propagation supervision, and embedding similarity can support predictive relevance, but do not establish that selected observations identify causal mechanisms. Interventions or tests that disrupt spurious associations would strengthen the cause-centered claim.

Response:

We thank the reviewer for this insightful comment. To demonstrate StateBundle selects evidence associated with the actual fault origin rather than spurious associations, we added an interventional test: we move the injected fault to a different target while holding everything else fixed, and check whether StateBundle's anchors move with it. If selection relied on a spurious association, such as a learned preference for particular racks, servers, or tenants, the anchors would stay where they were.

Fault-target relocation. We use the ten mechanisms whose faults have a specific rack, server, or tenant as target. For each, we build paired scenarios that differ only in the faulted target (AA or BB), with identical topology, workload, mechanism, severity, and injection time, and run five trials per mechanism. To isolate evidence selection from agent behavior, we extract the canonical observations at the same post-injection time in both scenarios, before any agent action. Each observation ii is assigned to a target r(i)r(i) through its observable resource identifiers.

Metrics. Fault-Target Anchor Share (FTAS) is the fraction of anchors on the injected target TIT_I:

FTAS(I)=1∣AI∣∑i∈AII[r(i)=TI].\mathrm{FTAS}(I)=\frac{1}{\lvert\mathcal{A}_I\rvert}\sum_{i\in\mathcal{A}_I}\mathbb{I}[r(i)=T_I].

In addition, we introduce Paired Target-Switch Effect (PTSE), which explicitly measures how anchor allocation changes when the injected fault moves between two targets. Let SX(Y)S_X^{(Y)} be the share of anchors on target XX when target YY is faulted.

PTSE=12[(SA(A)−SA(B))+(SB(B)−SB(A))]=FTAS−12(SA(B)+SB(A)).\mathrm{PTSE}=\frac{1}{2}\left[\left(S_A^{(A)}-S_A^{(B)}\right)+\left(S_B^{(B)}-S_B^{(A)}\right)\right]=\mathrm{FTAS}-\frac{1}{2}\left(S_A^{(B)}+S_B^{(A)}\right).

Table 2. Fault-target relocation results. Results are reported as macro-averages.:

SelectionFTAS(%)PTSE
StateBundle anchors24.48%0.2448

As shown in Table 2 , StateBundle achieves an FTAS of 24.48% and a PTSE of 0.2448. The equality between PTSE and FTAS indicates that virtually no anchors are selected from the opposite fault target, suggesting that anchor allocation responds to changes in fault location rather than reflecting a fixed target preference.

For comparison, we also report the FIAS of the full canonical observation which is 4.78%. Despite the diversity regularization that discourages semantically redundant anchors, StateBundle increases the fault-target observation share by approximately 5.12 times. These results provide evidence that StateBundle preferentially selects observations associated with the fault origin and adapts its anchor selection when the fault target changes.

Manuscript revision:

We added a new appendix subsection describing the relocation test, the two metrics, and the results above.

AuthorsOpenReview ↗

Response to Reviewer 1eQk. Q4

Response to Reviewer 1eQk

[W4&Q4]

Concern Summarization Despite aggregate gains, GPT-5.6 Sol’s localization success falls from 98.1% to 92.6%, and Claude Opus 5’s from 92.6% to 88.9%. These regressions warrant uncertainty estimates and analysis of whether selection removes evidence useful to capable models.

Response:

We thank the reviewer for highlighting the localization regressions. We agree that these differences warrant further investigation. To address this concern, we conducted uncertainty analysis of localization performance.

Uncertainty estimates. The table gives each agent's difference (StateBundle − Full-Canonical) with its 95% confidence interval. All ten intervals include zero, so there is no clear evidence of a consistent localization advantage for either setting.

AgentFull-CanonicalStateBundleDifference (pp)95% CI (pp)
DeepSeek-V4-Flash-073183.3%74.1%−9.3[−24.1, +7.4]
GPT-5.6 Luna88.9%83.3%−5.6[−14.8, +5.6]
Gemini 3.1 Flash-Lite87.0%90.7%+3.7[−7.4, +14.8]
Claude Sonnet 594.4%96.3%+1.9[−3.7, +7.4]
GPT-5.6 Sol98.1%92.6%−5.6[-11.1, +1.9]
Claude Opus 592.6%88.9%−3.7[−18.5, +11.1]
GPT-6 Astra96.3%98.1%+1.9[−5.6, +11.1]
Codex (GPT-5.6 Luna)85.2%92.6%+7.4[−5.6, +20.4]
Codex (GPT-5.6 Sol)87.0%90.7%+3.7[−7.4, +14.8]
Codex (GPT-6 Astra)88.9%88.9%0.0[−7.4, +7.4]

In addition, given the high success rates under both observation settings—487 of 540 episodes (90.2%) for Full-Canonical and 484 of 540 episodes (89.6%) for StateBundle—it can be inferred that localization is relatively well handled by the evaluated agents, leaving limited room for further improvement on many tasks. We further investigate the shared failure mode and find that the dominant failure mode is the same under both settings: agents identify a component affected by fault propagation rather than the component where the fault originates. This failure mode is concentrated in four mechanisms: storage I/O saturation (41 of 60 episodes across both settings), placement-policy misconfiguration (19/60), load-balancer misconfiguration (16/60), and autoscaler misconfiguration (11/60), which together account for 87 of the 109 failures (79.8%). The remaining 22 failures account for only 2.0% of all 1,080 localization episodes.

Overall, it can be inferred that, because the localization task is relatively easy, both Full-Canonical and StateBundle handle it well except for this common failure mode. The success-rate difference can be mainly attributed to randomness. However, these results indicate that, for tasks that are handled well, StateBundle maintains similar average performance while substantially reducing the telemetry presented to agents.

Manuscript revision:

We added the appendix subsection "Uncertainty Analysis of Localization Performance", containing the above data and analysis.

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

Data-center telemetry is fragmented and redundant, so agents either drown in context or miss the evidence that matters. StateBundle learns to build a token-budgeted bundle from a telemetry snapshot: three training stages perform cross-modal contrastive alignment, then hierarchical supervision against root-cause prototypes and subsystem propagation footprints, then four evidence-selection objectives (relevance, sufficiency, comprehensiveness, diversity); at inference it selects nonredundant root-cause-relevant anchors under a budget and attaches corroborating support observations to each. Crucially, the output is the original canonical records rather than a generated summary, so the agent can still check values, entities and timestamps. The paper also introduces DC-Bench, a deterministic discrete-time simulator that couples facility power and thermal state with compute, network, control-plane and application layers, giving 72 task instances from 18 fault mechanisms crossed with four objectives.

Across ten agent systems — seven controlled backends plus three Codex configurations, not ten independent base models — with paired runs differing only in the telemetry representation, StateBundle cuts recorded model tokens per episode by 37.4% to 80.9% and raises overall success for all ten by 2.3 to 7.4 points. At a matched budget, channel-stratified truncation and an adapted LLMLingua-2 both do substantially worse (Gemini 59.7% and 48.6% against StateBundle's 78.7%; GPT-5.6 Sol 67.6% and 54.2% against 87.5%), while unrestricted Full-Canonical reaches 72.7% and 81.0%.

One decomposition belongs in the summary, because the paper reports only aggregate success. Taking Table 1's four objective columns at equal weight across the ten systems, detection improves by 8.9 points, root-cause analysis by 6.3 and mitigation by 7.4, while localization declines by 0.55 points and falls for four of the ten systems (DeepSeek-V4-Flash 83.3% to 74.1%, GPT-5.6 Sol 98.1% to 92.6%, GPT-5.6 Luna 88.9% to 83.3%, Claude Opus 5 92.6% to 88.9%). It is also worth noting that the task names are stricter than they sound: detection requires naming the fault mechanism and citing an observed evidence term, not just flagging an anomaly, and every episode has a fault injected.

Critical strengths

1. The benchmark is the durable contribution, and the comparison is set up to be honest about what varies. Existing agentic IT-operations benchmarks model the IT stack and leave facility power and thermal behavior outside the dynamics; coupling them in one deterministic state transition, so a cooling fault propagates into service latency and a workload surge feeds back into rack power, is a real gap and a timely one. The appendix even separates true physical temperature from sensor bias, so that a biased sensor changes reported values and status without changing the physics used for throttling — which makes "actually overheating" versus "thermometer is lying" a well-posed task rather than a label.

Three controls deserve specific credit because each removes a cheap explanation of the results. First, every condition applies the same canonicalization, so the comparison is normalized-observations versus selected-normalized-observations, not raw logs versus cleaned data. Second, paired runs hold scenario manifest, topology, workload, fault target, seed, evaluator and pre-fault state fixed and vary only the agent-visible representation. Third, splits are incident-disjoint (1,868/230/206 incidents) and all benchmark seeds are excluded from training, with future records and privileged fields hidden at inference — so training on simulator-derived root-cause labels is not test-set leakage, and I would not treat it as such. I will add a fourth from the appendix: the cross-modal alignment rule refuses to treat co-membership in an incident, topological adjacency or shared propagation chain as sufficient for a positive pair, requiring compatible local manifestations instead. That is the right call — two symptoms of one root cause are not the same symptom — and it is more careful than the usual "embed all telemetry together".

The efficiency claim also survives being checked. The reported reductions reconcile with Table 1 at both ends of the stated range (Codex with GPT-5.6 Luna 181,200 to 113,484 is 37.4%; Gemini 139,114 to 26,552 is 80.9%) and for every row between. I ran the documented two-task subset through the released code under both conditions, scripting the agent's tool calls so no model endpoint was needed. To be explicit about what that run does and does not show: it measures nothing about task success. The tool calls were a fixed script and the semantic judge was the repository's own schema-only test transport returning a constant verdict, so no success or failure outcome in this paper was checked by me. What it does measure is the observation payload, which depends on neither agent nor judge, and there the mechanism holds: on an identical trajectory the agent-visible payload falls from 94,944 to 12,592 tokens on the detection task and 94,919 to 12,565 on mitigation, 86.7% and 86.8%. The budget accounting is also honest in a place where overstating would have been easy — the reported actual_serialized_tokens of 3,993 to 4,005 is exactly the token count of the evidence scope the code defines as the budget, stays under B=4096B = 4096 on every observation, and drops no selected row; the transport envelope adds a further 180 to 187 tokens, which is documented rather than a violation.

2. The token-matched control is the right control, and the paper does not lean only on it. Comparing against channel-stratified truncation at the same budget separates "shorter input helps" from "this selection helps", and the gap is large. Beyond it, the budget sensitivity sweep from 2,048 to 16,384 tokens finds improvement is not monotone in budget, which independently supports the paper's thesis rather than restating it; and the LLM semantic judge is not simply trusted — 54 responses spanning 18 mechanisms and three objectives were adjudicated by two independent human reviewers, with the lexicon matcher shown to reject 12.96% of semantically correct answers. Validating your own evaluator against humans, and reporting that your cheaper evaluator is the broken one, is a standard many submissions skip.

Critical weaknesses

1. The one capability that gets worse is the one the training objective does not cover, and the paper neither reports nor addresses this. Every Stage-3 objective is defined on the root-cause class distribution. Equation (12) is L(3)=λobsLobs+λsufLsuf+λcompLcomp+λdivLdiv\mathcal{L}^{(3)} = \lambda_{obs}\mathcal{L}_{obs} + \lambda_{suf}\mathcal{L}_{suf} + \lambda_{comp}\mathcal{L}_{comp} + \lambda_{div}\mathcal{L}_{div}; sufficiency is Lsuf=∑IDKL(sg(pIfull) ∥ pIsel)\mathcal{L}_{suf} = \sum_I D_{KL}(\mathrm{sg}(p^{full}_I) \,\|\, p^{sel}_I) over root-cause probabilities (eq. 39), and comprehensiveness is a margin on the correct root-cause confidence under complementary weights (eq. 40). Nothing in the objective refers to the faulty component identifier, the action to take, or whether recovery has completed.

The per-capability pattern in the paper's own Table 1 is the fingerprint of that scope. Equal-weight across the ten systems, RCA improves for ten of ten (+6.3 points) while localization declines on average (−0.55) and falls for four of ten, by as much as 9.2 points for DeepSeek-V4-Flash and 5.5 for GPT-5.6 Sol — the single best-performing system in the table. This is consequential in three ways. It bounds the contribution: "cause-centered selection improves agentic operations" is supported for the capability the objective targets and not supported for locating the fault, which is the capability an operator needs in order to act. It is a mechanism result the paper could have claimed and did not, since the authors' own limitations paragraph states that "a finite evidence budget may omit operationally relevant observations" — they predicted the effect, and the localization column is the measurement of it, but the two are never connected and the abstract reports only aggregate success. And it makes the framing question concrete: knowing what broke is not knowing where it broke, how to repair it, or whether the repair held.

Three further gaps in the method point the same way and should be answered together. (i) There is no token-cost term in the Stage-3 objective — no ℓi\ell_i, no BB, no constraint of the form ∑iπiℓi≤B\sum_i \pi_i \ell_i \le B — yet inference enforces a hard budget. Sufficiency as written is minimized by πi→1\pi_i \to 1 for all ii, so the training signal does not by itself require the retained set to be small; whether the learned soft ranking transfers to a discrete budget-constrained selection is asserted rather than shown. (ii) Stages 2 and 3 train on Ksnap=4K_{snap} = 4 snapshots drawn from the active-fault phase only, while episodes comprise baseline, active-fault and recovery phases and the mitigation task requires reasoning about partial recovery, resolved symptoms and residual risk. The selector is therefore trained on a distribution that excludes the states the hardest task operates in — which fits the paper's own failure analysis finding that agents repair a local problem and stop before verifying full recovery. (iii) Per equations (34)–(35) the gate scales observation vectors before hierarchical pooling, but attention pooling renormalizes over the entries in the set, so scaling a vector toward zero is not equivalent to removing that record from the normalization unless a mask is also applied. If the implementation applies one, say so; if not, the soft training objective and the hard deletion at inference differ in a second way. Relatedly, PgP_g and the aspect projections are stated to be frozen, but no full freeze/update list is given for Stage 3, so a reader cannot tell whether the teacher representation is actually fixed.

2. The aggregate gains are real but unattributable, and the three things that would attribute them are unreported, undefined, or unavailable. First, no uncertainty is reported anywhere, while the claims rest on differences of a few runs. Each objective rate is over 18×3=5418 \times 3 = 54 runs and each overall rate over 216, so headline improvements are typically 10 to 15 episodes out of 216 — Codex with GPT-6 Astra goes from 77.8% to 80.1%, which is 168/216 to 173/216, a net of five episodes. The design is paired and three trials were run, so McNemar or a paired bootstrap was directly available. I quantified what the absence costs: because only marginal counts are published and the discordant split is not, sweeping the discordant pairs over everything the marginals permit gives exact McNemar pp ranging from 6.1×10−56.1\times10^{-5} to 0.273 for DeepSeek-V4-Flash, 3.1×10−53.1\times10^{-5} to 0.152 for GPT-5.6 Luna, 2.4×10−42.4\times10^{-4} to 0.241 for Gemini 3.1 Flash-Lite, 9.8×10−49.8\times10^{-4} to 0.371 for Claude Sonnet 5, 1.2×10−41.2\times10^{-4} to 0.114 for GPT-5.6 Sol, and 2.4×10−42.4\times10^{-4} to 0.291 for Claude Opus 5. Every one of the six headline comparisons spans from clearly significant to clearly not; the ablations are in the same position (p=4.9×10−4p = 4.9\times10^{-4} if perfectly one-sided, 0.251 with 40 reversals). Three agent trials are also not three selector trainings, and no selector-seed variation is reported. I should say the table itself is arithmetically clean: all twenty rows have objective cells that are exact multiples of 1/541/54 and an overall rate equal to the pooled sum over 216, 80 cells in all, and the unit suite passes (743 tests, 108 of them StateBundle's own). The aggregate pattern — ten of ten systems improving overall — does carry evidential weight; what it does not do is license the per-objective and per-ablation conclusions drawn from it.

Second, no competitor receives the supervision StateBundle receives. StateBundle trains on 1,868 incidents with privileged root-cause and propagation labels; LLMLingua-2 is a released general-purpose compressor applied zero-shot, and TRUNC-B is a recency heuristic. Beating both shows supervised task-specific selection beats unsupervised compression, which is close to a foregone conclusion, and does not show that the hierarchical representation, the relevance/aspect split or the anchor-support structure is responsible. The missing comparison is one competitor with the same encoders, the same labels and the same training budget but a simpler selector — per-observation relevance scoring with top-kk or relevance-minus-redundancy under the same budget — plus operational heuristics (alert severity, deviation magnitude, configuration change, recency) and a direct diagnostic classifier to establish how much of the task the supervised representation already solves without an agent. The "w/o HR" ablation is not a substitute: it removes the subsystem level, the propagation loss and the propagation terms simultaneously for a 14.4-point drop, so it cannot attribute that drop to hierarchy. Two cheap separations are also missing: the same selected records presented flat versus grouped as anchors-and-supports, which would separate choosing content from organizing it; and whether the anchors-only ablation actually consumes the same tokens or merely supplies fewer records under the same cap. The LLMLingua-2 adaptation needs its conclusion scoped too — token-retention probabilities are averaged to a whole-observation score, which is a defensible way to avoid shredding structured records but is not the original algorithm, and averaging can bury the few decisive fields in a long record.

Third, the one component shared by all three budget-matched conditions is never defined. The text twice states that StateBundle, TRUNC-B and LLMLingua-2 apply "the same deterministic observation-retention policy", and that policy is nowhere specified: not whether it filters, force-retains, deduplicates or back-fills the budget; not whether it runs before or after learned selection; not how many alerts or configuration records it keeps; not whether it changes the effective budget. Since it is shared, it is a floor under all three arms, and its content determines how much of the margin is attributable to the learned module at all. Alongside it, a set of configurations needed to reproduce anything is absent: encoder dimensions, hash vocabulary size, optimizer and epochs per stage, loss weights λ\lambda, gate temperature and threshold, candidate count MM, support count KK, anchor budget share, maximum anchors, and the token-estimation rule. The supplement contains no results — the reproducibility statement promises source code only, and every evaluation path needs an agent API key, a judge key, and Docker for the Codex arms — so the trial-level outcomes that would settle every statistical question above were collected, are held by the authors, and are neither reported nor released.

Questions for authors
  1. Why does localization decline? Across the ten systems in Table 1 it falls by 0.55 points on average and drops for four systems, up to 9.2 points for DeepSeek-V4-Flash, while RCA improves for all ten. Does the loss concentrate on particular fault mechanisms, and is the bundle dropping component-identifying records (topology, entity identifiers, configuration state) that the root-cause objectives place no value on? A per-mechanism breakdown of the localization regression would be the most informative single addition to the paper. Please also report it in the main text rather than leaving the aggregate to stand alone.
  2. Given that every Stage-3 objective is defined over the root-cause class distribution, what happens with task-conditioned selection — distinct objectives or distinct bundles for detection, localization, RCA and mitigation? And what would an objective that scores retention of action-relevant and recovery-verification evidence add? Your own limitations paragraph anticipates the problem; the localization column suggests it is already measurable.
  3. How is the hard budget enforced in training? I see no ℓi\ell_i, no BB and no expected-cost constraint ∑iπiℓi≤B\sum_i \pi_i \ell_i \le B in equation (12) or Appendix C, and sufficiency alone is minimized by πi→1\pi_i \to 1. On the test set, measured on the discrete sets actually emitted at inference rather than on soft training representations, what are root-cause distribution fidelity, root-cause classification accuracy, propagation coverage and realized token usage?
  4. Do equations (34)–(35) apply a gating mask inside the attention-pooling normalization, or only scale the vectors? If only scaled, a near-zero weight still participates in the softmax denominator, which is not the same as deleting the record. Please also give the complete freeze/update list for Stage 3 — PgP_g and the aspect projections are stated as frozen, but if the encoders or pooling modules continue to update, the teacher representation is not fixed.
  5. Please define the deterministic observation-retention policy in full. It is shared by all three budget-matched conditions and therefore sits underneath every comparison in Table 2, and the paper states only that it exists. What does it filter, force-retain, deduplicate or back-fill; does it run before or after learned selection; and does it alter the effective budget?
  6. Can you report the per-episode outcomes, or at minimum the discordant counts, for the 216 matched episodes? Without them the published marginals are compatible with pp from roughly 10−410^{-4} to above 0.27 for every agent, so no reader can tell which of the ten improvements and which of the six ablation drops survive. Releasing trial-level results alongside the code costs no further experiments. Please also report variation across selector training seeds, since three agent trials do not bound it.
  7. What does a simple supervised selector achieve — same encoders, same 1,868 incidents, same root-cause and propagation labels, same training budget, but per-observation scoring and greedy budget filling — and what do operational heuristics and a direct diagnostic classifier achieve? Relatedly, what is the same selected content worth presented flat rather than as anchors with supports, and does the anchors-only ablation consume the same token count or simply fewer records?
  8. For the OOD evaluation, can you publish the specific held-out factor values, the per-axis task allocation and per-axis results, and add Full-Canonical and the other selectors under the OOD condition? Table 3 currently pools two backends and reports StateBundle alone, so similar ID and OOD rates cannot be distinguished from the shifted tasks simply not being harder. Since the text encoder is a trainable hashed-token embedding with mean pooling rather than a pretrained language model, a perturbation of log wording, metric naming or message templates — or an unseen fault mechanism — would test the dependence that matters most.
  9. Three measurement-scope clarifications. (a) Detection requires naming the fault mechanism plus an observed evidence term, and every episode contains an injected fault, so false-alarm behavior on healthy systems is not measured; would you add healthy and benign-perturbation scenarios, or rename the objective to reflect evidence-supported fault identification? (b) In Table 8, 87.04% and 12.96% are exactly complementary and 12.96%=7/5412.96\% = 7/54, so the reported FNR appears to be the share of all audited answers wrongly rejected rather than a rate over truly-correct answers; please publish the confusion matrix and state the denominator. (c) Mitigation success requires performing all required control actions; which of those are part of the task contract and which encode one preferred repair path, and would an alternative valid remediation be scored as failure?
  10. Two efficiency and framing scope items. Episode-level cumulative model tokens and a 4,096-token per-snapshot budget are different quantities, and the former also moves with interaction rounds and re-sent history — could you report input, output and other billable tokens separately, plus mean rounds, and the latency and training cost of canonicalization, encoding and retrieval? And since simulator time does not advance with model inference latency, the token reduction should not be read as reduced fault duration. Finally, the propagation head predicts subsystem membership in a hidden propagation footprint rather than recovering a causal graph, and the trace source is stated to be "a request-flow abstraction rather than a full OpenTelemetry span tree" with every output group marked critical path — both worth stating as scope in the main text, so "cause-centered" reads as root-cause-supervised selection rather than verified causal identification.
3 comments
AuthorsOpenReview ↗

Response to Reviewer [AfMq] [Q1-Q3]

[Q1]

Concern Summarization Why does localization decline?

Response:

We thank the reviewer for the insightful comment. We conducted uncertainty analysis of localization performance. As shown in Table 1, all ten intervals include zero, so there is no clear evidence of a consistent localization advantage for either setting.

Tabel 1. Uncertainty analysis for agents' difference in localization with 95% confidence interval.

AgentFull-CanonicalStateBundleDifference (pp)95% CI (pp)
DeepSeek-V4-Flash-073183.3%74.1%−9.3[−24.1, +7.4]
GPT-5.6 Luna88.9%83.3%−5.6[−14.8, +5.6]
Gemini 3.1 Flash-Lite87.0%90.7%+3.7[−7.4, +14.8]
Claude Sonnet 594.4%96.3%+1.9[−3.7, +7.4]
GPT-5.6 Sol98.1%92.6%−5.6[-11.1, +1.9]
Claude Opus 592.6%88.9%−3.7[−18.5, +11.1]
GPT-6 Astra96.3%98.1%+1.9[−5.6, +11.1]
Codex (GPT-5.6 Luna)85.2%92.6%+7.4[−5.6, +20.4]
Codex (GPT-5.6 Sol)87.0%90.7%+3.7[−7.4, +14.8]
Codex (GPT-6 Astra)88.9%88.9%0.0[−7.4, +7.4]

In addition, given the high success rates under both observation settings—487 of 540 episodes (90.2%) for Full-Canonical and 484 of 540 episodes (89.6%) for StateBundle—it can be inferred that localization is relatively well handled by the evaluated agents, leaving limited room for further improvement on many tasks. We further investigate the shared failure mode and find that the dominant failure mode is the same under both settings: agents identify a component affected by fault propagation rather than the component where the fault originates. This failure mode is concentrated in four mechanisms: storage I/O saturation (41 of 60 episodes across both settings), placement-policy misconfiguration (19/60), load-balancer misconfiguration (16/60), and autoscaler misconfiguration (11/60), which together account for 87 of the 109 failures (79.8%). The remaining 22 failures account for only 2.0% of all 1,080 localization episodes.

Overall, it can be inferred that, because the localization task is relatively easy, both Full-Canonical and StateBundle handle it well except for this common failure mode. The success-rate difference can be mainly attributed to randomness. However, these results indicate that, for tasks that are handled well, StateBundle maintains similar average performance while substantially reducing the telemetry presented to agents.

[Q2]

Concern Summarization What happens with task-conditioned selection — distinct objectives or distinct bundles for detection, localization, RCA and mitigation? And what would an objective that scores retention of action-relevant and recovery-verification evidence add?

We thank the reviewer for this insightful comment. As described in the Introduction and Method sections, the primary objective of StateBundle is to filter irrelevant and redundant telemetry while organizing evidence relevant to the underlying system fault, rather than optimizing evidence selection separately for individual operational tasks. Accordingly, the current Stage-3 objectives focus on preserving root-cause-relevant evidence and do not explicitly condition selection on whether the downstream task is detection, localization, RCA, or mitigation.

We agree that different operational tasks may benefit from different evidence. However, this revision may deviate the core objective of the design of StateBundle. We will carefully consider your suggestion and possibly conduct project about it in our future work.

We also recognize that the phrase "task-oriented evidence-selection objectives" in our Introduction may be misleading, as it could suggest that evidence selection is explicitly conditioned on individual operational tasks. We will revise this wording to "root-cause-oriented evidence-selection objectives" to clarify the intended scope of the proposed method.

[Q3]

Concern Summarization How is the hard budget enforced in training?

We thank the reviewer for highlighting the distinction between the differentiable training objectives and the discrete, budget-constrained inference procedure.

We clarify that the Stage-3 objective does not explicitly incorporate a token-cost penalty or a hard budget constraint. Instead, Stage 3 learns relevance scores and selection weights that guide evidence selection, while the token budget is enforced during inference. To evaluate the effectiveness of this approach, we conduct a Sensitivity to the Telemetry Token Budget experiment, examining the trade-off between task performance and token consumption under different budgets. The results show that a 4,096-token budget provides a favorable balance between these two objectives, supporting the practical effectiveness of the budget-constrained inference procedure.

AuthorsOpenReview ↗

esponse to Reviewer [AfMq] [Q4-Q8]

[Q4]

Concern Summarization Do equations (34)–(35) apply a gating mask inside the attention-pooling normalization, or only scale the vectors?

We thank the reviewer for requesting clarification of the Stage-3 training procedure.

In Equations (34)–(35), we scale the observation embeddings using the soft inclusion gates π\pi. This soft reweighting is not mathematically equivalent to removing observations but serves as a differentiable approximation during training.

Regarding PgP_g, it is used to initialize the observation- and subsystem-relevance projection heads rather than to provide the teacher representation during Stage 3.

Below is the list that explain the trainable and frozen modules in stage 3.

Module in the manuscriptManuscript symbolStage 3 status
Observation relevance projectionPrelP_{\mathrm{rel}}Trainable
Subsystem relevance projectionPsubP_{\mathrm{sub}}Trainable
Modality-specific observation encoders and channel projectionsfcf_c, PcP_cFrozen
Aspect projectionPaspP_{\mathrm{asp}}Frozen
Subsystem attention-pooling projectionWs\mathbf{W}_sFrozen
Global relevance projectionPgP_gFrozen

[Q5]

Concern Summarization Please define the deterministic observation-retention policy in full.

We thank the reviewer for the valuable comment. We apologize for not adequately describing the deterministic observation-retention policy in our paper. In practice, this policy preserves agent-requested evidence and post-action verification evidence (since StateBundle lack cross-loop memory). In addition, the policy retains salient observations, such as active severe and target-bearing alerts to imitate the real-world data-center operation systems.

It runs before the learned selection, and its retained observation will also be counted in the fixed budget. We will add the description for the deterministic observation-retention policy in section 3 main paper.

[Q6]

Concern Summarization Can you report the per-episode outcomes, or at minimum the discordant counts, for the 216 matched episodes?

We thank reviewer for this comment. However, after careful consideration, we think it not appropriate to report the per-episode outcomes which is totally 2160 pieces of data for the end-to-end result and 1296 pieces of data for ablation studies. For the discordant, there also will be hundard of pieces data which isn't appropriate to be pubilshed in main paper or appendix of ICLR. However, we opened the source code and parameter details with which the result can be reproduced by the reader and the required data can be accessable.

[Q7]

Concern Summarization What does a simple supervised selector achieve?

We thank the reviewer for this valuable suggestion. We agree that a simple supervised baseline is necessary for comparision. We added added STbase, a simple flat selector trained with the same supervision as StateBundle. Please refer to Response to Reviewer [CXZZ] W2&Q2 for the details

[Q8]

Concern Summarization For the OOD evaluation, can you publish the specific held-out factor values and add Full-Canonical under the OOD condition? We thank the reviewer for these helpful suggestions.

The held-out factor values are ai_training for workload, 1r-2row-4rack-10server for topology, and rack-r1-row1-02 for fault target.

To distinguish StateBundle's robustness from potential changes in task difficulty under distribution shifts, we additionally evaluate Gemini 3.1 Flash-Lite in the Full-Canonical setting on the OOD test set. The results are presented below.

BackboneTest SetDetectLocalizeRCAMitigateOverallTokens
Gemini 3.1 Flash-LiteID75.987.070.457.472.7139,114
Gemini 3.1 Flash-LiteOOD72.287.072.255.671.8135,409

The results show that Full-Canonical achieves comparable overall success rates on the ID and OOD test sets (72.7% versus 71.8%). This suggests that the shifted tasks have comparable difficulty to the original tasks.

For your suggestion regarding perturbations and unseen fault mechanisms, we have additionally conducted experiments involving stochastic system dynamics, telemetry imperfections, and unseen fault mechanisms. Please refer to our responses to Reviewer [CXZZ], W1&Q1, and Reviewer [1eQk], W1&Q1, for the experimental settings and results.

AuthorsOpenReview ↗

Response to Reviewer [AfMq] [Q9-Q10]

[Q9]

Concern Summarization (a)Would you rename detection to reflect evidence-supported fault identification? (b) The reported FNR appears to be the share of all audited answers wrongly rejected rather than a rate over truly-correct answers (c)Mitigation success requires performing all required control actions; which of those are part of the task contract and which encode one preferred repair path, and would an alternative valid remediation be scored as failure?

We thank the reviewer for these helpful comments.

(a) To avoid misleading terminology, we will rename the task Evidence-Supported Fault Identification (ESFI), which more accurately reflects its objective of identifying the underlying fault mechanism using observed evidence.

(b) The reviewer is correct: we computed FNR and FPR over all 54 audited submissions, so the reported 12.96% is the share of all audited submissions that the lexicon-based matcher wrongly rejected (7/54).

The revised confusion matrices and rates are:

EvaluatorTPFNFPTNAgreementFNRFPR
Lexicon-based matcher37701087.04%15.91% (7/44)0% (0/10)
LLM semantic judge440010100%0% (0/44)0% (0/10)

We will revise Table 8 to report the corrected FNR and FPR.

(c) Across the 18 mitigation scenarios, we require agents to execute one or two control actions that we consider necessary for successful mitigation. This requirement is primarily designed to prevent agents from merely satisfying the system-health criteria without addressing the underlying fault.

[Q10]

Concern Summarization Could you report the detailed token cost and training cost? Since simulator time does not advance with model inference latency, the token reduction should not be read as reduced fault duration."Cause-centered" reads as root-cause-supervised selection rather than verified causal identification.

Regarding token usage, most model tokens are input tokens, while output tokens account for approximately 1% of input tokens. We clarify that the reported episode-level token usage is cumulative across interaction rounds, whereas the 4,096-token budget applies to each selected telemetry snapshot. Regarding training cost, StateBundle was trained on a single NVIDIA L40 GPU for approximately six hours.

In our simulator, simulation time does not advance during model inference to reduce randomness and ensure reproducibility. Therefore, the reduction in token consumption does not directly translate into a shorter fault duration in our experiments. However, in real-world deployments, reduced inference latency could potentially enable faster interventions and shorten fault duration, although this effect is not evaluated in our current experiments.

Finally, we agree with the reviewer that "cause-centered" should be understood as root-cause-supervised evidence selection rather than verified causal identification. We will clarify these distinctions in the main manuscript.

Reviewer_CZXXOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes StateBundle, a method for selecting compact and relevant telemetry for data-center operation agents. It also introduces DC-Bench, a simulator-based benchmark covering both facility-level and IT-level faults. StateBundle uses root-cause and propagation supervision to select evidence under a token budget, and is evaluated against full telemetry and compression or truncation baselines.

Critical strengths
  1. DC-Bench covers both facility-level and IT-level data-center behavior. This gives the benchmark a broader operational scope than evaluations limited to the software stack.

  2. The comparison with full telemetry is reasonably controlled. It provides useful evidence that StateBundle can reduce token usage within the proposed benchmark.

Critical weaknesses
  1. The generalization claim is not sufficiently tested. Training and testing use the same fault families and simulator rules. The OOD evaluation changes workload, topology, or target, but does not test unseen fault mechanisms or propagation patterns.

  2. There is no simple baseline using the same supervision as StateBundle. StateBundle uses root-cause and propagation labels, while the main baselines do not. The current comparison does not isolate the effect of the proposed hierarchical design.

Questions for authors
  1. Can the authors evaluate StateBundle on unseen fault mechanisms or unseen propagation patterns? The current OOD evaluation changes workload, topology, or target, but the fault families remain the same.

  2. Can the authors add a simple selector trained with the same root-cause and propagation supervision as StateBundle? The current baselines do not receive the same supervision. The effect of the hierarchical design is therefore not isolated.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Response to Reviewer CXZZ W1&Q1

Response to Reviewer [CXZZ]

[W1&Q1]

Concern Summarization The generalization claim is not sufficiently tested. Can the authors evaluate StateBundle on unseen fault mechanisms or unseen propagation patterns? The current OOD evaluation changes workload, topology, or target, but the fault families remain the same.

Response:

We thank the reviewer for this valuable suggestion. We agree that our original OOD evaluation only considered shifts in workload, topology, and fault target, without assessing generalization to unseen fault mechanisms. To address this limitation, we have added a mechanism-OOD experiment.

Specifically, we hold out an entire thermal-derating family comprising four fault mechanisms: cooling degradation, rack hotspot, power overload, and thermal throttling. All incidents associated with these mechanisms are excluded from training across all three training stages. To control for the effect of training-set size, we generate additional incidents from the remaining 14 mechanisms, maintaining the same numbers of training and validation incidents as in the original ID setting. The model architecture, training procedure, and hyperparameters remain unchanged.

We evaluate the retrained StateBundle using GPT-5.6 Sol and Gemini 3.1 Flash-Lite as agent backends. As shown in Table 1, the mechanism-OOD model maintains comparable overall performance to the ID-trained model across the full benchmark. To directly assess generalization to unseen fault mechanisms, we further compare the two models exclusively on the four held-out thermal-derating mechanisms (Table 2). The results show that the mechanism-OOD model achieves comparable overall success rates despite having no training exposure to these four fault mechanisms.

Table 1. Overall performance across all 72 benchmark tasks under different evaluation settings. Factor-OOD refers to the original results in Section 5.5 with held-out scenario-factor values, whereas Mechanism-OOD refers to the new evaluation using StateBundle trained without the four held-out fault mechanisms.

AgentIDFactor-OODMechanism-OOD
Gemini 3.1 Flash-Lite78.7%79.6%77.8%
GPT-5.6 Sol87.5%86.1%87.0%

Table 2. Comparison of STATEBUNDLE performance under in-distribution (ID) and mechanism-OOD settings on the four held-out thermal-derating fault mechanisms.

Agent / SettingDetectLocalizeRCAMitigateOverall
Gemini 3.1 Flash-Lite — ID83.3%91.7%75.0%50.0%75.0%
Gemini 3.1 Flash-Lite — Mechanism-OOD91.7%83.3%66.7%50%72.9%
GPT-5.6 Sol — ID91.7%91.7%83.3%58.3%81.3%
GPT-5.6 Sol — Mechanism-OOD83.3%100.0%75.0%75.0%83.3%

Manuscript revision:

We will add these revision to the final manuscript including the revision for Section 5.5 and a new section in appendix that describe the training data construction protocol.

AuthorsOpenReview ↗

Response to Reviewer CXZZ W2&Q2

Response to Reviewer CXZZ

[W2&Q2]

Concern Summarization There is no baseline using the same supervision as StateBundle. Can the authors add a simple selector trained with the same root-cause and propagation supervision as StateBundle? The effect of the hierarchical design is therefore not isolated.

Response:

We thank the reviewer for this valuable suggestion. We agree that current comparison method TRUNC-B and LLMLingua-2 receive none of our root-cause or propagation supervision, and that the "w/o HR" ablation in Table 4 totally remove the subsystem supervision making the training protocal different from StateBundle. Hence, neither comparison isolates the hierarchical design. We have therefore added STbase, a simple flat selector trained with the same supervision as StateBundle.

Construction of STbase. STBase is constructed to compare StateBundle with a baseline using the same training supervision and assess the contribution of the hierarchical design. It is a simple and flat counterpart of StateBundle trained with the same supervision signals as StateBundle. STBase follows the same overall training and inference protocols as StateBundle but differs in three key aspects:

First, STbase forms no subsystem representations: all observations are pooled directly into the incident representation, trained with the unchanged Lrc\mathcal{L}_{\mathrm{rc}}:

gIflat=∑i=1NIωI,izI,i,ωI,i=softmaxi(wflat⊤tanh⁡(WflatzI,i)).\mathbf{g}^{\mathrm{flat}}_I=\sum_{i=1}^{N_I}\omega_{I,i}\mathbf{z}_{I,i},\qquad\omega_{I,i}=\mathrm{softmax}_i\big(\mathbf{w}_{\mathrm{flat}}^{\top}\tanh(\mathbf{W}_{\mathrm{flat}}\mathbf{z}_{I,i})\big).

Second, propagation membership is predicted for each observation, m^I,iobs=σ(gpropflat[zI,i∥gIflat∥(zI,i⊙gIflat)])\widehat{m}^{\mathrm{obs}}_{I,i}=\sigma\big(g^{\mathrm{flat}}_{\mathrm{prop}}[\mathbf{z}_{I,i}\mathbin{\Vert}\mathbf{g}^{\mathrm{flat}}_I\mathbin{\Vert}(\mathbf{z}_{I,i}\odot\mathbf{g}^{\mathrm{flat}}_I)]\big), and trained with the same subsystem labels mI,sm_{I,s} and class weights w+,w−w_{+},w_{-} as Lprop\mathcal{L}_{\mathrm{prop}}:

Lpropflat=∑I∑s∈SI1∣OI,s∣∑i∈OI,sBCEw+,w−(m^I,iobs,mI,s),\mathcal{L}^{\mathrm{flat}}_{\mathrm{prop}}=\sum_{I}\sum_{s\in\mathcal{S}_I}\frac{1}{\lvert\mathcal{O}_{I,s}\rvert}\sum_{i\in\mathcal{O}_{I,s}}\mathrm{BCE}_{w_{+},w_{-}}\big(\widehat{m}^{\mathrm{obs}}_{I,i},m_{I,s}\big),

where BCE stands for Binary Cross-Entropy, OI,s={i:a(i)=s}\mathcal{O}_{I,s}=\lbrace i:a(i)=s\rbrace and the factor 1/∣OI,s∣1/\lvert\mathcal{O}_{I,s}\rvert gives each subsystem the same total loss weight as in Lprop\mathcal{L}_{\mathrm{prop}}. Subsystem identity remains visible through the encoder's metadata branch, so STbase receive the same supervision during the training stage.

Third, the retrieval score drops the subsystem relevance term λssim(uI,i,hI,a(i)rel)\lambda_s\mathrm{sim}(\mathbf{u}_{I,i},\mathbf{h}^{\mathrm{rel}}_{I,a(i)}):

qI,iflat=λgsim(uI,i,gIrel)+λpm^I,iobs.q^{\mathrm{flat}}_{I,i}=\lambda_g\mathrm{sim}(\mathbf{u}_{I,i},\mathbf{g}^{\mathrm{rel}}_I)+\lambda_p\widehat{m}^{\mathrm{obs}}_{I,i}.

The comparison between StateBundle and STbase therefore isolates the hierarchical design under matched supervision.

Table 3. Success rates (%) over 72 tasks × 3 trials and average model tokens per episode:

BackboneMethodDetectLocalizeRCAMitigateOverallTokens
Gemini 3.1 Flash-LiteSTbase72.279.663.044.464.830,274
StateBundle83.390.779.661.178.726,552
GPT-5.6 SolSTbase87.081.572.250.072.785,471
StateBundle98.192.690.768.587.577,388

The results in Table 3 show that StateBundle outperforms STbase for both backbones, demonstrating the contribution from StateBundle's structural design (i.e. hierarchical subsystem modeling).

Manuscript revision:

We will add these revision to the final manuscript including the revision for Section 5.4 and a new section in appendix that describe the details of STbase.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.