How do you name a Claude Opus model in Anthropic's API, and why pin the dated snapshot?
answer
- two spellings for the same tier
- one string is frozen, one floats
- date suffix marks an immutable build
- a pointer can move without your deploy
- pin the dated snapshot in production
basics
~20 sAnthropic publishes each Claude Opus release as a dated snapshot ID such as claude-opus-4-1-20250805, plus a floating alias such as claude-opus-4-1 that resolves to the newest snapshot in that line. Production should pin the dated snapshot.
solid answer
~40 sThe `model` parameter on Anthropic's Messages API is a single string, and the Opus tier is addressable in two shapes. A **dated snapshot** — `claude-opus-4-1-20250805` — names one frozen release: same weights, same default behaviour, forever. An **alias** — `claude-opus-4-1` — is a convenience pointer that Anthropic may repoint to a newer snapshot within that line. Aliases are fine for notebooks, scratch scripts and harnesses that deliberately chase the newest build, but production pins the snapshot. If an alias moves, output formatting, tool-call phrasing, refusal boundaries and latency can shift under a running service with no deploy on your side, and every eval you ran was against the old weights. The working pattern is a pinned ID in configuration, an eval suite you can re-run against a candidate snapshot, and a deliberate version bump.
code
python · 16 linesimport os
from anthropic import Anthropic
# Pinned snapshot, overridable per environment for a canary rollout.
MODEL = os.environ.get("CLAUDE_MODEL", "claude-opus-4-1-20250805")
client = Anthropic()
response = client.messages.create(
model=MODEL,
max_tokens=512,
messages=[{"role": "user", "content": "Summarise this changelog."}],
)
print(response.model) # what actually served the request
print(response.content[0].text)go deeper
Know that the Opus tier is selected by writing a model ID string into the request, and that IDs come in a dated form and an undated form. Be able to point at the date suffix and say which one is frozen.
Explain the mechanics: the dated snapshot names one immutable build, the alias is a pointer Anthropic can repoint within a version line, and the difference is invisible in your code but visible in production behaviour. Name what can shift when it moves.
Show the operating discipline — model ID in config, golden-set evals before a bump, canary rollout, previous pin kept for rollback, and the response's model field logged so an incident can be traced to specific weights.
Own the policy: who is allowed to change a pin, what evidence gates the change, and how many distinct pinned IDs the organisation is willing to carry at once. Argue the tradeoff between chasing improvements automatically and keeping a stable, reproducible surface under contractual workloads.
## The model field is just a string Anthropic's Messages API does not take a family and a tier as separate parameters. There is no `tier="opus"` field: the entire model selection is one required string in the `model` parameter of the request. Choosing Opus therefore means writing an Opus model identifier into that string, and Anthropic publishes two spellings of it for every Opus release. ## Dated snapshots A dated snapshot looks like `claude-opus-4-1-20250805`. Read left to right it is: the family (`claude`), the tier (`opus`), the version within that tier (`4-1`), and the release date of that specific build (`20250805`, i.e. 5 August 2025). The important property is immutability. That identifier names one frozen artefact — the same weights, the same default output style, the same tool-call formatting, the same refusal boundaries — for as long as the model is served. Nothing Anthropic ships later changes what that string returns. ## Aliases An alias drops the date: `claude-opus-4-1`. It is a pointer that Anthropic controls, and it resolves to the newest snapshot released within that line. Anthropic documents aliases as a convenience and explicitly discourages them for production traffic. Two things about aliases surprise people. First, the alias tracks *its own line*, not "the strongest Opus that exists" — when a new Opus generation ships, it gets new snapshot IDs and its own alias, and the old alias keeps pointing inside the old line. Second, an alias resolving to a new snapshot is not a version upgrade you performed; it is a change to your production system made by a third party on their release calendar rather than yours. ## Why pinning is the production default Everything you validated about a model was validated against a specific set of weights. A snapshot change inside the same tier is usually an improvement in aggregate benchmark terms and can still be a regression for you, because a real service depends on far narrower behaviour than a benchmark measures: - **Output format brittleness.** Prompts that ask for a bare JSON object, a fixed heading structure or a specific citation style often depend on habits of a particular build. A newer snapshot may add a preamble, change list punctuation, or wrap output in a fence. - **Tool-call behaviour.** How eagerly the model calls a tool, how it fills optional arguments, and how many calls it batches per turn can all shift, which changes the shape of an agent loop even when every individual call is valid. - **Refusal and safety boundaries.** A prompt that sat just inside the line on one snapshot can sit just outside it on the next, producing a sudden class of empty or hedged responses in one workflow. - **Latency and token profile.** Response length distribution changes move p95 latency and per-request cost, which matters for timeouts and capacity assumptions even when quality is fine. - **Reproducibility.** When an incident is reported three weeks later, you need to know which weights answered. If the request named an alias and the alias has since moved, you cannot reproduce it. ## The operational pattern Put the model ID in configuration, not scattered through call sites — one constant or one environment variable, so a version bump is a single reviewable change. Keep a golden-set eval you can point at a candidate snapshot and diff against the incumbent. Roll the new snapshot out behind a flag or a percentage canary, exactly as you would a dependency upgrade, and keep the previous pin available so rollback is a config revert. Finally, log the `model` field the API returns on each response alongside your own request metadata: it tells you what actually served the traffic, which is the fact you will want during an investigation. ## When an alias is genuinely the right choice Aliases earn their place in throwaway scripts, notebooks, and internal tooling where "newest in the line" is the desired semantics and nobody is paged when the output shifts. They are also reasonable in an evaluation harness whose purpose is to notice change. The rule of thumb: use an alias where a silent behaviour change is information, and a pin where it is an outage. ## Common mistakes Treating the alias as pinned because it looks like a version number is the big one — `claude-opus-4-1` reads like a version and behaves like a branch name. A second is hardcoding a snapshot in a dozen files, which turns a one-line bump into a grep-and-pray exercise. A third is assuming a mistyped or unknown model string quietly falls back to some default; it does not — the request fails, which is the behaviour you want, but it means model IDs belong in config validated at startup rather than in a string built at request time.
- What concretely can change if an alias repoints under a running service?Nothing in your code changes, but the weights answering your traffic do. In practice that shows up as altered output formatting, different eagerness to call tools, a shifted refusal boundary on edge-case prompts, and a moved latency and response-length distribution. All of it lands without a deploy, so your first signal is usually a customer report or a downstream parser failing, not a build.
- Does the alias always point at the newest Opus model Anthropic offers?No. An alias tracks its own line — a `claude-opus-4-1` style alias stays within that version line and resolves to the newest snapshot released there. A new Opus generation ships with new snapshot IDs and its own alias, so an old alias can sit several releases behind the current flagship indefinitely.
- Where should the pinned model ID live in a deployed service?In configuration read once at startup — an environment variable or config file, validated on boot — with a single constant referenced by every call site. That makes a version bump one reviewable change, lets a canary run a different pin without a code branch, and makes rollback a config revert rather than a redeploy of application code.
A dated snapshot is like a git commit SHA and an alias is like a branch name: both point at something real today, but only one is guaranteed to point at the same thing tomorrow.
saying these in an interview costs you the question
- Calls an undated alias version-pinned because it contains a number
- Assumes only the date changes, so behaviour cannot change
- Believes an unknown model string falls back to a default model
- Thinks evals need not be re-run after a snapshot changes underneath
- Says the alias always resolves to the newest Opus ever released