Pith. sign in

REVIEW 5 major objections 6 minor 58 references

AtumAI's central claim: one agentic pipeline compiles a plain-language policy request into a formal searchable specification and autonomously finds policies that beat expert baselines on placement, scaling, and power.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-04 04:33 UTC pith:P26AFDTP

load-bearing objection A coherent and genuinely new framework for control-plane policy generation, but the headline numbers rest on simulator fidelity and baseline strength that the paper does not yet establish. the 5 major comments →

arxiv 2608.02569 v1 pith:P26AFDTP submitted 2026-08-03 cs.AI cs.DCcs.OS

AtumAI: A Principled Framework for Agentic Generation of Datacenter Control-Plane Policies

Qiushi Lin , Chaojie Zhang , \'I\~nigo Goiri , Aditya Akella , Ricardo Bianchini , Jovan Stojkovic This is my paper
classification cs.AI cs.DCcs.OS
keywords agentic AIdatacenter control planepolicy generationintermediate representationevolutionary searchworkload placementresource scalingpower management
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

AtumAI claims that datacenter control-plane policy design can be automated end to end: from a plain-language request, a compiler produces a machine-checkable specification of objectives, constraints, decision variables, and evaluation methodology, and an evolutionary loop searches that specification until it finds a validated policy. Across three tasks with very different trade-offs—workload placement, resource scaling, and power management—the paper reports that AtumAI's policies consistently beat expert-engineered baselines: 17% higher placement success, 24% better cost efficiency at 1.3% SLO violations, and 21% less power with 17% more throughput. The paper also claims the pipeline transfers control knowledge across tasks via a shared library of optimization passes and that its gains come mostly from the framework's structure, not from any single language model. A sympathetic reader would care because the status quo—months of manual prototyping for each policy, with the policy frozen once shipped—does not keep pace with evolving hardware and workloads; if AtumAI is right, a new policy task can be onboarded in hours and regenerated as conditions change.

Core claim

The paper's central claim is that datacenter control-plane policy design reduces to compilation plus search. The Datacenter Task Compiler turns a plain-language request into a machine-checkable intermediate representation—decision variables, prioritized objectives, hard constraints as predicates, evaluation methodology, and execution budget—grounded in mined workload and platform data. The Evolutionary Design Discovery Loop searches that IR by seeding with language-model proposals, expanding via masked structural edits and evolutionary parameter tuning, filtering with an uncertainty-aware surrogate, and simulating survivors across workload regimes; only constraint-satisfying candidates are a

What carries the argument

The load-bearing object is the intermediate representation (IR), a validated schema that makes every policy problem formal and searchable: it names decision variables, objectives with priorities, hard constraints as machine-checkable predicates, evaluation methodology, and an execution budget. Supporting it are a shared library of optimization passes—reusable, domain-agnostic control ideas whose canonical formulas are projected onto a target domain's concrete signals—and the Evolutionary Design Discovery Loop, which expands seeds via masked structural edits and evolutionary parameter search, filters candidates with an uncertainty-aware surrogate, evaluates survivors in a high-fidelity simula

Load-bearing premise

The load-bearing premise is that the high-fidelity simulators used for both search and final evaluation faithfully represent production behavior; Section VI asserts each simulator is validated against a real system but shows the detailed cross-check for only the resource-scaling one.

What would settle it

Run the generated policies in a production shadow fleet or hardware-in-the-loop testbed, replaying the same workload traces against live systems, and compare placement admission and throughput, scaling cost-efficiency at the SLO-violation rate, and power and accuracy against the expert baselines; if the measured gains do not reproduce within noise—for instance, the scaling policy cannot hold roughly 24% cost efficiency at 1.3% SLO violations outside simulation, or an audit shows the search exploited a simulator artifact—the central claim collapses.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • Onboarding a new control-plane task can shrink from months of hand engineering to writing a natural-language description plus providing traces and platform data; the compiler handles problem formulation.
  • Policies are no longer frozen at deployment: the same pipeline can be re-run as workloads, hardware, or operating conditions shift, which the paper frames as a self-evolving datacenter.
  • Control knowledge compounds across tasks: a pass distilled on one problem carries to others, so each new domain extends the library instead of restarting.
  • The system depends only modestly on which language model is used: all tested models beat the expert baseline, indicating the gains come from structure rather than the strongest model.
  • Because constraints are machine-checkable in the IR, accepted candidates carry a guarantee that they satisfy hard constraints across the evaluated workload regimes.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • Inference: the horizon-matching pattern in resource scaling—slow actions get long prediction horizons, fast actions get short ones—looks like a reusable design principle that could generalize beyond scaling, but the paper leaves it as a local observation.
  • Inference: a direct testable extension is to apply the same compiler-plus-loop to control problems the paper did not study, such as cache or replica placement, traffic routing, or thermal-aware scheduling; the IR and pass library were explicitly built for transfer.
  • Inference: the ablation pattern, where structured feedback alone adds little but multiplies the value of diffusion and evolution, suggests that failure feedback, not raw fitness, is the bottleneck in language-model-driven design search; testing this in other agentic optimization domains would be a natural next step.
  • Inference: if the framework transfers to real deployment, policy maintenance could shift from periodic human retuning to continuous automated re-optimization; the paper gestures at this with the self-evolving datacenter idea but does not demonstrate the long-run loop.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

