License notice. By downloading, accessing, using, distributing, or creating a derivative of LULA-1, you agree to the Om LULA Community License 1.3. LULA-1 is open-weight, not OSI open source. It may be used for research, evaluation, benchmarking, teaching, local inference, local fine-tuning, and Permitted Om Fulfillment Use. Commercial local/open-weight use outside Om Fulfillment, hosted API/SaaS access, resale, paid support or deployment, product bundling, and competing model services require a separate written Om commercial license. You may not publish, distribute, or make available raw or bulk LULA-1 Outputs, including scores, predictions, rankings, embeddings, screened molecule lists, or benchmark datasets, unless Om gives prior written approval. Public disclosure rights are limited to customer-derived experimental data, analyses, conclusions, and reports from molecules purchased through Om Fulfillment. For commercial licensing, contact dmc@omtx.ai.

+ + +

omtx.ai

Open-weight release track

LULA-1 — sequence-only protein–ligand scoring.

Protein amino-acid sequence plus ligand SMILES in, binding score out. No structure input, no docking, no folding step.

Sequence-only Local inference Open weights

Model at a glance

1.7M parameters 6.8 MB Sequence-only Local inference Open weights Public AUROC 0.7615 EF@1000 54.8×

LULA-1

LULA-1 is a lightweight, fast, sequence-only protein–ligand binding scorer, trained on ~500M data points from Om and public sources. It takes a protein amino-acid sequence and a ligand SMILES string and returns a binding score. There is no structure input, no docking, and no folding step.

It is fast because of how it is built: the protein is embedded once, and every additional ligand costs only a projection and a cosine similarity. That is what makes screening a million-molecule library practical.

The intended public interface is deliberately small:

score(protein_sequence: str, smiles: str | list[str]) -> record | list[record]

What this release contains

LULA-1 ships as a compact scoring head that runs on top of two public pretrained encoders. The checkpoint is 6.8 MB — 1,705,984 parameters. This makes the released Om weights easy to verify, cache, and move between local environments while using widely available protein and molecule representations at inference time.

Parameters

Component	Parameters	Source
LULA-1 scoring head	1,705,984	this repository
ESM-2 650M — protein encoder (1280-dim)	652,358,616	facebook/esm2_t33_650M_UR50D
ChemBERTa-77M-MTR — ligand encoder (384-dim)	~3,500,000	DeepChem/ChemBERTa-77M-MTR
Total at inference	~657.6M

The scoring head is ~0.26% of the parameters in play at inference. Breakdown of the checkpoint:

Tensor	Shape	Parameters
protein_projector.weight	1024 × 1280	1,310,720
protein_projector.bias	1024	1,024
ligand_projector.weight	1024 × 384	393,216
ligand_projector.bias	1024	1,024
Total		1,705,984

The checkpoint also carries score_logit_scale (10.0), a scalar loaded as a Python float rather than a tensor — it is a persisted hyperparameter, not a trainable parameter, and is excluded from the count above.

Architecturally this is a ConPLex-style contrastive scorer: each encoder output is passed through a single Linear → GELU → Dropout projection to a shared 1024-dim space, L2-normalized, compared by cosine similarity, scaled by the logit scale persisted in the checkpoint, and passed through a sigmoid. The output is a probability-like score in [0, 1].

The omtx lula download command downloads the LULA-1 weights and the required public encoder assets into the local cache for scoring. Om distributes the LULA-1 scoring head in this repository; the third-party encoders remain governed by their own upstream terms.

Usage

Quickstart notebook: notebooks/lula1_quickstart.ipynb — install, download, verify, and score a real target end to end. CPU works; GPU is faster.

Full workflow cookbooks: LULA Score To Order, Om Accessible Space To Order, and Explicit SMILES.

pip install "omtx[lula]>=2.0.20"

hf auth login         # required for gated LULA-1 weights; say no to adding the token as a git credential
omtx lula download --model lula1
omtx lula verify --model lula1

