---
title: "Read model call timings"
description: "Distinguish time waiting for capacity from time spent at the model. Older calls can lack measurements."
canonical_url: "https://docs.oz0.ai/spend/cost-and-usage/timings"
---
# Read model call timings

> Distinguish time waiting for capacity from time spent at the model. Older calls can lack measurements.

For: tenant administrators and cost owners.

Distinguish time waiting for capacity from time spent at the model. Older calls can lack measurements.

## How fast each call was

Every model call records how long it waited and how fast the model answered, next to its tokens. The gateway measures calls through the edge, and a node measures calls to its own model servers, each on its own clock; nothing is ordered by these times.

<table>
<thead>
  <tr>
    <th>
      Figure
    </th>
    
    <th>
      What it is
    </th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>
      Queued
    </td>
    
    <td>
      From the call's arrival to its upstream send: on the edge the caller's check, the budgets' reservation and a pool's moves to another member; on a node the edge's admission and the wait for a free slot on the model server. A busy machine queues; a slow one does not
    </td>
  </tr>
  
  <tr>
    <td>
      First token
    </td>
    
    <td>
      From the upstream send to the stream's first output: the first content, reasoning or tool-call delta (see below). Only streamed calls have one
    </td>
  </tr>
  
  <tr>
    <td>
      Prompt
    </td>
    
    <td>
      The prompt's processing time and its tokens per second: the server's own figures where it reports them, else the time to first token and the prompt tokens processed over it (cache reads left out)
    </td>
  </tr>
  
  <tr>
    <td>
      Decode
    </td>
    
    <td>
      The generation's time and its output tokens per second: the server's own figures where it reports them, else the time from the first output to the last, over the tokens after the first
    </td>
  </tr>
</tbody>
</table>

A figure a call did not measure is unknown, never 0: an unstreamed call has no first token, and has a prompt and decode speed only when its server reports its own. Replayed answers of the test bench and calls before this release carry none. Where the figures come from shows as *the model server's own figures* (llama.cpp's `timings`, and recent Ollama releases' on streamed chat completions) or *measured from the stream*.

The first output event, by format:

<table>
<thead>
  <tr>
    <th>
      Format
    </th>
    
    <th>
      First output
    </th>
    
    <th>
      Never counted
    </th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>
      Anthropic Messages (and Bedrock's, Vertex's)
    </td>
    
    <td>
      <code>
        content_block_delta
      </code>
      
      : text, thinking or a tool's input JSON
    </td>
    
    <td>
      <code>
        message_start
      </code>
      
      , <code>
        ping
      </code>
      
      , <code>
        content_block_start
      </code>
      
      , a thinking block's <code>
        signature_delta
      </code>
      
      , <code>
        message_delta
      </code>
    </td>
  </tr>
  
  <tr>
    <td>
      OpenAI chat completions
    </td>
    
    <td>
      a chunk whose <code>
        delta
      </code>
      
       has <code>
        content
      </code>
      
      , <code>
        reasoning_content
      </code>
      
       or <code>
        reasoning
      </code>
      
      , <code>
        refusal
      </code>
      
       or <code>
        tool_calls
      </code>
    </td>
    
    <td>
      the role-only first chunk, a <code>
        null
      </code>
      
       or empty content, the usage chunk, <code>
        [DONE]
      </code>
    </td>
  </tr>
  
  <tr>
    <td>
      OpenAI Responses
    </td>
    
    <td>
      an event whose type ends in <code>
        .delta
      </code>
      
      , such as <code>
        response.output_text.delta
      </code>
      
      , <code>
        response.reasoning_text.delta
      </code>
      
       or <code>
        response.function_call_arguments.delta
      </code>
    </td>
    
    <td>
      <code>
        response.created
      </code>
      
      , <code>
        response.in_progress
      </code>
      
      , <code>
        response.output_item.added
      </code>
      
      , <code>
        response.completed
      </code>
    </td>
  </tr>
  
  <tr>
    <td>
      Google generateContent
    </td>
    
    <td>
      a response with a part that has text or a function call
    </td>
    
    <td>
      an event with empty parts, the usage-only last one
    </td>
  </tr>
</tbody>
</table>

Where you see them:

- `oz0 job trace <job>` lists each model step's last successful call under Model timings, and each call when a step took more than one; the console's trace shows them in the step's details.
- `oz0 usage` ends with a Speed, by model block: the means over the period's calls that measured each figure, per model, and per node for a node's own model servers. `oz0 usage --json` has them on each total (`timedCalls` and `firstTokenMs`, `prefillCalls` and `prefillTps`, `decodeCalls` and `decodeTps`, `queuedCalls` and `queueMs`). The console's *Cost* page shows them under Speed by model.
- Prometheus gets [histograms](https://docs.oz0.ai/fleet/observability#metrics) of the first token, the decode speed and the queue.

They are figures per model and machine: none is cut by person or team. The [usage export](https://docs.oz0.ai/spend/cost-and-usage/exports#usage-export) leaves them out, and so does the gateway's signed record of each call: they are measurements, not what was charged.


## Sitemap

See the full [sitemap](https://docs.oz0.ai/sitemap.md) for all pages.