Skip to page content
SAVRN
Search Plan a project

Open-weight model · Text classification

laya-nextflow-nfcore

by PrimeOmicX LLC Primeomicx/laya-nextflow-nfcore

laya-nextflow-nfcore is an open-weight model for text classification from PrimeOmicX LLC, released under MIT License. It has 421M parameters. At 16-bit it needs about 1 GB of GPU memory, which fits on 1x MI300X from $1.85 an hour, at the lowest prices in the SAVRN Index.

Laya v3 is an ultra-fast, local System-1 Decision Engine fine-tuned on top of ModernBERT-Large for Nextflow DSL2 and the nf-core bioinformatics ecosystem.

Parameters421M
Context—
Weights1.7 GB
Licensemit
AccessOpen weights
Monthly Downloads—

Runs On

What it takes to serve laya-nextflow-nfcore (421M parameters): the memory its weights need at each precision, and the cheapest way to rent enough data-center GPUs to hold them.

PrecisionWeightsMemory neededCheapest setupPer hourAlso fits
16-bit 0.8 GB 1.0 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
8-bit 0.4 GB 0.5 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
4-bit 0.2 GB 0.3 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00

Memory is the weights at that precision plus 20% for the runtime and a short context; a long context needs more. Prices are the lowest on-demand hourly rates in the SAVRN Index, read Oct 18, 2026.

laya-nextflow-nfcore on every accelerator the SAVRN Index prices, at every precision

Model Card

By PrimeOmicX LLC, published under mit, revision 00085d7a3033.

Laya v3 is an ultra-fast, local System-1 Decision Engine fine-tuned on top of ModernBERT-Large for Nextflow DSL2 and the nf-core bioinformatics ecosystem. It is designed to make zero-latency, high-accuracy architectural decisions in autonomous pipeline compilers (such as Codaris), resolving complex setup questions without burning LLM tokens. Evaluated across 40 realistic Nextflow architecture tasks

Read PrimeOmicX LLC's full model card

Laya v3 (Primeomicx/laya-nextflow-nfcore)

Laya v3 is an ultra-fast, local System-1 Decision Engine fine-tuned on top of ModernBERT-Large for Nextflow DSL2 and the nf-core bioinformatics ecosystem.

It is designed to make zero-latency, high-accuracy architectural decisions in autonomous pipeline compilers (such as Codaris), resolving complex setup questions without burning LLM tokens.

Key Improvements in v3

  • Expanded to 11,654 Ground-Truth Decisions: Trained across 8 core architectural pillars of Nextflow workflow compilation.
  • Long-Read & QC Adaptation: Resolves Nanopore Direct RNA, PacBio HiFi, and Illumina WGS/WES quality control switches (e.g. swapping FastQC for NanoPlot) with 95.0% accuracy (eliminating the v2 blindspot).
  • Subworkflow Packaging: Tripled autonomous packaging accuracy (60.0% on benchmark), correctly recognizing when to bundle processes into reusable subworkflows vs using official nf-core subworkflows.
  • Samplesheet Schema Inference: Autonomously infers CSV/TSV header schemas and validation constraints with 98%+ confidence, outperforming frontier LLMs.
  • Ultra-Fast Local Inference: Runs in ~45–65 ms on Apple Silicon GPU and ~590 ms on CPU inside minimal Docker containers with 0 tokens consumed.

Benchmark: Laya v3 vs Frontier LLM vs Hybrid

Evaluated across 40 realistic Nextflow architecture tasks:

Evaluation Pillar (10 items each) Laya v2 Laya v3 (System 1) Frontier LLM (System 2) Hybrid (S1 + S2)
Container Image Resolution 100.0% (10/10) 100.0% (10/10) 100.0% (10/10) 100.0% (10/10)
Subworkflow Packaging 20.0% (2/10) 60.0% (6/10) 80.0% (8/10) 90.0% (9/10)
QC Read Adaptation 30.0% (3/10) 70.0% (7/10) 100.0% (10/10) 100.0% (10/10)
Samplesheet Schema Inference 20.0% (2/10) 50.0% (5/10) 40.0% (4/10) 50.0% (5/10)
OVERALL ACCURACY 42.5% (17/40) 70.0% (28/40) 80.0% (32/40) 85.0% (34/40)
Avg Latency 640 ms 596 ms 2,018 ms 2,804 ms
Tokens Consumed 0 tokens 0 tokens 5,433 tokens 7,872 tokens

