Training API quickstart

This quickstart covers both Training API paths. Use managed training when you want Fastino to run the loop. Use a custom training loop when your application must control sampling, rewards, and model updates.

1. Authenticate

Create a Fastino account.
Open API keys.
Create a key and copy it when shown.

Store the key in an environment variable:

export FASTINO_API_KEY="fast_sk_..."

$env:FASTINO_API_KEY = "fast_sk_..."

Send this key as X-API-Key: $FASTINO_API_KEY. See Authentication for the complete authentication contract.

2. Choose a path

Goal	Path
Provide data and configuration, then let Fastino run training	Managed training
Control sampling, rewards, and updates in your application	Custom training loop

Managed training

3. Prepare a dataset

Upload and process a training dataset, then wait until its version is ready.

4. Choose a model

Query the live catalog before submission:

curl "https://api.fastino.ai/v1/base-models?supports_training=true" \
  -H "X-API-Key: $FASTINO_API_KEY"

Save the selected model ID.

5. Create the job

curl -X POST "https://api.fastino.ai/v1/training/jobs" \
  -H "X-API-Key: $FASTINO_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "model_name": "my-trained-model",
    "base_model": "MODEL_ID_FROM_CATALOG",
    "datasets": [
      {"name": "my-ready-dataset", "version": "VERSION_NUMBER"}
    ],
    "training_type": "lora"
  }'

Save the returned id. It is the job_id used by every job-specific route. Reuse the same Idempotency-Key only when retrying this exact create request.

6. Poll the job

curl "https://api.fastino.ai/v1/training/jobs/JOB_ID" \
  -H "X-API-Key: $FASTINO_API_KEY"

For config jobs:

status is the persisted lifecycle value, such as errored.
normalized_status is the stable polling value, such as failed.
is_terminal_status tells your client when to stop polling.
error_message describes a failure when available.

Continue until is_terminal_status is true, then inspect the final status, checkpoints, logs, and deployment eligibility.

Custom training loop

Custom training loops require team access and Python 3.11 or later. The supported SDK client talks to Fastino’s hidden HTTP compatibility adapter. Use the client methods below. Do not construct adapter requests.

3. Install the tested client

uv init fastino-training
cd fastino-training
uv add "tinker==0.33.1"

mkdir fastino-training && cd fastino-training
python -m venv .venv
source .venv/bin/activate
pip install "tinker==0.33.1"

mkdir fastino-training
cd fastino-training
py -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install "tinker==0.33.1"

4. Configure the client

TINKER_CREDENTIAL_CMD runs for every token request and must print one nonempty credential.

export TINKER_BASE_URL="https://api.fastino.ai/v1/training/compat/tinker"
export TINKER_CREDENTIAL_CMD='printf "%s\n" "$FASTINO_API_KEY"'

$env:TINKER_BASE_URL = "https://api.fastino.ai/v1/training/compat/tinker"
$env:TINKER_CREDENTIAL_CMD = 'powershell -NoProfile -Command "[Console]::Out.WriteLine($env:FASTINO_API_KEY)"'

Use a normal Fastino key beginning with fast_sk_. Credentials beginning with tml- are rejected. Do not set TINKER_API_KEY.

5. Choose an enabled model

Call ServiceClient.get_server_capabilities() and select a model and LoRA rank from its response:

export FASTINO_TRAINING_MODEL="<model from capabilities>"
export FASTINO_TRAINING_LORA_RANK="<supported rank>"

$env:FASTINO_TRAINING_MODEL = "<model from capabilities>"
$env:FASTINO_TRAINING_LORA_RANK = "<supported rank>"

6. Create the job and sample

Create quickstart.py:

import os

import tinker


service_client = tinker.ServiceClient()
outcome = "errored"
try:
    capabilities = service_client.get_server_capabilities()
    print(capabilities)

    training_client = service_client.create_lora_training_client(
        base_model=os.environ["FASTINO_TRAINING_MODEL"],
        rank=int(os.environ["FASTINO_TRAINING_LORA_RANK"]),
    )

    job_id = training_client.get_info().model_data.model_id
    print(f"TRAINING_JOB_ID={job_id}")

    checkpoint = training_client.save_weights_for_sampler(
        "quickstart-sampler"
    ).result()
    sampling_client = service_client.create_sampling_client(
        model_path=checkpoint.path
    )

    tokenizer = sampling_client.get_tokenizer()
    prompt_tokens = tokenizer.apply_chat_template(
        conversation=[
            {
                "role": "user",
                "content": "Explain the purpose of a reward function in one sentence.",
            }
        ],
        add_generation_prompt=True,
        return_dict=False,
    )
    result = sampling_client.sample(
        prompt=tinker.types.ModelInput.from_ints(prompt_tokens),
        num_samples=1,
        sampling_params=tinker.types.SamplingParams(max_tokens=64),
    ).result()

    print(tokenizer.decode(result.sequences[0].tokens))
except KeyboardInterrupt:
    outcome = "interrupted"
    raise
else:
    outcome = "success"
finally:
    service_client.close(outcome).result()

Run the script:

python quickstart.py

Copy the value printed after TRAINING_JOB_ID=.

7. Verify the canonical job

export TRAINING_JOB_ID="<ID printed by quickstart.py>"
curl --fail-with-body \
  -H "X-API-Key: $FASTINO_API_KEY" \
  "https://api.fastino.ai/v1/training/jobs/$TRAINING_JOB_ID"

$env:TRAINING_JOB_ID = "<ID printed by quickstart.py>"
Invoke-RestMethod `
  -Headers @{ "X-API-Key" = "$env:FASTINO_API_KEY" } `
  -Uri "https://api.fastino.ai/v1/training/jobs/$env:TRAINING_JOB_ID"

The response describes the same job created by create_lora_training_client(...). Continue with the SDK client for model operations and use the canonical jobs API for documented job reads.

Continue

Datasets

Prepare and validate training data.

Jobs reference

Review the complete request and response contract.

Training loop

Add rewards, updates, and recovery to a custom loop.

Get Started

Decision Models

Entity & Classification

Training API

Inference API

Troubleshooting

SDK Integrations

Models

Account

1. Authenticate

2. Choose a path

Managed training

3. Prepare a dataset

4. Choose a model

5. Create the job

6. Poll the job

Custom training loop

3. Install the tested client

4. Configure the client

5. Choose an enabled model

6. Create the job and sample

7. Verify the canonical job

Continue

Datasets

Jobs reference

Training loop

​1. Authenticate

​2. Choose a path

​Managed training

​3. Prepare a dataset

​4. Choose a model

​5. Create the job

​6. Poll the job

​Custom training loop

​3. Install the tested client

​4. Configure the client

​5. Choose an enabled model

​6. Create the job and sample

​7. Verify the canonical job

​Continue

Datasets

Jobs reference

Training loop

1. Authenticate

2. Choose a path

Managed training

3. Prepare a dataset

4. Choose a model

5. Create the job

6. Poll the job

Custom training loop

3. Install the tested client

4. Configure the client

5. Choose an enabled model

6. Create the job and sample

7. Verify the canonical job

Continue