Cert Dojo — Exam Day

Exam-morning compression of all 25 Train modules across the four certifications. Read the tie-breakers once more outside the exam room, skim your cert's bet-the-exam list, then trust the process — not the adrenaline. English edition.

All four certs · read this twice

Universal tie-breakers — when you are not sure

Each rule recurs across the certifications tagged after it: AO Associate · DV Developer · AR-F Architect Foundations · AR-P Architect Professional.

Eliminate on sight

Prestige — "use the biggest / most capable model" as a first move or universal fix. Effort, configuration, and diagnosis come first; a promotion needs eval evidence plus a cost and latency envelope. AO · DV · AR-F · AR-P
Absolutes — "always", "never", "ban all connectors", "allow all writes", "one SLO for every surface". Proportional, conditional, per-tier answers win. AO · DV · AR-F · AR-P
Prompt-only enforcement — a sentence in a system prompt, CLAUDE.md, or Project instruction treated as a control. Controls are hooks, deny permissions, allowlists, server-side authorization, schema validation. AO · DV · AR-F · AR-P
Self-assessment as a gate — "ask Claude if it is sure", model confidence, a judge score with no code assertions, a rubber-stamp review queue. Fake HITL fails on every exam. AO · DV · AR-F · AR-P
"The platform remembers for you" — the Messages API is stateless, a subagent inherits no parent history or shared memory (only its own system prompt plus what you pass), a summary loses exact figures, Memory and knowledge go stale. Any option that assumes state the surface does not promise is wrong. AO · DV · AR-F · AR-P
Prose as a control signal — parsing "I'm done!", "looks good", or fluent output instead of stop_reason, isError, a schema check, or a claim map. AO · DV · AR-F · AR-P
Blind retry, blind trust — retrying a 401 like a 429; treating tool results or retrieved HTML as instructions; reading [] after a timeout as "no matches"; treating a citation as validation. AO · DV · AR-F · AR-P
No gate before irreversible — autosend, CRM/ticket/refund writes, deletes, deploys, money moves with no confirmation, idempotency key, or rollback path. AO · DV · AR-F · AR-P
Invention — flags, parameters, or values you never saw in docs (CLAUDE_HEADLESS, --batch), invented KPIs, owners, or citations. Mark UNKNOWN or escalate instead. AO · DV · AR-F · AR-P
"The vendor covers it" — a model card, Constitutional AI, ZDR, or "it's the frontier model" standing in for your controls, evals, retention, and accountability. AO · DV · AR-P
Fighting the guardrail — jailbreak framing or a model switch to dodge a refusal; bypassing permissions on a laptop that holds production credentials; treating a safety refusal as a bug. AO · DV · AR-F · AR-P
Change everything at once — a tier jump plus a prompt rewrite plus a reshuffled toolbox, or a 100% rollout with no canary. Nothing is debuggable afterwards. AO · DV · AR-F · AR-P
Two flavors of the same thing in "select TWO" items — the right pair spans two layers (enforce + distribute, mechanism + measurement, control + disclosure). AO · AR-P
Unbounded loops — an agent with no turn, tool, spend, or wall-time budget and no real stop or progress predicate. An iteration cap is the backstop, never the success signal. DV · AR-F · AR-P
"Enabled means access" — a marketplace listing, admin enablement, or model-garden switch does not grant authentication, authorization, scope, or regional availability. Check the whole chain. AO · DV · AR-F · AR-P

Prefer, when torn between two