Usage

1. Python (via laya)

from laya.agent import Agent

# Automatically downloads and caches from Hugging Face Hub
agent = Agent("Primeomicx/laya-nextflow-nfcore")

# Example 1: Quality Control Adaptation for Oxford Nanopore
state = {
    "assay": "Direct RNA sequencing on Oxford Nanopore PromethION",
    "tool": "FastQC",
    "read_type": "long_reads_direct_rna"
}
question = {
    "type": "choice",
    "instructions": "How should QC step FastQC be configured given sequencing characteristics: long_reads_direct_rna?",
    "criteria": {
        "Keep FastQC": None,
        "Drop FastQC": None,
        "Swap for NanoPlot": None
    }
}
res = agent.predict(state, {"decision": question})
print(res["answers"]["decision"]["choice"])
# Output: "Swap for NanoPlot" (confidence: 94.2%)

2. Samplesheet Schema Inference

state = {
    "field_name": "strandedness",
    "datatype": "categorical",
    "description": "Strandedness of RNA-seq library"
}
question = {
    "type": "choice",
    "instructions": "Determine JSON schema validation constraint for field strandedness:",
    "criteria": {
        "enum: [auto, unstranded, forward, reverse]": None,
        "pattern: ^[0-9]+$": None,
        "format: file-path": None
    }
}
res = agent.predict(state, {"decision": question})
print(res["answers"]["decision"]["choice"])
# Output: "enum: [auto, unstranded, forward, reverse]" (confidence: 98.4%)

Training Configuration

  • Base Architecture: ModernBERT-Large (1024-dim hidden states, 512 max seq len)
  • Decision Head: 2-layer residual projection head + calibrated temperature scaling
  • Precision: native bfloat16 / float16 trained with Apple Silicon MPS GPU acceleration
  • Training Dataset: Primeomicx/nfcore-laya-decisions (11,654 records)
  • Epochs: 8 (Best Val Loss: 0.599, Val Accuracy: 78.37%)

Identity and Version

Repository
Primeomicx/laya-nextflow-nfcore
Publisher
PrimeOmicX LLC
Task
Text classification
Modality
Text
Library
Not stated by the source
Parameters
421M parameters
Languages
en
Revision
00085d7a3033ff0bed8bbcc6f6163bf93c82c50a
First published
2026-10-02
Last updated
2026-10-04

Files and Weights

7 files, 1.7 GB in total. The weights are 1 file totalling 1.7 GB in safetensors.

Weights1 file · 1.7 GB
Configuration2 files · 3.0 KB
Tokenizer2 files · 3.6 MB
Documentation1 file · 4.5 KB
Repository1 file · 1.5 KB
Every file
FileTypeSizeSHA-256
model.safetensorsWeights1.7 GB 96a0f7407869
encoder/config.jsonConfiguration2.1 KB —
rl_agent_config.jsonConfiguration920 B —
README.mdDocumentation4.5 KB —
.gitattributesRepository1.5 KB —
tokenizer/tokenizer.jsonTokenizer3.6 MB —
tokenizer/tokenizer_config.jsonTokenizer308 B —

License and Download

License
mit
Access
Open weights, no gate
Download size
1.7 GB
Download from PrimeOmicX LLC

Released by PrimeOmicX LLC through its official repository on Hugging Face. Read the license.

Built From

Memory Requirements

PrecisionWeights in memory
As published1.7 GB
16-bit0.8 GB
8-bit0.4 GB
4-bit0.2 GB

Weights only, from the published parameter count; the key-value cache and runtime add to this.

Questions About laya-nextflow-nfcore

How much GPU memory does laya-nextflow-nfcore need?

About 1 GB at 16-bit and 0.3 GB at 4-bit: the weights (421M parameters) plus a working margin. A long context needs more.

What is the cheapest GPU to run laya-nextflow-nfcore on?

At 16-bit, 1x MI300X from $1.85 an hour; at 4-bit, 1x MI300X from $1.85 an hour, at the lowest on-demand prices the SAVRN Index lists.

Can I use laya-nextflow-nfcore commercially?

