What you will be able to do
- Spot a commitment in discovery notes or a draft SLA that a Claude-based architecture cannot guarantee: perfect accuracy, determinism, a fixed latency ceiling, unlimited throughput or unlimited uptime
- Rewrite an accuracy or determinism promise as a measurable target backed by a reproducible decision record
- Split a latency commitment by request class, and move long tool workflows to an asynchronous path with its own target
- Check a throughput figure against the organization's rate limit tier, and resolve the gap with higher limits, a smaller promise or the Message Batches API
- Set availability and data-handling commitments that stay within what the chosen service tier and model actually provide
Key concept
Measurable target with a fallback — Claude is a probabilistic model served on shared, rate-limited capacity, so an absolute promise about its output, speed or availability cannot be kept. Every commitment has to become a target you can measure in production, paired with what the system does when the target is missed.
1.Why absolute promises break on a Claude architecture
An SLA clause becomes unsupportable when it promises something the platform underneath it does not promise. Discovery notes collect these clauses all the time: "100% accurate", "same answer every time", "under two seconds for every request", "50,000 documents an hour, always". Each sounds like an ordinary engineering target. Each one runs into a property of the model or the API that no amount of build effort removes.
The standard API tier is the clearest example. Requests are served best-effort alongside everyone else's traffic, and the published rate limits are ceilings, not floors. A contract that promises more than that is promising capacity the architect doesn't control. When this happens the fix is one of two things, and usually both. Either the requirement is clarified so it describes something measurable, or the architecture changes so the promise covers a path that can keep it.
| Commitment as drafted | What the platform actually provides | Supportable shape |
|---|---|---|
| No hallucinations / 100% accuracy | The model can produce text that is factually wrong or inconsistent with its context | An accuracy target measured on an eval set, plus grounding and human review for the cases that fail |
| Same output for the same input | Identical inputs can give different outputs, even at temperature 0 | A stored decision record plus a measured agreement rate |
| Fixed latency for every request | Latency depends on model size, prompt complexity, output length and infrastructure | Percentile targets for each request class, with long work moved to an async path |
| Fixed throughput at all times | Organization-level rate and spend limits; best-effort standard tier | A figure checked against tier limits, with a batch path for work that can wait |
Checkpoint 1 of 9· Check yourself
Discovery notes for a document-processing system on the standard API tier say: "The vendor guarantees 50,000 documents per hour, at all times." What is the right way to handle this clause?
Rate limits are ceilings that apply to the whole organization, and the standard tier is best-effort, so the throughput promise has to fit under the tier's limits, with work that can wait moved to batch. Retries only delay work, and extra API keys share the same organization-level limit.
“All limits described here represent maximum allowed usage, not guaranteed minimums.”Source: platform.claude.com
2.Accuracy and determinism: promise the record, measure the variation
"No hallucinations" cannot go into a contract. Even strong models sometimes produce text that is factually wrong or doesn't match the material they were given. Prompting techniques reduce this, and you can see some of them in prompting technique selection, but none of them takes the rate to zero. A supportable version names an accuracy target on a defined evaluation set and says what happens to the outputs that miss it, for example routing them to human review.
Determinism fails for the same reason. Temperature 0 narrows the output toward the most probable answer, but it doesn't guarantee one. This applies whether you call Anthropic directly or go through a cloud provider. So the audit requirement has to change what it promises. Auditors don't need the model to produce the same text again. They need to see what the system decided and why. Reword the requirement to cover the decision record: for each triage call, store the input, the model identifier, the prompt version and the output. An auditor can then examine the actual decision rather than a fresh re-run.
The variation that remains should be measured, not denied. Run the same claims through the system repeatedly and track the agreement rate against a target the client agrees to. Constrain the output's shape with a JSON schema that is validated on every call, so that runs which disagree differ only in field values, never in structure. With structured outputs or strict tools, the API compiles the schema into a grammar.
Two shortcuts look like reproducibility but aren't. Replaying a disputed claim on whatever model the system uses at audit time tests a different system from the one that made the decision. That's why the record must store the exact model identifier. Prompt caching doesn't replay answers either. It stores the input prefix, and cache reads are counted as input tokens. The model still generates a new output on every call.
Checkpoint 2 of 9· Check yourself
A claims team wants auditors to see the exact answer the triage system gave months earlier. An engineer suggests turning on prompt caching, so that sending the same claim again returns the cached response. What is wrong with this plan, and what should the team do instead?
Prompt caching works on the input side: cache reads are counted as input tokens, and the model generates a new output on every call. Audits therefore need a stored decision record (input, model identifier, prompt version, output) rather than a replay.
“If you use prompt caching, the input count is split across input_tokens, cache_read_input_tokens, and cache_creation_input_tokens”Source: platform.claude.com
Checkpoint 3 of 9· Exam question
An insurance client's requirements say: "The system must be deterministic, giving the same output for the same input every time, so audits can reproduce any decision." The design uses the Claude Messages API for claim triage. Which two changes resolve this unsupportable commitment? Choose two.(Select 2)
Correct answers: A, B — Reword the requirement to cover the decision record, and store the input, model identifier, prompt version, and output of each triage call for reviewers to examine.; Measure output agreement across repeated runs of the same claims against an agreed target rate, and constrain responses with a JSON schema validated on each call.
- A. Correct: what auditors need is traceability of each decision. Storing the input, model identifier, prompt version and output gives a complete record to review, and it replaces a promise of identical regeneration that the API cannot back.
- B. Correct: consistency across repeated runs can be measured and held to an agreed target, and schema-validated structured output narrows how far runs can differ. This replaces an absolute guarantee with a commitment that can be tested.
- C. Incorrect: temperature 0 reduces variation but does not guarantee identical output, and model updates over a system's lifetime change results further. The contract clause would keep the unsupportable byte-identical promise instead of resolving it.
- D. Incorrect: an alias moves to newer model versions over time, so a replay on the current release can differ from the decision originally made. Audit support needs a pinned, recorded model version, not a moving target.
- E. Incorrect: prompt caching reuses processing of a repeated prompt prefix to cut cost and latency; it does not store completions. Each request still generates a fresh response, so no earlier answer is served back to an auditor.
3.Latency: split by request class and move long work off the clock
A single latency ceiling across all traffic is unsupportable because latency is not a single number. It depends on the size of the model, how complex the prompt is, and the infrastructure serving it. Output length matters too, since every generated token takes time. A chat reply and a multi-step agent run that calls three tools and writes a long report belong to different populations. A p99 that covers both is set by the slowest workflow.
| Measure | What it captures | Fits a commitment for |
|---|---|---|
| Time to first token (TTFT) | Time from sending the prompt until the first token of the response arrives | Streamed chat replies, where the user sees output begin |
| Baseline latency | Time to process the prompt and generate the response | Short, non-streamed calls with bounded output |
| Completion time on an async path | Time from job submission until the result notification | Multi-step tool workflows and long outputs |
The supportable SLA has two parts. For streamed chat, commit to time to first token, because streaming lets the user see output while the rest is still being generated. Set the percentile from measured production traffic, not from a number someone hoped for. Multi-step tool workflows go on an asynchronous path: the request returns a job ID, the system sends a notification when the work finishes, and that path gets its own completion-time target. The errors guidance makes a related point: long-running Messages API requests should use streaming rather than a blocking call that might time out.
Three tempting fixes don't hold up. A system-prompt rule telling Claude to stop calling tools after two seconds can't work, because elapsed wall-clock time is a property of your serving loop, not something the prompt controls. Moving to the smallest model and capping max_tokens so everything fits under two seconds also fails. max_tokens is a hard limit on output length, so it truncates the long answers the users asked for, and it does nothing about the round trips in a tool chain. Prompt caching speeds up repeated prefixes, but it can't put an upper bound on a p99 driven by generation length and tool steps.
Checkpoint 4 of 9· Match them up
You are rewriting one blanket latency clause, "every request under two seconds", into separate targets for each request class. Match each request class to the latency measure its commitment should be written against.
Tap a term, then the definition that fits it.
With streaming, the user sees output start before the reply is finished, so time to first token is the measure that matters to them. Short bounded calls can be held to total response time. Multi-step tool workflows are moved off the request path and get their own completion-time target, so they no longer set the p99 for interactive traffic.
“It’s particularly relevant when you’re using streaming (more on that later) and want to provide a responsive experience to your users.”Source: platform.claude.com
Checkpoint 5 of 9· Exam question
A draft SLA for a customer-facing Claude agent on the Messages API states: "p99 response latency under 2 seconds for all requests." The agent streams answers to chat users, but some requests trigger multi-step tool calls and long outputs. Which two changes make the latency commitment supportable? Choose two.(Select 2)
Correct answers: A, B — Split the commitment by request class, using time to first token for streamed chat replies and percentile targets based on measured production traffic.; Move multi-step tool workflows to an asynchronous path that returns a job ID and notifies on completion, with a separate completion-time target.
- A. Correct: streamed chat replies are experienced through how fast the first tokens appear, so time to first token is the right measure for them. Targets per request class, set from production percentiles, replace one blanket figure with commitments the system can actually meet.
- B. Correct: multi-step tool runs have variable duration, so an async job pattern with its own completion target removes them from the interactive latency promise. The commitment then matches the architecture.
- C. Incorrect: Claude has no reliable view of elapsed wall-clock time, so a prompt rule cannot enforce a latency bound. Skipping tool calls also leaves tasks unfinished, and a single p99 figure for long and tool-driven requests is still unsupported.
- D. Incorrect: a smaller tier is usually faster but gives no guaranteed upper bound, and each tool round trip adds time the model tier does not control. A max_tokens cap cuts answers off mid-way rather than making long outputs fast, so the 2-second figure still cannot be promised on tool-heavy requests.
- E. Incorrect: caching lowers the cost and processing time of repeated input prefixes, which mainly helps time to first token, and a longer cache duration only keeps those prefixes available for longer. Generation time still grows with output length and tool round trips add their own delay, so a single p99 figure for long outputs and multi-step tool calls remains unsupported.
4.Throughput: check the figure against the tier before signing
A throughput number in an SLA is an arithmetic claim, so check the arithmetic first. Messages API limits are set per organization and per model class, in requests per minute (RPM), input tokens per minute (ITPM) and output tokens per minute (OTPM). Multiply the promised documents per hour by the measured input and output tokens per document. If the result exceeds the tier's limits, the commitment can't be met as written. The two honest options are to request higher limits or to promise a lower volume.
| Limit | What it caps | SLA implication |
|---|---|---|
| RPM / ITPM / OTPM | Requests and tokens per minute, per model class, for the whole organization | Promised volume × tokens per item must fit under these numbers |
| Short-interval enforcement | 60 RPM may be enforced as 1 request per second; bursts can trigger 429s | Smooth traffic; a per-minute average can still fail in a burst |
| Ramp limit | How fast token usage on a model can grow; sharp increases can return 429 | A launch-day spike can fail even while you're under the per-minute limits |
| Monthly spend cap | Maximum monthly spend for Start, Build and Scale tiers | Reaching it pauses all usage until the next month |
For work that can wait, change the architecture instead of the number. The Message Batches API processes requests asynchronously. Most batches finish in under an hour, at half the cost and with higher throughput. Send non-urgent documents through the batch path and give that path its own turnaround target, separate from the real-time figure. Caching repeated content also stretches real-time capacity, because the default ITPM limits count only uncached input tokens.
The spend cap is the throughput failure that gets missed most often, because it looks like a rate limit and isn't one. When the tier's monthly cap is reached, requests return HTTP 429 with no retry-after header, and every retry fails until the next month begins:
{
"type": "error",
"error": {
"type": "rate_limit_error",
"message": "You have reached your API usage limits: your organization has crossed its monthly API usage threshold, set based on your organization's API tier. You will regain access on 2026-09-01 at 00:00 UTC.",
"details": { "error_code": "enforced_spend_limit_reached" }
},
"request_id": "req_018EeWyXxfu5pfWkrYcMdjWG"
}Retrying 429s with exponential backoff is good client behaviour, but it adds no capacity. It spreads the backlog over time while the promised hourly figure is still missed. Giving each worker pool its own API key doesn't help either, because limits apply to the organization, not to individual keys. Trimming prompts and capping max_tokens lowers the cost per document. Even so, the figure still has to be checked against the limits, because trimming alone doesn't show that the promise now fits.
Checkpoint 6 of 9· Fill the gap
A worker reads 429 responses to decide whether to back off and retry or to stop and escalate. Which error_code value means the monthly spend cap was reached, so retrying will keep failing until next month?
{
"type": "error",
"error": {
"type": "rate_limit_error",
"message": "You have reached your API usage limits: your organization has crossed its monthly API usage threshold, set based on your organization's API tier. You will regain access on 2026-09-01 at 00:00 UTC.",
"details": { "error_code": " ? " }
},
"request_id": "req_018EeWyXxfu5pfWkrYcMdjWG"
}The spend-cap response uses the same rate_limit_error type as a normal rate limit and has no retry-after header. Only details.error_code = enforced_spend_limit_reached tells it apart, and when it appears, retries fail until access resumes the next month.
Source: platform.claude.comCheckpoint 7 of 9· Exam question
A document-processing SLA draft commits to "50,000 documents per hour at all times." Your Claude API organization is on a rate limit tier whose limits cannot sustain that volume at the measured tokens per document. Which two actions make the throughput commitment supportable? Choose two.(Select 2)
Correct answers: A, B — Check the SLA figure against the organization's tier limits and measured token cost per document, then request higher limits or lower the promised volume.; Route non-urgent documents through the Message Batches API and give that path its own turnaround target, apart from the real-time figure.
- A. Correct: the draft needs to be checked against the real capacity, meaning the organization's tier limits and the measured token cost per document. Higher limits or a smaller promised volume then tie the SLA to throughput that actually exists.
- B. Correct: the Message Batches API suits work that is not time-sensitive, and a separate turnaround target for that path splits the promise into real-time and bulk parts. This takes bulk volume off the real-time rate limit path.
- C. Incorrect: exponential backoff absorbs short bursts of 429 responses but cannot lift sustained throughput above the limit. Because the limits cannot sustain the required volume, the backlog keeps growing and the hourly figure is missed.
- D. Incorrect: rate limits are enforced for the organization as a whole, not per key, so additional keys draw on the same allowance and add no capacity. The throughput gap remains and key management gets more complicated.
- E. Incorrect: a shorter prompt and capped output trim some tokens per request, but they do not close the structural gap between the volume promised and what the tier allows. It is a tuning step and does not make the SLA figure supportable.
5.Availability and data handling: inherit the platform's terms, not exceed them
No system can promise more uptime than the API it depends on. On the standard tier, availability is best-effort, and a busy API returns 529 overloaded_error. Priority Tier is the contracted option. It is available to organizations with a capacity commitment, and that commitment is tied to a specific model version. It targets 99.5 percent uptime, a target rather than a guarantee. Traffic above the committed tokens per minute falls back to the standard tier automatically. Priority Tier is also not offered on several of the newest models, including Claude Opus 5.5 and Claude Sonnet 5.5.
Not as written. Priority Tier targets 99.5% uptime, and only for traffic within the committed capacity; anything above that runs on best-effort standard capacity. The clause has to sit at or below what the dependency provides, or the design needs a fallback path for when Claude is unavailable, such as queueing work or degrading to a non-AI flow, with the SLA describing that degraded behaviour.
Data-handling promises in discovery notes need the same check against the model choice. "No customer data retained" sounds like a policy decision, but it depends on the model. Claude Fable 5.2 and the Mythos models require 30-day retention and aren't available under zero data retention unless Anthropic expressly authorizes it. If the requirement holds, the architecture changes to a ZDR-eligible model. If the model holds, the requirement is clarified. The broader design of compliance controls belongs to architectural controls for compliance obligations. The skill here is noticing the conflict while the clause is still a draft.
Checkpoint 8 of 9· Check yourself
A retailer has a Priority Tier commitment for one model version. Its draft SLA promises 99.5% uptime for all Claude traffic, including holiday peaks that run at about twice the committed tokens per minute. Why can't the SLA be supported as written?
Priority Tier targets 99.5% uptime only for traffic within the committed capacity. Requests above that capacity automatically run on best-effort standard capacity, so the SLA has to be limited to the committed share, or the design needs a fallback path for the overflow.
“Priority Tier targets 99.5 percent uptime with prioritized computational resources. Requests beyond your committed capacity automatically fall back to standard tier.”Source: platform.claude.com
Checkpoint 9 of 9· Check yourself
Discovery notes for a legal-review tool say "the vendor must retain no customer prompts or outputs", and the proposed architecture runs on Claude Fable 5.2. Anthropic has not given any special authorization. What resolves the conflict?
Fable 5.2 requires 30-day retention and is not available under ZDR without express authorization from Anthropic. Either the architecture changes to a ZDR-eligible model, or the requirement is clarified. Prompt rules and deleting your own records do not change what the provider retains.
“These models require 30-day data retention and are not available under ZDR unless expressly authorized by Anthropic.”Source: platform.claude.com
Sources
(9)
Every claim above is drawn from one of these pages, quoted as it was written on the date shown.
- 1.
“The API prioritizes these requests alongside all other requests with best-effort availability.”
↩︎ Why absolute promises break on a Claude architecture“Priority Tier targets 99.5 percent uptime with prioritized computational resources.”
↩︎ Availability and data handling: inherit the platform's terms, not exceed them“Requests beyond your committed capacity automatically fall back to standard tier.”
↩︎ Exam trap 4“Priority Tier targets 99.5 percent uptime with prioritized computational resources. Requests beyond your committed capacity automatically fall back to standard tier.”
↩︎ Checkpoint - 2.https://platform.claude.com/docs/en/api/rate-limitsOfficial docs
“All limits described here represent maximum allowed usage, not guaranteed minimums.”
↩︎ Why absolute promises break on a Claude architecture“Short bursts of requests can exceed the limit and trigger rate limit errors.”
↩︎ Throughput: check the figure against the tier before signing“After a sharp increase in usage, requests can return a 429 error”
↩︎ Throughput: check the figure against the tier before signing“API usage pauses until 00:00 UTC on the first day of the next month”
↩︎ Throughput: check the figure against the tier before signing“default ITPM rate limits count only uncached input tokens”
↩︎ Throughput: check the figure against the tier before signing“All limits described here represent maximum allowed usage, not guaranteed minimums.”
↩︎ Key concept“Limits are set at the organization level.”
↩︎ Exam trap 2 - 3.https://platform.claude.com/docs/en/test-and-evaluate/strengthen-guardrails/reduce-hallucinationsOfficial docs
“can sometimes generate text that is factually incorrect or inconsistent with the given context”
↩︎ Accuracy and determinism: promise the record, measure the variation - 4.
“Even with temperature set to 0, the results will not be fully deterministic”
↩︎ Accuracy and determinism: promise the record, measure the variation“identical inputs might produce different outputs across API calls”
↩︎ Exam trap 1 - 5.
“When using structured outputs or tools with strict: true, the API compiles JSON schemas into grammars”
↩︎ Accuracy and determinism: promise the record, measure the variation“These models require 30-day data retention and are not available under ZDR unless expressly authorized by Anthropic.”
↩︎ Availability and data handling: inherit the platform's terms, not exceed them - 6.https://platform.claude.com/docs/en/test-and-evaluate/strengthen-guardrails/reduce-latencyOfficial docs
“Latency can be influenced by various factors, such as the size of the model, the complexity of the prompt, and the underlying infrastructure”
↩︎ Latency: split by request class and move long work off the clock“Time to first token (TTFT): This metric measures the time it takes for the model to generate the first token of the response”
↩︎ Latency: split by request class and move long work off the clock“This can significantly improve the perceived responsiveness of your application”
↩︎ Latency: split by request class and move long work off the clock“Use the max_tokens parameter to set a hard limit on the maximum length of the generated response.”
↩︎ Exam trap 3“It’s particularly relevant when you’re using streaming (more on that later) and want to provide a responsive experience to your users.”
↩︎ Checkpoint - 7.https://platform.claude.com/docs/en/api/errorsOfficial docs
“For long-running Messages API requests, use the streaming Messages API.”
↩︎ Latency: split by request class and move long work off the clock“529 - overloaded_error: The API is temporarily overloaded.”
↩︎ Availability and data handling: inherit the platform's terms, not exceed them - 8.
“with most batches finishing in less than 1 hour while reducing costs by 50 percent and increasing throughput”
↩︎ Throughput: check the figure against the tier before signing
Also cited
“If you use prompt caching, the input count is split across input_tokens, cache_read_input_tokens, and cache_creation_input_tokens”
↩︎ Checkpoint