5 major / 6 minor

Summary. The paper introduces AtumAI, a framework that generates datacenter control-plane policies from plain-language requests. The Datacenter Task Compiler formalizes a request into a machine-checkable intermediate representation (IR) of decision variables, objectives, constraints, evaluation methodology, and execution budget, grounded in mined workload/platform characterization. The Evolutionary Design Discovery Loop searches this IR using LLM-generated seeds, masked structural edits realized via an LLM ('discrete diffusion'), evolutionary parameter tuning, a surrogate filter, high-fidelity simulation, and feedback-driven iteration, returning the best validated policy. The system is evaluated on three tasks—workload placement, resource scaling, and power management—reporting normalized gains over expert-engineered baselines (e.g., 1.13x, 1.27x, and 1.31x) and ablations isolating the loop mechanisms and the compiler. The paper claims that a single pipeline generalizes across distinct control-plane problems and that generated policies are deployable.

Significance. If the empirical claims hold, the contribution is substantial: AtumAI would be one of the first end-to-end frameworks to turn an informal policy goal into a validated datacenter control-plane policy, with a formal IR, a deterministic critic, fail-closed structural edits, explicit constraint checking, and a transferable pass library. The conceptual design is thoughtful and the detailed algorithms are a strength: the machine-checkable IR, the rule-based critic (not an LLM), the quota-based surrogate selection, and the workload-regime matrix are all concrete and plausible mechanisms. However, the quantitative headline—that generated policies consistently outperform expert-engineered baselines and reflect deployable behavior—is not yet established. The evaluation uses the same simulator, traces, and scoring function for both search and final reporting, with no held-out data, no variance estimates, and weak or underspecified baselines. These are load-bearing issues for the central claim, though they are addressable within the scope of a revision.

major comments (5)
  1. [Section VI, Algorithm 2] The reported scores are the result of selection on the evaluation set. Algorithm 2 returns 'best validated policy in rows' (line 10), and Figures 6–8 report that policy's score on the same simulator, same workload traces, and same scoring function used to rank candidates throughout the search. The baselines are not subject to any equivalent selection. The gains therefore conflate search effectiveness with selection bias and do not measure out-of-sample policy quality. I ask for a held-out evaluation (e.g., temporally separated or unseen traces) and repeated runs with confidence intervals. Without this, the central claim 'policies generated by AtumAI consistently outperform expert-engineered baselines' is not supported.
  2. [Section VI, first paragraph] The paper states 'Each simulator is validated against a real system (e.g., we cross-check the resource-scaling simulator against a Kubernetes deployment [19])' and then asserts that 'the reported gains reflect deployable behavior.' The only validation described is for resource scaling; no validation results are reported for workload placement or power management. If the placement or power simulators omit real constraints (e.g., colocation-induced tail latency, power-capping dynamics), the search can exploit simulator artifacts and the accepted policies can violate constraints in production. Provide quantitative validation for all three simulators, or substantially temper the deployability claim.
  3. [Section VI-A, VI-B, VI-C] The baselines are not convincingly 'expert-engineered.' The placement baseline is a generic hand-tuned best-fit policy; the scaling baseline is described as a reactive threshold-based autoscaler, whereas the cited production system, Autopilot, is more sophisticated; and the power baseline is explicitly 'the highest-accuracy, highest-power option an operator defaults to,' which is an unoptimized default rather than an expert policy. The power ablation in Figure 8(c) shows the LLM alone reaching 1.00x, exactly the baseline, which is consistent with a weak comparator. The reported gains also depend on author-chosen scoring weights (VMScore weights; 0.5/0.5 for scaling; 0.45/0.35/0.20 for power). Please compare against named production-grade policies or strong prior-art baselines, and include sensitivity analysis for the scoring weights.
  4. [Section VI, Figures 6–8] No error bars, no multiple seeds, and no significance tests are reported. The LLM-sensitivity spreads (e.g., placement 1.03–1.13, scaling 1.21–1.33, power 1.28–1.31) may be entirely within run-to-run noise, especially given the stochasticity of LLM sampling, diffusion edits, and evolutionary mutation. The 'score over generations' plots appear to be single trajectories. Add repeated independent runs and report distributions or confidence intervals for the final scores and ablations. Without these, the claimed quantitative improvements are not statistically grounded.
  5. [Section VI-D, Figure 9] The claim that 'an LLM alone fails to emit a valid policy at all, so it scores zero' is difficult to interpret. Without the Datacenter Task Compiler, there is no IR, no pass library, and no evaluation harness, so the zero may reflect missing scaffolding rather than the quality of LLM-generated policies. The configurations 'hand-written IR' and 'IR + hints' are also not described in enough detail to judge whether they are fair comparators. Please specify what exactly is provided in each configuration and how validity is assessed.