Smallest sufficient X — model, scope, privilege, autonomy class, context. Pilot, then expand; widen only on eval evidence. AO · DV · AR-F · AR-P
Explicit over implicit — pinned model IDs, passed context, allowlists, output contracts and schemas, idempotency keys, named owners with dates. AO · DV · AR-F · AR-P
Classify before you act — which error class (401 vs 429 vs 529), which layer (criteria → inputs → configuration → prompt → model), which risk tier on the module's own scale (L1–L4 in AO, T0–T4 in AR-P), coordinator vs worker. AO · DV · AR-F · AR-P
Structured signals over vibes — stop_reason, isError, schema checks, claim maps, eval results; never fluency, tone, or confidence. AO · DV · AR-F · AR-P
The right instrument for each check — code assertions for side effects and schemas, evals for quality, calibrated judges for rubrics, humans for judgment and irreversible impact. AO · DV · AR-F · AR-P
One variable at a time, with a rollback path and a success bar set before you look at results. AO · DV · AR-F · AR-P
A human gate exactly at the impact seam — before external or irreversible effects, sized to the risk; over-validating trivia is the paired wrong answer. AO · DV · AR-F · AR-P
Fail closed, escalate with context — attempted query plus partial results, UNKNOWN plus owner, annotated conflicts; never a silent drop, never an average of two sources. AO · DV · AR-F · AR-P
Trade-offs named — value AND limitations, cost AND quality, flexibility AND auditability. The pure-upside option is usually the distractor. AO · DV · AR-F · AR-P
A complete, testable brief — inputs, success criteria, format, and verification beat role prestige and adjectives ("be insightful"). AO · DV · AR-F · AR-P
Decompose, sequence, then parallelize — split consequential work into stages, run dependent stages in order, and parallelize only independent ones; one giant prompt or agent is the distractor. AO · DV · AR-F · AR-P
Segmented results over blended averages — slice quality and safety by intent, tenant, and document type; measure outcomes, not tokens, seats, or volume. DV · AR-F · AR-P

Stem-reading ritual: ① find the hard constraint the stem sets (residency, latency, risk tier, budget, "no waiting human") — the right answer honors it; ② locate the module and domain the stem lives in and answer with that module's mechanism and vocabulary — the same scenario can want a claim map (m23), a schema or idempotency fix (m02/m13), or a pattern and governance decision (m31/m33); never infer the altitude from the certification title alone; ③ honor the exam's named terms; ④ if a quoted phrase appears in the stem, the answer usually engages that exact phrase; ⑤ distractors often come in pairs of opposite extremes — the key sits between them.

CCAO-F · Associate Foundations (business user)

Judge the output, gate the risk

