# What is measured

> Input, output, cached and reasoning tokens per call, agent, run and team, in the provider's own currency.

Every figure in this section is built from one record: the **model call**, sent by your gateway for every call it makes. Nothing is sampled.

## One model call

| Field                                         | What it is                                                                                                 |
| --------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| `input_tokens`                                | Input tokens **not** read from the cache                                                                   |
| `cache_read_tokens`                           | Input tokens read from the prompt cache                                                                    |
| `cache_write_tokens`, `cache_write_1h_tokens` | Input tokens written to the cache; the second is the one-hour share where the provider reports it          |
| `output_tokens`                               | Output tokens, including any reasoning tokens the provider bills as output                                 |
| `cost_usd`                                    | What the call cost, on your deployment’s price card                                                        |
| `estimated`                                   | `true` where the cost was worked out from the price card rather than reported with a price by the provider |
| `model`, `backend`                            | The model, and the platform that served it (for example Bedrock in the EU)                                 |
| `pack`, `task`, `agent`, `run_id_hash`        | Which agent, task and run the call belongs to                                                              |
| `latency_ms`, `paced_ms`, `throttled`         | How long it took, how long it waited for a rate limit, and whether the provider throttled it               |
| `outcome`, `reason`                           | `ok`, `refused` or `error`, with a fixed reason code                                                       |

All input is the sum of the first three: uncached input, cache reads and cache writes. The same convention runs through every page and every API read.

No prompt, answer or document text is in the record. See [the telemetry contract](/concepts/telemetry-contract/).

### Reasoning tokens

A thinking model’s reasoning tokens are billed as output, and are counted in `output_tokens` and its cost. They are measured **separately** by [the Token Value Benchmark](/cost/token-value-benchmark/), which reports input, output, cached and reasoning tokens per task as four figures. A separate reasoning count on every model call: \[Coming]

### Currency

Model costs are recorded in US dollars today. Every read also carries each money figure in your display currency (`*_money`), converted at the European Central Bank’s rate for that amount’s own day, and never adds two currencies’ raw amounts together. Set the display currency in **Settings → Preferences** for yourself, or for the whole tenant in **Settings → Organisation**.

The benchmark records each result in the provider’s own currency (`currency` and `cost_native`) beside its dollar figure. Carrying a provider’s own currency through on every model call: \[Coming]

## Grouped the way you need it

| Grouping                                               | Read                                                                                                                   |
| ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------- |
| Per call                                               | Each `model_call` record, in your tenant’s [export](/data-sovereignty/leaving/#export)                                 |
| Per run                                                | `GET /api/v1/runs/{run_id_hash}` and its run map: tokens and cost of every step                                        |
| Per agent                                              | `GET /api/v1/billing/usage?group_by=agent`, and the agent’s own page                                                   |
| Per pack                                               | `GET /api/v1/usage?group_by=pack`. A pack is a department’s set of agents, which is how most clients see spend by team |
| Per model, task or day                                 | `GET /api/v1/usage?group_by=model` (or `task`, or `day`)                                                               |
| Per connection                                         | `GET /api/v1/billing/usage?group_by=connection`: each provider connection, direct or through Atlantic                  |
| Caching, by model, agent, pack, deployment or provider | `GET /api/v1/caching`                                                                                                  |

**curl**

```bash
# Tokens and cost by pack for October
curl "https://$AAL_TENANT.atlanticagenticlabs.com/api/v1/usage?since=2026-10-01&until=2026-10-31&group_by=pack" \
  -H "Authorization: Bearer $AAL_KEY" \
  -H "CF-Access-Client-Id: $CF_ACCESS_CLIENT_ID" \
  -H "CF-Access-Client-Secret: $CF_ACCESS_CLIENT_SECRET"
```

**Python**

```python
import os

import httpx

headers = {
    "Authorization": f"Bearer {os.environ['AAL_KEY']}",
    "CF-Access-Client-Id": os.environ["CF_ACCESS_CLIENT_ID"],
    "CF-Access-Client-Secret": os.environ["CF_ACCESS_CLIENT_SECRET"],
}
r = httpx.get(
    f"https://{os.environ['AAL_TENANT']}.atlanticagenticlabs.com/api/v1/usage",
    params={"since": "2026-10-01", "until": "2026-10-31", "group_by": "pack"},
    headers=headers,
)
r.raise_for_status()
print(r.json())
```

**TypeScript**

```ts
const q = new URLSearchParams({ since: "2026-10-01", until: "2026-10-31", group_by: "pack" });
const res = await fetch(`https://${process.env.AAL_TENANT}.atlanticagenticlabs.com/api/v1/usage?${q}`, {
  headers: {
    Authorization: `Bearer ${process.env.AAL_KEY}`,
    "CF-Access-Client-Id": process.env.CF_ACCESS_CLIENT_ID!,
    "CF-Access-Client-Secret": process.env.CF_ACCESS_CLIENT_SECRET!,
  },
});
console.log(await res.json());
```

Each group carries `calls`, `input_tokens`, `cache_read_tokens`, `cache_write_tokens`, `output_tokens`, `cost_usd`, `estimated_calls`, `refused` and `errors`. See the [Usage reference](/api/reference/read/#usage).

Spend is not broken out per person: a model call carries no person, and a person appears elsewhere in telemetry only as a keyed hash. Per-person **limits** do exist; see [Limits and alerts](/operations/limits-and-alerts/).

## Checked against the provider’s bill

The gateway’s figure is what your software reported. Where LightHouse can read the provider’s own figure (AWS Cost Explorer for Bedrock, Anthropic’s cost report for the Claude API), **Spend → Reconciliation** shows both per day and connection, and the difference, without smoothing it. `GET /api/v1/billing/reconciliation?month=YYYY-MM`.

Source: https://docs.atlanticagenticlabs.com/cost/what-is-measured/