minor comments (6)
  1. [Abstract] Typographical issues: 'nottransferable' and 'notsystematic' are missing spaces in the abstract.
  2. [Figures 6–8] The panel (c) x-axis label 'Atum' should be 'AtumAI' for clarity.
  3. [Section VI-B and VI-C] The text mentions 'Gemini 2.5 Flash-Lite' reaching 1.21x (scaling) and 1.28x (power), but Figures 7(d) and 8(d) only show three models (Flash, Pro, Opus). The figures should include all models discussed, or the text should be adjusted.
  4. [Section VI, first paragraph] The term 'Gen-0 policy' is used to define normalization but is not defined. Please explain this term or replace it with a clear definition of the baseline.
  5. [Section V-B] The method called 'discrete diffusion' is implemented as LLM mask-and-denoise with a fixed mask set, rather than a trained diffusion model. Consider naming it 'masked structural editing' to avoid confusion with standard diffusion models.
  6. [Section VI-A, VI-B, VI-C] The phrase 'tens of generations' is vague. Please report the exact search budget (generations, candidate counts, simulation quota) for each use case to support reproducibility.

Circularity Check

0 steps flagged

No significant circularity: reported scores are measurements of the returned policy, not predictions forced by the fitted inputs, and the surrogate is explicitly excluded from final scoring.

full rationale

I found no load-bearing step in which a claimed prediction reduces by definition to its inputs. The selection/evaluation loop uses the same high-fidelity simulator for search and reporting, and Algorithm 2 returns the best validated policy; this is a selection-bias and generalization concern, not a circularity, because the reported policy's score is a measured outcome of an optimization process that could have failed to beat the baseline. The paper explicitly separates the surrogate from the final result ('every reported policy is measured in the high-fidelity simulator, not the surrogate'), so the nearest fitted-input/prediction circularity is broken. The IR and pass library are representational/transfer mechanisms, not fitted predictors of the reported gains. The Section VI.D normalization ('All scores are normalized to the full Datacenter Task Compiler (=100%)') makes the full compiler's 100% a definitional convention, but the informative ablation evidence is the partial-configuration gaps (82-96%, LLM-only zero), so this is not a circular load-bearing claim. Self-citations such as [44], [46], [47] are background and data-source citations, not used to force the central result. The paper itself concedes that policies that perform well in the optimization loop can fail in production (Section I), and Section VI gives only one simulator-validation example, leaving placement and power simulator fidelity and baseline representativeness as genuine empirical risks; but those are correctness risks, not circularity. Overall, the derivation is not circular.

Axiom & Free-Parameter Ledger

2 free parameters · 4 axioms · 0 invented entities

The system's claims depend on the fidelity of its simulators and the representativeness of its traces, plus hand-chosen scoring weights that define the objective. These are not independently evidenced.

free parameters (2)
  • Evaluation scoring weights = placement 0.50/0.20/0.20/0.10; scaling 0.5/0.5; power 0.45/0.35/0.20
    Hand-chosen weights determine the objective being optimized and are also the exact axes on which results are reported; not justified by any stated utility function.
  • Search budget (generations, candidate quotas) = tens of generations; ~130 candidates/generation with 7 simulated (placement)
    Budgets affect search quality and cost but are not tuned or justified; not directly load-bearing for the qualitative claims.
axioms (4)
  • domain assumption The high-fidelity simulators faithfully represent production behavior for placement, scaling, and power management.
    Invoked in Section VI opening ('every reported policy is measured in the high-fidelity simulator... so the reported gains reflect deployable behavior'); one Kubernetes cross-check mentioned, no validation data.
  • domain assumption The workload traces (Azure VM, Alibaba, Azure LLM inference) are representative of production conditions.
    Used to drive search and evaluation; no held-out set or distribution-shift analysis.
  • domain assumption Hard constraints encoded in the IR and checked by the simulator are complete and correct.
    Evaluate stage drops constraint violators; if a real constraint is absent from the simulator, the returned policy is not actually feasible.
  • domain assumption The rule-based critic guarantees semantic correctness of the IR, not just well-typedness.
    Critic checks typing and invented values; playbooks fill gaps, but the paper does not prove the IR matches the engineer's intent.

pith-pipeline@v1.3.0-daily-deepseek · 20874 in / 14621 out tokens · 129713 ms · 2026-08-04T04:33:59.045206+00:00 · methodology

0 comments
read the original abstract

The efficiency of a datacenter rests on its control plane policies. Designing these policies is increasingly hard: the hardware-software stack grows fast, the design space is vast and interdependent, and prototyping a single policy takes months. Agentic AI promises to automate this search. Off the shelf, however, it falls short on three fronts. It is not formal: with no structured, searchable statement of the problem, the search has little structure to exploit and hard constraints are not guaranteed. It is not transferable: each task is solved from scratch, so nothing learned on one task carries to the next. Finally, it is not systematic: relying on the LLM as the sole source of candidates, it explores a narrow slice of the design space and settles into local optima. We introduce AtumAI, a framework that generates datacenter control-plane policies with agentic AI, making the process formal, transferable, and systematic. From a goal stated in plain language, AtumAI autonomously proposes, tests, and refines candidate policies until one satisfies the request. It does so through two components. The Datacenter Task Compiler automates problem formulation: it compiles the request into a formal, machine-checkable, and searchable specification of the task's objectives, constraints, decision variables, and evaluation methodology. The Evolutionary Design Discovery Loop then searches this specification, expanding the search beyond the LLM itself via a diffusion model, an evolutionary algorithm, and a surrogate model. Together, they reduce onboarding a new task from months of engineering to writing its description. We evaluate AtumAI on three control-plane tasks with distinct problem scopes, design spaces, and trade-offs: workload placement, resource scaling, and power management. Across all tasks, the policies generated by AtumAI consistently outperform expert-engineered baselines.

