REVIEW 2 major objections 6 minor 37 references
Ready Cohorts: Bounding GPU Opportunity and Avoiding Host Round Trips in LLM-Agent Control
T0 review · 2 major / 6 minor · reviewed 2026-08-16 · deepseek-v4-flash
Pith's one-line read The paper gives two measurable gates for placing LLM-agent control transitions on a GPU: enough same-route work must exist before launch deadlines, and the decision must not come back to the host.
desk verdict Carefully scoped, artifact-backed framework for when LLM-agent control transitions can be batched on GPU; the 43% share is an upper bound on model-level opportunity until route-key fusion is verified, but the paper deserves serious refereeing. read the letter →
The pith
A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.
The reading
What carries the argument
The carrying mechanism is the ready-cohort model with a precise boundary: each event has a release time, a launch deadline, and a route key, and a feasible batch must meet the route-specific hardware threshold $K_r$, share one route, and launch inside every member's window. The exact opportunity instrument is a specialized dynamic program for equal relative deadlines, with recurrence $D[j] = \max\{D[j-1], \max_{i \le j-K_r+1,\, t_j - t_i \le \delta}(D[i-1] + j - i + 1)\}$, implemented with a monotone deque; this computes $P^{\star}$ exactly on an integer-nanosecond clock. The mechanism instrument is a GPU root graph whose one-thread selector reads a GPU predicate and tail-launches per-epoch path graphs for $H$ epochs without exposing the decision to the host, compared against the matched host-mediated launch that copies and synchronizes the predicate result.
What would settle it
Recompute the exact offline share on the same raw 851-session trace panel using a verified executable grouping that checks state-machine node, schema, arguments, policy context, and multi-tool identities; if the share falls substantially below 43.00% toward the fixed-window 30.19%, the cohort-supply claim overstates GPU-feasible work. Separately, implement the device-resident mechanism with real route bodies, finite queues, CPU fallback, and tail-latency measurement; if the device-resident path is not faster than a tuned host-mediated path under that joined runtime, the placement gate narrows.
Extended reading notes
Core claim
The central claim, stated on the paper's own terms, is that the ready-cohort boundary quantifies GPU opportunity for agent control: a batch of control transitions is feasible only if it has at least $K_r$ events of one route, all released before a common launch time, and all with deadlines after that launch. The paper defines four shares—fixed-partition share $F$, exact offline share $P^{\star}$, local upper bound $U$, and online achieved share $A$—and proves $F \le P^{\star} \le U$ and $A \le P^{\star}$ under the stated model. In the frozen primary replay at 100,000 active sessions, $K=256$, and a 50 ms launch deadline, these are $F=30.19\%$, $P^{\star}=43.00\%$, and $U=45.85\%$, so exact sliding-deadline packing recovers 81.83% of the fixed-window alignment gap. The mechanism study then shows that retaining a GPU-computed decision on device beats the matched host round trip in all 36 cells across four named placements, and that a nested device graph which removes no host decision is slower in all 60 negative-control cells, ruling out device launch alone as the explanation.
Load-bearing premise
The load-bearing premise is that events sharing an outcome-derived route label can actually be executed together by one implementation without changing declared semantics; the paper calls the route key a conditioning proxy, so if fusibility fails, $P^{\star}$ and the 43.00% share are upper bounds on model-level opportunity rather than on real GPU-feasible work.
Editorial extensions
If this is right
- An online route compactor has a measurable workload budget: fixed-window eligibility is the floor ($F=30.19\%$ at the primary cell), exact packing is the ceiling ($P^{\star}=43.00\%$), and recovery $R_A = (A - F)/(P^{\star} - F)$ gives a direct runtime target for any future implementation.
- Cohort supply collapses below the boundary: at $K=256$, the exact share is zero for every tested deadline at $C \le 10{,}000$, and even at $C=100{,}000$ it is zero for 10 ms and 25 ms deadlines, so a large nominal swarm does not guarantee profitable cohorts inside a short launch budget.
- Lowering the hardware threshold can matter more than packing: at $C=100{,}000$ and 50 ms, $P^{\star}$ is 66.8% for $K=32$ but 0.0% for $K=64$ at $C=10{,}000$, showing route-specific $K$ is a first-order design lever.
- Keeping the tested binary decision on device reduces cohort-horizon wall time by 1.19x to 2.39x across four named placements, with absolute savings of 194 to 363 microseconds per 32-epoch cohort invocation at the primary mechanism cell.
- Device launch alone is insufficient: a fixed nested device graph that removes no host decision is slower in all 60 negative-control cells, so the gain comes specifically from removing the host observation and redispatch epoch.
- If either gate fails—no deadline-feasible cohort supply, or no placement advantage—the paper's boundary gives a concrete reason to keep that transition on the CPU.
Reading between the lines
- If the route-key proxy is tightened to verified executable grouping that also checks state-machine node, schema, arguments, policy context, and multi-tool identities, I expect $P^{\star}$ on the same trace panel to drop toward $F$; the paper already labels the key a conditioning proxy, so the 43.00% share is best read as a model-level upper bound on opportunity.
- The same boundary quantities apply to CPU-only control planes: $F$, $P^{\star}$, $U$, and $A$ measure scheduling headroom independent of the device, so the formal framework can be reused to evaluate host-side batching of agent transitions.
- The mechanism study fixes a regular synthetic state array and one binary decision; a testable extension is to run the resident path with per-event compaction, variable route bodies, and real ingress/egress, then check whether the 1.19x-2.39x advantage survives finite queues and CPU fallback.
- The trace packing omits per-session sequence constraints and permits completion-order inversions; incorporating those constraints could shrink the gap between $U$ and $P^{\star}$ and would give a stricter workload budget for the online runtime.
Signed reviews
Editorial analysis
A structured set of objections, weighed in public.
Referee Report
Summary. The paper formalizes the 'ready-cohort boundary' for deterministic control transitions in LLM-agent runtimes. It defines four workload shares—fixed-partition share F, exact offline share P*, local upper bound U, and online achieved share A—and proves a dynamic program that computes P* exactly under zero service time, unlimited capacity, and equal relative launch deadlines. In a stationary Poisson replay of a pinned 851-session public trace panel, the primary condition (100,000 target active sessions, K=256, 50 ms launch deadline) yields F=30.19%, P*=43.00%, U=45.85%, with an alignment-gap closure of 81.83%. A separate CUDA mechanism study compares a host-mediated GPU decision path with a device-resident path, finding the device-resident path faster in all 36 tested cells across four named placements (ratios 1.19x–2.39x), while a nested device-graph negative control loses in all 60 cells. The paper is explicit that a joined finite online runtime is required to measure A and that the route key is a conditioning proxy rather than proof of executable compatibility.
Significance. If the results hold under the stated assumptions, the paper establishes two measurable gates for GPU-based agent control: deadline-feasible cohort supply and observation placement. The strengths are substantial: the exact DP is derived with a clear proof; the trace study is prospectively frozen with pinned hashes, validity gates, and a full design grid; and the mechanism study includes a separate host oracle, a negative control, and explicit scope limitations. The reported numbers provide a falsifiable workload budget and a concrete mechanism comparison that can inform future system builders. The significance is tempered by the fact that P* measures opportunity under an outcome-derived route-key proxy and an abstract model that omits per-session sequencing, so the headline 43.00% is an upper bound on executable-route opportunity rather than an exact measure of GPU-feasible work. The paper is unusually transparent about these limits, which supports its credibility.
major comments (2)
- [§3.1, §5.1, §11] The paper should state explicitly that P* (and hence the reported 43.00%) is an upper bound on the share achievable by any scheduler that respects executable-route semantics and per-session ordering, not the exact share of GPU-feasible work. The route key is a coarsening of the executable grouping—it omits state-machine node, schema, arguments, policy context, and multi-tool identities—and the packing model omits per-session sequence constraints. Coarsening a partition cannot decrease the optimum, and dropping precedence constraints cannot decrease the optimum, so both effects push P* upward. The current wording ('a conditioning proxy, not proof of executable compatibility') is accurate but does not draw the logical consequence for the headline number. I recommend adding a sentence in the abstract and in Section 6: 'Because the route key coarsens executable grouping and the model drops per-session ordering, P* is an upper bound on the share any executable-route scheduler can attain.'
- [§5.2, Eq. (8)] The metric G = (P*−F)/(U−F) is described as 'exact packing recovers 81.83% of the opportunity lost at fixed window boundaries' in the abstract. Since U is a local upper bound that can count infeasible overlaps, G measures the fraction of the local-bound gap closed by exact packing, not the fraction of the true achievable gap (P*−F) that is recovered. The wording 'recovers' may overstate the operational meaning outside the paper's careful definitions. I recommend rewording to 'closes 81.83% of the gap between the local upper bound and the fixed-window share' and defining G as such in Section 5.2.
minor comments (6)
- [Title/Abstract] The title line contains a stray space in 'A voiding' in the provided text; the final PDF should be checked for this formatting artifact.
- [§3.1] The phrase 'Let K begin a measured safe suffix' should be 'Let K begin a measured safe suffix' (singular verb) or 'K is the start of a measured safe suffix' for grammatical clarity.
- [§4] The sentence 'Its bound is O(NR + ∑_r n_r log n_r) ... which is quadratic in the worst case' is imprecise: the term O(NR) is quadratic only when the number of routes R grows with N. Clarify that the evaluator is quadratic in the worst case over the route structure, while the reported instance sizes are small enough for the implementation to complete.
- [§6.1] The exact shares for K=32, 64, 128, 256 (66.8%, 66.0%, 48.4%, 43.0%) are given only in prose; consider adding a small table to improve readability and to allow quick comparison with the primary cell.
- [§7.2] It would help to specify how the common batch count 'calibrated from the fastest mechanism' is chosen (for example, a fixed target runtime or a memory limit), so readers can assess whether the batch count biases the comparison.
- [§8, §8.1] The paper reports 14,557,440 tested batched invocations and then 'All 3,240 measured rows' for the resident-policy study and 'All 12,000 rows' for the native-dispatch control. Clarify the relationship between row counts and batched-invocation counts, since the two are easily conflated.
Circularity Check
No circularity: F, P*, U, and the measured mechanism ratios are computed directly from their definitions and from separately implemented oracles; the route-key proxy is a disclosed limitation, not a circular reduction.
full rationale
The paper's quantitative claims are self-contained against their stated definitions. F is computed by summing events in fixed route/time buckets, P* by an exact dynamic program over release times, deadlines, routes, and a swept threshold K, and U by a defined local-overlap condition; none of these quantities is fitted to produce the headline value. The 43.00% primary result is conditional on the outcome-derived route key, and the paper repeatedly states that this key is a conditioning proxy rather than proof of executable compatibility (Sections 2.2, 5.1, and 11). That caveat is an honest limitation, not a circular step: Proposition 1 derives F <= P* <= U and A <= P* from the definitions, and the DP in Section 4 is a direct computation on declared inputs. The mechanism study compares measured wall times of matched CUDA mechanisms against a separately written host oracle, with exactness checked on 14,557,440 batched invocations; the negative device-launch control is an additional direct measurement. The paper makes no load-bearing self-citation: the only internally referenced artifacts (trace replay 003, resident-policy-001, native-dispatch calibration) are named experimental inputs or prior measurement layers, not citations invoked to justify the central derivation, and no uniqueness theorem is imported from prior work by the authors. The swept K is explicitly not claimed to be the resident source's measured crossover, so no fitted parameter is renamed as a prediction. Accordingly, no circularity is present, and the score is 0.
Assumptions & free parameters
free parameters (4)
- Target active sessions C =
100,000 (primary), grid 1,000 / 10,000 / 100,000
- Launch deadline delta =
50 ms primary, grid 10/25/50/100/250 ms
- Hardware threshold K =
256 primary, swept over 32/64/128/256
- Route grouping key =
route-key proxy (primary), also pooled and event-class
assumptions (6)
- domain assumption Zero service time and unlimited simultaneous capacity
- domain assumption Equal relative launch deadlines di = ti + delta
- domain assumption Events sharing a route key are executable-compatible
- domain assumption Stationary Poisson session arrivals with uniform template sampling
- domain assumption Safe-suffix threshold K is monotone and extrapolates beyond tested cohort sizes
- domain assumption A model completion marks the point at which a control transition becomes ready
Cite this review
Pith. "Pith review of Ready Cohorts: Bounding GPU Opportunity and Avoiding Host Round Trips in LLM-Agent Control." pith.science (2026). https://pith.science/paper/YRFLVZZQ
@misc{pith2026260812123,
author = {Pith},
title = {Pith review of: Ready Cohorts: Bounding GPU Opportunity and Avoiding Host Round Trips in LLM-Agent Control},
year = {2026},
howpublished = {\url{https://pith.science/paper/YRFLVZZQ}},
note = {Machine review of arXiv:2608.12123}
}
read the original abstract
LLM-agent services repeatedly execute small deterministic transitions between model and tool calls: route an outcome, update state, and emit the next effect. We ask when this control path exposes enough concurrent work for GPU execution, and what changes when a GPU-computed route decision remains on device. We formalize the ready-cohort boundary using fixed-partition share F, exact offline share P*, local upper bound U, and online achieved share A. Under zero service time, unlimited capacity, and equal relative launch deadlines, a specialized dynamic program computes P* exactly. In a stationary Poisson replay of one pinned 851-session public trace panel, the primary condition at 100,000 target active sessions, K=256, and a 50 ms launch deadline gives F=30.19%, P*=43.00%, and U=45.85%. Exact packing recovers 81.83% of the opportunity lost at fixed window boundaries. The outcome-derived route key is a conditioning proxy, not proof of executable identity. A separate mechanism study keeps a GPU-computed binary decision on device instead of returning four bytes to the host and redispatching. Across four named GPU placements, the device-resident path is faster in all 36 configurations; within-placement row-median ratios range from 1.19x to 2.39x. Across both admissible mechanisms, all 14,557,440 tested batched invocations match a separately implemented host oracle. A fixed nested device graph that removes no host decision is slower in all 60 configurations across five placements. Together, the studies establish two measurable gates for GPU agent control: deadline-feasible cohort supply and observation placement. A joined finite online runtime is required to measure A, CPU displacement, and service-level benefit.
Figures
Figures from the paper (1 more)
Reference graph
Works this paper leans on
-
[1]
Infercept: Efficient inter- cept support for augmented large language model inference
Reyna Abhyankar, Zijian He, Vikranth Srivatsa, Hao Zhang, and Yiying Zhang. Infercept: Efficient inter- cept support for augmented large language model inference. InProceedings of the 41st International Conference on Machine Learning, volume 235 ofPro- ceedings of Machine Learning Research, pages 81–95. PMLR, 2024. URL https://proceedings.mlr.pr ess/v235/...
work page 2024
-
[2]
Achieving anonymity via cluster- ing.ACM Transactions on Algorithms, 6(3):1–19,
Gagan Aggarwal, Tomás Feder, Krishnaram Kentha- padi, Samir Khuller, Rina Panigrahy, Dilys Thomas, 11 and An Zhu. Achieving anonymity via cluster- ing.ACM Transactions on Algorithms, 6(3):1–19,
-
[3]
Toshihiro Akagi and Shin ichi Nakano. On r- gatherings on the line. InFrontiers in Algorithmics, volume 9130 ofLecture Notes in Computer Science, pages 25–32. Springer, 2015. doi: 10.1007/978-3-3 19-19647-3_3. URL https://doi.org/10.1007/97 8-3-319-19647-3_3
doi:10.1007/978-3-3 2015
-
[4]
Amotz Bar-Noy, Sudipto Guha, Yoav Katz, Joseph Naor, Baruch Schieber, and Hadas Shachnai. Throughput maximization of real-time scheduling with batching.ACM Transactions on Algorithms, 5 (2):18:1–18:17, 2009. doi: 10.1145/1497290.1497294. URL https://doi.org/10.1145/1497290.149729 4
arXiv 2009
-
[5]
Victor Barres, Honghua Dong, Soham Ray, Xujie Si, and Karthik Narasimhan.τ 2-Bench: Evaluating conversational agents in a dual-control environment. InProceedings of the 43rd International Conference on Machine Learning, volume 306 ofProceedings of Machine Learning Research. PMLR, 2026. URL https://openreview.net/forum?id=OC2z7iSQKa
work page 2026
-
[6]
Yihan Cang, Ming Chen, and Kaibin Huang. Joint batching and scheduling for high-throughput mul- tiuser edge AI with asynchronous task arrivals.IEEE Transactions on Wireless Communications, 23(10): 13782–13795, 2024. doi: 10.1109/TWC.2024.3404811. URL https://doi.org/10.1109/TWC.2024.34048 11
arXiv 2024
-
[7]
Murakkab: Resource-efficient agen- tic workflow orchestration in cloud platforms
Gohar Irfan Chaudhry, Esha Choukse, Haoran Qiu, Inigo Goiri, Rodrigo Fonseca, Adam Belay, and Ri- cardo Bianchini. Murakkab: Resource-efficient agen- tic workflow orchestration in cloud platforms. In 20th USENIX Symposium on Operating Systems De- sign and Implementation (OSDI 26), pages 567–587, Seattle, WA, July 2026. USENIX Association. URL https://www....
work page 2026
-
[8]
MPK: A compiler and runtime for Mega-Kernelizing tensor programs
Xinhao Cheng, Zhihao Zhang, Yu Zhou, Jianan Ji, Jinchen Jiang, Zepeng Zhao, Ziruo Xiao, Zihao Ye, Yingyi Huang, Ruihang Lai, Hongyi Jin, Bohan Hou, Mengdi Wu, Yixin Dong, Anthony Yip, Songting Wang, Wenqin Yang, Xupeng Miao, Tianqi Chen, and Zhihao Jia. MPK: A compiler and runtime for Mega-Kernelizing tensor programs. In20th USENIX Symposium on Operating ...
work page 1909
Show all 37 references
-
[9]
Characterizing CPU-induced slow- downs in multi-GPU LLM inference, 2026
Euijun Chung, Yuxiao Jia, Aaron Jezghani, and Hyesoon Kim. Characterizing CPU-induced slow- downs in multi-GPU LLM inference, 2026. URL https://arxiv.org/abs/2603.22774
2026 arXiv
-
[10]
Multi-benchmark LLM agent traces
Exgentic. Multi-benchmark LLM agent traces. Hugging Face dataset, 2026. URL h t t p s : / / h u g g i n g f a c e . c o / d a t a s e t s / E x g e n t i c / a g e n t - l l m - t r a c e s / t r e e / f 7 c 9 4 0 1 2 d 0 b f b f 6 6 f e 4 d 6 e d 6 2 7 6 9 9 5 0 8 b b b 5 5 5...
2026
-
[11]
SAGA: Workflow-atomic scheduling for AI agent inference on GPU clusters, 2026
Dongxin Guo, Jikun Wu, and Siu Ming Yiu. SAGA: Workflow-atomic scheduling for AI agent inference on GPU clusters, 2026. URLhttps://arxiv.org/ abs/2605.00528
2026 arXiv
-
[12]
Huertas and Pascal Van Hentenryck
Jorge A. Huertas and Pascal Van Hentenryck. Con- straint programming models for serial batch schedul- ing with minimum batch size.Operations Research Perspectives, 15:100352, 2025. doi: 10.1016/j.orp.20 25.100352. URL https://doi.org/10.1016/j.or p.2025.100352
2025
-
[13]
Asimplealgorithmfor r-gatherings on the line.Journal of Graph Algorithms and Applica- tions, 23(5):837–845, 2019
ShinichiNakano. Asimplealgorithmfor r-gatherings on the line.Journal of Graph Algorithms and Applica- tions, 23(5):837–845, 2019. doi: 10.7155/jgaa.00514. URLhttps://doi.org/10.7155/jgaa.00514
2019 doi
-
[14]
Mowry, Zhihao Jia, and Tianqi Chen
Hongyi Jin, Bohan Hou, Guanjie Wang, Ruihang Lai, Jinqi Chen, Zihao Ye, Yaxing Cai, Yixin Dong, Xinhao Cheng, Zhihao Zhang, Yilong Zhao, Yingyi Huang, Lijie Yang, Jinchen Jiang, Gabriele Oliaro, Jianan Ji, Xupeng Miao, Vinod Grover, Todd C. Mowry, Zhihao Jia, and Tianqi Chen. ...
1917
-
[15]
ThunderAgent: A simple, fast and program-aware agentic inference system, 2026
Hao Kang, Ziyang Li, Weili Xu, Xinyu Yang, Yinfang Chen, Junxiong Wang, Beidi Chen, Tushar Krishna, Chenfeng Xu, and Simran Arora. ThunderAgent: A simple, fast and program-aware agentic inference system, 2026. URL https://arxiv.org/abs/2602 .13692
2026
-
[16]
Laszlo and Sumitra Mukherjee
Michael J. Laszlo and Sumitra Mukherjee. Opti- mal univariate microaggregation with data suppres- sion.Journal of Systems and Software, 86(3):677– 682, 2013. doi: 10.1016/j.jss.2012.10.901. URL https://doi.org/10.1016/j.jss.2012.10.901
2013 doi
-
[17]
Parrot: Efficient serving of LLM-based applications with semantic variable
Chaofan Lin, Zhenhua Han, Chengruidong Zhang, Yuqing Yang, Fan Yang, Chen Chen, and Lili Qiu. Parrot: Efficient serving of LLM-based applications with semantic variable. In18th USENIX Symposium 12 on Operating Systems Design and Implementation (OSDI 24), pages 929–945, Santa C...
-
[18]
Agentic CPU-GPU scheduling for heterogeneous AI workloads, 2026
Tianxi Lu and Sherief Reda. Agentic CPU-GPU scheduling for heterogeneous AI workloads, 2026. URLhttps://arxiv.org/abs/2607.22242
2026 arXiv
-
[19]
Gonzalez, and Ion Stoica
Michael Luo, Xiaoxiang Shi, Colin Cai, Tianjun Zhang, Justin Wong, Yichuan Wang, Chi Wang, Yan- ping Huang, Zhifeng Chen, Joseph E. Gonzalez, and Ion Stoica. Agentix: An efficient serving engine for LLM agents as general programs. In23rd USENIX Symposium on Networked Systems D...
2026
-
[20]
NVIDIA Corporation,
CUDA Programming Guide. NVIDIA Corporation,
-
[21]
FLAME GPU 2: A framework for flexible and per- formant agent based simulation on GPUs.Software: Practice and Experience, 53(8):1659–1680, 2023
Paul Richmond, Robert Chisholm, Peter Heywood, Mozhgan Kabiri Chimeh, and Matthew Leach. FLAME GPU 2: A framework for flexible and per- formant agent based simulation on GPUs.Software: Practice and Experience, 53(8):1659–1680, 2023. doi: 10.1002/spe.3207. URL https://doi.org/1...
2023 doi
-
[22]
Sohel Rahman
Anik Sarker, Wing-Kin Sung, and M. Sohel Rahman. A linear time algorithm for ther-gathering problem on the line.Theoretical Computer Science, 866:96– 106, 2021. doi: 10.1016/j.tcs.2021.03.015. URL https://doi.org/10.1016/j.tcs.2021.03.015
2021 doi
-
[23]
OpRAG: A resource-deterministic runtime for gpu-backed multi-stage RAG workflows, 2026
Arup Kumar Sarker, Mills Staylor, Aymen Alsaadi, Gregor von Laszewski, Shantenu Jha, and Geoffrey Fox. OpRAG: A resource-deterministic runtime for gpu-backed multi-stage RAG workflows, 2026. URL https://arxiv.org/abs/2608.08340
2026 arXiv
-
[24]
MARS: Efficient, adaptive co-scheduling for heterogeneous agentic systems, 2026
Yifei Wang, Hancheng Ye, Yechen Xu, Cong Guo, Chiyue Wei, Qinsi Wang, Dongting Li, Tingjun Chen, Hai Li, Danyang Zhuo, and Yiran Chen. MARS: Efficient, adaptive co-scheduling for heterogeneous agentic systems, 2026. URL https://arxiv.org/ abs/2604.26963
2026 arXiv
-
[25]
SMDP-based dynamic batching for efficient inference on GPU-based platforms
YaodanXu, JingzhouSun, ShengZhou, andZhisheng Niu. SMDP-based dynamic batching for efficient inference on GPU-based platforms. In2023 IEEE International Conference on Communications (ICC), pages 5483–5489. IEEE, 2023. doi: 10.1109/ICC450 41.2023.10278962. URL https://doi.org/1...
2023
-
[26]
Architectural implications of agentic AI workflows, 2026
Jirong Yang, Peizhe Liu, Chaojie Zhang, and Jovan Stojkovic. Architectural implications of agentic AI workflows, 2026. URLhttps://arxiv.org/abs/26 08.04458
2026
-
[27]
GPUOS: A GPU operating system primitive for transparent operation fusion, 2026
Yiwei Yang, Xiangyu Gao, Yuan Zhou, Yuhang Gan, Yusheng Zheng, and Andi Quinn. GPUOS: A GPU operating system primitive for transparent operation fusion, 2026. URL https://arxiv.org/abs/2604 .17861
2026
-
[28]
URLhttps://arxiv.org/abs/2406.12045
Shunyu Yao, Noah Shinn, Pedram Razavi, and Karthik Narasimhan.τ-bench: A benchmark for tool- agent-user interaction in real-world domains, 2024. URLhttps://arxiv.org/abs/2406.12045
2024 arXiv
-
[29]
AgentServe: Algorithm-system co-design for efficient agentic AI serving on a consumer-grade GPU, 2026
Yuning Zhang, Yan Yan, Nan Yang, and Dong Yuan. AgentServe: Algorithm-system co-design for efficient agentic AI serving on a consumer-grade GPU, 2026. URLhttps://arxiv.org/abs/2603.10342
2026
-
[30]
TokTier: Exact stateful CPU+GPU tokenization for agentic LLM serving, 2026
Zhenyu Zhang and Zhichao Cao. TokTier: Exact stateful CPU+GPU tokenization for agentic LLM serving, 2026. URL https://arxiv.org/abs/2607 .29678. 13 A Proof and evaluator scope A.1 Binary-program reference formulation For arbitrary deadlines under the same zero-service and unli...
2026
-
[34]
The smoke and full local run used the same GPU UUID and are not independent placements
A correctness and engineering smoke preceded the source freeze. The smoke and full local run used the same GPU UUID and are not independent placements
-
[35]
Both external placements were ultimately retained
The cloud protocol authorized Modal plus one of RunPod or Lambda. Both external placements were ultimately retained. The additional placement is a disclosed descriptive scope expansion
-
[36]
Horizon-ratio monotonicity is exploratory because the preregistration did not fully specify its operational test
-
[37]
Retained receipts support the successful execution and final resource absence
No unsupported account of failed Lambda provisioning attempts is used as scientific evidence. Retained receipts support the successful execution and final resource absence. Native dispatch.The native-dispatch plan proposed two fresh placements per available provider/SKU and at...
-
[2010]
URL https://doi.org/10.1145/1798596.1798602
doi: 10.1145/1798596.1798602. URL https://doi.org/10.1145/1798596.1798602
-
[2024]
ISBN 978-1-939133-40-3
USENIX Association. ISBN 978-1-939133-40-3. URL https://www.usenix.org/conference/osdi 24/presentation/lin-chaofan
-
[2026]
Chapter 4.2, CUDA Graphs; accessed 2026-08-12
URL https://docs.nvidia.com/cuda/cud a-programming-guide/04-special-topics/cuda -graphs.html. Chapter 4.2, CUDA Graphs; accessed 2026-08-12
2026
Reviewed August 16, 2026 · model on record in the stance chip above.
Discussion (0). Continue with ORCID to comment.