acceptodds
Under review as a conference paper at ICLR 2027

GenomeOcean Anywhere: Private WebGPU Inference for Genome MoEs

21 views

Abstract

Genome foundation models are most useful where sequences are generated, yet the largest models need datacenter accelerators and a place to send private DNA. We ask whether a 15-billion-parameter genome mixture-of-experts (MoE) model can instead run on volunteers' web browsers, with the experts spread across many untrusted devices, without changing its predictions and without revealing the sequence to any single device. We build a system in which a trusted coordinator runs attention and routing while browser workers run every expert feed-forward network through hand-written WebGPU kernels, and we protect the expert inputs with real-valued Lagrange coded computing: each worker receives only a Gaussian-padded share, computes the expert's linear maps, and the coordinator decodes from any two of three workers. On GenomeOcean-MoE (8 experts, top-2 routing, 24 layers), the browser path matches native llama.cpp at every quantization level, the distributed path stays at the BF16 numerical noise floor (KL 0.0036 nats per token), and an unfitted latency model predicts decode time within 0.74% (median) under emulated wide-area links. We first show that plaintext expert inputs are not private: a probe recovers the token from a single vector at every depth, and one worker can identify the source genome from 300 unordered tokens with 92% accuracy. With coded experts, an adaptive attacker trained on shares falls to the most-frequent-token baseline, one worker's information about each token is bounded below one bit per forward pass, and the fidelity cost stays below the BF16 noise floor; in Chrome, coded decoding runs at 220 to 376 ms per token, depending on how much of the routing is hidden, and continues without replicas when a worker fails.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
genome foundation models, WebGPU, decentralized inference, edge AI, efficient inference, computational genomics

Reviews

Among:
Shape:
1234this paper, Bottom 2%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.33 over 3 reviews, above 2% of the others.
Reviewer_qiQmOpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

The paper addresses a relevant practical problem: how to infer a genome foundation model on distributed computational infrastructure without presenting the original genomic data to individual workers.

The authors propose an architecture for privacy-preserving inference with the GenomeOcean-MoE model by distributing its experts among browser based workers. The architecture consists of a trusted central coordinator, browser expert workers, and Lagrange coded computing (LCC) for the model's hidden embeddings. The experiments demonstrate that leaked activations can be exploited to recover token information and identify the raw genomic data, while coding substantially reduces the success of these attacks. The proposed architecture is also robust to the failure of one worker in a three-worker configuration. In addition, the paper evaluates the impact of network latency on inference time.

The proposed architecture combines known technologies and methods, including mixture-of-experts (MoE), WebGPU, and LCC. The main novelty appears to lie in integrating these techniques into a unified architecture and applying them to a particular genome foundation model in a distributed web-based environment.

The paper does not sufficiently establish the novelty of combining existing methods, the privacy guarantees under an explicitly defined threat model, or the extent to which results obtained in an emulated infrastructure demonstrate the system's practical applicability. The methodological and theoretical foundations are insufficiently developed, and the potential for generalizing the proposed approach to other models and application domains remains unclear.

The results demonstrate the technical feasibility of the proposed approach for a specific genomic foundation model, but do not establish its methodological contribution and the readiness for industrial deployment.

Critical strengths
  1. An important and timely practical problem. The authors address a problem at the convergence of several research areas: genome foundation models, privacy-preserving machine learning, and distributed computing.

  2. Demonstration of the integration of coded computing, browser-based execution, and leakage analysis for a large genomic MoE model.

  3. Experimental evaluation of the trade-off between privacy protection and model fidelity in a emulated distributed environment, where workers may respond with delays or become unavailable.