Figures

Figures reproduced from arXiv: 2608.02569 by Aditya Akella, Chaojie Zhang, \'I\~nigo Goiri, Jovan Stojkovic, Qiushi Lin, Ricardo Bianchini.

Figure 1
Figure 1. Figure 1: Overview of AtumAI. The Datacenter Task Compiler [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: The Datacenter Task Compiler raises a natural-language request [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Projection as knowledge transfer. One abstract pass carries a canonical [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figure 5
Figure 5. Figure 5: Expansion and filtering. A seed is expanded along two axes, i.e., [PITH_FULL_IMAGE:figures/full_fig_p007_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Workload placement. (a) Baseline vs. AtumAI per quality component and final score, normalized to the baseline ( [PITH_FULL_IMAGE:figures/full_fig_p009_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Resource scaling. (a) Baseline vs. AtumAI per quality component and final score, normalized to the baseline ( [PITH_FULL_IMAGE:figures/full_fig_p010_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Power management. (a) Baseline vs. AtumAI per quality component and final score, normalized to the baseline ( [PITH_FULL_IMAGE:figures/full_fig_p011_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: Final policy quality with six configurations of increasing compiler [PITH_FULL_IMAGE:figures/full_fig_p011_9.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

58 extracted references · 16 linked inside Pith

  1. [1]

    AWS Graviton Processor,

    Amazon AWS, “AWS Graviton Processor,” https://aws.amazon.com/pm/ ec2-graviton/?trk=68d7c491-4ff9-4549-b7e7-778fc8ff3952, 2026

    2026

  2. [2]

    Memory Hierarchy for Web Search,

    G. Ayers, J. H. Ahn, C. Kozyrakis, and P. Ranganathan, “Memory Hierarchy for Web Search,” inProceedings of the IEEE International Symposium on High Performance Computer Architecture (HPCA’18), 2018

    2018

  3. [3]

    Kevin: Multi-Turn Reinforcement Learning for Writing CUDA Kernels,

    C. Baronio, P. Marsella, B. Panet al., “Kevin: Multi-Turn Reinforcement Learning for Writing CUDA Kernels,” arXiv preprint arXiv:2507.11948, 2025, https://arxiv.org/abs/2507.11948

    Pith/arXiv arXiv 2025

  4. [4]

    AdaEvolve: Adaptive LLM Driven Zeroth-Order Optimization,

    M. Cemri, S. Agrawal, A. Gupta, S. Liu, A. Cheng, Q. Mang, A. Naren, L. E. Erdogan, K. Sen, M. Zaharia, A. Dimakis, and I. Stoica, “AdaEvolve: Adaptive LLM Driven Zeroth-Order Optimization,” 2026. [Online]. Available: https://arxiv.org/abs/2602.20133

    arXiv 2026

  5. [5]

    Evaluating Large Language Models Trained on Code,

    M. Chen, J. Tworek, H. Jun, Q. Yuan, H. P. de Oliveira Pinto, J. Kaplan, H. Edwards, Y . Burda, N. Joseph, G. Brockman, A. Ray, R. Puri, G. Krueger, M. Petrov, H. Khlaaf, G. Sastry, P. Mishkin, B. Chan, S. Gray, N. Ryder, M. Pavlov, A. Power, L. Kaiser, M. Bavarian, C. Winter, P. Tillet, F. P. Such, D. Cummings, M. Plappert, F. Chantzis, E. Barnes, A. Her...

    Pith/arXiv arXiv 2021

  6. [6]

    Resource Central: Understanding and Predicting Work- loads for Improved Resource Management in Large Cloud Platforms,

    E. Cortez, A. Bonde, A. Muzio, M. Russinovich, M. Fontoura, and R. Bianchini, “Resource Central: Understanding and Predicting Work- loads for Improved Resource Management in Large Cloud Platforms,” inProceedings of the 26th Symposium on Operating Systems Principles, ser. SOSP ’17, 2017

    2017

  7. [7]

    Large Language Models for Compiler Optimization,

    C. Cummins, V . Seeker, D. Grubisic, M. Elhoushi, Y . Liang, B. Roziere, J. Gehring, F. Gloeckle, K. Hazelwood, G. Synnaeve, and H. Leather, “Large Language Models for Compiler Optimization,” 2023. [Online]. Available: https://arxiv.org/abs/2309.07062

    Pith/arXiv arXiv 2023

  8. [8]

    An Open-Source Bench- mark Suite for Microservices and Their Hardware-Software Implications for Cloud & Edge Systems,

    Y . Gan, Y . Zhang, D. Cheng, A. Shetty, P. Rathi, N. Katarki, A. Bruno, J. Hu, B. Ritchken, B. Jackson, K. Hu, M. Pancholi, Y . He, B. Clancy, C. Colen, F. Wen, C. Leung, S. Wang, L. Zaruvinsky, M. Espinosa, R. Lin, Z. Liu, J. Padilla, and C. Delimitrou, “An Open-Source Bench- mark Suite for Microservices and Their Hardware-Software Implications for Clou...

    2019

  9. [9]

    Introducing Google Axion Processors, our new Arm-based CPUs,

    Google, “Introducing Google Axion Processors, our new Arm-based CPUs,” https://cloud.google.com/blog/products/compute/introducing- googles-new-arm-based-cpu, 2026

    2026

  10. [10]

    DeepSeek-Coder: When the Large Language Model Meets Programming – The Rise of Code Intelligence,

    D. Guo, Q. Zhu, D. Yang, Z. Xie, K. Dong, W. Zhang, G. Chen, X. Bi, Y . Wu, Y . K. Li, F. Luo, Y . Xiong, and W. Liang, “DeepSeek-Coder: When the Large Language Model Meets Programming – The Rise of Code Intelligence,” 2024. [Online]. Available: https://arxiv.org/abs/2401.14196

    Pith/arXiv arXiv 2024

  11. [11]

    Protean: VM Allocation Service at Scale,

    O. Hadary, L. Marshall, I. Menache, A. Pan, E. E. Greeff, D. Dion, S. Dorminey, S. Joshi, Y . Chen, M. Russinovich, and T. Moscibroda, “Protean: VM Allocation Service at Scale,” inProceedings of the 14th USENIX Symposium on Operating Systems Design and Implementation (OSDI 20), 2020

    2020

  12. [12]

    Learning Memory Access Patterns,

    M. Hashemi, K. Swersky, J. Smith, G. Ayers, H. Litz, J. Chang, C. Kozyrakis, and P. Ranganathan, “Learning Memory Access Patterns,” inProceedings of the 35th International Conference on Machine Learn- ing, 2018

    2018

  13. [13]

    Learning memory access patterns,

    M. Hashemi, K. Swersky, J. A. Smith, G. Ayers, H. Litz, J. Chang, C. Kozyrakis, and P. Ranganathan, “Learning memory access patterns,” inProceedings of the 35th International Conference on Machine Learn- ing (ICML), 2018

    2018

  14. [14]

    MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework,

    S. Hong, M. Zhuge, J. Chen, X. Zheng, Y . Cheng, C. Zhang, J. Wang, Z. Wang, S. K. S. Yau, Z. Lin, L. Zhou, C. Ran, L. Xiao, C. Wu, and J. Schmidhuber, “MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework,” 2024. [Online]. Available: https://arxiv.org/abs/2308.00352

    Pith/arXiv arXiv 2024

  15. [15]

    Lifting the veil on Meta’s microservice architecture: Analyses of topology and request workflows,

    D. Huye, Y . Shkuro, and R. R. Sambasivan, “Lifting the veil on Meta’s microservice architecture: Analyses of topology and request workflows,” inProceedings of the USENIX Annual Technical Conference (USENIX ATC’23), 2023

    2023

  16. [16]

    A Survey on Large Language Models for Code Generation,

    J. Jiang, F. Wang, J. Shen, S. Kim, and S. Kim, “A Survey on Large Language Models for Code Generation,”ACM Trans. Softw. Eng. Methodol., Jan. 2026

    2026

  17. [17]

    Dynamic Branch Prediction with Percep- trons,

    D. A. Jim ´enez and C. Lin, “Dynamic Branch Prediction with Percep- trons,” inProceedings of the 7th International Symposium on High- Performance Computer Architecture, ser. HPCA ’01, 2001, p. 197

    2001

  18. [18]

    Profiling a warehouse-scale computer,

    S. Kanev, J. P. Darago, K. Hazelwood, P. Ranganathan, T. Moseley, G.-Y . Wei, and D. Brooks, “Profiling a warehouse-scale computer,” in Proceedings of the 42nd Annual International Symposium on Computer Architecture (ISCA’15), 2015

    2015

  19. [19]

    Production-Grade Container Orchestration,

    Kubernetes, “ Production-Grade Container Orchestration,” https://kubernetes.io/, 2026

    2026

  20. [20]

    Towards Robust Agentic CUDA Kernel Benchmarking, Verification, and Optimization,

    R. T. Lange, Q. Sun, A. Prasad, M. Faldor, Y . Tang, and D. Ha, “Towards Robust Agentic CUDA Kernel Benchmarking, Verification, and Optimization,” 2025. [Online]. Available: https: //arxiv.org/abs/2509.14279

    arXiv 2025

  21. [21]

    GPTuner: A Manual-Reading Database Tuning System via GPT-Guided Bayesian Optimization,

    J. Lao, Y . Wang, Y . Li, J. Wang, Y . Zhang, Z. Cheng, W. Chen, M. Tang, and J. Wang, “GPTuner: A Manual-Reading Database Tuning System via GPT-Guided Bayesian Optimization,”Proc. VLDB Endow., vol. 17, no. 8, p. 1939–1952, Apr. 2024

    1939

  22. [22]

    ChatDBG: Augmenting Debugging with Large Language Models,

    K. H. Levin, N. van Kempen, E. D. Berger, and S. N. Freund, “ChatDBG: Augmenting Debugging with Large Language Models,” Proceedings of the ACM on Software Engineering, vol. 2, no. FSE, pp. 1892–1913, Jun. 2025. [Online]. Available: http://dx.doi.org/10.1145/ 3729355

    1913

  23. [23]

    StarCoder: may the source be with you!

    R. Li, L. B. Allal, Y . Zi, N. Muennighoff, D. Kocetkov, C. Mou, M. Marone, C. Akiki, J. Li, J. Chim, Q. Liu, E. Zheltonozhskii, T. Y . Zhuo, T. Wang, O. Dehaene, M. Davaadorj, J. Lamy-Poirier, J. ao Monteiro, O. Shliazhko, N. Gontier, N. Meade, A. Zebaze, M.-H. Yee, L. K. Umapathi, J. Zhu, B. Lipkin, M. Oblokulov, Z. Wang, R. Murthy, J. Stillerman, S. S....

    Pith/arXiv arXiv 2023

  24. [24]

    Thunderbolt: Throughput-Optimized, Quality-of- Service-Aware Power Capping at Scale,

    S. Li, X. Wang, X. Zhang, V . Kontorinis, S. Kodakara, D. Lo, and P. Ranganathan, “Thunderbolt: Throughput-Optimized, Quality-of- Service-Aware Power Capping at Scale,” inProceedings of the 14th USENIX Symposium on Operating Systems Design and Implementation (OSDI ’20), 2020

    2020

  25. [25]

    KernelEvolve: Scaling Agentic Kernel Coding for Heterogeneous AI Accelerators at Meta,

    G. Liao, H. Qin, Y . Wang, A. Golden, M. Kuchnik, Y . Yetim, J. J. Ang, C. Fu, Y . He, S. Hsia, Z. Jiang, D. Li, U. Pashkevich, V . Puvvada, F. Shi, M. Steiner, R. Xiao, N. Yan, X. Yu, Z. Fang, R. Levenstein, K. Ho, H. Zhu, A. Hammond, R. Li, A. Mathews, K. Gondkar, A. Zainul-Abedin, K. Singh, H. Yu, W. Chi, B. Huang, S. Zhang, N. Weller, Z. Marine, W. Co...

    Pith/arXiv arXiv 2026

  26. [26]

    ECO: An LLM-Driven Efficient Code Optimizer for Warehouse Scale Computers,

    H. Lin, M. Maas, M. Roquemore, A. Hasanzadeh, F. Lewis, Y . Simonson, T.-W. Yang, A. Yazdanbakhsh, D. Altinb ¨uken, F. Papa, M. N. Edmonds, A. Patil, D. Schwarz, S. Chandra, C. Kennelly, M. Hashemi, and P. Ranganathan, “ECO: An LLM-Driven Efficient Code Optimizer for Warehouse Scale Computers,” 2025. [Online]. Available: https://arxiv.org/abs/2503.15669

    Pith/arXiv arXiv 2025

  27. [27]

    Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation,

    J. Liu, C. S. Xia, Y . Wang, and L. Zhang, “Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation,” 2023. [Online]. Available: https://arxiv.org/abs/2305.01210

    Pith/arXiv arXiv 2023

  28. [28]

    SkyDiscover: A Flexible, Adaptive Framework for AI-Driven Scientific and Algorithmic Discovery,

    S. Liu, M. Cemri, S. Agarwal, A. Krentsel, A. Naren, Q. Mang, Z. Li, A. Gupta, M. Maheswaran, A. Cheng, M. Pan, E. Boneh, K. Ramchandran, K. Sen, M. Zaharia, A. G. Dimakis, and I. Stoica, “SkyDiscover: A Flexible, Adaptive Framework for AI-Driven Scientific and Algorithmic Discovery,” inProceedings of the ACM Conference on AI and Agentic Systems, ser. CAI...

    arXiv 2026

  29. [29]

    Characterizing Microservice Dependency and Performance: Alibaba Trace Analysis,

    S. Luo, H. Xu, C. Lu, K. Ye, G. Xu, L. Zhang, Y . Ding, J. He, and C. Xu, “Characterizing Microservice Dependency and Performance: Alibaba Trace Analysis,” inProceedings of the ACM Symposium on Cloud Computing (SoCC’21), 2021. 12

    2021

  30. [30]

    The Power of Prediction: Microservice Auto Scaling via Workload Learning,

    S. Luo, H. Xu, K. Ye, G. Xu, L. Zhang, G. Yang, and C. Xu, “The Power of Prediction: Microservice Auto Scaling via Workload Learning,” in Proceedings of the ACM Symposium on Cloud Computing (SoCC’22), 2022

    2022

  31. [31]

    Workload Behavior Driven Memory Subsystem Design for Hyperscale,

    S. Mahar, H. Wang, W. Shu, and A. Dhanotia, “Workload Behavior Driven Memory Subsystem Design for Hyperscale,” 2023. [Online]. Available: https://arxiv.org/abs/2303.08396

    Pith/arXiv arXiv 2023

  32. [32]

    Rethinking the Cost of Distributed Caches for Datacenter Services,

    Z. Mao, J. Ellithorpe, A. Adya, R. Iyer, M. Zaharia, S. Shenker, and I. Stoica, “Rethinking the Cost of Distributed Caches for Datacenter Services,” inProceedings of the 24th ACM Workshop on Hot Topics in Networks, ser. HotNets ’25, 2025

    2025

  33. [33]

    Azure Public Dataset Version 2: VM Trace,

    Microsoft Azure, “Azure Public Dataset Version 2: VM Trace,” https://github.com/Azure/AzurePublicDataset/blob/master/ AzurePublicDatasetV2.md

  34. [34]

    Azure Cobalt processor-based Virtual Machines,

    Microsoft Azure, “Azure Cobalt processor-based Virtual Machines,” https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/cobalt- overview, 2026

    2026

  35. [35]

    A graph placement methodology for fast chip design,

    A. Mirhoseini, A. Goldie, M. Yazgan, J. W. Jiang, E. Songhori, S. Wang, Y .-J. Lee, E. Johnson, O. Pathak, A. Nazi, J. Pak, A. Tong, K. Srinivasa, W. Hang, E. Tuncer, Q. V . Le, J. Laudon, R. Ho, R. Carpenter, and J. Dean, “A graph placement methodology for fast chip design,”Nature, 2021

    2021

  36. [36]

    Device placement optimization with reinforcement learning,

    A. Mirhoseini, H. Pham, Q. V . Le, B. Steiner, R. Larsen, Y . Zhou, N. Kumar, M. Norouzi, S. Bengio, and J. Dean, “Device placement optimization with reinforcement learning,” inProceedings of the 34th In- ternational Conference on Machine Learning - Volume 70, ser. ICML’17, 2017

    2017

  37. [37]

    AlphaEvolve: A coding agent for scientific and algorithmic discovery,

    A. Novikov, N. V ˜u, M. Eisenberger, E. Dupont, P.-S. Huang, A. Z. Wagner, S. Shirobokov, B. Kozlovskii, F. J. R. Ruiz, A. Mehrabian, M. P. Kumar, A. See, S. Chaudhuri, G. Holland, A. Davies, S. Nowozin, P. Kohli, and M. Balog, “AlphaEvolve: A coding agent for scientific and algorithmic discovery,” 2025. [Online]. Available: https://arxiv.org/abs/2506.13131

    Pith/arXiv arXiv 2025

  38. [38]

    Towards Workload-aware Cloud Efficiency: A Large-scale Empirical Study of Cloud Workload Characteristics,

    A. Parayil, J. Zhang, X. Qin, I. n. Goiri, L. Huang, T. Zhu, and C. Bansal, “Towards Workload-aware Cloud Efficiency: A Large-scale Empirical Study of Cloud Workload Characteristics,” inProceedings of the 16th ACM/SPEC International Conference on Performance Engi- neering (ICPE ’25), 2025

    2025

  39. [39]

    Autopi- lot: workload autoscaling at Google,

    K. Rzadca, P. Findeisen, J. Swiderski, P. Zych, P. Broniek, J. Kusmierek, P. Nowak, B. Strack, P. Witusowski, S. Hand, and J. Wilkes, “Autopi- lot: workload autoscaling at Google,” inProceedings of the Fifteenth European Conference on Computer Systems, ser. EuroSys ’20, 2020

    2020

  40. [40]

    Toolformer: Language Models Can Teach Themselves to Use Tools,

    T. Schick, J. Dwivedi-Yu, R. Dess `ı, R. Raileanu, M. Lomeli, L. Zettlemoyer, N. Cancedda, and T. Scialom, “Toolformer: Language Models Can Teach Themselves to Use Tools,” 2023. [Online]. Available: https://arxiv.org/abs/2302.04761

    Pith/arXiv arXiv 2023

  41. [41]

    Practices for Gov- erning Agentic AI Systems,

    Y . Shavit, S. Agarwal, M. Brundage, S. O’Keefe, R. Campbell, T. Lee, P. Mishkin, T. Eloundou, A. Hickey, K. Slama, L. Ahmad, P. McMil- lan, A. Beutel, A. Passos, and D. G. Robinson, “Practices for Gov- erning Agentic AI Systems,” https://api.semanticscholar.org/CorpusID: 266312974

  42. [42]

    Applying Deep Learning to the Cache Replacement Problem,

    Z. Shi, X. Huang, A. Jain, and C. Lin, “Applying Deep Learning to the Cache Replacement Problem,” inProceedings of the 52nd Annual IEEE/ACM International Symposium on Microarchitecture, ser. MICRO- 52, 2019

    2019

  43. [43]

    Accelerometer: Understanding Accel- eration Opportunities for Data Center Overheads at Hyperscale,

    A. Sriraman and A. Dhanotia, “Accelerometer: Understanding Accel- eration Opportunities for Data Center Overheads at Hyperscale,” in Proceedings of the Twenty-Fifth International Conference on Archi- tectural Support for Programming Languages and Operating Systems (ASPLOS’20), 2020

    2020

  44. [44]

    Dy- namoLLM: Designing LLM Inference Clusters for Performance and Energy Efficiency,

    J. Stojkovic, E. Choukse, C. Zhang, I. Goiri, and J. Torrellas, “Dy- namoLLM: Designing LLM Inference Clusters for Performance and Energy Efficiency,” inProceedings of the IEEE International Symposium on High-Performance Computer Architecture (HPCA ’25), 2025

    2025

  45. [45]

    µManycore: A Cloud-Native CPU for Tail at Scale,

    J. Stojkovic, C. Liu, M. Shahbaz, and J. Torrellas, “µManycore: A Cloud-Native CPU for Tail at Scale,” inProceedings of the 50th Annual International Symposium on Computer Architecture (ISCA’23), 2023

    2023

  46. [46]

    SmartOClock: Workload- and Risk- Aware Overclocking in the Cloud,

    J. Stojkovic, P. Misra, I. Goiri, S. Whitlock, E. Choukse, M. Das, C. Bansal, J. Lee, Z. Sun, H. Qiu, R. Zimmermann, S. Samal, B. Warrier, A. Raniwala, and R. Bianchini, “SmartOClock: Workload- and Risk- Aware Overclocking in the Cloud,” inProceedings of the 51st Annual International Symposium on Computer Architecture (ISCA ’24), 2024

    2024

  47. [47]

    TAPAS: Thermal-and power-aware scheduling for LLM inference in cloud platforms,

    J. Stojkovic, C. Zhang, ´I. Goiri, E. Choukse, H. Qiu, R. Fonseca, J. Torrellas, and R. Bianchini, “TAPAS: Thermal-and power-aware scheduling for LLM inference in cloud platforms,” inProceedings of the 30th ACM International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS’25), 2025

    2025

  48. [48]

    DCPerf: An Open-Source, Battle-Tested Performance Benchmark Suite for Dat- acenter Workloads,

    W. Su, A. Dhanotia, C. Torres, J. Gandhi, N. Gholkar, S. Kanaujia, M. Naumov, K. Subramanian, V . Andrei, Y . Yuan, and C. Tang, “DCPerf: An Open-Source, Battle-Tested Performance Benchmark Suite for Dat- acenter Workloads,” inProceedings of the 52nd Annual International Symposium on Computer Architecture (ISCA’25), 2025

    2025

  49. [49]

    VeriGen: A Large Language Model for Verilog Code Generation,

    S. Thakur, B. Ahmad, H. Pearce, B. Tan, B. Dolan-Gavitt, R. Karri, and S. Garg, “VeriGen: A Large Language Model for Verilog Code Generation,” 2023. [Online]. Available: https://arxiv.org/abs/2308.00708

    Pith/arXiv arXiv 2023

  50. [50]

    Understanding design of microservices architecture at Netflix,

    K. Varshneya, “Understanding design of microservices architecture at Netflix,” https://www.techaheadcorp.com/blog/design-of-microservices- architecture-at-netflix/, 2021

    2021

  51. [51]

    Large-scale cluster management at Google with Borg,

    A. Verma, L. Pedrosa, M. Korupolu, D. Oppenheimer, E. Tune, and J. Wilkes, “Large-scale cluster management at Google with Borg,” in Proceedings of the Tenth European Conference on Computer Systems, ser. EuroSys ’15, 2015

    2015

  52. [52]

    Geak: Introducing Triton Kernel AI Agent & Evaluation Benchmarks,

    J. Wang, V . Joshi, S. Majumder, X. Chao, B. Ding, Z. Liu, P. P. Brahma, D. Li, Z. Liu, and E. Barsoum, “Geak: Introducing Triton Kernel AI Agent & Evaluation Benchmarks,” 2025. [Online]. Available: https://arxiv.org/abs/2507.23194

    Pith/arXiv arXiv 2025

  53. [53]

    Dynamo: Facebook’s Data Center-Wide Power Management System,

    Q. Wu, Q. Deng, L. Ganesh, C.-H. Hsu, Y . Jin, S. Kumar, B. Li, J. Meza, and Y . J. Song, “Dynamo: Facebook’s Data Center-Wide Power Management System,” inProceedings of the 43rd Annual International Symposium on Computer Architecture (ISCA ’16), 2016

    2016

  54. [54]

    Automated Program Repair in the Era of Large Pre-Trained Language Models,

    C. S. Xia, Y . Wei, and L. Zhang, “Automated Program Repair in the Era of Large Pre-Trained Language Models,” inProceedings of the 45th International Conference on Software Engineering, ser. ICSE ’23. IEEE Press, 2023, pp. 1482–1494. [Online]. Available: https://doi.org/10.1109/ICSE48619.2023.00129

    arXiv 2023

  55. [55]

    SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering,

    J. Yang, C. E. Jimenez, A. Wettig, K. Lieret, S. Yao, K. Narasimhan, and O. Press, “SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering,” 2024. [Online]. Available: https: //arxiv.org/abs/2405.15793

    Pith/arXiv arXiv 2024

  56. [56]

    ReAct: Synergizing Reasoning and Acting in Language Models,

    S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y . Cao, “ReAct: Synergizing Reasoning and Acting in Language Models,”

  57. [57]

    Sinan: ML- Based and QoS-Aware Resource Management for Cloud Microservices,

    Y . Zhang, W. Hua, Z. Zhou, G. E. Suh, and C. Delimitrou, “Sinan: ML- Based and QoS-Aware Resource Management for Cloud Microservices,” inProceedings of the 26th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’21), 2021. 13

    2021

  58. [2023]

    Available: https://arxiv.org/abs/2210.03629

    [Online]. Available: https://arxiv.org/abs/2210.03629

    Pith/arXiv arXiv