Skip to content

Example scripts

The examples/ folder holds complete programs, one file each. The descriptions below are generated from the scripts’ docstrings. Every script but one has a command-line interface, and --help lists its options. train_supervised.py is a Python experiment, which dew train runs.

The first group trains one kind of model on one dataset. The second group runs a full job, from data to scored or exported weights. Each script in the second group takes --smoke, which replaces the real settings with the repository’s tiny fixtures, a few steps and one CPU device; the test suite runs them that way. End-to-end runs gives both command lines for each.

Train a toy language model, resume it, learn preferences, and generate images.

Run from an installed Dew checkout, without downloads: JAX_PLATFORMS=cpu python examples/readme_demo.py —out runs/readme-demo

Use a new output directory for each invocation. The generated data demonstrates mechanics, not language ability, preference quality, or useful image generation.

Source on GitHub

Train a byte-level language model on a token store, then generate.

The text is split into lines to train on and lines held out, and each is tokenized into a store of its own by dew data export: training reads every token of its store, and the held-out store is what examples/evaluate_and_serve.py scores.

Terminal window
curl -o data/shakespeare.txt --create-dirs \
https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt
head -n 36000 data/shakespeare.txt > data/shakespeare-train.txt
tail -n +36001 data/shakespeare.txt > data/shakespeare-val.txt
dew data export data/shakespeare-train.txt data/shakespeare --tokenizer byte --eos --read memory
dew data export data/shakespeare-val.txt data/shakespeare-val --tokenizer byte --eos --read memory
python examples/train_lm.py --tokens data/shakespeare --epochs 4
python examples/train_lm.py --tokens data/shakespeare --steps 20 --sequence-length 32 # smoke run

Source on GitHub

Train MDLM on TinyStories, score its held-out perplexity bound and unmask stories.

Terminal window
python examples/train_masked_lm.py --out runs/mdlm-tinystories
python examples/train_masked_lm.py --dataset Salesforce/wikitext \
--config wikitext-103-raw-v1 --prompts "The game" --out runs/mdlm-wikitext
JAX_PLATFORMS=cpu python examples/train_masked_lm.py --smoke --out /tmp/mdlm-smoke

The first run reads the dataset’s train split with datasets and tokenizes it once into Dew’s cache, each row a document ended by the tokenizer’s eos id. Later runs read the cached ids offline. The head 1% of that stream is held out, and training never reads it. A bidirectional CausalTransformer learns MDLM’s negative ELBO (MaskedDiffusionObjective). The mask is one id past the tokenizer’s vocabulary, so no text can contain it. Every --eval-every steps the trainer scores the held-out windows, and val/perplexity is the exponential of the NELBO per token, the bound MDLM reports.

At the end the script loads the run back with dew.pipeline, which returns a MaskedGeneration task over the saved weights. It scores the whole held-out split with those weights, unmasks a continuation of each of --prompts, and writes result.json and samples.txt beside the run. --smoke writes a few lines of text as JSON, byte-tokenizes them and trains a tiny model for four steps on one CPU device. It needs no network.

Source on GitHub

Train a pixel-space diffusion model on prepared Oxford Flowers ArrayRecords.

Terminal window
CUDA_VISIBLE_DEVICES=0 JAX_PLATFORMS=cuda python examples/train_flowers.py \
--data ~/.cache/dew/datasets/oxford_flowers102/2.1.1 --steps 1000

It trains on every record: no split is held out, and nothing is scored. With --profile N it is a profiling run, which traces N steps into <output>/profile after two warm-up steps and draws no samples:

Terminal window
CUDA_VISIBLE_DEVICES=0 JAX_PLATFORMS=cuda python examples/train_flowers.py \
--data ~/.cache/dew/datasets/oxford_flowers102/2.1.1 --steps 50 --profile 20

Source on GitHub

Train a text-to-image diffusion model on Oxford Flowers, sample from it, export the weights.

Terminal window
python examples/train_diffusion.py --data-path /data/oxford_flowers102/2.1.1 --epochs 200
python examples/train_diffusion.py --data-path /data/oxford_flowers102/2.1.1 --steps 20 --image-size 32

Source on GitHub

Train an I-JEPA encoder on Oxford Flowers, probe it, save the encoder.

