Skip to main content
A post-training run reports in three places:
  • Together AI console: Shows each session’s status, step, and checkpoints, and what its model resource costs.
  • Service-emitted metrics: Measure the health of each update. In a group relative policy optimization (GRPO) run, every forward_backward call returns them.
  • Cookbook logs: Record every step of a cookbook recipe in a run directory and, when the config sets wandb_project, in Weights & Biases.
The console and the service-emitted metrics work with any training loop, not only cookbook recipes. This page covers what the console shows and how to read the metrics of supervised fine-tuning (SFT), direct preference optimization (DPO), and GRPO runs.

Watch a run in the console

To follow a run, open its session on the Training sessions tab under Post-Training: The session’s page shows:
  • Status: The session’s lifecycle state. If the session fails, a banner at the top of the page shows the error the service reported.
  • Step: The session’s current step, under Details. The same section lists the session’s base model, model resource, and low-rank adapter (LoRA) settings. For a resumed run, Resumed from gives the ID of the checkpoint it started from.
  • Checkpoints: The Inference checkpoints and Training checkpoints tables fill in as the run saves checkpoints, newest first. Each row shows the checkpoint’s step and the IDs you deploy or resume with.
  • Weights & Biases: The project, group, and run name the session reports to. The page links to the run only when the session’s metadata includes the run’s ID or URL, which cookbook recipes don’t send.
To see the cost, select the Model resource ID under Details. The model resource’s page shows:
  • Status: The resource’s lifecycle state. If the resource fails, a banner shows the error.
  • Rate and cost: Rate is the estimated hourly price. Cost so far is an estimate counted from when the resource was created. It includes any time the resource spent waiting for GPUs, which isn’t billed, so it can run ahead of your bill. Once the resource stops, Total cost replaces it.
  • Training sessions: The sessions attached to the resource.
You can also create or stop a resource from the console.

What to watch first

SFT metrics

Each step, the SFT recipe logs:

DPO metrics

Each step, the DPO recipe logs loss, which should trend down, and pairs, the number of preference pairs the step trained on. Every val_interval steps, it also runs validation and logs:

GRPO metrics

Any training loop receives the service-emitted metrics, because the service returns them. Cookbook recipes compute every other metric in this section. If you write your own loop, compute the equivalents yourself.

Service-emitted metrics

Every forward_backward call with LOSS_TYPE_GRPO returns these metrics in its metrics dict. They measure the health of the update itself. Cookbook recipes log them with the fb/ prefix the table shows. In your own loop, the keys have no prefix, as in loss/ratio/mean. loss itself is a poor progress signal for GRPO. It can be flat, slightly negative, or non-monotonic while reward improves. Watch reward and accuracy for progress, and these metrics for stability.

Cookbook metrics

The cookbook computes these after sampling and scoring.

Dynamic sampling metrics

The cookbook logs these metrics when max_sampling_attempts is above 1, which turns on dynamic sampling. Runs that use async collection don’t log them.

Validation metrics

Every validation_interval steps, the cookbook samples the validation set greedily and logs:
  • Single-turn runs: val/accuracy, val/reward_mean, and val/mean_response_length.
  • Multi-turn runs: Per-episode equivalents such as val/reward_mean, val/num_turns_mean, and val/terminated_ratio.
val/accuracy is the headline metric. It should rise and then plateau. Two patterns signal a problem:
  • Reward hacking: Validation accuracy falls while training reward keeps rising.
  • Length runaway: val/mean_response_length drifts upward, even when reward looks fine.

Multi-turn metrics

Multi-turn GRPO replaces per-completion metrics with per-episode ones: num_turns_mean, terminated_ratio (episodes that ended on task logic), truncated_ratio (episodes cut short by the turn limit, context overflow, a parse failure, or the environment), parse_failure_ratio, and context_overflow_ratio. Two patterns point to specific fixes:
  • Low terminated_ratio with high truncated_ratio: Episodes run out of turns or context before finishing. Raise max_turns or max_model_length, or simplify the task.
  • Rising parse_failure_ratio: The model is emitting malformed tool calls. Check the system prompt and tool schemas.

Async collection metrics

The cookbook logs these metrics every step when max_steps_off_policy is set, which turns on async collection. They show whether async collection keeps the generators busy or discards most of its rollouts. To see which policy version the trainer and the generators are on, read policy_state from session.retrieve():
  • trainer_step: The version the last optimizer step produced.
  • target_weights_version: The version the latest weights_sync promised the generators.
  • applied_weights_version: The version the generators are serving.

Next steps

Reinforcement learning with GRPO

The service-emitted metrics and fixes for common GRPO problems.

Tune a GRPO recipe

The settings that the GRPO metrics point you toward.

Pricing

Turn timing/step_total_s into a cost estimate.

Manage checkpoints

Save the run once the metrics look right.