- In short
- Training-time alignment is the broad safety behaviour baked into Claude before any deployment exists; it reduces general-purpose harm on every request but never saw your partner's data rules, authorization model, or domain policy. Inference-time control is the runtime layer you build - system instructions paired with input screening, output screening, tool authorization, and human review - and it is the only layer that actually enforces deployment-specific rules.
Two layers with two entirely different jobs
Before an architect adds a single guardrail, some safe behaviour is already present in the model, and some is still theirs to build. The Claude Certified Architect - Professional (CCAR-P) exam treats drawing that line as the first governance decision, because it sits upstream of every control choice that follows. Get the boundary wrong and you either duplicate protection the model already provides, or - far worse - assume the model is enforcing a rule it has never seen.
Anthropic trains Claude against a written constitution: a document describing the values and behaviour the model should exhibit, used during training both to generate examples the model learns from and to rank candidate responses. It shapes how Claude handles sensitive or ambiguous requests, so the model arrives with a class of harmful output already reduced. Anthropic revises the document over time, with the most recent published version dated January 2026. That is real, and it is valuable. But it is general by design: it was set before your deployment existed, so it cannot know your partner's domain policy, data-handling rules, or authorization model. The exam wants you to hold both facts at once - the model reduces broad harm, and it enforces none of your specific rules.
The constitution also encodes a priority order the model follows when goals conflict: be broadly safe first, then ethical, then compliant with guidelines, and then genuinely helpful to operators and users. That ordering matters because a helpful answer is sometimes an unsafe one. Note that the order is holistic rather than strict - higher-priority goals generally take precedence, but the model weighs them together rather than stepping through them in rigid sequence. None of this changes the boundary: the ordering governs how broad safety is applied, not whether your partner's specific rules are enforced.
- Training-time alignment vs inference-time control
- Training-time alignment is the broad safety behaviour trained into Claude before deployment; it lowers baseline risk on every request but is general by design. Inference-time control is the runtime layer the deployment team configures - system instructions plus input screening, output screening, tool-call authorization, and human review - and it is the only layer that enforces deployment-specific policy.
What training-time alignment reliably covers
Training-time alignment steers the model to refuse dangerous requests and default toward safer responses. It handles broad, general-purpose harm: refusing to help synthesise a weapon, declining plainly hateful content, resisting obviously malicious instructions. Because it applies to every request without configuration, it lowers the baseline risk of the whole system for free.
The strength is also the limit. A request can sit comfortably inside Claude's general alignment and still violate a rule that matters intensely to your partner - disclosing another customer's order record, or advising outside an approved script. Nothing about those requests looks harmful in general terms, so trained alignment has no reason to stop them. The single most useful sentence to carry into the exam is this: Claude cannot enforce a rule it was never given.
What inference-time control must add
Inference-time control is everything you configure at runtime for your specific deployment. System instructions shape the model's behaviour, but an instruction alone does not block anything - it is guidance, not a gate. Deployment-specific policy is enforced only when the instruction is paired with a runtime control that actually stands in the way: input screening that can reject a request, output screening that can withhold a response, tool-call authorization that can refuse an action, and human review that can hold a decision.
That pairing is the heart of the boundary. Training lowers baseline risk; inference-time control enforces your rules. Treating the two as interchangeable is how a design passes review and still fails in production, because the rule everyone assumed was live never existed in any executable layer.
What the CCAR-P exam trips candidates on
The exam builds items around a specific and seductive mistake: reasoning from a clean safety test to a false sense of coverage. A team throws harmful prompts at Claude, watches it refuse every one, and concludes the model will also stop an in-domain but policy-violating request - a cross-tenant data read, say - that looks harmless on its surface. The refusals were evidence about trained alignment. They were never evidence about a domain rule, because the domain rule was never encoded anywhere the system could act on it.
The second trap is subtler: treating a system-prompt instruction as enforcement. A scenario names a policy, points to a line in the system prompt that describes it, and asks whether the policy is enforced. The credited reading is no - an instruction that no runtime check backs is a statement of intent, not a control. The exam rewards candidates who can tell the difference between a rule that is written down and a rule that is actually blocked.
Worked example
A team deploys an internal assistant for a partner whose policy forbids users from reading records belonging to other business units. In review, Claude refused every harmful prompt the team tried, so they shipped without building an authorization check. In production, a normal-looking in-domain request asked for a forbidden record and Claude answered it. What went wrong, and how should the design change?
The failure is a boundary error. The team conflated a deployment-specific rule - no cross-unit disclosure - with Claude's trained alignment. Trained refusals cover broad harm; they never covered this partner's authorization model, because the model was never given it. The forbidden request looked ordinary in general terms, so nothing in training had a reason to stop it, and nothing the team built stood in the way either.
The fix is to move the rule into a layer that can enforce it. Cross-unit access is a deterministic authorization question - this caller, this record, this business unit - so it belongs in a tool-call authorization check that runs before any record is returned, keyed to the requester's identity and unit. A system-prompt line describing the policy can support that, but it cannot replace it. The rule has to live somewhere the system can act on it, not somewhere a reviewer merely reads it.
The general lesson the exam wants: after you observe a model refusing harmful prompts, you have learned something about alignment and nothing about your domain policy. Every partner-specific rule needs its own encoded control.
Common misreadings to avoid
Misconception
Because Claude refused every harmful prompt in testing, it will also block a policy-violating request that looks harmless on the surface.
What's actually true
Misconception
Writing the policy into the system prompt means the policy is enforced.
What's actually true
How this shows up on the exam
Domain 5 items on this knowledge point hand you a system that passed its safety testing and still leaked or misbehaved in production, and ask you to locate the missing enforcement. The reliable reading is that a deployment-specific rule was assumed to live in trained alignment when it lived in no executable layer at all. The correct move is always to name the runtime control that should carry the rule.
This is the foundation the rest of the domain builds on. It leads directly into the three-point guarded request path, which is where those runtime controls actually sit, and it frames the LLM system risk taxonomy you check every design against. It also underpins the compliance view that regulations state outcomes, not controls, since translating an outcome into an owned control is the same discipline applied to law rather than to safety.
A team tested their Claude assistant against dozens of harmful prompts and it refused all of them. They conclude their partner's rule against returning another tenant's data is therefore covered. What is the accurate assessment?
People also ask
What does Claude’s training already handle before I add controls?
Why can’t a system prompt alone enforce a domain policy?
Is a model refusing test prompts proof my rules are enforced?
Watch and learn
Official Anthropic Academy lessons first, then hand-picked walkthroughs. Videos load only when you press play.
No videos curated for this concept yet
We are still curating the best official and community videos for this topic.
Official prep for this domain
Anthropic's own free prep module for this part of the syllabus, on the official prep course. Free with an Anthropic Academy sign-in.
References & primary sources
Master this concept with Archie
Practice it inside an adaptive study session. Archie, your Socratic AI tutor, tracks your mastery with Bayesian Knowledge Tracing and schedules the perfect next review.