from omtx.lula import load_model

CA2 = (
    "MSHHWGYGKHNGPEHWHKDFPIAKGERQSPVDIDTHTAKYDPSLKPLSVSYDQATSLRIL"
    "NNGHAFNVEFDDSQDKAVLKGGPLDGTYRLIQFHFHWGSLDGQGSEHTVDKKKYAAELHL"
    "VHWNTKYGDFGKAVQQPDGLAVLGIFLKVGSAKPGLQKVVDVLDSIKTKGKSADFTNFDP"
    "RGLLPESLDYWTYPGSLTTPPLLECVTWIVLKEPISVSSEQVLKFRKLNFNGEGEPEELM"
    "VDNWRPAQPLKNRQIKASFK"
)
mols = [
    "CC(=O)Nc1nnc(s1)S(N)(=O)=O",
    "Cc1ccc(cc1)S(=O)(=O)N",
    "CC(C)Cc1ccc(cc1)C(C)C(=O)O",
    "CCN(CC)CCNC(=O)c1ccc(N)cc1",
    "c1ccc(cc1)C(=O)O",
    "CCO",
]

model = load_model("lula1")
for row in sorted(model.score(protein_sequence=CA2, smiles=mols), key=lambda r: r["rank"]):
    print(row["rank"], round(row["score"], 4), row["smiles"])

Verified in Google Colab on 2026-07-29. LULA-1 is gated on Hugging Face, so run hf auth login or pass a Hugging Face token before omtx lula download. Expected CA2 ranking:

1 0.9995 CC(=O)Nc1nnc(s1)S(N)(=O)=O
2 0.9991 Cc1ccc(cc1)S(=O)(=O)N
3 0.2331 CCO
4 0.1643 CCN(CC)CCNC(=O)c1ccc(N)cc1
5 0.1518 CC(C)Cc1ccc(cc1)C(C)C(=O)O
6 0.0984 c1ccc(cc1)C(=O)O

Batch scoring returns, per molecule: score, rank, and top_percentile_in_batch. rank and top_percentile_in_batch are computed within the batch you submit, making the output directly useful for prioritizing a candidate set.

Common Workflows

Use smiles=[...] when you want to score molecules you already have. This is local open-weight scoring after model and encoder setup.

from omtx.lula import load_model

protein_sequence = "MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQANN"
smiles = [
    "CCOc1ccc2nc(S(N)(=O)=O)sc2c1",
    "Cn1ccnc1CCNCc1cn(-c2ccc(F)c(Cl)c2)nn1",
    "CCO",
]

model = load_model("lula1")
scores = model.score(protein_sequence=protein_sequence, smiles=smiles)

Use source="om" and a Wallet Credit tier when you want Om to return orderable molecules from Om Accessible Space. This requires an Om API key. For local open-weight scoring, the SDK fetches the authenticated molecule slice without sending your protein sequence to Om.

from omtx import OmClient
from omtx.lula import load_model

protein_sequence = "MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQANN"

with OmClient(api_key="your-api-key") as client:
    model = load_model("lula1")
    scores = model.score(
        protein_sequence=protein_sequence,
        source="om",
        tier=50,
        n=50000,
        client=client,
    )

Only Om Accessible Space rows include source_metadata and can be ordered directly with Wallet Credits:

from uuid import uuid4
from omtx import OmClient

selected = sorted(scores, key=lambda row: row["score"], reverse=True)[:96]

with OmClient(api_key="your-api-key") as client:
    order = client.molecules.order(
        items=selected,
        shipping_address_id="your-shipping-address-id",
        idempotency_key=f"order-round-1-{uuid4()}",
    )

Intended use

Ranking and triage of compound sets against a protein target — particularly where no structure is available, or where a structure-based method would be too slow across the full set. LULA-1 returns a relative score for prioritization.

Your data stays local

Scoring and fine-tuning run entirely on your machine. Nothing about your targets or compounds is transmitted to Om.

