acceptodds
Under review as a conference paper at ICLR 2027

Beyond Surface Semantics: Logic-Guided Privacy-Preserving Cloud-Edge LLM Reasoning

Abstract

Large language models (LLMs) excel at complex reasoning, but their large resource demands make them difficult to deploy on edge devices. Thus, many users rely on APIs to access cloud-side LLMs for complex reasoning tasks, raising privacy concerns when sending queries to the cloud. Existing methods protect user queries on the edge before cloud reasoning. Recent work further explores cloud-edge collaboration, where the cloud-side LLM provides guidance and the edge-side small language model (SLM) completes reasoning with private data. However, to balance utility and privacy, these methods mainly preserve surface semantics and often fail to retain the logical structure needed for solving the query, making cloud guidance unstable. In this paper, we propose LoGic, a logic-guided analogical reasoning framework that shifts the focus from preserving surface semantics to preserving reasoning-critical logical structure under privacy constraints. This enables the cloud-side LLM to provide more effective guidance for improving edge-side SLM reasoning. Specifically, LoGic decouples each private query on the edge side into a logic skeleton and an entity mapping, applying sensitivity-aware differentiated LDP protection and a privacy-aware GRPO strategy to preserve useful logical structure under privacy guarantees. The cloud-side LLM then generates a structure-consistent query from the protected structure and derives its step-by-step solution, serving as a query-specific analogical example for the edge side. Finally, the edge-side SLM transfers the cloud-side LLM's reasoning pattern from the structurally similar query to solve the original query. Experiments on complex reasoning tasks show that LoGic delivers stronger reasoning performance with lower leakage than existing baselines.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Large language models, Privacy, Cloud-edge collaboration, Reasoning

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_oLPDOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2(+1)
Read review
Paper summary

This paper proposes LoGic, a privacy-preserving cloud-edge collaborative LLM reasoning framework. Its core idea is that, rather than preserving surface semantics, privacy-preserving collaboration should prioritize preserving the logical structure that is critical for reasoning. On the edge side, LoGic decomposes each private query into a Logic Skeleton and an Entity Mapping, applies sensitivity-aware differentiated LDP protection to the two components, and optimizes the extractor using a privacy-aware dual-reward GRPO strategy. The cloud-side LLM then generates a structure-consistent analogical example from the protected representation, and the edge-side SLM performs structure-aligned analogical pattern transfer to solve the original private query. Experiments are conducted on MathQA and StrategyQA, with comparisons against multiple privacy-preserving and cloud-edge collaborative reasoning baselines. The results show that LoGic generally achieves stronger performance than the compared privacy-preserving methods, together with several additional analyses of the proposed framework.

Critical strengths

The paper explicitly decomposes each query into a logic skeleton and an entity mapping, and uses the cloud-side LLM to generate a structurally consistent analogical reasoning example. The overall framework is well aligned with the central motivation of preserving reasoning-critical logical structure rather than surface semantics.

The paper includes overall performance comparisons, component ablations, privacy-budget analysis, evaluations with different judge models and cloud LLMs, as well as reasoning-time efficiency analysis, covering the main aspects of the method’s effectiveness and robustness.

Critical weaknesses

The empirical Leakage metric is mainly based on LLM judgments, while the paper does not include explicit reconstruction, attribute-inference, linkage, or similar attack experiments conducted from the cloud side or over the communication channel. As a result, the current evaluation does not sufficiently demonstrate that the preserved logical structure cannot itself be exploited to infer private information.

Although LoGic generally outperforms Edge-Only and the privacy-preserving baselines, it still shows a clear performance gap from Cloud-Only. Moreover, the improvement diminishes as the edge-side model becomes stronger. This raises concerns about the practical usefulness of the method, since the privacy–utility trade-off is not convincingly demonstrated under stronger edge models.

The efficiency analysis compares LoGic only with several privacy-preserving cloud-edge collaborative reasoning methods, without including Cloud-Only, Edge-Only, or a matched non-private cloud-edge variant. Therefore, it is difficult to quantify the additional resource overhead introduced specifically by the privacy-preserving mechanism, including potential communication and end-to-end latency costs in realistic deployment.

The experiments only cover static QA datasets such as MathQA and StrategyQA, without considering tool-use, code execution, data processing, or similar multi-step interactive settings. Such scenarios also involve substantial privacy concerns, so the current evaluation is insufficient to establish the general applicability of the proposed framework.