Terminal window
python examples/train_jepa.py --data-path /data/oxford_flowers102/2.1.1 --epochs 300
python examples/train_jepa.py --data-path /data/oxford_flowers102/2.1.1 \
--steps 20 --image-size 32 --patch-size 4

Source on GitHub

Fine-tune a decision model on BANKING77, then answer and score it.

The script scores Laya’s released checkpoint on BANKING77’s 77 intents zero-shot, fine-tunes it on the training split, fits its temperatures on held-out rows, and scores the test split again. --backbone qwen instead trains a LoRA adapter on Qwen3-0.6B under a fresh decision head.

Terminal window
python examples/banking77_decisions.py --backbone laya --epochs 3 --run runs/laya-banking77
python examples/banking77_decisions.py --backbone qwen --epochs 3 --learning-rate 1e-4 \
--run runs/qwen-banking77

Each score is one JSON line, on stdout and appended to --out: accuracy, expected calibration error, the area under the risk-coverage curve and the log loss. The run checkpoints into --run every ten minutes and resumes from it when started again.

Source on GitHub

A classifier written as a Python experiment and trained with dew train.

Terminal window
dew train examples/train_supervised.py --set trainer.steps=600 --set model.hidden=64

This file builds the run in plain Python: its own Flax model and loss, two interleaved spirals it writes once as JSON lines, and Supervised, which trains any model on a loss over its outputs, with no subclass of Objective. run is the RunConfig; each --set changes one field of it, read as that field’s own type reads it. dew train imports the file as the module train_supervised, so run.json names the model and the loss by import path (train_supervised:MLP), and a new process rebuilds the same run from that record alone:

Terminal window
PYTHONPATH=examples dew train checkpoints/train_supervised/run.json \
--trust train_supervised --set trainer.checkpoint_dir=again

Without --set, the record continues the run from its own checkpoints.

Source on GitHub

A physics-informed network to float64 precision: the self-similar blowup profile of 1D Burgers.

Terminal window
python examples/pinn_burgers.py --out runs/burgers
python examples/pinn_burgers.py --model mlp --out runs/burgers-mlp
JAX_PLATFORMS=cpu python examples/pinn_burgers.py --smoke --out /tmp/burgers-smoke

The inviscid Burgers equation u_t + u u_x = 0 blows up in finite time along the self-similar profile u = tau^lambda U(x tau^-(1 + lambda)), whose profile solves

Terminal window
F(y) = -lambda U + ((1 + lambda) y + U) U_y = 0, lambda = 0.5,

on y in [0, inf). As Zhao et al. (arXiv 2605.24278, Appendix J, after Wang et al. 2026) set it up, the network learns U~ over eta in [-c, c], c = 30, y = sinh(eta), and the profile is odd with the known tail built in:

Terminal window
U(eta) = U~(eta) - U~(-eta) - (y / (1 + y))^15 y^(lambda / (1 + lambda)).

Each step draws a batch of eta uniform in [0, c) from its key and minimizes the mean of F^2 + (dF/deta)^2 in float64, with Adam at 1e-4 decayed to zero by a cosine over the run (epsilon 1e-15). --model pyramid (the default) reads U~ through a 12-level Fourier feature pyramid, grids of 2 to 4096 points of 4 channels, at the coordinate (eta + c) / (2c), into a tanh MLP of width 20 and four layers; --model mlp is that MLP alone, on eta. --damping steps by Gauss-Newton instead of Adam (dew.gauss_newton.gauss_newton, the residuals’ system its objective states), damped as Levenberg-Marquardt’s.

The run writes metrics.json to --out: on the grid eta_i = c (i + 1/2) / 1000, the mean of F^2 and log10 of the largest |F|, which the paper reports (its Table 2) as 6.29e-19 and -8.46 for the pyramid after 20,000 steps of 4096 points, and 6.21e-7 and -2.41 for the MLP alone. On one H100 this example’s default run reaches 2.26e-18 and -7.91 in 26 minutes, and --model mlp 5.68e-8 and -2.95 in 15.

Source on GitHub

A language model trained without backpropagation, against the same model trained with it.

Terminal window
python tools/noise_fineweb.py data/noise
python examples/forward_only_lm.py --data data/noise --method perturbation --out runs/forward
python examples/forward_only_lm.py --data data/noise --method backprop --out runs/backprop
JAX_PLATFORMS=cpu python examples/forward_only_lm.py --smoke --out /tmp/forward-smoke