Critical weaknesses
  1. The proposed architecture combines well-known ideas (MoE, WebGPU, and LCC). While applying this architecture to a genomic model has practical value, the paper lacks a clear scientific contribution and methodological novelty.

  2. The title and the paper as a whole emphasize genomics, but the proposed architecture is not specific to genomic applications. It implements distributed privacy-preserving inference for models with public weights in a distributed environment involving untrusted workers. However, the applicability of the architecture to other models and application domains is not explored. The work focuses on applying the architecture to a specific model, which raises several methodological questions. For example, what architectural properties must a model have for the proposed approach be useful? If a new version of GenomeOcean-MoE is released, will all experiments need to be repeated? Would the same be true if a similar MoE model were fine-tuned on new data or applied to a different domain outside genomics? The generalization of the results is not investigated either theoretically or experimentally.

  3. The authors do not establish that every leakage of genomic token necessarily leads to the identification of a specific individual or reveals sensitive information. The experiments demonstrate token leakage in specific scenarios, but the paper does not establish a relationship between the proportion of leaked tokens and the disclosure of meaningful genomic information. The number of leaked tokens alone is a weak privacy metric. A more important question is what information an attacker can infer from all the recovered tokens.

  4. The mathematical principles underlying the proposed architecture do not require browser-based execution. The encoding and decoding of embeddings are determined by the architecture of MoE and the experts' linear transformations, rather than by any browser-specific API. Moreover, data protection in distributed computing is achieved through coding, not through the fact that the code runs in a browser. It is therefore unclear why the authors make such emphasis on WebGPU. Does using other types of distributed nodes – such as GPU servers, cloud virtual machines, mobile devices, or edge nodes – require a different arvhitecture to be developed? Moreover, questions arise as how well the emulated environment which mimics communication channel latencies with the browser corresponds to the real network environment.

  5. The paper states that the coordinator can reconstruct the result from the responses of any two out of three workers. This demonstrates fault tolerance to the failure of one worker, but it does not establish Byzantine fault tolerance. Although the paper claims resilience to worker failures, it does not provide evidence of guaranteed correction of arbitrary malicious responses. Addressing this question would require both a theoretical proof and experimental evaluation.

Questions for authors

What properties must a model possess for the proposed architecture to be applicable and beneficial? Would the architecture and its privacy guarantees remain valid for a new version of GenomeOcean-MoE, a fine-tuned version of the model, or a similar MoE model in a different application domain? Which experiments would need to be repeated when the model or its weights change, and which results can be expected to generalize?

Can the authors establish a relationship between the proportion of leaked tokens and the sensitive information that an attacker can obtain, rather than relying primarily on leaked token fraction as a proxy for privacy leakage?

What specific benefits for the mathematical model does WebGPU provide beyond enabling browser-based deployment, given that the underlying encoding and decoding mechanisms do not inherently require a browser? Would replacing browser workers with GPU servers, cloud virtual machines, mobile devices, or edge nodes require changes to the proposed architecture or its privacy guarantees?

6 comments
AuthorsOpenReview ↗

Thank you, Reviewer qiQm, for a detailed and rigorous assessment (1/3)

We are grateful for the depth of this review. Your summary captures the system accurately, and your questions identify exactly where the paper needs to be clearer. We also appreciate your recognition that the problem is important and timely and that the trade-off between privacy and fidelity is evaluated experimentally. During the discussion period, we ran four new experiments on real hardware and developed two new analyses: a sequence-level privacy bound and a proof of Byzantine detection and correction. We respond to each point below and describe the corresponding revisions.

W1:

We agree that MoE, WebGPU, and LCC each exist. Our contribution is not to stack them. It is to show why they fit together for this problem and to measure the consequences.

  1. A new negative result. It is widely assumed that scattering tokens across experts provides some privacy. We show that it does not. A single expert input reveals its token at every one of the 24 layers (MLP probe top-1 of at least 0.92 on held-out organisms). One worker reconstructs 98% of the tokens, recovers contiguous spans of up to 3,338 bp, and identifies the source genome. To our knowledge, this is the first such measurement for MoE expert inputs.
  2. Coded computing for nonpolynomial experts without approximation. LCC applies to polynomials, and SwiGLU is not one. Prior work on nonpolynomial models uses approximate coding (ApproxIFER, BACC) and gives up privacy. We observe that public weights and a coordinator that already runs the nonlinear parts reduce each expert to two rounds of linear maps. Decoding is therefore exact in exact arithmetic, any K+T workers suffice, and in FP32 the error stays below the BF16 noise floor.
  3. Real-valued privacy with two independent checks. We calibrate Gaussian pads per dimension from activation statistics and derive the per-token information bound of Eq. 2. We pair it with an adaptive attacker that knows the scheme and retrains on shares. The attacker falls to the most-frequent-token baseline at pad scale 100. At pad scale 1000, one worker learns at most 0.92 bits per token per forward pass, and fidelity stays below the BF16 noise floor (KL 0.0030 against 0.0036).