• omtx lula score and local fine-tuning make no network calls. Protein sequences, SMILES, labels, scores, and checkpoints never leave your environment.
• There is no telemetry in the local path — no usage pings, no analytics, no phone-home.
• omtx lula download is the only command that uses the network. It fetches the weights and the two public encoders, and sends nothing about your data.
• After that download, the whole path runs offline. Point OMTX_LULA_HOME at a shared cache and scoring works on an air-gapped machine.

This is a property of the code, not a policy promise: the scoring module contains no HTTP client and no network imports. It is verifiable by inspection of the published package.

For teams that cannot send proprietary targets or compound libraries to a third-party API, this is the point of an open-weight release.

Free to Use With Om Fulfillment

You may use LULA-1 locally, including local fine-tuning, to select, prioritize, order, and test molecules through Om.

If you purchase molecules through Om Fulfillment, you may use the resulting customer-derived experimental data, assay results, validation data, analyses, conclusions, and reports internally and commercially for your own discovery programs, subject to the License and the applicable Om fulfillment, platform, or enterprise agreement.

You may not resell LULA-1, host it as an API/SaaS, provide LULA-powered services to third parties, or use LULA-1 as a free internal commercial screening engine while ordering or testing outside Om. Those uses require a separate Om commercial license.

You own your targets, compounds, and Customer-Derived Om Fulfillment Data, subject to the applicable Om fulfillment, platform, or enterprise agreement. This does not include a right to publish raw or bulk LULA-1 Outputs, scores, predictions, rankings, embeddings, screened molecule lists, virtual screening results, or benchmark datasets without Om's prior written approval.

Hosted models and fulfillment

LULA-1's weights are open-weight so you can screen locally with no dependency on Om. Three things are available from Om when you want more than that:

Hosted LULA-1 — the same model, no local setup, no encoder downloads, no GPU. Useful for large screens and for teams that want managed runs and tracking. omtx.ai/models

LULA-2 — Om's cross-attention successor for higher-resolution protein-ligand ranking. It reads the protein and ligand together rather than scoring from independent embeddings. Public weights are available on Hugging Face and hosted scoring is available through Om. huggingface.co/omtx/lula-2

Molecule Fulfillment — once you have a ranked shortlist, order the physical compounds through Om with Wallet Credits and track order status in one flow. LULA Score To Order

Pricing for hosted scoring is at omtx.ai/pricing.

A practical pattern: screen wide and cheap with open-weight LULA-1, then use Om's hosted models and fulfillment tools for managed runs, ordering, and final prioritization.

What ships

Path
model/best.pt	Scoring-head checkpoint
model/model_config.json	Model configuration
release_manifest.json	Machine-readable hashes used by omtx lula verify
checksums.txt	Human-readable SHA256 list
examples/	Runnable scoring examples
LICENSE, NOTICE	Terms and third-party components

Use is governed by LICENSE. Third-party pretrained encoders are governed by their own terms. This release package focuses on the LULA-1 scoring head, verification assets, examples, and documentation.

Training data

LULA-1 was trained on ~500 million data points from Om and public sources.

Evaluation

LULA-1 is evaluated as a ranking model for hit triage. Scores are optimized for prioritizing candidate molecules within a target-specific screening set.

Public metrics

The LULA-1 release checkpoint is lula1_v6.

Metric	LULA-1 v6
Public validation AUROC	0.7615
Proteome-scale macro AUROC	0.633
Proteome-scale aggregate EF@1000	54.8×

Proteome-scale sweep

LULA-1 was also evaluated in a large proteome-scale ranking sweep.

Proteins scored	10,569
Protein–ligand pairs scored	10,575,246,882
Known binders	5,025,463
Macro AUROC	0.633
Median AUROC	0.678
Aggregate EF@1000	54.8×

EF@1000 measures top-of-list enrichment: across the sweep, LULA-1 found 267,324 known binders in the top-1000 ranked molecules per target, versus 4,877.6 expected under random ranking.