tools/noise_fineweb.py prepares Noise’s fixed FineWeb data (qlabs-eng/noise): rows of 2,049 ids of its BPE-4096 tokenizer, checked against its pinned hashes. This trains Dew’s decoder at the shape of Dust’s 37.7M-parameter GPT (8 layers of width 512, 8 heads of 64, 4,096 ids, rows of 2,048 predictions, windows of half a row on three layers in four and the last layer whole, logits capped at 15, an untied head) on the first --tokens of it, one epoch of 8 rows a step, and scores Noise’s validation rows every --eval-every steps. Four of Dust’s block features are not Dew’s (ledger 1852): its value embeddings, its residual mix with the first layer’s input, its parameter-free norms and its ungated ReLU^2 MLP, which a gated SwiGLU of the same parameter count stands in for. So the model is Dust’s shape, not Dust’s model, and the comparison is of the two learning rules on one model.

--method perturbation trains it by node perturbation (dew.objectives.perturbation.NodePerturbation), Dust’s estimator in Dew’s general form: every Dense and Embed output jittered by --draws antithetic pairs a step, each token credited by its own loss, with Adam at 1.5e-3, betas (0.7, 0.95), and a linear warmdown over the last 30% of steps, Dust-with-Adam’s settings in Noise. --method backprop trains it by backpropagation with the same Adam and schedule at --backprop-lr. Each run writes curves.json to --out: the training and validation losses by step, and the wall time of the training.

Source on GitHub

Text-to-image DiT from scratch on Oxford Flowers, across a TPU slice.

Prepare the TFDS ArrayRecords once:

Terminal window
python -c "import tensorflow_datasets as tfds; tfds.builder('oxford_flowers102', \
data_dir='~/.cache/dew/datasets').download_and_prepare(\
file_format='array_record')"

Then launch the same file on every worker of the slice:

Terminal window
python examples/train_flowers_tpu.py \
--data ~/.cache/dew/datasets/oxford_flowers102/2.1.1 --steps 200000

--data reads whichever of two layouts it is given: the TFDS version directory, its captions made from the class names, or a directory of captioned ArrayRecords Dew published (its manifest.json). The smoke run writes a handful of synthetic records in that second layout and trains on them on one CPU device:

Terminal window
JAX_PLATFORMS=cpu python examples/train_flowers_tpu.py --smoke --out /tmp/flowers-smoke

Source on GitHub

Full-weight SFT of a Gemma 4 text decoder on a Hub chat dataset.

Terminal window
python examples/sft_gemma4.py --model google/gemma-4-E2B \
--dataset hf://datasets/allenai/tulu-3-sft-mixture --steps 4000 --out runs/gemma4-sft

The run holds the first --held-out conversations out for its validation perplexity, packs the rest into windows, counts the loss on assistant targets alone, shards the weights over the visible devices and accumulates micro-batches into one update. It ends by exporting the trained weights to the Hugging Face layout, so transformers and Pretrained.load both read them, and the run directory itself scores through the harness:

Terminal window
python -m dew.eval --model dew --model_args run=runs/gemma4-sft/checkpoints/gemma4-sft \
--tasks hellaswag --limit 64

The sft preset reads the Hub dataset through its hf:// source, so the URL on the command line is what the run trains on: it renders every conversation with the checkpoint’s own chat template and packs them into windows.

Terminal window
JAX_PLATFORMS=cpu python examples/sft_gemma4.py --smoke --out /tmp/gemma4-smoke

Source on GitHub

LoRA SFT of DiffusionGemma on chat data, with the base weights host-streamed.

The optimizer updates only the adapter, and Layout(host=("variables",)) keeps the whole train state on the host between steps, with the scanned stack fetching one layer at a time. The 26B-A4B base has not been run through it:

Terminal window
python examples/sft_diffusion_gemma.py \
--model google/diffusiongemma-26B-A4B-it \
--chat data/tulu-3-sft.parquet --steps 2000

--chat is an hf:// Hub dataset, a .jsonl file or a parquet file of conversations, which the canvas preset reads and renders with the checkpoint’s own chat template. Each assistant turn becomes one row: the conversation before it is the clean prompt, and the turn alone fills the canvases the denoiser scores. The run writes the PEFT adapter directory Adapter.save produces, which transformers loads, then loads the base again through dew.pipeline, merges the adapter into it and writes the decoded canvases to samples.txt. Image-conditioned training on real Oxford Flowers is examples/sft_diffusion_gemma_images.py; it uses a fresh small model, not the released 26B model’s qualification.

