---
title: "Pins and Receipts (Keeping Your Setup Stable)"
description: "Why the model name you send is not a promise: aliases resolve at request time and move, hosted limits shift, aggregators fall back, a platform router changes who answers. Pin the versioned build and log a receipt from every call, across every venue, on one wire contract."
license: "© 2026 Peripatos · free to read; quoting with credit welcome, reuse by permission. Unofficial educational resource; Jev and TypeSafe are trademarks of TypeSafe AI."
published-date: 2026-10-04
verified-date: 2026-10-04
source: "https://peripatos.dev/courses/jev-fundamentals/s01e04-pins-and-receipts/"
---

*Level L2 (intermediate) · prerequisites: S01E02, S01E03 · ~20 min · verified 2026-10-04 · Tags: jev, pinning, receipts, portability, routing*

A judge pipeline has a property no other service has: you cannot control what served. Remember the expense-report judge from S01E02, the one that approves or routes expense lines under thresholds you tuned against one build. If the platform answers with a different model, that judge keeps saying compliant, and you may be waving policy violations through: the name you send is not a promise, it is a request. This lesson covers what can change under that name: aliases that resolve at request time, limits that move with platform load, aggregators and gateways that may answer with a different model than the one you named. The habit that answers all of it has two halves: **pin** the versioned build, and log a **receipt** from every call. By the end you can pin a judge, verify what actually served every request, and carry both across venues without rewriting the request.

## In this lesson

