- Rating
- 1
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 1
- Soundness
- 3
Read review
Paper summary
The paper proposes RetroGEF, a single-step retrosynthesis method based on continuous-time Markov chains. During inference, the model starts out by taking the product molecule (in graph format) as input and iteratively adding atoms and bonds, changing atom properties, and removing bonds, until it ends up in a reactant. The network takes the partially formed graph as input and outputs 1) a total rate of "how many changes will happen per unit time", and 2) probabilities for which changes will happen next. These outputs are trained by 1) taking reactant-product pairs from the data, and making edits from the product side until we end up in the reactants 2) for a given intermediate state, making the network predict the next possible additions to the graph (e.g., atoms to attach directly to the existing structure or non-connected atoms that start new molecules), and also the total rate based on how many such possible actions still exist. After reaching the product, the amount of such actions goes to zero, and the network learns this, and this ultimately ends the generation of new atoms.
Critical strengths
- The USPTO-50k and USPTO-Full benchmark numbers seem quite good, and improve over the baselines.
- The core idea of restricting updates to incremental edits on the current molecular graph seems sensible
Critical weaknesses
- I think that the writing needs substantive improvement for acceptance. As it is, it was not easy to clearly understand what is the proposed method and what were the novel components. As an example, section 4.5 introduces ablations on multiple method/architecture variants that are introduced in single sentences in the same section. It's unclear what is the takeaway of Figure 5, aside from some cases existing where the proposed method matches with the ground-truth better than RetroDiT. Figures 1-3 have lots of notation that is not defined in the figures themselves, making them difficult to read. The paper should include a description of the basic generative framework (with relevant citations for the work that this is building on clearly laid out), and then clearly show how it adapts the framework for retrosynthesis, and how it differs from other related work such as RetroDiT and Retrobridge. And how is the data actually represented in the network. Right now the paper goes into the weeds too fast. Smaller writing issues: Table 4 is referenced before Table 3 in the text.
- Right now, the visibility to why the method is better than the alternative diffusion/flow based methods is not great. The method seems to make multiple changes compared to, e.g., RetroDiT, and it is difficult to say which one mattered here. In particular, it would be important for the key claim of the paper to include an ablation where each atom/bond is generated independently vs. in the coupled fashion presented in this paper, while keeping everything else fixed.
- There is no discussion on inference speed in the paper.
Questions for authors
- What are all the differences between the method in the paper and RetroDiT?
- What is the concrete benefit of variable-sized graph generation? Is it inference speed, or an inductive bias for better retrosynthesis modelling?
4 comments
Response to Reviewer#E8HH 2/2
Q1: RetroGEF predicts complete-edit rates on evolving graphs. The main differences are the graph state, the transition parameterization and the training target. RetroGEF's Equation (3) conditions the first bond on the new atom, applies both as one graph transition, and uses the resulting graph for the next decision. Its bridge also aggregates latent atom assignments that correspond to the same observable edit. The baseline descriptions follow Section 3.2 of RetroBridge [2] and Section 4 and Appendix C of RetroDiT [3].
| Method | State and transition | Training target |
|---|---|---|
| RetroBridge | Product graph augmented with dummy nodes; categorical atom/bond transitions | Endpoint-conditioned Markov-bridge transitions |
| RetroDiT | Center-rooted graph ordering with dummy nodes; discrete flow over atom/bond variables | Factorized endpoint-category predictions |
| RetroGEF | Current graph expanded and revised through complete edits | Observable edit rates from product–reactant bridges |
Q2: New structure guides subsequent edits. RetroGEF provides a construction bias for retrosynthesis and reduces graph updates. Each decision operates on the current graph, and a newly created atom and its first bond immediately become context for subsequent edits. This supports interleaving fragment construction, connectivity changes and scaffold revision within one process. The structural analysis also covers products requiring more than twenty graph changes: Oracle Top-1 is 42.5% for RetroGEF versus 33.6% for RetroDiT (Table 3). This grouping counts attribute updates and bond changes alongside atom additions, complementing the growth analysis. In W2, RetroGEF outperforms separate updates at Top-1/3/5/10 under both center conditions. W3 quantifies the reduction in graph-edit events and graph-update time.
[1] Holderrieth et al., Generator Matching: Generative modeling with arbitrary Markov processes (2025).
[2] Igashov et al., RetroBridge: Modeling Retrosynthesis with Markov Bridges (2024).
[3] Wang et al., Order Matters in Retrosynthesis: Structure-aware Generation via Reaction-Center-Guided Discrete Flow Matching (2026).
I thank the authors for the clarifications and additional experiments. They partially address my concerns, but I still see issues with the paper.
- I appreciate the clarifications to the paper figures. Note that Figure 1 still doesn't define e or m.
- I'm still not sure what Figure 5 demonstrates exactly: this could be a special case where RetroGEF happens to work better? Is it supposed to show something general, e.g., that RetroDiT can't handle these types of reactions?
- The results on W2 look good, but what exactly is "the other creates the atom and its attachment through separate graph updates"? can you provide details on this?
- W3: I think the time should be included in the paper, with comparisons to other methods.
- Q1: Thank you for the clarification, but it would still be useful to have a clear conceptual handle on what are e.g. the core conceptual components that are different from RetroDiT spelled out. E.g., is the data representation different? How about the architecture? Generator matching methodology / loss function? The sampling process? As in, how many distinct changes to RetroGEF would we have to make to turn it into RetroDiT.
- Q2: Thank you for clarifying. Regarding "Each decision operates on the current graph, and a newly created atom and its first bond immediately become context for subsequent edits" -> the basic fact here holds also for RetroBridge and RetroDiT in that each decision operates on the current graph, changing the graph for the next edit. It indeed seems possible that RetroGEF provides a useful inductive bias for retrosynthesis, but it still seems difficult to be confident in what factors are actually providing the improvement on benchmarks.
In general, I think the paper would still benefit from an overhaul in the writing and experiment design to clearly pinpoint the factors driving the improvements over previous methods.
Follow-up Response to Reviewer E8HH
Dear Reviewer E8HH,
Thank you for following up. We address your questions below.
W1. The revised Figure 1 caption defines m as the attributes of the new atom u and e as those of its first bond to the existing atom j (Eq. (3)). Figure 5 shows two examples in which matching the reference reactant set requires reconstructing a separate molecule. In panel (b), both methods recover the ring-opened amino alcohol, and RetroGEF also reconstructs triphosgene. On USPTO-Full, RetroGEF leads RetroDiT in Oracle Top-1 in every added-atom group in Table 4. For the 5,624 products requiring 11–20 added atoms, as in panel (a), Oracle Top-1 is 33.4% for RetroGEF versus 26.0% for RetroDiT.
W2. In RetroGEF’s separate-update variant (Table 8), one edit adds an isolated atom and a later bond edit connects it to an existing atom. With complete edits, RetroGEF chooses the attachment site and the new atom’s element together, predicts the first bond conditioned on the atom’s attributes, and adds the atom and bond in one edit (Figure 2B).
W3. We timed the original RetroGEF and RetroDiT implementations on the USPTO-50K test set in the same computing environment, using 100 trajectories per product. Mean generation time per worker was 0.49 s/product for RetroGEF and 2.62 s/product for RetroDiT. Section 4.5 reports these times, and Table 15 gives the breakdown. RetroDiT reserves positions for possible new atoms and predicts atom and bond labels for those positions at every sampling step. RetroGEF adds atoms as needed and can form the first bond in the same edit, saving the extra forward pass required by separate atom and bond updates.
| Model | Graph updates (s/product) | Forward passes (s/product) | Total (s/product) |
|---|---|---|---|
| Complete Edits | 0.0147 | 0.4739 | 0.49 |
| Separate updates | 0.0209 | 0.4878 | 0.51 |
| RetroDiT | 0.63 | 1.99 | 2.62 |
Q1. To construct reactants of unknown size and connectivity, RetroGEF starts from the product and learns rates for complete edits that grow and revise the graph (Section 3). RetroDiT [1] appends dummy nodes before sampling and predicts final atom and bond labels on this fixed node set. Its graph Transformer encodes atom order from the reaction center with rotary position embeddings. Its sampler derives update rates from the label distributions learned with cross-entropy. Our graph Transformer encodes changes relative to the product and predicts the total edit intensity and complete-edit probabilities (Figure 3). We fit the resulting rates to bridge targets along alternative construction paths using the generalized KL loss in Eq. (4). During generation, we sample edit times and complete edits from the learned rates (Figure 1 and Algorithm 2).
Q2. Table 8 compares construction choices within RetroGEF under both center conditions on USPTO-50K. The complete-edit generator outperforms the separate-update variant at all four cutoffs. Among the variants that create the atom and bond together, conditioning the first bond on the new atom’s learned embedding improves Top-3/5/10. In the training bridge, setting the atom-addition rate to the number of atoms still to add raises Pred. Top-10 on USPTO-Full by 7 percentage points over a constant rate (Table 5).
We have submitted a revised manuscript that includes these clarifications and the timing comparison. Thank you again for your time and consideration. We hope our responses and the additional experiments have addressed your concerns.
[1] Wang et al., Order Matters in Retrosynthesis: Structure-aware Generation via Reaction-Center-Guided Discrete Flow Matching (2026).
Response to Reviewer#E8HH 1/2
Thank you for recognizing the performance and the value of incremental graph edits. We respond to your comments as below:
W1: RetroGEF learns complete edits from reaction pairs. RetroGEF builds on Generator Matching [1], cited in Sections 2 and 3, and learns the rates of complete edits that transform a product graph into a reactant graph. Sections 3.1–3.4 and Appendices A–C describe the graph state, bridge, rate network and training objective. We will add a short method overview before the technical definitions. The initial state is the product graph. Nodes represent inherited or newly created atoms, and edges carry the current bond attributes. Paired reactants supply intermediate bridge states and corrective edit rates, accommodating alternative orders and equivalent missing-atom assignments. A graph Transformer encodes atom and bond features, their changes relative to the product, time and the center condition. It predicts total edit intensity and conditional distributions over edit type, location and attributes. Generation samples an event time and a complete edit, updates the graph, and recomputes rates on the new state; the terminal graph is decoded into reactants. The bridge endpoint is the reactant graph, where the target outgoing rate is zero (Equation (4)). Figures 1–3 illustrate the formulation; we will define the graph states and network quantities directly in their captions. Q1 compares the state, transitions and training target with RetroDiT and RetroBridge. Figure 5 demonstrates reconstruction of the complete reactant set: in example (b), both methods recover the ring-opened amino alcohol, while RetroGEF additionally reconstructs the complete triphosgene component (Section 4.6). We will make this takeaway explicit in the caption. Tables 3–4 quantify the corresponding demands of fragment construction and scaffold revision. Section 4.5 defines the ablated factors: constant addition fixes the total growth rate to one, while the edge-update variant removes Transformer edge updates and retains bond inputs and bond-edit actions. We will expand these variant descriptions and introduce Table 3 before Table 4.
W2: Complete edits improve prediction. Complete edits improve Top-1/3/5/10 over separate atom/bond updates under both Pred. and Oracle conditions. Under the same USPTO-50K test setting as in the paper, we compare Top-k accuracy (%) for RetroGEF and two variants: one removes the new atom's learned embedding from first-bond prediction; the other creates the atom and its attachment through separate graph updates. RetroGEF achieves Top-1 of 62.4% versus 59.6% under Pred. and 72.3% versus 72.0% under Oracle. It also exceeds the variant without learned atom-to-bond conditioning at Top-3/5/10 under both center conditions. These results support creating the atom and its first bond together and using the new atom to predict that bond.
W3: Complete edits reduce graph-update cost. Profiling shows 41.7% and 40.1% fewer graph-edit events under Pred. and Oracle, respectively, with 29.6% and 31.1% less graph-update time per trajectory than separate atom/bond updates. With batched inference on one H200 GPU, the complete-edit generator produces 100 trajectories per product in an average of 0.49 seconds under Pred. and 0.48 seconds under Oracle, including graph sampling, RDKit decoding and prediction collection (Appendix D.5).