Today we’re launching the Fastino Training API, a cost-efficient API for supervised fine-tuning and reinforcement learning with day-zero support for NVIDIA Nemotron 3.5 Super VL.

Until now, post-training large open weight models has largely been limited to teams able to build and operate specialized GPU infrastructure. The Fastino Training API makes this infrastructure available through an API without taking control of the research process away from users. Teams bring their training loops and data and define their rewards and evaluations, while our API handles model execution, sampling, gradient computation, weight updates, and checkpoints.

The Fastino Training API lets teams post-train large open weight models at per-token rates 25% to 50% below Tinker’s published rates. Our API is fully compatible with the Tinker SDK, so teams can easily bring their existing Tinker training and sampling code. In addition to NVIDIA Nemotron 3.5 Super VL, we also support Nemotron 3.5 Lightning.

Alongside the Training API, we’re releasing two open weight models fine-tuned on NVIDIA Nemotron 3.5 Super VL, specialized for finance and healthcare. Together, they improved performance across all 15 held-out benchmarks we measured.

Running RL Infrastructure is Hard

Post-training a large open model involves much more than choosing a dataset and a learning rate. A team also needs to provision GPUs, coordinate training and sampling, move updated weights between them, preserve checkpoints, and recover when a worker fails.

Reinforcement learning continuously generates training data from the model’s latest responses. Each step must generate rollouts, calculate rewards, update the model, and make the new weights available before sampling resumes. Ultimately, the training and generation stages of this loop place different demands on GPU memory and throughput. Training consumes memory for gradients and optimizer state, while generation needs capacity for parallel rollouts and KV cache, so teams often have to operate and synchronize separate systems.

The Fastino Training API resolves these issues by running the trainer and sampler in a single managed GPU container and letting the training loop publish updated weights for the next round of sampling. As a result, teams can now run sophisticated post-training workloads without hiring dedicated inference engineers or building the underlying systems themselves. This opens large-model SFT and RL to research and ML teams that previously lacked the infrastructure expertise to attempt it.

Fastino Training API: An API for Supervised Fine-Tuning and Reinforcement Learning

The Fastino Training API is a low-level post-training API for running customer-authored SFT and RL loops on hosted GPUs. It supports:

• Supervised fine-tuning: LoRA ranks from 1 to 32, cross-entropy loss, AdamW optimization, and gradient accumulation.

• Reinforcement learning: Grouped sampling with token log probabilities and training with importance sampling, PPO, CISPO, or DRO.

• Training and sampling primitives: Run forward-only evaluations, use seeded sampling and token log probabilities, and save or resume checkpoints containing the adapter and optimizer state.

Users provide their own prompts, datasets, environments, tools, reward functions, and evals and call the API from their own Python training loops, deciding when to sample, score outputs, update weights, evaluate the model, and save checkpoints. This allows users to maintain control over their post-training workflows without having to build or operate the underlying GPU infrastructure.

Lower Post-Training Costs with Per-Token Pricing

The Fastino Training API bills per token processed, rather than per GPU hour, meaning users are never charged for idle GPU time.

Users are billed separately for prompt tokens, generated output tokens, and tokens processed during training, plus storage for saved checkpoints. Reused prompt tokens cost less when the service can retrieve them from cache. Furthermore, a prompt used to generate several rollouts is only billed once, and shared training prefixes can be billed once on Nemotron and Qwen.

Our rates are significantly lower than Tinker’s across prefill, sampling, and training tokens for each supported model:

*Price per million tokens as of October 15, 2026

Full Tinker Compatibility for Easy Migration

For teams already using Tinker, moving to the Fastino Training API does not require translating the training loop into another framework. Our API is compatible with the official open-source Tinker SDK and cookbook, so existing SFT and RL recipes continue to use the same training and sampling clients.

Compatibility also covers the Tinker command-line tool, REST client, billing endpoints, and every route called by the Tinker SDK. The only parts of your existing code that need changing are the server address and API key. See our migration guide for more information.

Optimized for Post-Training NVIDIA Nemotron 3.5 Super VL

Nemotron 3.5 Super VL is a 120B-parameter vision-language model with hybrid Mamba-Transformer mixture-of-experts model with 12B active parameters. The Fastino Training API fine-tunes it using a 75.2M-parameter LoRA adapter, updating only 0.06% of the model’s parameters. 

Using an early access checkpoint and text-only inputs, we fine-tuned finance and healthcare adapters that improved all 15 held-out benchmarks we measured. Full domain runs took only between two and 5.5 hours.

Nemotron 3.5 Super VL proved highly responsive to post-training. Data and hyperparameters developed on the smaller Nemotron 3.5 Lightning model transferred unchanged across every benchmark we measured, meaning the larger model required no additional recipe search. For more information about our fine-tuned adapters, including benchmarks and lessons learned, see our Nemotron 3.5 Super VL fine-tuning report.

Use Cases

The Fastino Training API supports post-training workflows ranging from domain-specific supervised fine-tuning to reinforcement learning for coding and tool-using agents. Teams can train from labeled examples, executable tests, or task-completion rewards through the same API.

• Domain-specific Nemotron models. Fine-tune Nemotron on internal examples to teach domain terminology, response formats, or task-specific behavior.

• Coding agents trained with executable feedback. Improve coding agents on code generation, debugging, and repository-level tasks.

• Tool-use selection for agents. Train agents to select the right tools, sequence actions, and complete multi-turn workflows in support, research, or operations.

• Reasoning models trained with verifiable rewards. Improve performance on math, logic, or other tasks where answers can be checked automatically.

• Structured-output models. Fine-tune models to return valid JSON, follow schemas, or produce consistent formats for downstream systems.

• Distilled open weight models. Train supported models on outputs from a larger teacher model to reproduce selected task-specific behavior.

Availability

The Fastino Training API is available today. For information on pricing and getting started, please refer to our docs. For more information about the Nemotron 3.5 Super VL finance and healthcare specialized models, including benchmark results, training recipes, and links to their weights on Hugging Face, read our full technical report.