The proposed Logic-Entity decoupling is closely related to structured anonymization/de-identification, yet the paper does not provide direct empirical comparisons with such methods. Consequently, the specific differences and relative advantages in terms of privacy, utility, and efficiency remain unclear. The paper also lacks analysis of extraction reliability and computational complexity across different query types.

Questions for authors

Could the authors include an attack-oriented privacy evaluation, for example by attempting to reconstruct the original query, infer sensitive entities or attributes, or perform linkage attacks? Could the current key-noun-based Leakage metric underestimate privacy leakage conveyed through the preserved logical structure?

Compared with Cloud-Only, Edge-Only, and an otherwise identical cloud-edge pipeline without the privacy-preserving components, how much additional latency, memory, computation, and communication overhead does LoGic introduce?

Compared with existing anonymization/de-identification methods, what are the direct advantages of Logic-Entity decoupling in terms of utility, privacy, and efficiency? Are there query types for which a reliable logic skeleton cannot be extracted, or for which extraction incurs substantially higher computational cost?

Does LoGic remain effective in multi-step interactive tasks such as tool-use, code execution, and data processing? If the same user interacts with the cloud multiple times, how are the corresponding privacy budgets composed across interactions?

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

This paper proposes LoGic, a privacy-preserving cloud-edge collaboration framework for complex reasoning. The authors argue that existing anonymization and token-level perturbation methods mainly preserve surface semantics while destroying the logical constraints needed for reliable reasoning.LoGic first decomposes a private query into a logic skeleton and an entity mapping. It then applies differentiated local differential privacy (LDP), using a larger privacy budget for the logic skeleton and a smaller budget for the entity mapping. A privacy-aware dual-reward GRPO procedure is used to train the logic extractor so that the perturbed representation remains structurally consistent and useful for downstream reasoning. The cloud LLM generates a structure-consistent analogical query and reasoning trajectory from the protected representation. Finally, the edge-side SLM transfers this reasoning pattern to the original private query.

Critical strengths

1.The logic-entity decomposition is conceptually interesting. Separating reasoning constraints from concrete entities provides a plausible way to improve cloud-side guidance while reducing direct exposure of private content.

2.The experimental study is reasonably broad. The authors evaluate multiple edge models and datasets and include ablations for logic extraction, decoupling, GRPO, analogical examples, and analogical transfer.

Critical weaknesses

1.The privacy proof does not establish end-to-end query-level privacy. The paper defines adjacency only between tokens that share the same customized output set and proves a token-level guarantee under that restricted relation. This is substantially weaker than standard query-level or user-level LDP. Tokens from different groups may reveal their group membership because their output supports differ. Moreover, the logic extractor is a data-dependent mapping of the full private query, and the released skeleton and entity mapping contain multiple tokens and structural information. The paper does not account for composition over multiple tokens, sequence length, structural patterns, repeated queries, or repeated use of the system. Therefore, the stated max{εz, εe}-LDP result does not justify an end-to-end privacy guarantee for the complete query or for task intent.

2.The privacy objective and leakage metric are not well aligned. The paper assumes that the logic skeleton is generally less sensitive than the entities, but logical operations, constraints, and goals can themselves reveal highly sensitive task intent. For example, the structure of a medical allocation or investment optimization problem may reveal the user’s purpose even when all entities are replaced. The reported leakage metric is based on whether an LLM detects shared key nouns between the uploaded representation and the original query. This does not measure semantic paraphrase leakage, relation leakage, numerical inference, task-type identification, or active reconstruction attacks. The additional judge-model experiments validate the same weak criterion rather than a stronger privacy threat model.

Questions for authors

1.Can the authors provide an end-to-end privacy definition and proof under standard query-level adjacency, including the data-dependent extractor, multiple tokens, sequence length, group membership, and repeated queries? If not, should the privacy claim be explicitly restricted to the proposed token-level adjacency model?

2.Can the authors evaluate stronger privacy attacks, such as task-intent classification, semantic relation reconstruction, numerical recovery, or inference of the original query from the transmitted representation?

3.How exactly are MathQA’s multiple-choice options, numerical operations, and answer labels converted into the logic skeleton and analogical-query format? Please provide examples and direct measurements of extraction and structural-alignment accuracy.

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

