m4olgen-molecular-generation

name	m4olgen-molecular-generation
title	M4olGen: Multi-Agent, Multi-Stage Molecular Generation under Precise Multi-Property Constraints
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2601.10131
keywords	["molecular-generation","multi-agent","property-constraints","fragment-based","GRPO"]
description	Generates molecules meeting precise numeric property constraints across multiple dimensions through two-stage multi-agent framework with fragment-level edits and Group Relative Policy Optimization, improving validity and property satisfaction.

Overview

Design a multi-agent molecular generation system that creates valid molecules satisfying precise numeric constraints on multiple physicochemical properties (QED, LogP, Molecular Weight, HOMO, LUMO). Use a two-stage approach with fragment-level reasoning to enable controlled, property-aware generation.

When to Use

• For drug discovery requiring molecules meeting specific property constraints
• When you need precise multi-property control (not just single objectives)
• For molecular optimization with numeric property bounds
• When working with structure-based design constraints

When NOT to Use

• For property prediction or molecular analysis
• When single-property optimization is sufficient
• For molecules where fragment-based reasoning doesn't apply
• In environments lacking pretrained molecular models

Key Technical Components

Stage I: Prototype Generation via Multi-Agent Fragment Editing

Generate candidate molecules through multi-agent collaboration using fragment-level operations.

# Multi-agent prototype generation
class PrototypeGenerator:
    def __init__(self):
        self.fragment_retriever = FragmentRetriever()
        self.editor_agent = FragmentEditorAgent()
        self.validator_agent = StructuralValidatorAgent()

    def generate_prototype(self, property_constraints, num_candidates=10):
        """Generate candidate molecules near feasible region"""
        candidates = []

        for _ in range(num_candidates):
            # Start with seed molecule
            molecule = self.select_seed_molecule(property_constraints)

            # Multi-agent editing
            current_molecule = molecule
            for edit_step in range(MAX_EDITS):
                
                edit_proposal = .editor_agent.propose_edit(
                    current_molecule,
                    property_constraints
                )

                
                fragments = .fragment_retriever.retrieve(
                    edit_proposal[],
                    k=
                )

                
                 candidate_fragment  fragments:
                    edited = .apply_fragment_edit(
                        current_molecule,
                        edit_proposal[],
                        candidate_fragment
                    )

                    
                     .validator_agent.is_valid(edited):
                        current_molecule = edited
                        

            
             .is_near_feasible(current_molecule, property_constraints):
                candidates.append(current_molecule)

         candidates

     ():
        
        
           

     ():
        
        
        mol = Chem.MolFromSmiles(molecule)
        frag = Chem.MolFromSmiles(fragment)

        
        
        edited = .perform_substitution(mol, position, frag)

         edited  :
             

         Chem.MolToSmiles(edited)

     ():
        
        props = .compute_properties(molecule)

        distance = 
         prop_name, (min_val, max_val)  constraints.items():
            current = props[prop_name]
             current < min_val:
                distance += (min_val - current) ** 
             current > max_val:
                distance += (current - max_val) ** 

        
         distance < FEASIBILITY_TOLERANCE