{"id":"48879aa8-b674-4474-b23e-040d83432877","arxiv_id":"2608.12123","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"Exact deadline packing raises the GPU-eligible share of agent control events from 30.19% to 43.00% in a frozen trace replay, and keeping a GPU decision on device beats host round trips by 1.19x to 2.39x.","lead":"This paper asks when the small control steps in LLM-agent services can be grouped and run on a GPU instead of the host CPU, and whether a GPU-computed decision should stay on the device. In an idealized trace model, exact scheduling recovers about 12.8 percentage points of eligible work over fixed time windows, and a device-resident decision path is faster in all 36 tested configurations.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"P* is exact only for the route-key proxy, not for the model's executable-route definition; until same-label events are shown fusible, 43.00% remains an upper bound on GPU-feasible cohort supply.","rationale":"The reader's weakest assumption—that route-key grouping is a conditioning proxy rather than proof of executable compatibility—is the same concern I would put at the center. The paper is unusually explicit about this limitation, so the critique does not expose an internal contradiction or a mathematical error. I checked the DP derivation, the boundary ordering argument, and the mechanism-study controls: the deterministic packing recurrence is sound, the negative device-launch control is well designed, and the correctness oracle is strong. The unresolved semantic gap is nevertheless load-bearing because the headline contribution is a quantitative statement about 'deadline-feasible same-route control events.' If events sharing a route label cannot in fact be executed together by one implementation, P* and the derived gap closure are upper bounds on model-level opportunity, not on real GPU-feasible work. The concrete re-extraction test I propose would settle this by refining the grouping with the exact fields the paper says are omitted; it is feasible because the pinned source shards are content-hashed and commit-resolved. Given the paper's own framing, a conditional verdict is appropriate: the trace gate is a well-defined first-order measurement, but it must be re-derived under an executable semantic key before 43.00% can be claimed as actual GPU-feasible supply.","tokens_in":14894,"tokens_out":6355,"duration_ms":63973,"concrete_test":"Recompute the primary-cell F, P*, and U with the route key refined to include the fields Section 2.2 lists as omitted—state-machine node, schema/version, arguments, policy context, and multi-tool identities—by re-extracting from the pinned Exgentic Parquet shards rather than the published route-key table. Keep the same 100,000-session Poisson replay, K=256, 50 ms deadline, route-key-compatible grouping, and three seeds. If refined P* falls materially below 43.00% (for example, by at least 5 percentage points), the route-key proxy inflates the executable-opportunity claim, and the headline 43.00% must be read as an upper bound on GPU-feasible work.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The load-bearing assumption is that grouping by the outcome-derived route key approximates the model's executable route. Proposition 1 and the DP compute P* exactly for the declared partition, but Section 3.1 defines a route as 'one implementation can process the grouped events without changing their declared transition semantics,' while Section 2.2 states that the route key omits state-machine node, schema, arguments, policy context, and multi-tool identities. Grouping by outcome alone can therefore place events from different state-machine nodes or with different transition bodies into one bucket. Coarsening a partition can only increase the optimum (the Section 3.3 fragmentation inequality for F has the analogous effect on P*), so the reported 43.00% is an upper bound on executable-opportunity share, not the exact share of GPU-feasible work. The paper states this repeatedly, so it is not a hidden flaw; it is, however, the point where the headline quantitative claim is least secure. The additional omission of a per-session sequence constraint (overlapping spans, completion-order inversions) reinforces the same gap: two spans with the same route label may not be simultaneously ready in one session's state machine.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","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.","tokens_in":15092,"tokens_out":16338,"duration_ms":142010,"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":[{"comment":"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.'","section":"§3.1, §5.1, §11"},{"comment":"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.","section":"§5.2, Eq. (8)"}],"minor_comments":[{"comment":"The title line contains a stray space in 'A voiding' in the provided text; the final PDF should be checked for this formatting artifact.","section":"Title/Abstract"},{"comment":"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.","section":"§3.1"},{"comment":"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.","section":"§4"},{"comment":"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.","section":"§6.1"},{"comment":"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.","section":"§7.2"},{"comment":"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.","section":"§8, §8.1"}],"recommendation":"minor_revision","confidential_remarks":"The paper's prospective-freeze claim is self-reported and not independently timestamped; the artifact hashes and frozen chronology in the repository mitigate this, but the journal may want to consider whether a second-party audit of the artifact would add value. The paper is well within scope for a systems venue and is a careful, honest measurement study."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Two things before anything else. This paper gives systems people a clean set of names for the GPU-agent control question—fixed-partition share, exact offline share, local upper bound, achieved share—and measures the first three against one pinned trace replay with a public artifact. The headline numbers are internally consistent, the DP derivation is correct for its stated assumptions, and the mechanism study is a real A/B with a negative control. It deserves a serious referee.\n\nThe genuinely new bit is the application: nobody has quantified deadline-feasible same-route cohort supply for deterministic post-model transitions, or measured the cost of one host round trip for a device-resident route decision in this setting. The packing recurrence itself is known r-gathering/real-time batching material, and the paper says so without fuss. Good.\n\nWhat it does well: the paper is unusually disciplined about claim boundaries. It does not multiply the trace numbers by the mechanism numbers. It says repeatedly that the route key is a conditioning proxy, not executable identity. It distinguishes placement (named hardware) from population inference. It ships hashes, source revisions, a build script, preregistered gates, and a separately implemented oracle. That is reproducible in the sense that matters.\n\nSoft spots, in proportion. The route-key proxy is the load-bearing one. P* and the 43.00% are exact for the declared partition, but coarsening a partition can only raise the optimum, and the route key omits state-machine node, schema, arguments, policy context, and multi-tool identities. So 43.00% is an upper bound on GPU-feasible work, not the exact share. The paper flags this itself, so it is not a hidden flaw, but it is the place where the headline claim is easiest to overread. The missing per-session sequence constraint (overlapping spans, completion-order inversions) points the same direction. Also minor: the mechanism study uses technical repetitions rather than independent hardware replications, and the provider/host/image confound is real. Direction is robust within the named placements, but the 1.19–2.39x range is not a population claim, and the paper says so.\n\nThe math checks out under the documented assumptions; there is no circular fitting and no cooked comparison. The trace threshold is swept, not fit to the resident mechanism. The citation pattern is fair.\n\nThis paper is for people building or evaluating GPU-resident agent control planes. It gives them gates and vocabulary, and it clearly marks what remains unmeasured: A, CPU displacement, and service-level impact. I would send it to referees and let the authors defend the proxy. If the route-key grouping turns out to be fusible in practice, this will become a standard reference.","headline":"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.","tokens_in":15613,"tokens_out":2286,"would_cite":true,"duration_ms":20814,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"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.","keywords":["ready-cohort boundary","LLM-agent control","GPU scheduling","deadline-feasible batching","trace replay","device-resident decisions","exact packing","cohort supply"],"falsifier":"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.","tokens_in":2080,"feed_emoji":"⚙️","tokens_out":4413,"duration_ms":83585,"temperature":0.7,"pith_summary":"The paper claims that the deterministic control work between LLM and tool calls in agent runtimes holds more GPU-packable work than fixed-window schedulers admit, and that the benefit depends on where the decision is observed. In a frozen stationary Poisson replay of one pinned 851-session public trace panel, fixed windows make only 30.19% of events eligible at the primary cell, while exact offline packing reaches 43.00% and a local overlap bound is 45.85%; exact packing recovers 81.83% of the gap fixed boundaries leave. A separate GPU mechanism study keeps one computed binary decision on device instead of copying four bytes back to the host, and finds a 1.19x to 2.39x speedup in all 36 tested placement-cells. The two studies are deliberately separate because the trace threshold is swept, not measured for the resident policy, and the paper does not claim a service-level acceleration figure.","feed_headline":"Exact packing finds 12.8% more GPU-ready agent work than fixed windows","feed_subtitle":"A frozen 851-session replay shows fixed-window schedulers leave 81.83% of cross-boundary cohort opportunity on the table.","key_machinery":"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.","core_discovery":"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.","pith_inferences":["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."],"forward_implications":["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."],"supporting_citations":[{"why":"Supplies the motivating characterization that agentic workflows repeatedly cross the CPU-GPU boundary and place host orchestration on the critical path.","marker":"[26]"},{"why":"Provides the pinned 851-session public trace panel from which all trace-study events are derived.","marker":"[10]"},{"why":"Defines the airline, retail, and telecom environments whose domain labels appear in the trace route keys.","marker":"[5]"},{"why":"Is the original tool-agent-user benchmark on which the tau2 environments build.","marker":"[28]"},{"why":"Documents the device graph launch and conditional-node substrate used by both the device-resident and nested-launch mechanism experiments.","marker":"[20]"}],"fun_headline_variants":["Exact packing recovers 81.83% of fixed-window GPU gap","Device-resident decisions beat host round trips in 36/36 cells","Sliding-deadline packing lifts GPU share from 30.19% to 43%","GPU-cohort packing: 81.83% of dead time recovered"],"cache_read_input_tokens":17792,"weakest_assumption_plain":"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.","fun_headline_variants_meta":{"raw":{"variants":["Exact packing recovers 81.83% of fixed-window GPU gap","Device-resident decisions beat host round trips in 36/36 cells","Sliding-deadline packing lifts GPU share from 30.19% to 43%","GPU-cohort packing: 81.83% of dead time recovered"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000396,"raw_usage":{"total_tokens":2179,"prompt_tokens":1151,"completion_tokens":1028,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":767,"completion_tokens_details":{"reasoning_tokens":942}},"tokens_in":767,"tokens_out":1028,"duration_ms":8467,"temperature":1.0,"reasoning_tokens":942,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-16T00:15:09.654144+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"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.","supporting_citations":[{"cited_title":"Architectural implications of agentic AI workflows, 2026","cited_arxiv_id":null,"evidence_quote":"Supplies the motivating characterization that agentic workflows repeatedly cross the CPU-GPU boundary and place host orchestration on the critical path."},{"cited_title":"Multi-benchmark LLM agent traces","cited_arxiv_id":null,"evidence_quote":"Provides the pinned 851-session public trace panel from which all trace-study events are derived."},{"cited_title":"InProceedings of the 43rd International Conference on Machine Learning, volume 306 ofProceedings of Machine Learning Research","cited_arxiv_id":null,"evidence_quote":"Defines the airline, retail, and telecom environments whose domain labels appear in the trace route keys."},{"cited_title":"NVIDIA Corporation,","cited_arxiv_id":null,"evidence_quote":"Documents the device graph launch and conditional-node substrate used by both the device-resident and nested-launch mechanism experiments."}],"review_version":1}