(L1–L4, claim map, poisoned-number scan and the 4D names are this pack's mnemonics — the exam tests the judgment, not the labels)

Output evaluation & validation21%

Workflow integration & solution design16%

Governance, risk, responsible use15%

Prompting & task execution14%

Product & model selection12%

Configuration & knowledge management12%

Troubleshooting & optimization10%

Bet the exam on these

Risk tiers L1–L4: L1 skim, keep the draft label · L2 spot-check claims + completeness · L3 full claim map + peer review · L4 expert + primary sources. Legal, medical, financial, HR/employment-effect, and safety work with real consequences is L4 (a public 10-K summary is not investment advice) — the expert gate is mandatory. External commitments, public publishing, money movement, and systems of record are at least L3.
Claim map: extract load-bearing claims (numbers, names, dates, quotes, commitments) → tag SUPPORTED / UNSUPPORTED / CONTRADICTED / AMBIGUOUS / OUT_OF_SCOPE → keep, rewrite, drop, or escalate. Polish last.
Poisoned-number scan: check numbers before names, dates, and opinions — exams hide one bad figure in fluent prose.
Citation ≠ validation: a 404 or a real-but-irrelevant link fails the same as no citation.
Text review ≠ authorization to execute — Connector writes (email, CRM, tickets) need an explicit authorization step — reviewing the draft is not approving the send.
Surfaces: Chat = quick turns · Projects = standing knowledge + instructions · Artifacts = self-contained deliverable · Skills = procedures Claude loads when relevant (Projects hold knowledge — swapping their jobs is the classic trap) · Connector = live data, upload = snapshot · Incognito = one confidential task · Memory = per-user context (edit in Settings → Memory).
Model ladder: lightest shippable model; raise effort before you jump tier.
Domain 1 playbooks: analysis: rubric + FACTS vs INFERENCES; research: scope, timeframe, source rules, citations; drafting: approved facts + voice samples + banned phrases; brainstorming: diverge then converge. Name defect, change one variable; two tightened failures → change layer, not adjectives. Temperature/fine-tuning are wrong-track.
Investigate verbs: “what did we decide?” → the surface that holds the record (Project knowledge, Memory, or a connector) — not chat recall; public cited landscape → Research (paid + web search on; never for one uploaded PDF); totals/pivots/Excel-PPT → code execution. Chat does not “calculate” 10k rows.
Three named tiers: Haiku (extract/classify/high-volume) · Sonnet (daily default) · Opus (after a lighter model or better brief failed). “Escalate past Opus” is the prestige distractor.
Policy ladder: disallowed → refuse; high-risk → allowed WITH safeguards (human gate + disclosure + eval); ordinary → still minimize; uncertain → escalate to the owner. Employment/finance/legal = high-risk-with-safeguards, not refuse-outright.
Augment vs redesign + context moves: regulated/external/irreversible flows augment first; redesign needs high waste, low risk, willing owners, and a pilot. Restart (drift) · summarize (handoff brief) · persist (Project instructions + knowledge). Memory is user-level (Settings → Memory); Project knowledge + instructions are the project-scoped store; incognito ≠ invisibility (Enterprise still retains/exports).
Governance: minimize PII + follow the org classification for venue; org/commercial data is typically not trained on by default — but confirm live privacy docs, don't repeat hallway lore; disclose when customers talk to AI; uncertain legality → policy/compliance owner, never improvise. Personal/consumer accounts follow the individual's own training/retention setting — a further reason they are the wrong venue for company data (confirm live docs).
Diagnostic ladder: success criteria → inputs → configuration (stale knowledge, stale Memory) → prompt → context (thread drift: summarize + restart) → only then model/effort. Cheapest lever on the worst metric.

If unsure, on this exam…

Between "ship it" and "check it": check, proportionally to the tier. The stock wrong pair is prestige-skip on one side and over-validating trivia on the other.
Stem quotes a safety refusal → honoring it is correct policy behavior; "bug", "tier problem", or jailbreak options are wrong.
"Which judgment catches this?" → Discernment spots the unsafe output; Diligence scales the review with the risk. (A stem that says Skill means the product feature — reusable instructions — not these labels.)
Output feeds a spreadsheet or system next → the structured-format answer wins over prose.
A number the brief wants doesn't exist → UNKNOWN or escalate; never a crisp invented KPI.
Repeated wrong template style after new files appear → configuration debt (purge or prioritize knowledge), not a model problem.
Anything "org-wide edit so nobody is blocked" → wrong; least privilege + Can view / Can edit split.

CCDV-F · Developer Foundations

Integrate deterministically, spend deliberately

Applications & integration33.1%

Model selection & optimization16.8%

Agents & workflows14.7%

Prompt & context engineering11.0%

Tools & MCPs10.6%

Security & safety8.1%

Claude Code3.1%

Eval, testing & debugging2.6%

Bet the exam on these

Three-axis frame: capability × cost × latency — find the vertex the stem hard-constrains, kill options that ignore it. Optimize cost per successful task, not per token.
Effort before tier: effort is the intra-model dial. Adaptive thinking starts with 4.6; sampling params return 400 on Opus 4.7/4.8/5, Sonnet 5, and Fable, while 4.6 accepts them. “Lower temperature” as a reliability fix is the distractor: choose schema / structured output. (Model-currency claims here are unverified against live docs — the guide itself names only Haiku, Sonnet, Opus.)
Pin in production: aliases drift; CI and prod pin model IDs. Pin bundle = model + prompt + tool versions; prompt changes ship like code (PR diff → eval suite → canary → record prompt_version).
Prompt caching: stable prefix first (tools → system → examples), volatile content last; reordering tools or shuffling examples busts the cache.
Message Batches: 50% cost · up to 24 h · no streaming · no multi-turn tool loop · correlate and resubmit by custom_id; use streaming (SSE) for interactive UX.
Tool design bar: task-shaped tools beat a god tool (run_sql, freeform action string = wrong); read/write split; idempotency keys on writes (model retries after timeouts double-charge); fail closed.
Pairing rule: every tool_use needs a tool_result — return ALL results, keep the assistant tool-use turn. The API is stateless: resend the full alternating history.
Agent loop: drive from stop_reason, never parse prose; budgets + stop conditions; a max-turn cap is the safety stop, not the primary stop.
Security: defense in depth against injection; fence untrusted content as evidence; authorize server-side at the owning seam; secrets in a secret manager or env — never frontend JS, prompts, CLAUDE.md, or the repo. MCP is not automatically safe.
Evals: frozen golden set + side-effect assertions + adversarial pack; canary with rollback criteria; kill switch for 3am cost explosions.
Debug loop: reproduce → diff the pin bundle → classify the layer → change one variable. Tier-jump before reading the trace is the named wrong answer.
Claude Code operations: .claude/commands/<name>.md is project/version-controlled; ~/.claude/commands/ is personal. .claude/agents/*.md defines custom subagents; plugins use an org-managed marketplace. Headless: claude -p --output-format json --json-schema; --continue resumes recent, --resume selects; settings: managed → CLI → project local → project shared → user.
Fast mode: same model, ~2.5× output speed at premium price; Opus 5/4.8 only, on Claude API and Managed Agents. Not Batch, Bedrock, Vertex, or Priority Tier; own rate limit; switching speed busts cache; never choose it to reduce the bill.
Adaptive-thinking lineup: Fable always-on; Opus 5 on by default; 4.7/4.8 opt-in; 4.6 adaptive recommended and budget_tokens legacy; Haiku 4.5 uses old-style extended thinking with a 200K window.
Client-side vs server-side tools: client tools run by you and return tool_result; web search, web fetch, and code execution are API server tools that run on Anthropic infrastructure and return content blocks in the same response (Claude Code’s Bash/file tools run locally). Reuse across apps → MCP; local logic → custom tool; procedure → Skill; file/shell → built-in.
Hosting first question: must tool execution and session artifacts stay inside your boundary? → self-hosted execution (Agent SDK, custom loop, or a Managed Agents self-hosted environment); otherwise Anthropic-hosted (or a third-party cloud — Bedrock/Vertex — when that vendor is the boundary). “Uses Claude” ≠ Managed Agents; hosting never waives evals or allowlists.
Streaming safety: Messages uses HTTP SSE (message_start → deltas → message_stop); WebSockets are your UI↔backend duplex channel; polling checks batch status. Execute tools only after complete tool_use; cancel gates writes; reconnect never double-applies.
SE control plane: branch + PR, protected main, human gate on secrets, authZ, migrations, and irreversible scripts. Refactor = plan → tests first → small diffs; “Claude wrote it” is a draft, not a merge.
Debugging split: integration-layer failure (bad request, dropped tool_result, schema drift, wrong pin) → code fix; model-output failure → prompt/eval. Verify caching with usage.cache_read_input_tokens; ≤4 breakpoints; short prefixes never cache; caches are model-scoped.
MCP trust in Claude Code: committed .mcp.json project servers need workspace trust; permissions are mcp__server__tool; never put secrets in .mcp.json; expose five needed tools, not 80.

If unsure, on this exam…

Error handling: 401/403 → fix config, don't retry · 429 → backoff + jitter + queue · 529-class → retry with a budget, then shed load · 400 → fix the request.
"Cache hits dropped" → something volatile entered the prefix (dynamic tool descriptions, timestamps). Per-request data goes in the user turn, not the cached system prefix.
"Claude forgot the last turn" → the app didn't resend history. Nothing server-side remembers for you on the Anthropic API.
Choosing a framework: swap Bedrock models or vendors without rewriting the loop → the vendor-agnostic framework; "any async work" ≠ Managed Agents; Batches ≠ agents (offline asynchronous model calls with no local or hosted tool loop).
Two answers both plausible → pick the one that validates output with code before side effects, not the one that trusts the model obeyed.
“Managed agent deployment models” means two Managed Agents environments: Anthropic cloud and self-hosted; Agent SDK is not “Anthropic hosts my sandbox”.
“Lower temperature” offered as a reliability fix is the distractor — pick schema / structured output.

CCAR-F · Architect Foundations · Bedrock/Vertex configuration modules are OUT of scope · Claude 101 / AI Fluency modules are background

Orchestrate agents, enforce in code

D1 · Agentic architecture & orchestration27%

D3 · Claude Code configuration & workflows20%

D4 · Prompt engineering & structured output20%

D2 · Tool design & MCP integration18%

D5 · Context management & reliability15%

Bet the exam on these

Context isolation: only the spawn prompt carries context into a subagent — no shared memory, no implicit flow. Pass context explicitly; parallelize only independent work.
The Q7 shape: worker logs show correct work but coverage is incomplete → blame the coordinator's decomposition, not the specialists.
Stop correctly: drive the loop from stop_reason == "end_turn"; never parse "I'm done!". --resume <session> continues a prior conversation; fork_session branches it — history copied to a new session ID, the original unchanged.
Advisory vs enforced: prompts are probabilistic; a hook or programmatic prerequisite gate refuses the downstream call until the upstream completes. Escalation is a structured handoff (attempted query + partial results), never a silent drop or empty escalation. Access failure ≠ empty result — [] after a timeout is silent suppression.
Claude Code (D3): CLAUDE.md hierarchy user/project/directory CONCATENATES; user-level is not shared via VCS. @import modularizes standards; .claude/rules/ with paths: globs beats per-directory CLAUDE.md for scattered files. .claude/commands/ ships with a clone; ~/.claude/commands/ is personal. SKILL.md: context: fork, allowed-tools, argument-hint. Plan mode suits multi-approach/architectural work; direct suits a single-file fix. Explore handles verbose discovery. -p fixes the CI hang; --output-format json + --json-schema create PR-postable findings. /memory shows what loaded; hooks: PreToolUse deny, PostToolUse normalize.
Structured output & prompts (D4): explicit categorical criteria beat “be conservative”; use 2–4 few-shots for the ambiguous case and show why. tool_use + JSON input_schema (forced with tool_choice: any when document type is unknown; a named tool to force extraction first) eliminates syntax errors, not semantic ones. Nullable/optional fields + enum unclear / other + detail stop fabrication. Retry = original document + failed extraction + named validation errors; it fixes format, never absent information. Add calculated_total vs stated_total, conflict_detected, detected_pattern.
Batches & review (D4): 50% cost · ≤24 h · no latency SLA · no multi-turn tool calling · custom_id to correlate and resubmit only failures. Blocking pre-merge = sync; overnight = batch. An independent second instance reviews; use per-file passes plus a cross-file integration pass, never a bigger window.
Tool design & MCP (D2): descriptions are the primary selection signal — expand inputs, examples, edge cases, and boundaries before few-shots, routers, or consolidation; split/rename overlapping tools. Use 4–5 tools per agent, not 18. Structured errors: errorCategory (transient/validation/business/permission), isRetryable, human text; access failure ≠ valid empty result. Scoped cross-role verify_fact handles the 85% case; a coordinator handles the rest. .mcp.json + ${GITHUB_TOKEN} is shared; ~/.claude.json is personal. Resources = content catalogs; Grep contents / Glob paths / Edit non-unique → Read + Write; isError is inside the result.
Escalation & calibration (D5): explicit human request → escalate now (offer once if trivial, escalate on reiteration); policy silent/ambiguous → escalate; no progress → structured handoff; multiple identity matches → ask for identifiers. Sentiment and self-confidence are wrong routers — first fix is explicit criteria + few-shots. “97% overall” can hide a 60% stratum: segment by document type × field, stratify samples, calibrate per-field confidence on labeled sets.
Context reliability: resend a case-facts block (amounts/dates/IDs) every turn outside the summary; lost-in-the-middle is real — repetition ≠ placement; crash manifests limit loss to one phase; conflicting sources get annotated, never averaged.

If unsure, on this exam…

Any "the subagent will remember / inherit" option is wrong — it gets no parent history or memory, only its spawn prompt plus what its own tools read (a Read/Grep/web-search worker still sees the world).
Style or preference problems → prompt rung. "Must never / compliance / dollar caps" → hook or deny rung. Deny wins when several fire.
"Which file / where" stems → answer with the guide's mechanic: commands dir, rules globs, SKILL.md keys, -p, @import; CLAUDE.md levels concatenate, they do not override (managed settings do override user/project settings).
A spawn that "just won't work" → check the tool allowlist and AgentDefinition before blaming the model.
Two summarization passes lost an exact figure → the answer is a resent case-facts block, not a bigger window or "be precise".

CCAR-P · Architect Professional

Design the system, govern the blast

Integration19%

Solution design & architecture17%

Evaluation, testing & optimization16%

Governance, safety & risk14%

Stakeholder comms & lifecycle14%

Claude models, prompting & context engineering13%

Developer productivity & enablement7%

Bet the exam on these

Pattern selection: workflow (fixed steps, auditable transitions) vs agent (dynamic); router for mixed intents; parallelization for independent subtasks; evaluator–optimizer for refine-until-pass. Graphs encode allowed transitions for control and audit; free loops maximize flexibility but fail compliance stems. Multi-agent only for clear role separation (read-only researcher + write executor with approval).
Who executes client tools? Your runtime. Never the model, never the provider. Authorization lives at the seam that owns the resource.
RAG at scale: retrieval matched to data shape and query pattern (hybrid BM25 + vector when queries mix exact tokens and semantics), section-aware chunking, citations required, honest empty retrieval, index tenancy, authz at the retrieval seam. SSRF guard on fetch/MCP.
Eval machinery: gold / adversarial / regression / slice sets; code judge for schema and exact-match; model judge calibrated against ≥2 humans on the same rubric, run blind, versioned like code; a judge score is never the sole production gate without code assertions; pre-register thresholds before looking at results.
Optimization order (only after quality is acceptable): measure → shrink context + cache prefixes → route easy traffic to cheaper models → parallelize independent work → async UX.
Safety architecture: threat-model injection, indirect injection, insecure output handling, over-privilege, leakage, supply chain (MCP/Skills). Tool controls are the hardest brakes; Constitutional AI ≠ your app's safety — provider properties don't cover your tool privileges, data flows, or UX risks, and accountability stays yours.
Graduated autonomy: automatic only for reversible + small-impact + logged; unfamiliar or irreversible writes get human or dual control; widen the auto class only when eval error rates are acceptable for the impact scope. Fake HITL (rubber-stamp queues, self-grade) fails.
ZDR ≠ your retention: it is provider posture; your logs, warehouses, and eval stores still need minimization. Erasure goes beyond SQL rows: indexes, caches, embeddings.
Stakeholder & lifecycle: discovery metrics before pattern choice (jumping to a pattern is penalized); ADR = context, decision, alternatives, consequences, date; name non-goals; phase autonomy ("suggest now; auto-send after metric ≥ T for two weeks"); publish residual miss rates; never promise identical wording or zero errors; handoff = runbook + dashboards + RACI + named DRI with an end date; model EOL is a lifecycle event (pin inventory, migration owners, compat evals, comms plan).
Enablement: paved road = org-managed settings + curated marketplace + CLAUDE.md + Skills + hooks; builder vs production credentials — no god keys in the IDE; break-glass via PAM with audit.
Cache and value: cached ≠ evicted — cached tokens still occupy the window; caching changes price/TTFT only. The five value pillars are efficiency, transformation, productivity, cost, performance SLAs; “quality” is an evaluation stem, not a pillar.
Grounding: empty retrieval → refuse/clarify/escalate; cited IDs ⊆ retrieved IDs; tenant isolation = hard filter bound to a verified token.
Write reliability: use a server-side idempotency key; never commit from a partial streamed plan; chat memory is not a ledger.
Route facts: Claude Platform on AWS ≠ Bedrock; IDs differ per route, so use a provider adapter; residency pin differs per route.
Exam-verb template: implement → mechanism; identify → risk + where; ensure → control + measurement; design → layers + owners; recommend → one option with trade-offs. Answer = mechanism + metric + owner.
Confidence and GA: confidence is a system signal — retrieval score, validator pass, classifier margin — never “I’m sure”; irreversible/regulated writes stay human. A critical safety/privacy red or HITL-staffing red blocks GA regardless of weighted average; demo ≠ GA.
Compliance and diagnosis: GDPR → minimization, DPIA, erasure incl. embeddings/eval caches/backups; HIPAA → BAA, minimum-necessary, no web tools on PHI, clinician HITL; FedRAMP → boundary, logging, residency. Sources wrong → retrieval; right but invents → grounding/cite/refuse; format broken → schema/few-shot; hard cases → tier/thinking.

If unsure, on this exam…

Compliance constraint in the stem (FedRAMP-like, residency, authorized clouds) → eliminate by constraint first, then design inside the surviving option.
"Simplest thing that works" beats the impressive architecture — smallest sufficient model, augmented LLM before workflow, workflow before agent, single agent before swarm.
Promotion or upgrade questions → evidence + cost/latency envelope, never prestige or family-name loyalty.
An exec in the room → the artifact is a one-page decision brief with a recommendation and a review date, not a lecture or a raw table.
"Select TWO" enforcement stems → org-managed settings + the managed marketplace: enforce the policy and distribute only approved tools (never two flavors of the same control). (practice-exam pattern, not guide text)
Cache or latency stems → volatile content before the stable prefix (or thinking/config flips) is the cause; stabilize configs on latency-sensitive paths.