{"id":"8dd9cfe0-dd7d-4ac6-91b8-7eb3bee882e4","arxiv_id":"2504.15905","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"high","formal_verification":"none","parameter_count":2,"one_line_summary":"A graph-cut plus multi-agent reinforcement learning method for offloading GNN tasks in edge networks reduces simulated system cost and cross-server communication in dynamic scenarios.","lead":"GraphEdge is a proposed edge-computing architecture for graph neural networks that groups related users before deciding where to send their tasks. It reports lower time and energy costs than simpler offloading rules in simulations with changing user locations and relationships.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Eq. (12)-(13) sum the aggregate inter-server transfer cost once per user, inflating that term by N; the objective DRLGO minimizes and the evaluation metric are therefore not the stated system cost.","rationale":"The reader's weakest_assumption correctly identifies the cost model in Eqs. (7)-(13) as load-bearing. My reading of the paper confirms that the objective being minimized, the reward used for DRL training, and the evaluation metric are all built from the same equations. The factor-N inflation of the inter-server transfer term is not a cosmetic typo: it changes the relative weight of communication cost versus upload and computation cost by an amount that scales with the number of users, so the learned policy may be optimizing a different trade-off than the one claimed. The undefined indices in Eqs. (7)-(8) reinforce that the communication model was not written down carefully enough to support the quantitative claims. HiCut's optimality is also asserted rather than proven, but the cost-model defect is more fundamental because it undermines both the training signal and the experimental evidence for the whole architecture. I nevertheless agree with the reader's CONDITIONAL verdict rather than REJECT: the core idea, partition the user graph into strongly associated subgraphs and co-offload each subgraph to one server, is plausible and could survive correction of the equations and re-evaluation. The concern is concrete and testable, and the paper's reported simulation improvements would need to be regenerated under the corrected objective before the central claim can be accepted.","tokens_in":25669,"tokens_out":3292,"duration_ms":34435,"concrete_test":"Re-run DRLGO training and the Fig. 7-9 evaluations with corrected objective formulas: T_all = sum_{n,m} T^up_{n,m} + sum_{k≠l} T^tran_{k,l} + sum_{n,k} T^com_{n,f_k}, and I_all = sum_{n,m} I^up_{n,m} + sum_{k≠l} I^com_{k,l} + sum_layers (I^agg + I^upd), with Eq. (8) rewritten as a double sum over associated user pairs i,j. If the normalized-cost gaps and the ordering DRLGO > PTOM > GM/RM persist and the learned offloading decisions are substantially unchanged, the concern is resolved. If the corrected curves shift or reorder, the central minimization claim fails as stated.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Eq. (12) defines T_all = sum_{n=1..N} (sum_m T^up_{n,m} + sum_{k,l≠k} T^tran_{k,l} + sum_k T^com_{n,f_k}). The middle term, T^tran_{k,l}, is defined in Eq. (7) as the aggregate communication delay between servers SV_k and SV_l and has no dependence on the user index n. Summing it inside the outer sum over N users therefore multiplies the total inter-server transfer time by a factor of N. Eq. (13) does the same thing for I^com_{k,l} inside the user sum, inflating the inter-server energy term by N as well. Eq. (8) is also not a well-defined sum: it contains e_ij, w_ik, w_jl, and X_i with indices i and j unbound, so the energy term as written cannot be evaluated without additional summation assumptions. Because DRLGO's reward is the negative of T_all + I_all and the reported system costs are computed from the same formulas, the training objective and the evaluation metric both overweight cross-server communication by a factor of N relative to upload and computation costs. This is load-bearing: the central claim is that GraphEdge minimizes real system cost, but the minimized quantity is not a faithful statement of that cost, and an overweighted transfer term can push the learned policy toward excessive server-collocation even when that increases true time and energy. The HiCut cross-server cost claims inherit the same issue, since Eq. (15) minimizes I_com under the same malformed definition.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"This paper proposes GraphEdge, an architecture for GNN inference in edge networks. It models user data associations as a dynamic graph, partitions the graph into weakly coupled subgraphs using a BFS-based hierarchical cut (HiCut), and then uses a MADDPG-based deep reinforcement learning algorithm (DRLGO) to offload whole subgraphs to edge servers. The objective is to minimize total time and energy, including upload, inter-server communication, and GNN computation. Experiments on CiteSeer, Cora, and PubMed against PPO, greedy, and random offloading baselines report lower system cost and lower cross-server cost, with additional results on convergence and an ablation. The paper claims that DRLGO 'can minimize system cost' even in dynamic scenarios and that HiCut 'can effectively reduce cross-server communication cost.'","tokens_in":25969,"tokens_out":12075,"duration_ms":104056,"significance":"The manuscript addresses a relevant and timely problem: serving GNN inference over distributed edge servers with dynamic user topology. The proposed architecture is cleanly decomposed into a dynamic graph model, a graph partition algorithm (HiCut), and a multi-agent reinforcement learning offloading algorithm (DRLGO), and the simulation study is self-contained in that all methods are evaluated on the same cost equations. If the cost model were correct, the results showing DRLGO below PPO, greedy, and random baselines, together with the ablation against DRL-only, would provide preliminary evidence that graph-aware partition plus subgraph-level offloading can reduce system cost and cross-server communication. However, the load-bearing cost model issues identified in the major comments—particularly the factor-N inflation of transfer costs in Eqs. (12)-(13), the undefined indices in Eqs. (7)-(8), and the unverified optimality of HiCut—mean that the quantitative results as presented do not support the central claims. The work is a reasonable starting point, but it needs substantial correction and re-evaluation.","major_comments":[{"comment":"In the definitions of T_all and I_all, the terms sum_{k,l≠k} T^tran_{k,l} and sum_{k,l≠k} I^com_{k,l} do not depend on the user index n, yet they are placed inside the outer sum over n=1..N. This counts the aggregate inter-server transfer time and energy N times, overweighting cross-server communication by a factor of N relative to upload and computation costs. Because DRLGO's reward is the negative of T_all + I_all and the experimental results are computed from these same formulas, both the training objective and the evaluation metric are distorted. The transfer terms should be moved outside the user sum, or a per-user share of the transfer cost should be defined. This is a load-bearing issue: the paper's central claim is that GraphEdge minimizes the true system cost, but the minimized quantity is not a faithful statement of that cost, and the overweighted transfer term can bias the learned policy toward collocation even when that increases true time and energy.","section":"3.5, Eqs. (12)-(13)"},{"comment":"The inter-server communication model is not well defined. In Eq. (7), x_{k→l}(t) is written as sum_{i=1}^N X_i · w_ik · e_ij, but the index j is free; a sum over j (or over edges (i,j)) with a condition on the destination server, such as w_jl = 1, is missing. In Eq. (8), I^com_{k,l}(t) contains e_ij(t), w_ik(t), w_jl(t), and X_i(t) with i and j unbound and no summation; as written it is a product of scalars for a single unspecified edge, not the total energy cost of communication between servers k and l. Without a precise definition, the objective in Eqs. (12)-(13) and the HiCut cost in Eq. (15) cannot be evaluated or reproduced. These equations need to be rewritten with explicit summations over the appropriate user pairs.","section":"3.3, Eqs. (7)-(8)"},{"comment":"The paper asserts that HiCut finds a cut that 'ensures minimal inter-subgraph edges' and 'ensures that the correlation between subgraphs is minimized,' but no proof or counterexample-based argument is provided. The algorithm's decision rule compares edge counts between consecutive BFS layers and records local troughs; the output depends on the choice of the BFS starting vertex, and this local heuristic is not guaranteed to yield a global minimum cut. In addition, Eq. (15) places the minimization over G_sub inside the double sum over server pairs k and l, which would allow a different partition for each pair; the intended optimization is min_{G_sub} of the sum over pairs. The authors should either supply a correctness argument for the optimality claim or explicitly present HiCut as a heuristic, and they should correct Eq. (15).","section":"4.2-4.3, Eq. (15)"},{"comment":"The experiment comparing different GNN models (GCN, GAT, GraphSAGE, SGC) does not support the claimed 'strong model adaptation capability' because the cost model in Eqs. (9)-(11) depends only on the number of layers, the feature dimensions S_k, the degrees, and the server speed f_k; the GNN architecture itself appears nowhere in the cost equations. The text states that all models have three layers and 64 neurons, so for a fixed dataset and offloading plan the computed system cost is identical across the four models. The results in Fig. 10 therefore cannot demonstrate any variation due to the GNN model, and the model-adaptation claim needs reformulation or a cost model that actually reflects the different operations of GCN, GAT, GraphSAGE, and SGC.","section":"6.3, Fig. 10"},{"comment":"The reward function in Eq. (25) includes the subgraph-grouping term R_sp with a weight constant ζ, but the value of ζ is not reported anywhere in Table 2 or the text. Since this term shapes the learned policy in addition to the system cost C = T_all + I_all, the training objective is not fully specified and the experiments are not reproducible without this value. The authors should report ζ and, ideally, include a sensitivity analysis over ζ.","section":"5.2, Eq. (25), and Table 2"}],"minor_comments":[{"comment":"Table 1 lists σ_{k,l} twice, with slightly different descriptions; one entry should be removed.","section":"Table 1"},{"comment":"In Eq. (13), the first term inside the user sum is written as I^up_{i,m}, while the outer sum uses index n; the indices should be consistent.","section":"Eq. (13)"},{"comment":"Eq. (15) has a typo in the upper limit of the second sum: 'm' should presumably be 'M'.","section":"Eq. (15)"},{"comment":"In Section 4.2, d_n is described as 'the number of edges in the current layer,' but in Algorithm 1 it is incremented for neighbors of current-layer vertices that are not in the subgraph; the definition should be stated precisely.","section":"Section 4.2 and Algorithm 1"},{"comment":"Section 6.2 compares HiCut to the min-cut method in [36] only in terms of runtime (Fig. 6); no comparison of cut quality (e.g., number of inter-subgraph edges or resulting communication cost) is reported, so the claim that HiCut reduces cross-server communication is not directly validated against the min-cut baseline.","section":"Section 6.2, Fig. 6"},{"comment":"Fig. 12 appears garbled in the manuscript version I received (the figure body consists of '/uni0000...' tokens), so the ablation result comparing DRLGO and DRL-only cannot be verified from the text.","section":"Fig. 12"},{"comment":"The paper does not compare DRLGO to an optimal offloading solution on small instances or to a standard graph partitioner such as METIS; such comparisons would strengthen the claims that the offloading is 'optimal' and that HiCut has good cut quality.","section":"Section 6.3"}],"recommendation":"major_revision","confidential_remarks":"The paper has a substantive technical problem: the factor-N inflation in the cost model and the ill-defined inter-server communication equations mean the evaluation needs to be redone after correcting the model. This is not a rejection-level issue because the architecture idea is coherent and the errors appear fixable, but the authors should be asked to provide the corrected model, the value of ζ, and a clear-cut comparison to a standard partitioner or optimal cut on small graphs. Also, the garbled Fig. 12 should be fixed before resubmission."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"First thing you should know: GraphEdge is a plausible architecture for GNN inference at the edge, and the combination of a graph partition tailored to GNN aggregation (HiCut) with a MADDPG offloader (DRLGO) is genuinely new relative to the cited prior work. But the cost model at the center of the paper is not written down correctly. Eq. (12)-(13) sum the aggregate inter-server transfer time and energy inside the outer loop over users, which inflates those terms by a factor of N. Eq. (8) has unbound indices i and j. These are not cosmetic typos: the reward for DRLGO and the evaluation metric are both computed from these formulas, so the paper is optimizing and measuring something that is not the stated system cost.\n\nWhat the paper does well: the dynamic graph model with mask and position attributes is a reasonable way to represent user churn and mobility; HiCut is a simple, fast heuristic that plausibly reduces inter-subgraph edges; DRLGO is a standard MADDPG application with a subgraph-grouping reward term. The experiments are consistent across three citation datasets and four GNN models, and DRLGO beats PPO, greedy, and random in every figure. That consistency is worth something, even if the baselines are weak.\n\nWhere it falls short: the equation problem is load-bearing. In addition, HiCut's optimality is asserted, not proved; there are no error bars or variance measures despite the claim of 10 runs; no comparison to standard partitioners like METIS or to an exact optimum; and the subgraph grouping weight zeta in Eq. (25) is never reported. No code or data is provided, so reproducibility is limited to the description in the text.\n\nMy take: the core idea — cut the user graph along weak associations and co-offload the pieces to the same server — is sound and likely to survive correction. The paper deserves a serious referee, but it needs a major revision: fix the equations, report zeta, add error bars, and compare against at least one strong partitioner. I'd bring it to reading group for a discussion of the cost-model pitfall, but I wouldn't cite it while the objective function is wrong.","headline":"Plausible GNN edge-offloading architecture with a genuinely new partition-for-aggregation idea, but a factor-N inflation in the cost model undermines the central quantitative claim.","tokens_in":26552,"tokens_out":1895,"would_cite":false,"duration_ms":18174,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"GraphEdge claims that cutting the user-association graph into weakly linked subgraphs and offloading each subgraph to a single edge server minimizes system cost and cross-server communication for GNN inference in dynamic edge networks.","keywords":["edge computing","graph neural networks","task offloading","graph partitioning","deep reinforcement learning","multi-agent reinforcement learning","dynamic graph topology","cross-server communication"],"falsifier":"Settle it by taking the objective apart: in Eq. (12) the inter-server transfer delay $T^{\\mathrm{tran}}_{k,l}$ appears inside the sum over all $N$ users, so the same transfer is counted once per user rather than once per server pair. Rewriting the objective with the transfer summed over server pairs and retraining DRLGO, or measuring actual transfer latency on a two-server testbed under the same offloading decisions, would show whether the reported cost advantage is an artifact of the counting. If the corrected or measured costs put DRLGO on par with the baselines, the central claim collapses.","tokens_in":25414,"feed_emoji":"🕸️","tokens_out":7598,"duration_ms":67623,"temperature":0.7,"pith_summary":"This paper tries to establish that the cost of serving graph neural network tasks on distributed edge servers can be minimized by treating the user graph itself as the object to optimize: first cut the graph into strongly associated subgraphs, then offload each subgraph as a single unit. The proposed GraphEdge architecture combines a breadth-first hierarchical cut (HiCut), which places cuts where associations between layers are weakest, with a multi-agent deep reinforcement learning offloader (DRLGO) trained to keep each subgraph on one server. If the claim is right, correlated IoT tasks such as traffic prediction and social recommendation can be served at the edge without paying the full message-passing communication cost between servers, and the system can re-plan as users join, leave, or move. The paper's simulations on citation graphs show lower system cost and lower cross-server communication than PPO, greedy, and random offloading baselines under dynamic user counts, associations, and positions.","feed_headline":"Cutting user graphs first cuts GNN edge-server costs","feed_subtitle":"GraphEdge groups strongly linked users into subgraphs and sends each subgraph to a single edge server, trimming message-passing traffic.","key_machinery":"The load-bearing machinery is the pair HiCut plus DRLGO. HiCut is a hierarchical traversal graph cut: it runs a breadth-first search from an unchosen vertex, counts the edges between consecutive layers, and records a candidate cut whenever the edge count falls; when the count later rises, it closes a subgraph at the recorded layer, ensuring that vertices inside a subgraph are strongly associated and vertices across subgraphs are weakly associated. This directly targets GNN message passing, since aggregation requires a server to fetch neighbor features across cut edges. DRLGO is a multi-agent deep reinforcement learning offloader built on the MADDPG scheme (multi-agent deep deterministic policy gradient): each edge server is an agent that acts on local observations, a central critic trains them together, and the reward is the negative system cost plus a penalty proportional to the number of servers a subgraph is spread across. The dynamic graph model, a mask array for joining and leaving users plus position attributes for mobility, feeds both stages at each time step. Together they convert the integer offloading problem into graph partitioning followed by learned subgraph-to-server assignment.","core_discovery":"The central claim is that GNN inference cost in an edge system splits into two manageable subproblems instead of one intractable integer program. The first subproblem is graph layout: because a GNN aggregates a user's features with its neighbors' features, any edge of the user graph that crosses server boundaries forces a data transfer. HiCut traverses the graph layer by layer and cuts where the number of edges between successive BFS layers dips, producing subgraphs whose inter-subgraph edges are few. The second subproblem is offloading: given those subgraphs, DRLGO, a multi-agent actor-critic policy with centralized training and distributed execution, assigns each subgraph to an edge server, with a reward that penalizes scattering a subgraph across servers. The paper argues that this two-step procedure minimizes the system cost $T_{\\mathrm{all}} + I_{\\mathrm{all}}$ and adapts to dynamic user states through a mask module and position attributes in the graph model; the experiments are offered as evidence that the architecture outperforms PPO-based, greedy, and random offloading in dynamic scenarios.","pith_inferences":["Beyond the paper's stated claims, the cost objective in Eq. (12) sums the inter-server transfer time $T^{\\mathrm{tran}}_{k,l}$ inside the loop over all $N$ users, so the same cross-server transfer appears to be counted once per user rather than once per server pair; a corrected objective could change both the training signal and the reported cost comparisons.","A natural test the paper does not run is to replace the citation graphs with a temporal network of real mobility or social interactions, where edges appear and disappear at fine time scales; the mask and position model would then face edge churn rather than resampled static graphs, and it is an open question whether HiCut's edge-count heuristic still finds good cuts.","The claim that cutting by BFS-layer edge-count dips is near-optimal is heuristic; comparing HiCut against exact or balanced graph-partition objectives on the same datasets would tell whether the communication savings come from the cut heuristic itself or from the subgraph-cohesive offloading reward."],"forward_implications":["A service operator can run GNN inference over geographically distributed servers while exchanging data only across subgraph boundaries; the amount of inter-server traffic is set by HiCut's cut quality, not by the raw number of user associations.","When users join, leave, or move, the mask and position attributes update the graph and the same trained DRLGO can re-plan the offloading, so the architecture does not need to retrain from scratch at every topology change.","The reported complexity advantage means the graph-cut stage remains usable as graphs grow: $O(N^2 + NE)$ versus the compared min-cut method's $O(V^2E)$, with the gap widening on dense graphs.","Because DRLGO's reward couples system cost with subgraph cohesion, the learned policy should transfer across GNN models that share the aggregation step, which the experiments support by testing GCN, GAT, GraphSAGE, and SGC."],"supporting_citations":[{"why":"Supplies the cost-efficient GNN-at-the-edge baseline whose min-cut graph cut method HiCut is compared against, and the prior formulation of distributed GNN serving over edge servers.","marker":"[36]"},{"why":"Provides the multi-agent actor-critic (MADDPG) training scheme that DRLGO adapts for subgraph-to-server offloading.","marker":"[46]"},{"why":"Gives the GCN aggregation and update equations used to justify cutting the graph by association strength.","marker":"[31]"},{"why":"GraphSAGE is used as one of the four GNN models and supplies the message-passing and aggregation view of GNN inference.","marker":"[30]"},{"why":"Breadth-first search reference that HiCut builds its layer-by-layer traversal and cut-position logic on.","marker":"[44]"},{"why":"PPO is the basis of the PTOM baseline, the main comparison showing DRLGO's lower cost.","marker":"[55]"},{"why":"Original source of the Cora, CiteSeer, and PubMed graph datasets used to instantiate users and user associations in the experiments.","marker":"[53]"}],"fun_headline_variants":["GraphEdge: partition graphs first, then offload to cut GNN costs","Two-step plan: split user graph, then schedule to trim GNN traffic","HiCut then DRLGO: graph partitioning beats GNN edge communication","Dynamic graph cutting plus DRL offloading trims GNN edge costs"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing assumption is that the paper's equations for time and energy (Eqs. 7-13) accurately describe what a real edge server would spend, since DRLGO is trained to minimize those equations and the experiments evaluate those same equations; if the model over- or under-counts transfer cost, the claimed savings are not real.","fun_headline_variants_meta":{"raw":{"variants":["GraphEdge: partition graphs first, then offload to cut GNN costs","Two-step plan: split user graph, then schedule to trim GNN traffic","HiCut then DRLGO: graph partitioning beats GNN edge communication","Dynamic graph cutting plus DRL offloading trims GNN edge costs"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000754,"raw_usage":{"total_tokens":3411,"prompt_tokens":1058,"completion_tokens":2353,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":674,"completion_tokens_details":{"reasoning_tokens":2272}},"tokens_in":674,"tokens_out":2353,"duration_ms":17584,"temperature":1.0,"reasoning_tokens":2272,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-16T11:16:09.758593+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Settle it by taking the objective apart: in Eq. (12) the inter-server transfer delay $T^{\\mathrm{tran}}_{k,l}$ appears inside the sum over all $N$ users, so the same transfer is counted once per user rather than once per server pair. Rewriting the objective with the transfer summed over server pairs and retraining DRLGO, or measuring actual transfer latency on a two-server testbed under the same offloading decisions, would show whether the reported cost advantage is an artifact of the counting. If the corrected or measured costs put DRLGO on par with the baselines, the central claim collapses.","supporting_citations":[{"cited_title":"Gnn at the edge: Cost-efficient graph neural network processing over distributed edge servers.IEEE Journal on Selected Areas in Communications, 41(3):720–739, 2022","cited_arxiv_id":null,"evidence_quote":"Supplies the cost-efficient GNN-at-the-edge baseline whose min-cut graph cut method HiCut is compared against, and the prior formulation of distributed GNN serving over edge servers."},{"cited_title":"Multi-agent actor-critic for mixed cooperative- competitive environments.Advances in Neural Information Process- ing Systems, 30, 2017","cited_arxiv_id":null,"evidence_quote":"Provides the multi-agent actor-critic (MADDPG) training scheme that DRLGO adapts for subgraph-to-server offloading."},{"cited_title":"Spatio- temporalfusiongraphconvolutionalnetworkfortrafficflowforecast- ing","cited_arxiv_id":null,"evidence_quote":"Gives the GCN aggregation and update equations used to justify cutting the graph by association strength."},{"cited_title":"Inductive repre- sentation learning on large graphs.Advances in Neural Information Processing Systems, 30, 2017","cited_arxiv_id":null,"evidence_quote":"GraphSAGE is used as one of the four GNN models and supplies the message-passing and aggregation view of GNN inference."},{"cited_title":"Designing multithreaded algorithms for breadth-first search and st-connectivity on the cray mta-2","cited_arxiv_id":null,"evidence_quote":"Breadth-first search reference that HiCut builds its layer-by-layer traversal and cut-position logic on."},{"cited_title":"Revisiting semi-supervised learning with graph embeddings","cited_arxiv_id":null,"evidence_quote":"Original source of the Cora, CiteSeer, and PubMed graph datasets used to instantiate users and user associations in the experiments."}],"review_version":1}