Privacy preferences

Strictly necessary

Always on

Remembers your choice on this page. Stored in your browser as gb_consent for up to 6 months. If you switch the site to dark mode, that choice is kept as gb_theme. Nothing is sent to a server.

Anonymous analytics

Helps us count visits. At most once every 24 hours we send one ping to our own telemetry server, using the same anonymous approach as the WeightsLab package. No advertising, no third-party trackers, no cross-site tracking.

Exactly what is sent
uuid
A random ID created in your browser (gb_tid). It is not linked to your name or email.
event, version
website_visit and website, so website visits can be told apart from WeightsLab package pings.
os
Operating-system family only, for example Windows, Darwin, Linux or Android.
tz
Your time zone, for example Europe/Paris.
On our server
Your IP address is used to estimate country and city. Only a salted hash of it is kept, never the raw address.
GitHub star count
With analytics on, your browser also asks api.github.com for the public star count of our repository, so GitHub sees your IP address. With analytics off, the page shows a fixed number and makes no request to GitHub.

Turning analytics off deletes gb_tid and stops all pings.

The product

Work on the run while it is still going.

WeightsLab runs next to your training script and opens in your browser, on your machine.

WeightsLab by Graybx
The WeightsLab workspace: training and test loss curves, a 3D projection board, a data table sorted by per-sample loss, and an agent window asking to monitor the run for overfitting
  • Experiment workspace

    Pause training, compare runs and analyse experiments in one place.

  • In-training signals

    Per-sample loss and your own custom signals point to data issues as they appear.

  • Agent-assisted

    Talk to your experiment, signals and data in natural language. Bring any LLM, hosted or local.

Built-in agent · Bring your own LLM

Any LLM provider, or a local LLM.

The agent runs on OpenCode, so it works with any LLM provider OpenCode supports, hosted or on your own hardware. Your provider credentials stay in OpenCode, never in WeightsLab. With a model you host yourself, the agent works air-gapped and your sample-level data stays on your machine.

Hosted providers

On-prem models · your own hardware

Run open-weight models such as Llama, Qwen or Gemma on your own GPUs: the model, the data and the agent all stay on-prem.

Plug it into your training pipeline in a few lines.

Keep your PyTorch script. Wrap the objects you already create, one call each, and start the studio.

  1. 01Install pip install weightslab
  2. 02Wrap your model, optimizer, loss and data with wl.watch_or_edit
  3. 03Train inside the guard, then open the studio with weightslab start

Works with PyTorch PyTorch Lightning Ultralytics Notebooks

Coming from TensorBoard or Weights & Biases? Follow the TensorBoard guide or the Weights & Biases guide.

training_script.py
import weightslab as wl

# <your code>: cfg, model, optimizer, train_ds ...

# wrap what you already have: one call per object
hp        = wl.watch_or_edit(cfg, flag="hyperparameters")
model     = wl.watch_or_edit(model, flag="model", device=device)
optimizer = wl.watch_or_edit(optimizer, flag="optimizer")
loss      = wl.watch_or_edit(
    nn.CrossEntropyLoss(reduction="none"),   # one value per sample
    flag="loss", signal_name="train/loss", log=True)
loader    = wl.watch_or_edit(
    train_ds, flag="data", loader_name="train_loader", is_training=True,
    batch_size=hp["data"]["train_loader"]["batch_size"], shuffle=True)

wl.serve(serving_grpc=True, serving_cli=True)

# your training loop
for epoch in range(epochs):
    for step in range(steps_per_epoch):
        with wl.guard_training_context:
            inputs, uids, labels = next(loader)
            optimizer.zero_grad()
            logits = model(inputs)
            loss_per_sample = loss(logits, labels, batch_ids=uids,
                                   preds=logits.argmax(1, keepdim=True))
            loss_per_sample.mean().backward()
            optimizer.step()
            # <your code>: logging, anything else per step
    # <your code>: evaluation, checkpoints
$ weightslab start # launches the UI

How it works

Observe, diagnose and intervene inside the run.

WeightsLab wraps your PyTorch data loader, model and loss. After that you can look at every sample and weight, and edit them, while training keeps going.

Signalstrain_loader
Samples per event8,000 samples · 24 events
head · model succeeds mean loss long tail · model fails
most frequent eventsrarest events →
“Pick up toy”1,900 samples · well represented · model succeeds
“Pour water in …”14 samples · rarely seen · model fails
  • loss
  • confidence
  • weight health
  • custom: blur_score
  • custom: label_agreement

On-prem · Licence

On-prem for every customer, whatever they train.

WeightsLab always runs on your infrastructure. Your data, your models and your GPUs stay where they are. It is free for students and individuals, and licensed per seat for organisations of any size.

Physical AI

Sensor data and IP stay on your site

Robot demonstrations and camera, video and LiDAR streams, including the edge cases in them, never leave your infrastructure.

  • Images, video and LiDAR on your own storage
  • Per-sample signals on the GPUs you manage
  • Rebalance scenario coverage during the run
See the robot-manipulation example

LLM training & fine-tuning

Prompts, answers and weights stay inside your network

Fine-tuning data, human-preference labels and checkpoints are reviewed where they live: on your servers.

  • Read prompts and answers sample by sample, in place
  • Per-sample loss and your own signals on your own GPUs
  • Resume from your own checkpoints
See the preference example

AI Training

Start with MNIST, then bring your own data

Classification, detection and segmentation on your own images, plus tabular and other data, run on your side.

  • Example: MNIST, a CNN digit classifier you can watch train sample by sample
  • Per-sample loss, tagging and mid-run intervention
  • Runs entirely on your machine
Open the MNIST example

Medical AI

Rare cases found on your own infrastructure

Radiology and pathology data never leaves your site. WeightsLab connects model behaviour to individual samples, which helps where data quality and explainability matter.

  • Images and annotations stay on your own storage
  • Trace model behaviour back to individual samples
  • Find rare cases and likely mislabels from per-sample loss
See the medical imaging use case

The licence

Free for students and individuals. Licensed per seat for companies.

WeightsLab runs on your own infrastructure, with the same deployment for every user. Students and individuals working on personal projects can use it free of charge. For companies, whatever their size, WeightsLab is licensed per seat, one seat per user. Get in touch and we will walk you through the terms for your team.

Included with every company seat

  • Support from the Graybx team
  • Updates as new versions ship
  • Custom features your team needs
  • On-prem deployment, on your own GPUs
  • The full WeightsLab workspace
  • Per-sample signals while the model trains
  • Mid-run intervention: drop, retag or re-annotate samples, steer the learning rate
  • Built-in agent, with any LLM provider or an on-prem model
  • Physical AI, LLM, medical imaging and general AI training
  • You keep ownership of your data and models
  1. 01Talk to usBook 30 minutes and bring a real run.
  2. 02Try the sandboxExplore WeightsLab in your browser.
  3. 03Get your seatsOne seat per user, with support and updates.

See it on one of your runs.

Try the sandbox in your browser, or book 30 minutes with us and bring a real run.

Join the early-access programme

Tell us what you train and we'll get back to you with a demo and licence terms.