1. [Aliases move: the name you send is not the model you get](#whypin)
2. [Pin and echo: the receipt habit](#receipt)
3. [The page moves under your feet: dynamic limits](#limits)
4. [Same name, different counter: aggregator providers](#aggregators)
5. [Portability: one wire contract, new counters](#portability)
6. [The platform grew a router](#router)
7. [Verification is becoming infrastructure](#infrastructure)
8. [The habit in six rules](#rules)
9. [Knowledge check](#knowledge-check)
10. [Sources & further reading](#sources)

## Aliases move: the name you send is not the model you get

An **alias** is a model name the server resolves to a concrete build at request time. A **versioned ID** names one build. The vendor's alias table lists `jev-latest` and `jev-preview`, both currently resolving to `jev-1.13.0`, and it states the mechanism in its own words: "an alias moves when a new release ships, so the answers behind it can change without a change on your side" ([TypeSafe AI docs](https://docs.typesafe.ai/models)).

A model name can carry two different contracts. An alias is a pointer: `jev-latest` names _whatever the vendor currently prefers_, and the vendor repoints that pointer whenever a release ships, so the answers behind it can change with no change on your side. A versioned ID names one build, and only that build. One of the two names is your floor: with the alias, your code stands on a pointer the vendor moves at release time; with the versioned ID, the build only changes when you change it. And the vendor's ID answers "which build did I send" in one direction only: nothing your code can compute proves what answered, which is exactly why the verifying half lives in the response, not in your math.

The vendor's pinning advice reads exactly parallel: "if you have tuned confidence thresholds against a specific version, pin that version's ID instead of the alias and move to the new one on your own schedule." The reason is S01E03's: a threshold and a sweep are facts about the build that produced the scores. Applied silently to a newer build, the operating point stops matching reality, and nothing in your repo changes to tell you.

## Pin and echo: the receipt habit

Pinning is the request half: the `model` field carries the versioned ID, so the request names the build you want. The echo is the verification half: the response's `model` field "reports the versioned ID that answered, so you can log which model produced each result."

> 🏷️ New term: **receipt** [glossary](/courses/jev-fundamentals/glossary/)
> The run's own record of what actually served it: the log line beside every answer, carrying the versioned model ID from the response's model field, the run's timestamp, and any routing metadata the venue exposes when present. Comparisons are valid only between runs whose receipts agree.

The expense judge S01E02 built answers under the same keys, and the receipt's raw evidence sits beside them:

```
{
  "answers": {
    "receipt_referenced": 0.86,
    "within_cap": 0.93,
    "lane": { "value": "auto_approve", "confidence": 0.71,
              "probabilities": { "auto_approve": 0.71, "manager_review": 0.21,
                                 "finance_audit": 0.05, "other": 0.03 } },
    "policy_risk": { "value": 1.5, "confidence": 0.44,
                     "probabilities": [0.08, 0.44, 0.41, 0.07] }
  },
  "usage": {"input_tokens": 412},
  "model": "jev-1.13.0"
}
```

The request could have carried the alias `jev-latest`; the `model` field answers with the build that actually served. Whatever sits between your code and the weights, this field is where the serving truth lives; the next sections walk the places that can move it.

Log the receipt beside every answer, and compare only runs whose receipts agree. That rule earns its place because every measurement in this course is a comparison between runs: S01E02's repeat-run flip counts, S01E03's reliability curve and Brier score; none of them means anything unless one build produced both sides. A logged receipt is what makes that checkable after the fact, and it is one line of code.

<svg viewBox="0 0 640 528" style="width:100%;max-width:640px;height:auto;margin:0 auto;display:block;" aria-label="One request flows top to bottom: your code sends the pinned versioned build to one of three possible venues (hosted API, aggregator, gateway or router), the reply comes back with the model field that actually served; an assert gate checks model equals pin: on match the echo is written as one line in the receipt log beside every answer; on mismatch the response is routed like a torn answer and the pin is re-checked" xmlns="http://www.w3.org/2000/svg"> <style> .pi-bg { fill: var(--surface, #fff); } .pi-text { fill: var(--ink, #111); font-family: var(--font-ui, sans-serif); font-size: 13px; } .pi-mono { fill: var(--ink, #111); font-family: var(--font-mono, monospace); font-size: 12px; } .pi-small { fill: var(--ink-muted, #666); font-family: var(--font-ui, sans-serif); font-size: 12px; } .pi-label { fill: var(--ink-muted, #666); font-family: var(--font-ui, sans-serif); font-size: 10.5px; } .pi-box { fill: var(--surface, #fff); stroke: var(--border, #999); stroke-width: 1.5; } .pi-accentbox { fill: var(--accent, #0066cc); fill-opacity: 0.10; stroke: var(--accent, #0066cc); stroke-width: 1.5; } .pi-gate { fill: var(--surface, #fff); stroke: var(--accent, #0066cc); stroke-width: 1.5; stroke-dasharray: 5 4; } .pi-lane { fill: var(--accent, #0066cc); fill-opacity: 0.06; stroke: var(--accent, #0066cc); stroke-width: 1.5; stroke-dasharray: 6 4; } .pi-arrow { stroke: var(--ink-muted, #666); stroke-width: 1.5; fill: none; marker-end: url(#pi-arrowhead); } .pi-plain { stroke: var(--ink-muted, #666); stroke-width: 1.5; fill: none; } .pi-drop { stroke: var(--ink-muted, #666); stroke-width: 1.5; fill: none; stroke-dasharray: 5 4; marker-end: url(#pi-arrowhead); } .pi-arrowhead { fill: var(--ink-muted, #666); } </style> <defs> <marker id="pi-arrowhead" viewBox="0 0 10 6" refX="10" refY="3" markerWidth="10" markerHeight="6" orient="auto"> <polygon points="0 0, 10 3, 0 6" fill="#666" class="pi-arrowhead"></polygon> </marker> </defs> <rect x="0" y="0" width="640" height="528" rx="8" class="pi-bg" fill="#fff"></rect> <rect x="160" y="8" width="320" height="104" rx="6" class="pi-box" fill="#fff" stroke="#999"></rect> <rect x="16" y="150" width="186" height="56" rx="6" class="pi-box" fill="#fff" stroke="#999"></rect> <rect x="227" y="150" width="186" height="56" rx="6" class="pi-box" fill="#fff" stroke="#999"></rect> <rect x="438" y="150" width="186" height="56" rx="6" class="pi-box" fill="#fff" stroke="#999"></rect> <rect x="170" y="254" width="300" height="96" rx="6" class="pi-accentbox" fill="#0066cc" fill-opacity="0.10" stroke="#0066cc"></rect> <rect x="240" y="378" width="160" height="44" rx="6" class="pi-gate" fill="#fff" stroke="#0066cc"></rect> <rect x="12" y="466" width="616" height="48" rx="6" class="pi-lane" fill="#0066cc" fill-opacity="0.06" stroke="#0066cc"></rect> <line x1="320" y1="112" x2="320" y2="146" class="pi-arrow" stroke="#666" fill="none"></line> <line x1="109" y1="206" x2="109" y2="230" class="pi-plain" stroke="#666" fill="none"></line> <line x1="320" y1="206" x2="320" y2="230" class="pi-plain" stroke="#666" fill="none"></line> <line x1="531" y1="206" x2="531" y2="230" class="pi-plain" stroke="#666" fill="none"></line> <line x1="109" y1="234" x2="531" y2="234" class="pi-plain" stroke="#666" fill="none"></line> <line x1="320" y1="234" x2="320" y2="250" class="pi-arrow" stroke="#666" fill="none"></line> <line x1="320" y1="350" x2="320" y2="374" class="pi-drop" stroke="#666" fill="none"></line> <line x1="320" y1="422" x2="320" y2="458" class="pi-drop" stroke="#666" fill="none"></line> <line x1="400" y1="400" x2="614" y2="400" class="pi-drop" stroke="#666" fill="none"></line> <text x="320" y="30" text-anchor="middle" class="pi-text" fill="#111" font-weight="700">YOUR CODE</text> <text x="180" y="56" class="pi-mono" fill="#111">model: "jev-1.13.0"</text> <text x="180" y="78" class="pi-small" fill="#666">the pin: one versioned ID, not the alias</text> <text x="180" y="100" class="pi-mono" fill="#111">POST /v1/systemone</text> <text x="109" y="174" text-anchor="middle" class="pi-text" fill="#111" font-weight="700">hosted API</text> <text x="109" y="192" text-anchor="middle" class="pi-small" fill="#666">limits adjust dynamically</text> <text x="320" y="174" text-anchor="middle" class="pi-text" fill="#111" font-weight="700">aggregator</text> <text x="320" y="192" text-anchor="middle" class="pi-small" fill="#666">load balance + fallbacks</text> <text x="531" y="174" text-anchor="middle" class="pi-text" fill="#111" font-weight="700">gateway / router</text> <text x="531" y="192" text-anchor="middle" class="pi-small" fill="#666">evaluation fallback, lists</text> <text x="320" y="280" text-anchor="middle" class="pi-text" fill="#111" font-weight="700">RESPONSE</text> <text x="190" y="304" class="pi-mono" fill="#111">answers + usage</text> <text x="190" y="324" class="pi-mono" fill="#111">model: "jev-1.13.0"</text> <text x="190" y="344" class="pi-small" fill="#666">what actually served, in one field</text> <text x="320" y="394" text-anchor="middle" class="pi-small" fill="#666" font-weight="700">assert</text> <text x="320" y="412" text-anchor="middle" class="pi-mono" fill="#111" font-size="11">model = pin?</text> <text x="334" y="438" class="pi-label" fill="#666">match</text> <text x="334" y="136" class="pi-label" fill="#666">one request, any one venue</text> <text x="624" y="370" text-anchor="end" class="pi-label" fill="#666">mismatch: route like torn,</text> <text x="624" y="384" text-anchor="end" class="pi-label" fill="#666">then re-check the pin</text> <text x="30" y="493" class="pi-text" fill="#111" font-weight="700">RECEIPT LOG</text> <text x="150" y="493" class="pi-small" fill="#666">the echo, one line beside every answer:</text> <text x="612" y="493" text-anchor="end" class="pi-mono" fill="#111">#41 · "jev-1.13.0" · gateway</text> </svg>

Figure 1. The pin-and-echo flow: one request, three possible venues, the assert gate on the model field, and the receipt log receiving the echo on match.

The same picture holds at every venue on the path: whatever sits between your code and the weights (a hosted API, an aggregator, a gateway, a router), the response always comes back with the one field that names what served. That field, logged beside the answer, is the receipt lane in Figure 1. The rest of this lesson walks the venues one by one; the lane never changes.

## The page moves under your feet: dynamic limits

On the same models page, in the vendor's own words: "rate limits are adjusting dynamically," and "the limits above can change without notice." Hosted APIs share capacity across thousands of callers, and when traffic spikes, your rate limits drop. The consequence lands on measurement: p95 latency (the 95th-percentile request time) and the share of rate-limited responses (the 429s) are properties of the platform's load as much as of your code. A run measured on Monday and one measured on Friday can differ in ways your own diff never touches.

The countermeasure is one line of logging plus the standard retry discipline. A 429 is transient: honor `retry-after` (the response header that says how long to wait) and retry; a 401 is not: fix the request. And log the timestamp of every call, so a run is tied to the limits it faced: **the timestamp rides the same receipt line as the model ID**.

> 💡 Key insight A measurement is only as good as the setup it holds fixed, and the setup is bigger than the model: build, limits, venue, and your own question wording all sit inside it. Receipts do not hold those parts still; they make each one visible. That is the next best thing, and the only realistic one.

## Same name, different counter: aggregator providers

An aggregator buys breadth with one integration: one API key and one wire contract, many vendors' models behind it. The price is a second resolver on the path: the aggregator decides which provider answers the request. The aggregator's own docs concede the variance: default routing "load balance[s] requests across the top providers to maximize uptime"; the models fallback list triggers on errors including "rate-limiting, downtime" and moderation refusals. When a fallback fires, "requests are priced using the model that was ultimately used, which will be returned in the `model` attribute of the response body."

Read that as contract language: the platform reserves the right to answer with a different model than the one you named, and the response's `model` field is where it tells you. For a judge pipeline the consequence is direct: two identical requests can be served by different providers and builds, the answers can differ, and the only ground truth is the receipt your code does or does not log.

The same clause prices the fallback: a cheap decision model falling away under load means an expensive frontier model serving your judge, and the first place the swap surfaces is the bill. The receipt is what makes that traceable.

## Portability: one wire contract, new counters

> 🏷️ New term: **wire contract** [glossary](/courses/jev-fundamentals/glossary/)
> The request/response shape two programs agree on, independent of who serves them: POST /v1/systemone, a state, named questions: answered by answers, usage, and the response's model field. One contract, several servers. The contract covers the request shape and the one receipt field; the hop detail (provider routing metadata, pipeline metadata, fallback mechanics) is a per-venue extension returned on top of it: read the venue's docs for that part, and moving venues adds a metadata reader without rewriting how the contract itself is parsed.

Because the wire contract holds across venues, one judge request moves by re-pointing the base URL and the credential and keeping the request. Two receipts make the pattern concrete before Table 1 generalizes it. On the hosted API the expense judge logs `"model": "jev-1.13.0"`. The same request on a local runtime (Ollama 0.35, the `/v1/systemone` endpoint on your own machine since 2026-09-29) logs `"model": "nimble"`: a decision model from the local catalog, named in the same one field. The base URL and the credential changed; the request shape and the receipt did not. The full venue reference, per each venue's docs:

Table 1. The venues and their receipts: what each venue's docs show and how the response's model field reports what served there.

| Venue | What the docs show | The receipt there |
| --- | --- | --- |
| TypeSafe hosted API | The origin contract; the venue every lesson in this course works against | Response `model` field: the versioned ID that answered |
| OpenRouter | Adapted serving; fallbacks across models and providers (§4) | Response `model` attribute names the model ultimately used; pipeline metadata per request (§6) |
| Cloudflare Workers AI | `typesafe/jev` in the catalog; `env.AI.run` with state and questions | Example responses carry `"model": "jev-1.13.0"`: the resolved build, in the one field the generic name never fills |
| Vercel AI Gateway | TypeSafe-compatible endpoint; re-point the SDK base URL + credential, keep the request | Response `model` + `provider_metadata.gateway.routing`; can also re-run an evaluation with a fallback model on a confidence condition you set, and names the model that served |
| Ollama 0.35 (local) | The same `/v1/systemone` endpoint from your own machine (since 2026-09-29); decision models such as `nimble` in the catalog | Response `model` field carries through (`"model": "nimble"`); the receipt survives the loss of the network hop |

Two rows carry teeth. Cloudflare's examples show the name you send (`typesafe/jev`) and the name that answers (`jev-1.13.0`) as different strings, so the receipt is the only place the resolved build appears. And Vercel documents something stronger than serving variance: a fallback _evaluation_, re-run by the gateway with another model when the primary's confidence misses a condition you set: the gateway names that model when it served. Both strengthen the same discipline, and it stays small: **the first response from a new venue gets its receipt read before its answers act.**

## The platform grew a router

OpenRouter added a router built on Jev itself (listed 2026-09-25): `typesafe/jev-router`. Jev "reads the conversation and judges the task type, difficulty, and how much a stronger model would help," then routes to "the cheapest candidate that meets that bar," inside include and exclude lists (model IDs) that you pass. With the metadata header enabled, the response carries pipeline metadata naming the resolved models, the lists applied, and the tier served at.

Two list behaviors fail differently, and the difference is the lesson:

> 🔧 Fail-open versus fail-loud an include list that matches nothing is ignored: the request proceeds on the whole pool, and the pipeline metadata reports list_fallback: "models_ignored": if it is read; an exclude list that removes every candidate fails the request with a 404, instead of routing to a model you banned. For a list you treat as policy, fail-loud is the half you can trust by itself, and the silent half is why the receipt rule follows the router too: log resolved_models the same way you log the build echo.

The scope line of the whole pattern: **the router picks which model answers; your thresholds pick what to do with the answer.** It reads as a clean separation, and it is one, _as long as the receipt agrees with the pin_. A threshold and a band are facts about the build that produced the scores (the reason §1 pins); if the router serves the request with a model other than the one pinned, your code is now comparing its fixed numbers against a different calibration. Re-run under a router, S01E02's expense judge steers policy decisions with thresholds built for another build, and the pin check is what catches it before the bill or the policy ruling does. That is why the receipt rule does not stop at logging: **the echo is asserted against the pin**, and a mismatch routes the response the way a torn answer does: re-check, or hold the decision. S01E03's band-as-router rule stays in your code; the platform router sits one layer below it, changes the model behind a response, and joins the same rule: any routing decision you did not write is one you verify.

The assertion in code is one if:

```
if (resp.model !== "jev-1.13.0") {   // the echo, asserted against the pin
  routeTorn();        // metric or hold; re-check the pin before the answers act
}
```

## Verification is becoming infrastructure

Step back one level: the receipt habit is becoming public infrastructure. The UK AI Security Institute (AISI, the government lab that benchmarks frontier models) publishes verified evaluation results through EvalEval, a public registry of Evaluation Cards: what a third party needs to understand and re-run a reported evaluation. The 2026-09-22 release carries results, context, and configuration for five benchmarks, six frontier models, and two cyber evaluations, released alongside AISI's paper on how evaluation protocol and inference compute shape benchmark scores. The launch post (2026-06-11) measured the gap the cards close: of more than 50,000 collected records, 96.5% are missing at least one field needed to re-run them. That is this lesson's phenomenon at ecosystem scale: a score that omits its configuration is a promise without a receipt. And the cost of a missing receipt compounds: a number no third party can re-run cannot be cross-checked, so every downstream judge that adopts it inherits blind the very build drift the pin habit exists to catch.

## The habit in six rules

The pin-echo habit compresses to six rules, wired in order.

1. **Pin per judge:** the versioned ID in the request; the alias stays in the vendor's examples.
2. **Echo per call, asserted:** the response's `model` field beside every answer, and in code: a check that the echo matches the pin (the build you believe is serving). Logged-and-never-compared is a receipt that only records; **asserted-and-acted-on** is the verification, and a mismatch is a metric or a hold condition, not a silent field.
3. **Receipt per hop:** the aggregator's model attribute, the gateway's routing metadata, the router's pipeline metadata, the local runtime's model field: each hop names what served, and each name is logged.
4. **Gate the venue:** the first response from a new venue must come back named by the right build before its answers act. The gate is not the habit; the per-call assertion (rule 2) is, because aggregators and gateways can fall back mid-stream without the venue changing.
5. **Re-verify on drift:** any change, wording or input mix (S01E02's repeat-run procedure and S01E03's re-check rule), a new model ID, or a new venue, makes the first response after it evidence, read before the change is treated as safe.
6. **Lists and limits are configuration, and lists are not controls**: include lists, exclude lists, thresholds, and band widths are named policies you version. That fail-open behavior (router rules above) means an include list is not the boundary that keeps requests on approved models; the boundary lives in the per-call assertion (rule 2) and the metadata that names resolved models. A failed match must be visible, not survived.

## Knowledge check

**What does the alias jev-latest guarantee about the build that answers your request?**

- **✓** Nothing about any particular request: an alias resolves at request time and moves when a new release ships
- That the same build answers every request until you switch it off yourself
- That the build matching your API version at signup is pinned
- That the vendor notifies you before an alias repoints

The vendor says it plainly: an alias moves when a new release ships, so the answers behind it can change without a change on your side. The alias is a convenience name for humans; the versioned ID is the pin.

**What are the two halves of the pin-and-echo habit?**

- Pin the pricing tier, and echo the token count
- **✓** Send the versioned ID in the model field, and log the response model field as the receipt for each call
- Pin the endpoint URL, and echo the request body
- Retry on 429, and fail fast on 401

The request half names one build; the verification half reads back what actually answered. The response model field reports the versioned ID that served, so every logged answer carries its own provenance.

**Your judge pipeline p95 latency doubles over a weekend and you shipped nothing. What did the vendor document beforehand?**

- **✓** That rate limits adjust dynamically and can change without notice, so platform load moves latency and the error mix even when your code is unchanged
- That latency is fixed contractually under the standard plan
- That p95 only changes when the model version changes
- That latency spikes are always the caller's fault

The models page states the limits can change without notice while the platform scales. The logged run date ties a run to the conditions it faced; the receipt discipline covers platforms, not just builds.

**Through an aggregator, two identical requests for the same model ID can be answered by different providers. Where is that written down?**

- **✓** In the aggregator fault-handling docs: default routing load balances across providers, fallbacks trigger on rate limits or downtime, and the model ultimately used is returned in the response model attribute
- Nowhere; this is community folklore discovered in outage postmortems
- Only in enterprise contracts with dedicated support
- In the model release notes for each build

OpenRouter itself documents load balancing, model fallbacks, and that requests are priced using the model ultimately used, returned in the model attribute. The receipt field is the only ground truth for what served.

**What does the AISI and EvalEval release of 2026-09-22 give someone running a judge?**

- A replacement for labeled examples collected on your own inputs
- A new family of benchmark models to compete against
- **✓** Verified evaluation results with configuration and provenance, published as reference points for interpreting reported performance in context
- A stricter rate limit on third-party evaluators

Verified results, context, and configuration for five benchmarks, six frontier models, and two cyber evaluations, released with the accompanying paper. The lesson takes the trend, not the numbers: receipts and configuration are becoming public infrastructure.

**You move the judge from the hosted API to a local runtime (Ollama 0.35). What carries over untouched?**

- The pricing model, including per-token billing
- The latency profile, since the same model runs
- **✓** The wire contract and the receipt habit: the same /v1/systemone request shape works, and the response model field reports what answered, so the new venue's first response is verified before its answers act
- The network hop: local calls still traverse the gateway

The endpoint, request shape, and response model field survive the move; only the base URL and the model you pin change. The habit changes venue without changing rule: read the receipt before reading the answers.

**On the jev-router, an include list that matches nothing is ignored, while an exclude list that removes every candidate fails with 404. Why does the difference matter?**

- It does not: both cases end in the same 404
- **✓** Fail-silent lists keep serving and only metadata reveals the miss; fail-loud lists surface the error. A policy that can fail without a trace cannot be trusted passively, so the router metadata is part of the receipt
- Include lists are deprecated in favor of exclude lists
- The router retries the request until an include match appears

list_fallback: models_ignored in the pipeline metadata is the only signal that your include list did not bind. A list you treat as policy needs at least one way to prove it applied; the exclude list failing loud provides that property by itself.

**The platform router picks which model serves each request. What stays yours?**

- The router model choice itself
- The router include list, and everything the model name implies
- **✓** What to do with the answer: the thresholds, the abstention band, and the escalation rule, owned by code and versioned
- Nothing: a platform router absorbs the judgment policy too

The scope line holds within one build: the router picks which model answers; the thresholds pick what to do with the answer, and they are only valid while the receipt agrees with the pin. When the router serves a different model, the fixed thresholds inherit that build's calibration, so the receipt is asserted against the pin and a mismatch triggers a re-check. The band-as-router rule (S01E03) stays in your code, and the router joins the disciplined set of layers you log receipts for.

## Sources & further reading

- [Models & aliases](https://docs.typesafe.ai/models) · TypeSafe AI docs · docs page · verified 2026-10-04
  The alias table, the pinning advice, the dynamically-adjusting limits, and the response `model` field: the primary source behind every section above.
- [Model Fallbacks](https://openrouter.ai/docs/guides/routing/model-fallbacks) · OpenRouter docs · docs page · verified 2026-10-04
  Provider load balancing, fallback triggers, and the `model` attribute that names what actually served.
- [Jev Router](https://openrouter.ai/docs/guides/routing/routers/jev-router) · OpenRouter docs · docs page · verified 2026-10-04
  The router built on Jev, with include/exclude lists and the pipeline metadata (including `list_fallback`).
- [Jev on Cloudflare Workers AI](https://developers.cloudflare.com/ai/models/typesafe/jev/) · Cloudflare docs · catalog page · verified 2026-10-04
  `typesafe/jev` in the catalog; example responses carrying the resolved build in the `model` field.
- [TypeSafe API with AI Gateway](https://vercel.com/docs/ai-gateway/sdks-and-apis/typesafe) · Vercel docs · docs page · verified 2026-10-04
  The TypeSafe-compatible endpoint, routing metadata, and the gateway's evaluation fallbacks.
- [Ollama 0.35 decision models](https://ollama.com/blog/ollama-now-supports-jev-style-decision-models) · Ollama blog · release post · verified 2026-10-04
  The `/v1/systemone` endpoint on your own machine since 2026-09-29, with the receipt carrying through.
- [How UK AISI and EvalEval Are Making Benchmark Results Reproducible](https://huggingface.co/blog/evaleval-aisi) · Hugging Face blog · published 2026-09-22 · verified 2026-10-04
  Verified evaluation results with configuration and provenance, as public infrastructure.
- [Evaluation Cards launch](https://huggingface.co/blog/evaleval/evaluation-cards-launch) · Hugging Face blog · published 2026-06-11 · verified 2026-10-04
  The 96.5% missing-field statistic behind the section above.

> **🧭 Practice** Your turn. Write the pin policy for one judge your code calls: the pinned versioned ID (not the alias), the receipt that travels with every answer (the response's model field, plus whatever hop metadata sits between your code and the judge), and the list of changes that force a re-verify. Name each one: new wording, new input mix, new model ID, or a new venue. Write the three down as IDs and field names, not adjectives. If an AI assistant is part of your workflow, Copy page in the header menu hands it this whole lesson as markdown, citation included. Ask it to audit the pin policy you wrote, or to read the receipt rules back against the venues table. The glossary is the canonical vocabulary when terms blur.

**An example policy, for self-grading**

```
judge: expense-policy-check (S01E02's expense judge)
pin: model = "jev-1.13.0"; the alias stays in the vendor's docs
receipt: response.model + run timestamp, one line per answer
assert: response.model == pin; mismatch: route torn, re-check the pin
re-verify on: reworded questions / new input mix / new model ID / new venue
```

## See also

- [📖 Jev Glossary](/courses/jev-fundamentals/glossary/)
- [🔤 S01E02: Jev State and Typed Questions](/courses/jev-fundamentals/s01e02-jev-state-and-typed-questions/)
- [🎯 S01E03: Confidence, calibration & composite scoring](/courses/jev-fundamentals/s01e03-jev-confidence-calibration-composite/)
---

Source: [Pins and Receipts (Keeping Your Setup Stable)](https://peripatos.dev/courses/jev-fundamentals/s01e04-pins-and-receipts/), Peripatos — free to read; reuse by permission.