Terminal window
JAX_PLATFORMS=cpu python examples/sft_diffusion_gemma.py --smoke --out /tmp/dg-smoke

Source on GitHub

Image-conditioned DiffusionGemma SFT from scratch on Oxford Flowers, scored by naming held-out flowers.

Terminal window
python examples/sft_diffusion_gemma_images.py --out runs/flowers-caption
JAX_PLATFORMS=cpu python examples/sft_diffusion_gemma_images.py --smoke --out /tmp/flowers-caption-smoke

This trains a fresh DiffusionGemma, a byte-vocabulary text stack with a small Gemma 4 vision tower, with BlockDiffusionObjective, the published DiffusionGemma SFT loss. It starts from random weights; it does not load or fine-tune the released 26B-A4B checkpoint. Flowers has class labels rather than human captions, so each target is “a photo of a ”. The image sits in the clean prompt as placeholder slots that the vision tower’s features fill, and the caption is the response canvas the denoiser learns.

The run reads the dataset’s three splits from the Hub at the commit --revision names, prepared once by datasets, and the data chain decodes each image once into memory, shrunk so that its shorter side is --staging-size pixels. Training reads the train and validation splits with random crops and flips. Every --eval-every steps the trainer scores the canvas cross entropy over held-out test images. At the end the script loads the run back with dew.pipeline, which returns a BlockGeneration task. That task captions every test image, and result.json records how many captions name the right flower. --smoke writes a few synthetic images as parquet and trains a tiny model for four steps on one CPU device, on the same path. It needs no network.

Source on GitHub

RLVR: GRPO on programs that must pass their tests, rolled out asynchronously.

Terminal window
python examples/train_rlvr.py --backend native --steps 40 --out runs/rlvr-native
python examples/train_rlvr.py --backend vllm --steps 40 --out runs/rlvr-vllm
python examples/train_rlvr.py --backend sglang --steps 40 --out runs/rlvr-sglang

Every prompt asks for a Python program that reads two integers from stdin and prints a stated function of them. A completion’s reward is the fraction of three hidden test cases its program passes, run in a SandboxFleet. --runner container runs each program in a network-less python:3.12-slim container. --runner process (the default, and the only choice where Docker is absent, as on Colab) runs it as a process with a wall clock, CPU time and memory cap; that process has your user’s filesystem and network.

Rollouts run on a rollout server while the trainer updates. --backend native serves them from Dew’s own continuous-batching Server in this process, with weights pushed in place. --backend vllm and --backend sglang start that engine’s OpenAI-compatible server on an export of the same checkpoint, sample from it by token ids, and push weights by writing safetensors and asking the engine to reload them (vLLM’s development endpoints, VLLM_SERVER_DEV_MODE=1; SGLang’s /update_weights_from_disk). --vllm and --sglang name the executables, which may live in their own environments. A RolloutScheduler over a PromptSource draws one batch ahead of the update, so each batch is at most one update stale; the GRPO objective’s importance cap corrects for it. A completion that runs out of --new-tokens is still scored and trained on (truncation="score"): a closed code block followed by cut-off prose can pass every test.

--turns N gives each task up to N attempts through an EnvironmentSource, Dew’s in-process multi-turn session source. An attempt that fails a test gets back how many of the three it passed and tries again; the reward is the last attempt’s. A harness would render the report as a user turn with the chat template instead, and tools/audit_template.py tells whether that stays append-only.

The run prints one line per update and writes rewards.json to --out with the per-update reward, policy version and lag, the mean reward of the first and last --window updates, and the seconds each weight push took.

Terminal window
JAX_PLATFORMS=cpu python examples/train_rlvr.py --smoke --out /tmp/rlvr-smoke
JAX_PLATFORMS=cpu python examples/train_rlvr.py --smoke --turns 2 --out /tmp/rlvr-smoke-turns

Source on GitHub

Agentic GRPO: a harness runs in Harbor sandboxes, a gateway records its

model calls, and Dew trains on them.

