How Serverless Fine-Tuning works

Serverless fine-tuning adapts open models to your domain or task using LoRA-based supervised training, without provisioning or managing GPU infrastructure yourself. You provide a dataset, configure a job, and Crusoe handles scheduling, training, and checkpoint storage.

The fine-tuning lifecycle

Use the diagram below to understand the fine-tuning lifecycle and which steps of the lifecycle you're responsible for:

1. 1
   Upload a datasetYou

   Upload a JSONL file of chat-format conversations to the Files API. Each line is one training example.

2. 2
   Create a jobYou

   Reference the uploaded file's ID, pick a base model, and supply hyperparameters such as learning rate, number of epochs, and checkpoint frequency.

3. 3
   Schedule the jobCrusoe

   Crusoe queues the run, provisions GPUs, downloads the base model, and starts training. You don't pick a region, instance type, or GPU count.

4. 4
   Emit checkpointsCrusoe

   The trainer saves a LoRA adapter at the configured checkpoint interval and records training and validation loss for each evaluation pass.

5. 5
   Deploy the model with Self-Serve DeploymentsYou

   When the job succeeds, use the checkpoint ID to deploy your custom model through Self-Serve Deployments.

6. 6
   (Optional) Download checkpointsYou

   When the job succeeds, the job record lists every checkpoint's file ID. Download the one you want and serve it from your own inference stack.

Key use cases

• Domain adaptation: Teach a general-purpose model the vocabulary, tone, and conventions of a specific industry or product area, for example, legal, medical, or customer support
• Task-specific behavior: Train a model to follow a strict output format, such as always returning JSON, a classification label, or a structured report
• Latency and cost reduction: Distill a large model's behavior into a smaller, faster model for high-throughput or latency-sensitive production workloads
• Persona and tone alignment: Fine-tune a model to match a specific brand voice, communication style, or persona consistently across outputs
• Private data grounding: Incorporate proprietary knowledge that can't be shared with third-party model providers, keeping sensitive data on your own infrastructure

Key capabilities

• Fully serverless—with no instance lifecycle to manage. You pay for the job, not idle GPUs.
• Automated job queueing, scheduling, monitoring, and failure recovery
• OpenAI-compatible API surface for files, jobs, and checkpoints, so existing OpenAI fine-tuning code works with minimal changes.
• Automatic checkpointing during training, with downloadable LoRA adapters for each checkpoint.

What gets trained

Serverless fine-tuning trains a LoRA adapter, not the full base model. The base model's weights stay frozen, and the trainer learns a small set of low-rank matrices that modify the model's behavior. This keeps training fast and produces a compact adapter (tens or hundreds of megabytes) that you load on top of the original base model at inference time.

The trainer applies loss only to assistant turns in each conversation. User and system turns are masked, so the model learns what to produce, not what to consume.

Datasets and checkpoints

Datasets and checkpoints both live in the Files API and share the same lifecycle primitives:

Artifact	Created when	Format	Used for
Training dataset	You upload it	JSONL chat conversations	Input to a job
Validation dataset	You upload it (optional)	JSONL chat conversations	Evaluation during training
Checkpoint	The trainer emits it automatically	LoRA adapter archive	Downloading and serving models

If you don't supply a validation dataset, Crusoe holds out 10% of the training data automatically.

Each checkpoint is independently usable. After a run finishes you can compare validation loss across checkpoints and pick the one with the best fit for your task.

How serverless fine-tuning differs from VM-based training

Three things distinguish serverless fine-tuning from running a training job on a virtual machine (VM):

• No instance lifecycle: You don't have to request, monitor, or terminate GPUs. The platform handles provisioning and teardown.
• No persistent storage to manage: Datasets and checkpoints live in the Files API. You don't need to attach disks or mount object stores.
• Per-job billing: You pay for the training job, not for idle GPUs between jobs.

API access

The interface is OpenAI-compatible, so you can drive the service with the official openai Python client or with curl against the REST API.

• Base URL: https://api.intelligence.crusoecloud.com
• OpenAPI specification: https://api.intelligence.crusoecloud.com/docs

Next steps

Self-serve deployments: Run inference on your model after a fine-tuning job completes by deploying it with self-serve deployments.