The paper studies cloud-edge collaborative reasoning with LLMs. It proposes an algorithm called LoGic, which preserves reasoning-critical logical structure under privacy constraints for data at the edge. The main idea is to tune an extractor model that extracts the logical structure and the entity mapping. The logical structure is shared with the cloud LLM after applying local differential privacy, which then performs the reasoning. The reasoning result is then transferred back to the edge via a pattern transfer mechanism. Experiments show the advantage of the proposed method.

Critical strengths
  • The studied problem is timely and useful in practical applications where not all the information can be sent to a cloud LLM for processing.
  • The paper is generally well-written and easy to understand.
Critical weaknesses
  • The overall approach seems to be a relatively straightforward combination of differential privacy, model tuning with GRPO, and entity recognition and mapping. Thus, the novelty seems to be limited.
  • Some important components in the proposed method, especially structure-aligned analogical pattern transfer, are not clearly explained. It is therefore unclear how it works.
  • The experiments only consider two benchmark datasets that contain somewhat classical reasoning tasks, since the MathQA and StrategyQA benchmarks were created more than 5 years ago. It is unclear whether the proposed approach works with more sophisticated reasoning tasks nowadays, such as those that are solved using an agentic workflow.
Questions for authors
  • What is the key novelty and non-obvious contribution in this work?
  • How does structure-aligned analogical pattern transfer work exactly?
  • Does the proposed approach work with more sophisticated reasoning tasks nowadays, such as those that are solved using an agentic workflow?
4 comments
AuthorsOpenReview ↗

Response to Reviewer qedR [Part 1/2]

We are grateful for your valuable feedback and constructive comments. We kindly clarify that all of your suggested additional experiments and explanations have been completed and addressed. We also expect to submit the complete revised manuscript in PDF format within the next two days. We would greatly appreciate it if you would reconsider the final evaluation of our work!


W1: The overall approach seems to be a relatively straightforward combination of differential privacy, model tuning with GRPO, and entity recognition and mapping. Thus, the novelty seems to be limited.

Q1: What is the key novelty and non-obvious contribution in this work?

Rather than merely combining existing techniques, we propose a logic-structure-driven paradigm for privacy-preserving cloud-edge collaborative inference.

The key novelty of our work lies in redefining the form of information on which cloud–edge collaborative inference relies under privacy constraints: preserve logic structure, not surface semantics. This enables the system to protect private entities while retaining the essential information required for inference.

The non-obvious contributions are threefold.

  • Structure-aligned analogical reasoning transfer. Existing cloud–edge methods reason directly over perturbed text, degrading performance. In contrast, we use the cloud to generate a structure-consistent analogical query and reasoning trajectory from the logic skeleton, enabling the edge SLM to transfer the reasoning pattern to the private query.
  • Sensitivity-aware differentiated privacy protection. Existing LDP methods perturb text as a whole; we decouple the logic skeleton from the entity mapping and apply differentiated LDP, preserving reasoning structure while strongly protecting entities.
  • Privacy-aware GRPO optimization. We extend GRPO: we keep its objective but redefine the reward on the LDP-perturbed representation, jointly rewarding structural consistency and downstream utility so the policy adapts to the protected input at deployment.

In summary, we co-design information representation, collaborative reasoning, differentiated privacy protection, and model optimization around the unified goal of preserving reasoning-critical logical structures, establishing a paradigm distinct from approaches that primarily rely on surface-semantic preservation.


W2: Some important components in the proposed method, especially structure-aligned analogical pattern transfer, are not clearly explained. It is therefore unclear how it works.

Q2: How does structure-aligned analogical pattern transfer work exactly?

The workflow of the structure-aligned analogical pattern transfer module is described in Section 4.3.2, illustrated as part of the overall framework in Figure 1, and further exemplified in Appendix E. Nevertheless, we acknowledge that the existing explanations may not be sufficiently detailed or explicit, and will clarify the relevant descriptions in the revised manuscript.