We will revise the introduction to state these contributions in this form.

W2 and Q1:

You are right that the architecture is not specific to genomics, and we will say so explicitly. The approach requires three properties of a model:

  1. Experts are feed-forward networks whose weight matrices act linearly on the input (SwiGLU, GeGLU, or plain MLP).
  2. Expert weights are public.
  3. The nonlinearity is elementwise and cheap enough for the coordinator.

What carries over without new experiments. The privacy bound of Eq. 2 depends only on the pad scale relative to the per-dimension input statistics, not on the weights. The fidelity cost is set by FP32 precision, which leaves about 24 minus log2(σ) bits for the signal regardless of the model. The latency model depends only on the number of layers, the bytes per exchange, and the network. The results also carry over across hardware: in a new experiment (Part 2), outputs with consumer RTX 2080 Ti workers were bitwise identical to outputs with H100 workers.

What must be redone for a new version or a fine-tuned model. Only two inexpensive steps: recomputing the per-dimension calibration (eight windows in our setup) and running one fidelity pass against the uncoded model. The kernels, protocol, and coding do not change.

Why genomics is the focus. Genomic scoring relies on likelihoods, which are sensitive to small numerical changes. This motivates our noise-floor methodology. DNA is also a case where fragmentation is especially weak as privacy, because reassembling fragments is exactly what genome assembly does. Our exposure results confirm this.

AuthorsOpenReview ↗

Response to Reviewer qiQm on privacy metrics and the role of WebGPU (2/3)

W3 and Q2:

We agree that token accuracy alone is a weak privacy metric. The paper already measures two sequence-level harms for plaintext inputs (Section 5.4). From 300 unordered tokens, one worker identifies the source genome among six candidates with 0.92 accuracy (chance 0.17). A worker holding one expert index across layers recovers correct spans of up to 3,338 bp. These harms are why we treat plaintext distribution as unsafe.

For coded experts, the information bound answers your question directly, because it limits every inference rather than one attack. A fresh pad is drawn for every share, so a worker's shares form a memoryless Gaussian channel. Mutual information over such a channel is at most the sum of the per-share terms. For a query of n tokens, one worker therefore learns at most n times b bits about the entire sequence, where b is the per-token bound of Eq. 2. By the data processing inequality, the same cap holds for any property of the sequence, such as the organism, a variant, or the presence of a gene.

The pad scale therefore acts as a privacy budget per query. At pad scale 10^4, b is below 0.01 bits. A 1,000-token query (about 5 kb) then reveals less than 10 bits about the whole sequence to any single worker, while the model's own likelihood puts the information content of such a sequence at about 6,000 bits. At this pad scale, the likelihood changes by only +0.0010 nats per token (Appendix D). We will add this sequence-level bound to Section 5.5.

W4 and Q3:

We agree, and we see this as a strength. The coding is independent of the device. GPU servers, cloud VMs, mobile devices, or edge nodes can replace browser workers with no change to the protocol or the privacy guarantee, since a worker only computes a matrix product on a share. We will state this explicitly.

The browser matters for deployment. It makes volunteer participation realistic: a volunteer joins by opening a URL with no installation, the sandbox isolates the worker code from the host, and one WebGPU kernel runs across vendors. It also needs its own technical work: our WGSL kernels match PyTorch to a relative error of 2.4 × 10⁻⁶, and browser likelihoods match native llama.cpp at every quantization level.

Emulated versus real networks. Our emulation sets delay and bandwidth, the two quantities the latency model uses, so that each can be varied alone. The model has no fitted parameter and predicts all 48 emulated conditions with a median error of 0.74%. We have now also run the system on real hardware and real links, with no emulation, in four new experiments.

  1. A consumer GPU (two experiments). Chrome exposes WebGPU on a consumer NVIDIA RTX 2080 Ti with the same buffer limits as on the H100. Our kernels show the same error against PyTorch on both GPUs in all 18 tested configurations.
  2. Real cluster network, different GPUs. The coordinator ran on an H200, and two Chrome workers ran on the 2080 Ti in another node. With all 192 experts remote, all 48 evaluation windows were bitwise identical to the H100 run in the paper, including every log-probability and routing decision.
  3. Public internet, different vendor and operating system. A volunteer browser on a consumer AMD GPU under Windows, 569 km away in a straight line on a different internet service provider, ran the unmodified kernels with no errors.
