> The full index of these docs is at [llms.txt](https://u22a8.ai/llms.txt).

# Reproducibility

The system fingerprint tells you when anything behind a verdict moved, and the model identifier reproduces a verdict.

*Applies to a8-1. Last reviewed 2026-10-22.*

The **system fingerprint** is the `system_fingerprint` value on every response. It covers everything that determines a verdict: your teaching and our software. It answers one question: has anything behind this verdict moved?

The fingerprint detects change, and the `model` identifier reproduces. Read the fingerprint to learn that something moved, and send the `model` back to get the earlier verdict.

## 1 What it is

The fingerprint names your model and the software that served it. It changes when a fit of your teaching completes, when we publish a new reference model for yours to build on and when we ship a correction to how A8 judges. Between those events, it stays the same from request to request.

Read it as an opaque token and compare it for equality. Its format is ours, and a new model generation can bring a new one.

```jsonc
// annotated, trimmed: the response fields this page is about
{
  "model": "a8-1-1:90@20260715t140322z", // the identifier that answered
  "system_fingerprint": "fit-1a2b3c4d5e6f7890.9e2a1b3c" // what served it
}
```

## 2 What a comparison tells you

| Compared with last time | It means                                                                                                                                |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| The same                | Everything that determines a verdict is as it was: your data and our software. A changed verdict means your input changed.              |
| Different               | Something moved: a fit landed, we published a new reference model or we shipped a correction. Re-check anything you hold as a baseline. |

*Table 1.* The two readings of a fingerprint comparison.

Under the same fingerprint, A8 is deterministic: the same request returns the same verdict. The fingerprint covers every input to a verdict except the request itself.

## 3 Reading a change

### 3.1 The model identifier reproduces

You read the fingerprint, and you send back the `model`. The `model` names the exact horizon that answered, and sending it back reproduces the verdict. A correction we ship is the one change that reaches a pinned horizon, and the fingerprint marks it. To store one value for reproducibility, store the `model`. See [Reproduce a verdict](#reproduce-a-verdict).

### 3.2 It moves with our releases

Most fingerprint changes are your own teaching landing. The rest are a new reference model, or a correction we ship. A correction reaches pinned callers too, because a pin holds what the model learned and the software that serves it stays current. A fingerprint that changes while your `model` identifier stays the same is our change. See [Model identifiers](https://u22a8.ai/docs/a8-model-identifiers.md).

### 3.3 A change means re-check

Every completed fit mints a new fingerprint, including a fit of teaching the model already agreed with. A changed fingerprint means re-check: a baseline that still passes stands.

### 3.4 It belongs to one organization

A fingerprint is scoped to the organization that owns the teaching, in one environment. Compare fingerprints within that scope.

## 4 Reproduce a verdict

Every response names the exact horizon that answered, with the minimum accuracy as its tag, including when the request asked for `a8`. Send that value back as `model`, and the request returns the same verdict. A pinned horizon answers from the reference model it was fitted over, so later releases move the alias and leave the pin where it was.

**curl**

```bash
curl https://api.u22a8.ai/eval/v1/chat/completions \
  -H "Authorization: Bearer $U22A8_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "a8-1-1@20260715t140322z",
    "messages": [
      {"role": "system", "content": "Does the reply promise a refund?"},
      {"role": "user", "content": "We will refund you in full by Friday."}
    ]
  }'
```

**Python**

```python
import os

from openai import OpenAI

client = OpenAI(
    base_url="https://api.u22a8.ai/eval/v1",
    api_key=os.environ["U22A8_API_KEY"],
)

messages = [
    {"role": "system", "content": "Does the reply promise a refund?"},
    {"role": "user", "content": "We will refund you in full by Friday."},
]

first = client.chat.completions.create(model="a8", messages=messages)

# later: the identifier that answered brings the same verdict back
again = client.chat.completions.create(model=first.model, messages=messages)
assert again.choices[0].message.content == first.choices[0].message.content
```

**TypeScript**

```typescript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.u22a8.ai/eval/v1",
  apiKey: process.env.U22A8_API_KEY,
});

const messages = [
  { role: "system" as const, content: "Does the reply promise a refund?" },
  { role: "user" as const, content: "We will refund you in full by Friday." },
];

const first = await client.chat.completions.create({
  model: "a8",
  messages,
});

// later: the identifier that answered brings the same verdict back
const again = await client.chat.completions.create({
  model: first.model,
  messages,
});
const same =
  again.choices[0].message.content === first.choices[0].message.content;
console.log(same); // true
```

A stored result carries its own provenance when you keep the response’s `model` beside the verdict. The fingerprint tells you the alias has moved on since, and the `model` takes you back. See [Horizons](https://u22a8.ai/docs/a8-horizons.md).

## 5 Practical patterns

| You want to                                     | Use                                                                             |
| ----------------------------------------------- | ------------------------------------------------------------------------------- |
| Cache verdicts and know when to empty the cache | Key the cache on `system_fingerprint`. A new fingerprint empties it.            |
| Detect that your model moved between two runs   | Compare the two runs’ fingerprints                                              |
| Publish a number someone can re-derive          | Record the response’s `model` beside the number                                 |
| Run a regression suite against a fixed model    | Pin a horizon, and move the pin on your schedule                                |
| Know when your teaching is being served         | Watch the fingerprint change, or the new horizon turn `active` in `GET /models` |

*Table 2.* The fingerprint is a signal and the pin is a control.

> **One sentence to remember.** The fingerprint tells you the ground moved, and the `model` identifier takes you back to where it stood.

## 6 Related concepts

- [Horizons](https://u22a8.ai/docs/a8-horizons.md): pinning, and the models list
- [Teaching](https://u22a8.ai/docs/a8-teaching.md): the usual reason a fingerprint changes
- [Testing](https://u22a8.ai/docs/a8-testing.md): checking that a change did what you meant

## Next steps

- [Horizons](https://u22a8.ai/docs/a8-horizons.md): A horizon is the timestamp that names a fitted version of your model, and pinning one holds its verdicts still.
- [Testing A8](https://u22a8.ai/docs/a8-testing.md): Test what A8 learned the way you would test a student, with new questions, known answers, accuracy and coverage, on a pinned version.
- [API overview](https://u22a8.ai/docs/api-overview.md): What every request to A8 shares, from the base URL and authentication to the request parts and the response fields.