In this module, the edge-side SLM receives the original private query qq together with the analogical example (q^,y^)(\hat{q}, \hat{y}) generated by the cloud, where q^\hat{q} shares the same logical structure as qq and y^\hat{y} is its complete reasoning trajectory. The edge-side model learns the reasoning pattern of (q^,y^)(\hat{q}, \hat{y}) through prompting, and then transfers this reasoning pattern onto the real private entities of the original query qq to produce the final response yy. Consequently, this module transfers the reasoning pattern embedded in the analogical example, rather than simply reusing its answer. As stated in lines 329–337: "Given the private query qq and the analogical example (q^,y^)(\hat{q}, \hat{y}) returned by the cloud, … , Specifically, the edge-side model first aligns the shared logical structure between qq and q^\hat{q}, and then follows the reasoning trajectory y^\hat{y} to transfer its reasoning pattern to the private entity information."

AuthorsOpenReview ↗

Response to Reviewer qedR [Part 2/2]

W3: The experiments only consider two benchmark datasets that contain somewhat classical reasoning tasks, since the MathQA and StrategyQA benchmarks were created more than 5 years ago. It is unclear whether the proposed approach works with more sophisticated reasoning tasks nowadays, such as those that are solved using an agentic workflow.

Q3: Does the proposed approach work with more sophisticated reasoning tasks nowadays, such as those that are solved using an agentic workflow?

Following your suggestions, we conducted additional experiments on EC²-Bench [1] to evaluate whether our method remains effective on more sophisticated reasoning tasks involving agentic workflows. EC²-Bench targets cloud–edge collaborative LLM agents and provides executable tasks with a unified OpenClaw execution and evaluation environment, covering tool invocation, file and code execution, data processing, and multi-step interactions. We adopt its two evaluation dimensions, Completion Score and Privacy Exposure, where Privacy Exposure measures the proportion of task-annotated sensitive information units exposed in cloud-visible execution traces. We include Cloud-Only and Edge-Only as pure-cloud and pure-edge architectural references, respectively, and compare LoGic with privacy-preserving cloud–edge methods. We do not include CollabLLM because it is specifically designed for numerical reasoning and is not directly applicable to the broader range of executable agent tasks in EC²-Bench. We use Qwen2.5-1.5B-Instruct as the edge-side SLM, GPT-4.1 as the cloud-side LLM, and GPT-6.1-Sol as the judge.

The results below show that our method achieves the best privacy–utility trade-off among the compared baselines. It achieves the highest task completion score among the privacy-preserving collaborative methods, substantially improving the reasoning performance of the edge-side SLM while reducing sensitive information exposure. These results demonstrate that our method remains effective beyond conventional QA tasks and can support more sophisticated reasoning tasks involving tool use, multi-step interactions, and execution feedback under privacy constraints.

MethodsCompletion Score ↑Privacy Exp. ↓
Cloud-Only (upper bound)45.2588.39
Edge-Only10.280.00
InferDPT9.525.26
PRISM22.517.54
LoGic (ours)26.284.23

References

[1] Huang et al. "Empowering Edge Agents: A Systematic Analysis of Edge-Cloud Collaboration in LLM Agent Execution." 2026.

Thanks for the answers. I still feel that the novelty of this work is somewhat limited, as the improvement appears to be in some implementation details rather than something fundamentally novel. It's unclear why these new contributions are non-obvious or what are the core technical challenges therein. Besides, please make the response comments visible to everyone instead of only the reviewers and AC/PC.

Thank you for your follow-up. We have made our response comments public as requested. We would like to further clarify the novelty of our work and its core technical challenge.

The core novelty is the interface redesign: the cloud receives a protected logic structure rather than perturbed surface semantics, and the reasoning pattern generated on a structurally corresponding query is transferred back to the private query on the edge. This is non-obvious because the prevailing assumption is that preserving more surface semantics helps the cloud reason better; our observation is that complex reasoning depends primarily on the logical structure that determines the solution path, and that this structure is both more useful to the cloud and less instance-specific than raw entities. Simply perturbing surface text can destroy reasoning-critical relations, while exposing unprotected logical structures can compromise privacy.

Our contribution is therefore primarily at the framework and paradigm level, with the technical components designed to realize this central idea. The core technical challenge is coupled rather than a set of implementation steps: reliably extracting reasoning-critical constraints without losing the relations needed to solve the query, preserving that structure under LDP noise via differentiated protection, and enabling a weaker edge-side SLM to align and transfer the cloud-side LLM’s reasoning pattern. These challenges motivate the coordinated design of LoGic, rather than a straightforward combination of existing techniques.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.