AuthorsOpenReview ↗

Response to Reviewer qiQm on Byzantine workers, and our thanks (3/3)

W5:

You are correct. Our experiments establish tolerance to crashes and stragglers, not to malicious responses. We will use the term "crash and straggler tolerance" throughout and state the threat model (honest-but-curious workers and a trusted coordinator) in Section 3.

Byzantine detection and correction follow from the same code, with no change to the workers. Each coded expert evaluates a polynomial of degree 1, so the N results form a codeword of a real-valued Reed-Solomon code. The LCC theorem of Yu et al. (2019) then gives the condition N ≥ K + T + S + 2A for S stragglers and A malicious workers.

  • Detection with N = 3. Our encoding matrix has the parity-check vector (-0.764, -0.236, 1). Every entry is nonzero, so altering any single result changes the parity check. The coordinator detects it by waiting for the third response.
  • Correction with N = 4. Any two columns of the parity-check matrix are linearly independent, so the code has minimum distance 3 and corrects one malicious result.

In FP32, detection uses a threshold above rounding error, and any perturbation small enough to pass it has a bounded effect on the output. We will add the theorem with its proof to the appendix and evaluate the check experimentally in the revision.

Summary of revisions in response to this review.

  1. A restated contribution list: the measured leakage, coding for nonpolynomial experts without approximation, and the joint privacy and fidelity evaluation.
  2. A paragraph on generality, with the three required model properties and the steps needed for a new model.
  3. The sequence-level information bound and the per-query privacy budget in Section 5.5.
  4. An explicit statement that the protocol is device-agnostic, and the four new real-hardware experiments.
  5. An explicit threat model, corrected fault-tolerance wording, and the Byzantine detection and correction theorem.

We truly appreciate the care you put into this review. Your comments on generality, privacy metrics, and Byzantine workers point to concrete improvements, and the paper is stronger for them. We hope the clarifications and new results address your concerns, and we would welcome any further questions during the discussion period.

Reviewer_nG4VOpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

AI slop.

Critical strengths
Critical weaknesses
Questions for authors

see above

1 comment
AuthorsOpenReview ↗

We appreciate Reviewer nG4V's time and welcome specific feedback

Thank you for taking the time to review our submission. We value every reader's perspective. Because the review does not yet list specific concerns, we briefly summarize what the paper contributes and how each claim can be checked. We would be glad to address any concrete issue you raise during the discussion.

What the paper shows, with evidence.

  1. Fidelity. A 15-billion-parameter genome MoE runs with every expert in browser workers without changing its predictions. Browser likelihoods match native llama.cpp at every quantization level. The distributed BF16 path reaches KL 0.0036 nats per token, equal to the noise floor between two correct BF16 implementations (Section 5.1 and Appendix D).
  2. Predictable performance. An unfitted latency model predicts decode time under 48 network conditions with a median error of 0.74% (Section 5.2).
  3. Privacy risk. Plaintext expert inputs are not private. A probe recovers the token at every layer, and one worker identifies the source genome with 0.92 accuracy (Section 5.4).
  4. A defense. Lagrange-coded experts reduce an adaptive attacker to the most-frequent-token baseline, bound one worker's information below one bit per token per forward pass, and keep fidelity below the BF16 noise floor (Section 5.5).

How the results can be verified. The supplementary material contains the coded-computing implementation, the WGSL kernels and browser worker, and the result files behind every figure. It also includes a CPU-only script that recomputes the headline numbers from these files. Appendix D reports every plotted value with sample sizes and interquartile ranges.

Thank you once more for your service as a reviewer.

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