Terminal window
python examples/train_harbor.py --tasks path/to/harbor/task ... --gateway http://127.0.0.1:9090 \
--sandbox-gateway http://proxy:9091 --engines http://127.0.0.1:8011 --served runs/harbor/served
JAX_PLATFORMS=cpu python examples/train_harbor.py --smoke --out /tmp/harbor-smoke

Each update draws --prompts Harbor tasks and runs --groups trials of each through HarnessSource(Harbor(...)): Harbor starts the task’s sandbox and the harness (mini-swe-agent by default), the harness’s model calls go through rllm-model-gateway to the engines, and the gateway’s traces become the session’s calls. RolloutScheduler admits complete groups at most --max-lag updates stale and packs them; the GRPO objective trains on the sampled ids only. Publication pushes each version to every engine with SafetensorsReload and then stamps the gateway, so every call carries the version it was sampled under.

The example writes the policy to --served and then waits, up to --ready-timeout seconds, for the gateway to route to an engine: launch the engines on --served (vLLM with VLLM_SERVER_DEV_MODE=1) and the gateway in front of them while it waits, as docs/concepts/post_training.md describes (warm each engine, size the gateway’s health interval, keep its admin routes away from the sandboxes).

--smoke needs neither Harbor nor an engine. A stand-in harbor script runs a two-turn harness against an in-process gateway whose engine is Dew’s own server on the committed tiny Qwen2, so the ids and likelihoods it records are the policy’s own draws. The reward is the share of vowels in the replies. Two updates on CPU.

Source on GitHub

Score a finished run four ways, then compare it against a served model.

Perplexity over held-out tokens, an lm-evaluation-harness suite, greedy continuations, and, for a diffusion run, CLIPScore of a sampled grid against its prompts and FID against a reference set. Everything is read through dew.pipeline, so a run directory, a published checkpoint and a Hub repository all work.

Terminal window
python examples/evaluate_and_serve.py --run runs/shakespeare/checkpoints \
--tokens data/shakespeare-val --tasks hellaswag arc_easy --harness-limit 200
python examples/evaluate_and_serve.py --run runs/shakespeare/checkpoints \
--image-run runs/flowers-tpu/checkpoints/flowers-256 \
--reference-images data/flowers-heldout

The same suites run from the command line, which is the harness’s own entry point with Dew’s model registered:

Terminal window
python -m dew.eval --model dew --model_args run=runs/shakespeare/checkpoints \
--tasks hellaswag --limit 200

--openai-base-url adds a served comparison: the same prompts through the OpenAI SDK (vLLM serves the same API), or --ollama-host through ollama’s. Each SDK is an optional extra, needed only when its flag is given; with the endpoint unreachable, the report says so and the rest of the run is unaffected. The OpenAI key is OPENAI_API_KEY when set; a vLLM server started without --api-key takes any key, so an unset one sends vLLM’s placeholder.

Terminal window
JAX_PLATFORMS=cpu python examples/evaluate_and_serve.py --smoke --out /tmp/eval-smoke

Source on GitHub

Sample the pretrained text-to-image model over prompts, seeds and samplers.

Run from the repository root on a GPU. By default the script downloads the model from the Hugging Face Hub:

Terminal window
python examples/sample_text_to_image.py

--model takes another Hub repository, pinned as repo@revision or not, or a Dew run directory, read through TextToImage.from_run:

Terminal window
python examples/sample_text_to_image.py --model RUN_DIR

The default model, dewml/hybrid-dit-176m, is a hybrid DiT of state-space and attention blocks trained with Dew. Its denoiser holds 175.6M parameters, beside a 123.1M-parameter CLIP text encoder and an 83.7M-parameter Stable Diffusion autoencoder, and it samples 256x256 images.

Each sampler draws one batch per seed, holding every prompt. The output directory gets one PNG per image, one grid per sampler (rows are prompts, columns are seeds) and manifest.json, which records each image’s prompt, seed, sampler, steps and guidance, and each batch’s wall time. The first batch of a sampler includes compiling it, or reading it from JAX’s compilation cache.

Source on GitHub

Train a small mixture-of-experts decoder on a device mesh, generate from it, and draw where its tokens go.

On eight CPU devices simulated in one process, as a mesh of data 2, expert 2 and fsdp 2:

Terminal window
XLA_FLAGS=--xla_force_host_platform_device_count=8 JAX_PLATFORMS=cpu python examples/moe_mesh.py --out runs/moe-mesh