Yes. laya-nextflow-nfcore is released under MIT License. The MIT License is a short permissive license. It permits commercial use, modification and redistribution, provided the copyright notice and permission notice are included.

Similar Models

Model · Text classification

laya-typed-decisions

Convai Innovations

Non-autoregressive System 1 decision model, fine-tuned on the typed-decisions workflows: agent-trace observability, customer service, invoice processing and security incidents. Part of the Laya family. 400 test cases, 2,000 decisions, measured on the official test split. +3.9 points over Jev's published 0.727, above the 0.735 teacher ceiling, with 2.4x better Brier and 1.6x better score MAE. Jev figures are third-party published, not measured here — there is no TypeSafe API access in this project, and sample sizes and prompts differ. Treat the comparison as indicative. Router will not select this checkpoint automatically unless you construct it with autotaskdetection=True — it is…

Open weights apache-2.0 421M parameters transformers

Model · Text classification

laya

Convai Innovations

Multilingual, non-autoregressive System 1 decision model. Give it a state (text, email, ticket, or JSON) and typed questions; it returns typed answers with mathematically calibrated probabilities in a single forward pass (~33 ms) across 100+ languages. Trained with reinforcement learning against strictly proper scoring rules (RLCD), so reporting honest probabilities is the only way to maximise reward. It never generates text, so there is nothing to parse and nothing to hallucinate. This repo holds all three checkpoints and is the hub for the family. The English checkpoint is at the repo root; the other two are bundled subfolders, and only the one you request is downloaded: pip install -U…

Open weights apache-2.0 421M parameters transformers

Model · Text classification

laya-kvp10k-noul

Sothiara Em

A fine-tuned Laya model (Convai Innovations, 421M, ModernBERT-large backbone) that answers one typed noul question: does a value correctly match its key label? (e.g. firstname = John → true, firstname = 1992 → false). Fine-tuned on the IBM KVP-10K dataset via the pre-parsed community mirror (OCR pre-extracted; no OCR step needed). This is the v2 (remediated) release: document-level 80/10/10 data partitioning, mixed-class frozen test set, calib-split temperature fitting, and a frozen category-stratified release gate. It supersedes the v1 release pre-remediation, historical artifact). Laya is a non-autoregressive decision model: you give it a state (text/dict) plus typed questions (choice…

Open weights apache-2.0 421M parameters laya

Model · Text classification

afm-de

Ariacompute

Laya-layout ModernBERT + MASK option head, RLCD fine-tune from convaiinnovations/laya. Checkpoint files: model.safetensors, rlagentconfig.json, tokenizer/, encoder/. Load with AFM-D: python -m afmd.de.eval --checkpoint --device cuda. See AFM-D / product docs. License follows the base Laya / ModernBERT stack.

Open weights 421M parameters transformers

Model · Text classification

openjevx

Muthukumaran Navaneethakrishnan

OpenJevX is an open-weight, non-autoregressive System One decision model specialized from Laya, which uses answerdotai/ModernBERT-large plus a dynamic typed-decision head. It accepts runtime-defined choice, score, and noul questions and returns calibrated probabilities in one forward pass. It is compatible with the TypeSafe Jev /v1/systemone request shape through the OpenJevX server. - CUDA p50 latency per five-question case: 22.8 ms The benchmark uses the untouched 400-case, 2,000-decision test split from LocalLLaMA/typed-decisions. Training uses only its 1,200-case train split. OpenJevX is a derivative of Laya by ConvAI Innovations and ModernBERT by Answer.AI and LightOn. Laya and…

Open weights apache-2.0 421M parameters laya

Model · Text classification

ProKope-421M

Alan Canto

Creator, Sole Author & Lead Architect: Alan Canto Architecture: ModernBERT-large (System 1 Non-Autoregressive Decision Engine) Hardware Runtime: Trained, fine-tuned, and certified locally on NVIDIA GeForce RTX 3050 Attribution: Conceived, engineered, and published by Alan Canto. All rights reserved. ProKope 421M (named after the classical Stoic concept of disciplined, measured progress and operational mastery) is a high-speed, non-autoregressive System 1 decision model engineered by Alan Canto. Unlike autoregressive language models (which incur significant token latency, JSON parsing errors, and hallucination loops), ProKope 421M processes structured input states in a single forward pass…

Access requested at publisher cc-by-nc-4.0 421M parameters transformers