The authors propose a method for decentralizing the inference of a Mixture-of-Experts(MoE) genome language model using the webGPU of each browser. The authors show that it is possible to achieve privacy with their method, compared to a plain-text alternative baseline, that protects users' private data from leakage. In results authors show that their method can provide strong privacy while maintaining good efficiency, fidelity and robustness.

Critical strengths
  1. The paper is well written and easy to read.
  2. The idea itself makes sense to me, since the genome language model users usually emphasize their privacy concerns and not necessarily have a computing cluster to run it, distributing the experts among webGPUs sounds a practical solution.
  3. The authors have provided enough evidence of the feasibility of their approach in the result sector.
Critical weaknesses
  1. I think a weakness here is that the paper has emphasized the system-level success, while this is a machine learning conference and the methodology of this paper itself is mainly a well-established one -Lagrange coded computing.
  2. The paper presents a good demo of how such a system might potentially be a good solution, yet it remains proof-of-concept rather than practical since it only conducts experiments on hypothetical settings. No real world deployment is conducted.
Questions for authors
  1. Is there any ML-side contribution you would like to emphasize? I think the paper's advantages mainly lie on the system side.
  2. Is this method generalizable to heterogeneous volunteer devices? Assume there would be huge difference between them both on speed and their running environment.
  3. Is the method generalizable to other MoE biological language models? I think there is already some on the shelf.
3 comments
AuthorsOpenReview ↗

We thank Reviewer xWyy for a clear and encouraging review (1/2)

We sincerely thank you for your time and for a thoughtful, well-organized review. We are glad that you found the paper well written, the motivation practical for privacy-conscious genomics users without clusters, and the feasibility evidence sufficient. During the discussion period, we ran four new experiments on real hardware, with no emulation, in direct response to your questions on deployment and heterogeneity. We answer each point below.

W1 and Q1:

Thank you for raising this. We submitted to the ICLR primary area "infrastructure, software libraries, hardware, systems", so we see the systems results as in scope. We also agree that the paper should state its learning contributions more directly. There are two.

  1. A measured property of MoE representations. A common intuition is that scattering tokens across experts hides the sequence. We test it with probes trained on organisms disjoint from the test organisms. A single expert input reveals its token at every one of the 24 layers (MLP probe top-1 of at least 0.92). One worker reconstructs 46,766 of 47,535 tokens and identifies the source genome from 300 unordered tokens with 0.92 accuracy (Section 5.4). This is a property of the learned representations, not of the system.
  2. A private-inference design that follows from MoE structure, with a matching evaluation. Expert weights are public, and the coordinator already computes the nonlinear parts. Each SwiGLU expert therefore reduces to linear maps, which Lagrange coding evaluates on Gaussian-padded shares. We calibrate the pads per dimension from activation statistics and bound the per-token leakage for real-valued activations (Eq. 2). We then evaluate privacy and fidelity jointly. An adaptive attacker that knows the scheme falls to the most-frequent-token baseline, the bound is 0.92 bits per token per forward pass, and the KL cost (0.0030 nats per token) stays below the BF16 noise floor (0.0036).

In the revision, we will state these two contributions explicitly in the introduction.

W2:

This is a fair point. In the submission, the browsers, kernels, and numerics are real: every expert runs in an unmodified Chrome, the crash test kills a real worker process, and one slow-device test uses a real CPU WebGPU adapter. The GPU workers ran on H100s, and the wide-area links were emulated so that each factor could be isolated. To move closer to deployment, we ran four new experiments on real hardware.

  1. WebGPU on a consumer GPU. Chrome exposes WebGPU on a consumer NVIDIA GeForce RTX 2080 Ti (Turing, 2018, 11 GB) with the same buffer limits as on the H100.
  2. Kernel accuracy on that GPU. Our expert kernels show the same error against PyTorch on the 2080 Ti as on the H100, in all 18 tested configurations.
  3. End to end across machines. The coordinator ran on an H200 node, and two Chrome workers ran on the 2080 Ti in a different node. All 192 experts were remote, and all traffic crossed the real cluster network. On all 48 evaluation windows, the output was bitwise identical to the H100 run in the paper, for every log-probability over the full vocabulary and every routing decision. Between 99.86% and 99.91% of the individual expert outputs were bitwise identical to PyTorch FP32. Decoding took 141 ms per token.
  4. A volunteer over the public internet. A volunteer browser joined from a residential site 569 km from the coordinator in a straight line, on a different internet service provider. It used a consumer AMD Radeon GPU (RDNA 3) under Windows in an unmodified Chrome, so the GPU vendor, operating system, and driver all differ from our cluster. With the experts of three layers in the browser, it ran the same kernels with no code change and no errors. It answered each layer request in a median of 3.4 ms, in the same range as our data center GPUs.