On one accelerator, where the experts cannot be split, each device computes every expert:

Terminal window
python examples/moe_mesh.py --out runs/moe-mesh-gpu --expert 1 --fsdp 1 --dispatch global

The training text mixes three kinds of line: short English sentences, sums and assignments. Before every training step the script runs the step’s batch through the step’s parameters once more and reads the experts each token’s router picked. For each MoE layer it counts the slots each device sends to every other device, and predicts, by the exchange’s own rule, the most exchange rounds any expert group needs for them. The drawing reads the placement from the objects the run used: the device grid from the mesh, each device’s experts and kernel slice from the expert kernel’s sharding, each device’s rows from the sharding the layout gives the layer’s input, and the all-to-all operations the compiled training step’s program holds.

After training, dew.inference.serving.Server generates greedy continuations of eight prompts on the same mesh, with the model’s own dispatch. (dew.sampling.generate refuses the exchange dispatch until jax-ml/jax#40907 is fixed.)

Writes OUT/moe-mesh.json with every step’s traffic, and OUT/moe-mesh.svg, an animation with a frame every snapshot_every steps and a last frame that routes the generated text.

Source on GitHub

Send each request to the Laya checkpoint that can read it.

Laya ships an English checkpoint and a multilingual one in the same Hub repository. A deployment that serves both picks one per request: text in a non-Latin script, or Latin text with many letters English does not use, goes to the multilingual model, and everything else to the English one. This is a simplified version of Laya’s own router (laya/router.py). That router also reads stop words, so it catches Latin text with no accented letters at all, such as most Italian; it keeps the most recently used checkpoints resident; and it accepts a caller’s language code. A service that knows its users’ language should pass that instead of guessing.

Terminal window
python examples/route_decisions.py

Source on GitHub

Serve a decision model over HTTP, in TypeSafe Jev’s wire format.

Dew has no HTTP server of its own. Decide.systemone takes a Jev request body and returns a Jev response body, so serving it is a few lines of any web framework; this uses Starlette, which the serve extra installs with uvicorn:

Terminal window
uv pip install "dewml[serve] @ git+https://github.com/AshishKumar4/dew" \
--extra-index-url https://pypi.dewml.dev/simple
python examples/serve_decisions.py --model convaiinnovations/laya --port 8000
python examples/serve_decisions.py --run runs/tickets

--model loads a released Laya checkpoint (with --subfolder multilingual for the multilingual one) or a joint-head release, and --run a DecisionObjective run with the calibration saved into it. --dtype chooses the compute dtype (bfloat16 on a GPU), and --max-len, --head-max-len and --option-tokens widen the layout’s budgets. POST /v1/systemone takes what Jev’s endpoint takes and answers as it answers, so a client written for Jev only changes its base URL:

Terminal window
curl -s localhost:8000/v1/systemone -H 'content-type: application/json' -d '{
"state": "I was charged twice for March, fix it today.",
"questions": {"urgent": {"type": "noul", "instructions": "Is this urgent?"}}}'

A request Jev would refuse gets a 422 with the reason, as Jev’s does. With --api-key (or DEW_API_KEY) set, a request must carry Authorization: Bearer <key>, and gets a 401 without it. --details adds Laya’s extra answer fields (a noul’s confidence, abstention, how much of the state was read); --strict answers exactly as Jev’s endpoint does, dropping the request fields Jev does not know, such as images. --whole refuses, with a 422 naming the maximum context length, a request the layout could answer only by cutting its state, instructions or options, as Decision Index requires of an engine:

Terminal window
python examples/serve_decisions.py --run runs/encoder --whole --dtype bfloat16 \
--max-len 8192 --head-max-len 6144 --option-tokens 512
python -m decision_index pipeline --edition 0.2.1 --engine http \
--option base_url=http://127.0.0.1:8000 --out runs/di-encoder

The task is served by Dew’s serving engine (dew.inference.engine.Engine) as a scoring server (dew.inference.scoring.ScoringServer): concurrent requests are answered together, one forward pass a turn over the rows waiting, up to --batch-rows rows and --batch-tokens of their padded tokens a pass (the task’s Budget), each as it would be alone; a request Jev would refuse gets its own 422 and the others their answers. GET /health answers once the model is loaded.

Source on GitHub