CertSafari
    Anthropic Claude Certified Architect – Professional (CCAR-P) - December 7 onwards· Lessons

    Domain 6 · Lesson 34/39

    Unsupportable commitments in Claude requirements and SLAs

    Unsupportable Commitments in Requirements and SLAs

    17 min read
    2.33% of exam
    9 sources
    Published 18 Nov 2026
    Docs as of 18 Nov 2026

    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.

    Common absolute commitments and the property of the platform they collide with
    Commitment as draftedWhat the platform actually providesSupportable shape
    No hallucinations / 100% accuracyThe model can produce text that is factually wrong or inconsistent with its contextAn accuracy target measured on an eval set, plus grounding and human review for the cases that fail
    Same output for the same inputIdentical inputs can give different outputs, even at temperature 0A stored decision record plus a measured agreement rate
    Fixed latency for every requestLatency depends on model size, prompt complexity, output length and infrastructurePercentile targets for each request class, with long work moved to an async path
    Fixed throughput at all timesOrganization-level rate and spend limits; best-effort standard tierA 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?

    Sources12

    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?

    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)

    0 of 2 selected

    Sources345

    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.

    Latency measures and which commitment each one fits
    MeasureWhat it capturesFits a commitment for
    Time to first token (TTFT)Time from sending the prompt until the first token of the response arrivesStreamed chat replies, where the user sees output begin
    Baseline latencyTime to process the prompt and generate the responseShort, non-streamed calls with bounded output
    Completion time on an async pathTime from job submission until the result notificationMulti-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.

    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)

    0 of 2 selected

    Sources67

    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.

    Limits that cap throughput, and what each means for an SLA
    LimitWhat it capsSLA implication
    RPM / ITPM / OTPMRequests and tokens per minute, per model class, for the whole organizationPromised volume × tokens per item must fit under these numbers
    Short-interval enforcement60 RPM may be enforced as 1 request per second; bursts can trigger 429sSmooth traffic; a per-minute average can still fail in a burst
    Ramp limitHow fast token usage on a model can grow; sharp increases can return 429A launch-day spike can fail even while you're under the per-minute limits
    Monthly spend capMaximum monthly spend for Start, Build and Scale tiersReaching 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:

    The 429 returned when the organization's monthly spend cap is reached; details.error_code tells it apart from a rate limitjson
    {
      "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"
    }

    Checkpoint 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)

    0 of 2 selected

    Sources28

    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.

    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?

    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?

    Sources175

    Sources

    (9)

    Every claim above is drawn from one of these pages, quoted as it was written on the date shown.

    1. 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. 2.
      “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. 3.
    4. 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. 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. 6.
      “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. 7.
      “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. 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

    Ready to test yourself?

    Practise Anthropic Claude Certified Architect – Professional (CCAR-P) - December 7 onwards in quiz mode.

    Spotted a mistake, or was something unclear? Tell us.