We will add these experiments to the paper, and we will release the worker page so that anyone can join from their own browser.

AuthorsOpenReview ↗

Response to Reviewer xWyy on heterogeneous devices and other models, with our thanks (2/2)

Q2:

Yes. The new experiments let us answer at three levels.

  1. Runtime environment. Our kernels avoid optional WebGPU features such as shader-f16, which many drivers do not expose. The 2080 Ti does not expose it either. The kernels ran unchanged on three GPU families: NVIDIA Hopper (H100), NVIDIA Turing (RTX 2080 Ti), and AMD RDNA 3 under Windows. They also run in WebGPU compatibility mode on a CPU adapter (Appendix D, "Heterogeneous workers").
  2. Numerics. Device diversity does not change predictions. The kernels show the same error against PyTorch on the 2080 Ti as on the H100 (experiment 2), and the end-to-end output with 2080 Ti workers is bitwise identical to the output with H100 workers (experiment 3). A CPU adapter also returns the same numerics.
  3. Speed. Slow devices can be absorbed. A worker that is 5 times slower raises decode latency by a factor of 2.36; with its experts replicated on a fast worker, the factor returns to 1.00. A worker on a CPU adapter is 3.38 times slower without mitigation and 1.04 times with replication (Section 5.3). In coded mode, the coordinator decodes from the first K+T of N responses by design, so it does not wait for the slowest worker in a group.

Q3:

Yes. The design requires three properties, and none of them is specific to GenomeOcean.

  1. The experts are feed-forward networks whose weight matrices act linearly on the input, as in SwiGLU, GeGLU, or plain MLP experts.
  2. The weights are public, so workers may hold them.
  3. The nonlinearity is elementwise and cheap enough to run at the coordinator.

Open MoE models in the Mixtral family satisfy all three. The privacy bound in Eq. 2 depends on the pad scale relative to the input statistics, not on the weights. Moving to a new model, therefore, requires only two steps: recomputing the per-dimension calibration (eight windows in our setup) and one fidelity pass. The kernels and the coding do not change. We will state these conditions and the porting steps in the revision.

Thank you again for engaging so constructively with our work. Your questions on deployment and heterogeneity led directly to the four new experiments above, and they sharpened how we present the learning contributions. We hope these answers address your concerns, and we would be grateful if you would consider them in your final assessment.

AuthorsOpenReview ↗

A brief update for Reviewer xWyy, with our thanks

Thank you again for your encouraging review and for your support of this work. We would like to share a brief update from the discussion period, since it also relates to your first question about the ML-side contribution.

We have now stated the two guarantees of the method as theorems with proofs, and confirmed each with a new experiment.

  1. Privacy of a whole query. The information one worker can gain about any property of the input sequence is at most the per-token bound times the number of tokens. In a new experiment, an optimal attacker that sees the coded shares of every token and knows the six candidate genomes identifies the organism with 0.95 to 0.97 accuracy on plaintext inputs. At pad scale 10^4, its accuracy stays between 0.14 and 0.19 for every query length up to 900 tokens, while random guessing gives 0.17.
  2. Byzantine detection and correction. The same code that hides the inputs also detects a malicious worker with three workers and corrects one with four. In a new experiment over all 48 evaluation windows, every call corrupted by noise, sign flips, forged results, or output scaling of 10^-4 or more was detected, with no false alarms. With four workers, the coordinator identified the malicious worker and kept the likelihood within 0.0012 nats per token of the plaintext model.

We will add both theorems and both experiments to the revision, together with the four real-hardware experiments described in our earlier response.

We hope this update is helpful. If you find that it strengthens the paper, we would be grateful if you would consider it in your final assessment. Thank you very much for your time and your thoughtful review.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Thank You to the SAC, AC, and All Reviewers