Enrichment by target evidence

LULA-1 enrichment improves as more target evidence is available:

Known binders	Proteins	Median AUROC	Mean P@1000	Expected P@1000	Implied EF
1-9	4,910	0.648	0.0092%	0.0003%	~31×
10-49	2,230	0.610	0.1016%	0.0024%	~42×
50-199	1,528	0.686	0.6811%	0.0103%	~66×
200-999	1,102	0.738	3.8868%	0.0470%	~83×
>=1000	799	0.810	26.4541%	0.5175%	~51×

Target-level results

Per-protein metrics from the proteome-scale sweep, for well-known drug targets.

EF is AUPR divided by the target's observed positive rate in the ranked sweep.

Target	UniProt	Known binders	AUROC	AUPR	EF
KIT	P10721	5,354	0.891	0.1005	19×
PIM1	P11309	9,127	0.887	0.3810	42×
PARP1	P09874	6,982	0.878	0.3436	50×
ALK	Q9UM73	4,265	0.876	0.1802	42×
BACE1	P56817	15,149	0.876	0.4582	31×
BTK	Q06187	14,504	0.873	0.1465	10×
CA2	P00918	10,901	0.870	0.5495	51×
HDAC1	Q13547	12,855	0.853	0.5510	43×
CDK2	P24941	16,693	0.845	0.2298	14×
MTOR	P42345	10,258	0.824	0.1394	14×
ABL1	P00519	5,808	0.808	0.0540	9×
EGFR	P00533	18,363	0.788	0.1895	11×
ESR1	P03372	7,815	0.757	0.2192	28×
AR	P10275	5,551	0.724	0.0799	14×

Kinases and well-characterized enzyme families rank strongly. Target-level metrics and batch rankings help prioritize each campaign.

License

Weights are released under the Om LULA Community License 1.3. By downloading, accessing, using, distributing, or creating a derivative of LULA-1, you agree to that license. See LICENSE for the full terms and NOTICE for third-party components.

Summary (the LICENSE file governs):

• Allowed without a separate paid model license - non-commercial research, evaluation, benchmarking, teaching, security testing, local inference, local fine-tuning, non-commercial demos, using LULA-1 to select, prioritize, order, test, or generate data through Om, and use or publication of Customer-Derived Om Fulfillment Data as allowed by the License and the applicable Om agreement.
• Output publication restriction - raw or bulk LULA-1 Outputs, including scores, predictions, rankings, embeddings, screened molecule lists, virtual screening results, or benchmark datasets, may not be published, distributed, or made available without Om's prior written approval.
• Requires a separate Om commercial license - commercial use of local/open- weight LULA-1 itself outside Om Fulfillment, commercial screening or production discovery not fulfilled through Om, self-hosting, monetized hosting, paid API/SaaS access, reselling model access, support/deployment, third-party services, bundling LULA-1 into a paid product, or building a competing model API around Om weights.
• Commercial licensing contact - email dmc@omtx.ai.
• Publication attribution required - permitted public papers, preprints, reports, or presentations using Customer-Derived Om Fulfillment Data must cite Om Therapeutics Inc. LULA-1, checkpoint lula1_v6, and the Hugging Face model page.

Attribution

LULA-1's architecture is derived from ConPLex, developed at MIT.

Singh, R., Sledzieski, S., Bryson, B., Cowen, L., & Berger, B. (2023). Contrastive learning in protein language space predicts interactions between drugs and protein targets. Proceedings of the National Academy of Sciences, 120(24). doi:10.1073/pnas.2220778120

Reference implementation: github.com/samsledje/ConPLex (MIT License).

If you use LULA-1 in published work, please cite the ConPLex paper alongside Om.

Links

• Om — https://omtx.ai
• Hosted models — https://omtx.ai/models
• Pricing — https://omtx.ai/pricing
• GitHub — https://github.com/omtx-ai