From a paragraph of intent to weights you own.

1. 01

   Specify

   You write what the job is, in plain language, and attach a few dozen real examples plus any policies or reference documents.

   Nexus compiles this into a task specification: input and output schemas, a grading rubric, an inventory of edge cases, and a held-out test set.

   The test set is frozen before training starts and is never shown to a teacher or a student. Everything downstream is measured against it.

   Compute profile Light — minutes of teacher inference

2. 02

   Synthesize

   Your examples are the seed, not the dataset. Large open-weight teacher models expand them into a corpus of hundreds of millions of tokens: varied inputs, worked reasoning, correct outputs.

   A second pass critiques and filters. Rubric-based judges score every sample, programmatic verifiers check everything checkable, near-duplicates are removed, and anything resembling the frozen test set is discarded.

   Teachers are open-weight models whose licenses permit distillation. We don't train on outputs from services whose terms forbid it.

   Compute profile Heavy inference — models with hundreds of billions of parameters, served across multi-GPU nodes for sustained batch generation

3. 03

   Distill

   Several open-weight base models between one and eight billion parameters are fine-tuned on the corpus in parallel, across a sweep of data mixtures and hyperparameters.

   Each candidate is scored on the frozen test set. Nexus keeps the smallest model that clears your bar, because every parameter you don't need is latency, memory and energy you don't pay for.

   Compute profile Training — parallel fine-tuning runs on multi-GPU nodes

4. 04

   Reinforce

   Fine-tuning teaches a core to imitate. Reinforcement learning teaches it to be right. The core attempts the task over and over; verifiable rewards — schema validity, executable checks, rubric-based judges — tell it which attempts to learn from.

   This is where reliability on the long tail comes from: malformed inputs, ambiguous cases, the one-in-a-thousand request.

   Compute profile Heaviest — millions of rollouts, each generated, judged and learned from

5. 05

   Prove

   Every checkpoint faces the same trial: the frozen test set, a growing regression suite, and adversarial probes written to break it. It is scored head to head against its own teacher and against a general-purpose baseline.

   Failures flow back into synthesis as new training targets. The loop runs until the core clears the bar — or until the evidence says a small model isn't enough for this task, and we tell you so.

   Compute profile Continuous inference — every candidate, every suite, every release

See the planning estimate in GPU-hours →

A core is a deliverable, not a subscription.

Design targets · alpha

Weights

safetensors, plus quantized GGUF and ONNX builds.

Evaluation report

accuracy against teacher and baseline, failure analysis, latency and throughput on reference hardware.

Model card

intended use, limits, known failure modes.

Training manifest

base model and license, data lineage, hyperparameters and seeds: enough to reproduce or audit the run.

Regression suite

yours to keep, so every future version answers to the same tests.

Runs where your data lives.

• Your cloud

• On-premises

• On device

Cores serve through the open-source runtimes you already know — vLLM, llama.cpp, ONNX Runtime — behind an OpenAI-compatible endpoint, or embedded directly in your application.

Guardrails we build in, not bolt on.

License-clean

Teachers and base models are open-weight, with licenses that permit distillation and commercial use, disclosed up front.

Isolated

A customer's data and cores are never used to train anything for anyone else.

Honest evaluation

Test sets are frozen before training and never seen by teachers or students.

Bounded use

Cores are built for defined tasks with documented limits. We won't build cores intended to deceive, surveil or harm people.