We sincerely thank the Senior Area Chair, the Area Chair, and all the reviewers for your time and for your careful reading of our paper. We are grateful for your encouragement, and just as grateful for the questions and concerns you raised. Your reviews showed us where the paper needs to be clearer and where the evidence needed to be stronger. We will take all of your comments into account and use them to improve the paper.

In response to the reviews, we ran several new experiments on real hardware during the discussion period, and we added new analysis of privacy and robustness. We describe them in our responses to the individual reviewers.

The goal of this work is to let genome foundation models run where DNA sequences are produced. Field stations, clinical laboratories, and public health agencies often lack datacenter accelerators. They also hold sequences that they cannot send to a third party. Our system keeps a light coordinator on the user's side and places the experts of a large genome mixture-of-experts model in ordinary web browsers. We show that simply splitting a sequence across experts does not protect it. We then use coded computing so that each volunteer device sees only noise-padded shares, while the model's predictions stay within numerical noise. Open foundation models usually have public weights and private inputs, so we believe this approach is useful in genomics and beyond.

We will release all of our code and data, including the browser worker, the WebGPU kernels, and the coded-computing protocol. We hope they offer something useful to the community and help others build on this work.

Building on these results, we plan to develop a mature open-source platform for decentralized model deployment. Our aim is that any laboratory, even one with modest hardware, can run large models on its own data, and DNA models in particular. Volunteers anywhere could contribute computing power simply by opening a web page.

We hope our work and our software can serve the community, researchers, and developers, so that genome AI can reach more people and protect their data.

Thank you again for your time and your support.

AuthorsOpenReview ↗

Summary of the revised paper, with our thanks to the SAC, AC, and reviewers

We sincerely thank the Senior Area Chair, the Area Chair, and all reviewers for their time and guidance. The reviews and the discussion led directly to stronger guarantees, new experiments, and a clearer paper. We have uploaded a revised PDF and supplementary material. The main changes are listed below.

1. Title and positioning. Following Reviewer qiQm's suggestion, the new title is "Private Decentralized Inference for Genome Mixture-of-Experts Models." The title no longer names WebGPU, since the protocol does not depend on the device. The paper now presents the method and its guarantees first (Section 3), and the browser system as the deployment case study (Section 3.1).

2. Contributions stated more directly (Section 1). As suggested by Reviewers xWyy and qiQm, the contributions are now: the measured leakage of MoE expert inputs, coded computing for nonpolynomial experts without approximation, guarantees with experimental confirmation, and a browser case study on real hardware.

3. Threat model and generality (Section 3). We state the threat model explicitly. We also list the three model properties the method needs, the steps to port it to a new model, and the fact that the protocol is device-agnostic.

4. Theorem 1: privacy of a whole query (Section 3, proof in Appendix E). One worker's information about any property of an n-token query is at most n times the per-token bound. A new experiment confirms it (Section 5.2, Appendix F). At pad scale 10^4, an optimal organism attacker on the shares stays at chance for every query length up to 900 tokens.

5. Theorem 2: detection and correction of malicious workers (Section 3, proof in Appendix E). The same code that hides the inputs detects a malicious worker with three workers and corrects one with four. A new experiment over all 48 evaluation windows confirms it (Section 5.3, Table 1, Appendix G). Every corrupted call was detected with no false alarms, and with four workers the likelihood stayed within 0.0012 nats per token of the plaintext model.

6. Real hardware and real networks (Section 5.7, Appendix H). We added the four experiments from our responses. Outputs with consumer RTX 2080 Ti workers across machines are bitwise identical to the H100 run on all 48 windows. A volunteer browser on a consumer AMD GPU under Windows, over the public internet, ran the unmodified kernels with no errors.

7. Wording. We use "crash and straggler tolerance" for the replication results, and "exact in exact arithmetic" for the decoding.

8. Supplementary material. It now also contains the code and result files for both new experiments.

All earlier results are unchanged, and the main text remains within the page limit. Thank you again for your careful reading and constructive feedback. We hope the revision addresses your comments, and we are happy to answer any further questions.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.