CCDV-F study sheet (red and yellow topics)
Every fact below was checked against the live official docs on 2026-10-20 and carries its source link. Where current docs differ from what an exam written in July 2026 might key, the line is marked EXAM-LAG. On those items, answer from the scenario's model: if the stem names a current model (Opus 5.5, Sonnet 5.5, Haiku 5.5, Fable 5.1), use current behavior.
Practice quiz: [[2026-10-20-ccdv-f-quiz-1]] · interactive at https://ccdv-quiz.rdco.dev
See [[2026-10-20-ccdv-f-readiness]] for the full domain-by-domain readiness read and prep-plan ROI order this sheet backs.
0. Exam logistics (from the guide PDF)
- 53 items, 120 minutes, multiple-choice and multiple-response ("each item states how many responses to select"); scaled pass mark 720 on 100-1,000; fee $125; valid 12 months.
- Retakes: wait 14 days after the 1st fail, 30 after the 2nd, 90 after the 3rd; at most 4 attempts in a rolling 12 months.
- Rescheduling: the exam guide v1.0 says 24 hours ("You may cancel or reschedule up to 24 hours before your appointment"). A resources researcher reports that the official exam FAQ says 48 hours. Ray could not verify the FAQ. Treat 48 hours as the safe deadline.
- Weights: D1 Agents and Workflows 14.7 · D2 Applications and Integration 33.1 · D3 Claude Code 3.1 · D4 Eval/Testing/Debugging 2.6 · D5 Model Selection and Optimization 16.8 · D6 Prompt and Context Engineering 11.0 · D7 Security and Safety 8.1 · D8 Tools and MCPs 10.6.
1. Current models
Source: https://platform.claude.com/docs/en/about-claude/models/overview · https://platform.claude.com/docs/en/about-claude/pricing
| Model | API ID (= Google Cloud ID) | Bedrock ID | Input / output $ per MTok | Cache read | Default effort | Thinking |
|---|---|---|---|---|---|---|
| Claude Fable 5.1 | claude-fable-5-1 |
anthropic.claude-fable-5-1 |
10 / 50 | 0.025x | high | adaptive, always on |
| Claude Opus 5.5 | claude-opus-5-5 |
anthropic.claude-opus-5-5 |
4 / 20 | 0.05x | medium | adaptive, always on |
| Claude Sonnet 5.5 | claude-sonnet-5-5 |
anthropic.claude-sonnet-5-5 |
2 / 10 | 0.05x | high | adaptive; between_tools instead of disabled |
| Claude Haiku 5.5 | claude-haiku-5-5 |
anthropic.claude-haiku-5-5 |
0.10 / 0.50 (prompts up to 100K); 0.50 / 2.50 above | 0.1x | medium | adaptive; disabled only at effort high or below |
- All four: 1M-token context, 128K max output; up to 300K output in Batches with beta
output-300k-2026-03-24(not Fable 5.1). Knowledge cutoff Jun 2026. - Every model ID is a pinned snapshot, including the dateless IDs from the 4.6 generation on ("Every Claude model ID is a pinned snapshot"). EXAM-LAG: older material pins with dated IDs and calls dateless names aliases.
- The docs' default recommendation: "start with Claude Opus 5.5 for most workloads. Use Claude Fable 5.1 for demanding reasoning and long-horizon agentic work." Course vs docs: the partner MSO course says to start with Sonnet. Both agree the tier moves are eval-driven: move up when an eval shows a quality miss, move down when it shows the drop is acceptable.
- No over-200K long-context premium on 4.6+ models; Haiku 5.5 has its own 100K price step. US-only
inference_geo= 1.1x on all token categories (4.6+). - Fast mode: GA on Opus 5.5, no beta header,
speed: "fast", $8 / $40, up to 2.5x output tokens per second (output speed, not time to first token), separate rate limit, not on Batches, Bedrock or Google Cloud. Opus 5 and Opus 4.8 still need thefast-mode-2026-02-01header ($10 / $50). https://platform.claude.com/docs/en/build-with-claude/fast-mode - Tokenizer: Claude 4.7 and later produce about 30% more tokens for the same text. Recount with the target model; chars-per-token depends on tokenizer generation. https://platform.claude.com/docs/en/build-with-claude/token-counting
2. Breaking-change matrix (the EXAM-LAG hot zone)
| Setting | Opus 5.5 | Sonnet 5.5 | Haiku 5.5 | Fable 5.1 | Source |
|---|---|---|---|---|---|
thinking: {type: "enabled", budget_tokens} |
400 | 400 | 400 | 400 | extended-thinking ("Claude 4.7 and later models ... reject requests that use it") |
thinking: {type: "disabled"} |
400 | 400 (use between_tools) |
OK at effort high or below | 400 | thinking-troubleshooting |
tool_choice any / tool |
400 | 400 (even on count_tokens) | allowed | 400 | thinking |
Non-default temperature / top_p / top_k |
400 | 400 | 400 | 400 | api/messages |
| Assistant prefill | 400 | 400 | 400 | 400 | all Claude 4.6+ models |
display default |
omitted | omitted | omitted | omitted | thinking |
- Replacements: thinking depth goes to
output_config.effort; forced tools becometool_choice: auto+strict: true+ a prompt instruction, or structured outputs; prefill becomesoutput_config.formator a user-turn instruction. budget_tokensis now called "legacy manual thinking budget" (steering thinking). It still works on Haiku 4.5 and older (minimum 1,024, must be less thanmax_tokens), and is deprecated on Opus 4.6 / Sonnet 4.6. EXAM-LAG: an exam item may still test thebudget_tokensform. Answer it as legacy-correct only when the stem uses an older model.- Sampling: temperature defaults to 1.0 and ranges 0-1; "even with temperature of 0.0, the results will not be fully deterministic." On current models only defaults are accepted (temperature 1.0; Haiku 5.5 guide: top_p must be 0.99; top_k any value rejected). Docs conflict: the API reference says top_p >= 0.99 is accepted, while the thinking page and Haiku 5.5 guide say top_p 1 returns a 400. Safest answer: omit sampling parameters and steer through prompting.
- Course module 1 claims checked: input over the window = 400; generation hitting the window =
model_context_window_exceeded; non-default sampling = 400; temperature 0 not deterministic; tokenizer-dependent counts. All match the docs. - Prompting modes (zero-shot, one-shot, multi-shot): examples live in the prompt, show the output shape, and cost tokens on every call. The docs call examples "one of the most reliable ways to steer Claude's output format, tone, and structure"; wrap them in
<example>tags (several in<examples>), make them diverse and cover edge cases, and "Include 3-5 examples for best results." Course vs docs: the course says one or two examples usually fix a structure or casing miss. Either way, try examples before upgrading the model or adding more rules; examples can let a cheaper model pass the eval. https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices - Long inputs: put documents at the top, the query at the end ("can improve response quality by up to 30 percent"), each document in
<document>tags with<source>and<document_content>. Same source. - MSO course claim checked: "reasoning is independent of model choice" is only partly true now. Opus 5.5 and Fable 5.1 cannot turn thinking off (effort
lowis the floor), and Sonnet 5.5 usesbetween_tools.
3. Thinking and effort
Sources: https://platform.claude.com/docs/en/build-with-claude/thinking · https://platform.claude.com/docs/en/build-with-claude/effort · https://platform.claude.com/docs/en/build-with-claude/adaptive-thinking
- Config:
thinking: {type: "adaptive"}(omitting it is equivalent on Opus 5.5). Effort lives atoutput_config.effort, not insidethinking. Levels:low,medium,high,xhigh,max. - Effort affects all tokens: text, tool calls and arguments, and thinking. Low effort means fewer, more consolidated tool calls and terser output. Use
lowfor high-volume, latency-sensitive or simple work (chat, classification, lookups),high/xhighfor hard multi-step coding and agentic work. Sonnet 5.5 levels were recalibrated: run a fresh effort sweep. display:"summarized"returns a readable summary;"omitted"(default on current models) returns an emptythinkingfield but thesignaturestill carries the encrypted full thinking;"updates"(betathinking-display-updates-2026-08-18) returns progress notes. No setting returns the raw chain of thought. You pay for the full thinking, billed as output tokens.- Tool use with thinking: "pass the thinking blocks from the assistant message back to the API, complete and unmodified." You cannot rearrange, edit or partially drop them, including
redacted_thinkingblocks (encrypteddatafield). Filtering ontype == "thinking"alone dropsredacted_thinkingand breaks the protocol. Outside tool use, older-turn thinking blocks may be omitted. - Interleaved thinking is automatic with adaptive thinking (no beta header). The
interleaved-thinking-2025-05-14header applies only to manual mode on Opus 4.5 / Sonnet 4.5 and earlier. - Streaming: thinking arrives as
thinking_delta, then onesignature_deltajust beforecontent_block_stop. - Changing the thinking config or the effort level starts a new cache prefix (messages level).
4. Prompt caching
Source: https://platform.claude.com/docs/en/build-with-claude/prompt-caching
- Syntax:
"cache_control": {"type": "ephemeral"}on a content block; or one top-levelcache_controlon the request (automatic caching; it uses one of the 4 slots). - Max 4 breakpoints. Prefix order:
toolsthensystemthenmessages. Exact prefix match: any byte change invalidates that point and everything after. - Lookback: 20 blocks per breakpoint. The system only finds entries that earlier requests wrote at a breakpoint.
- TTL: default 5 minutes, refreshed free on each hit, measured from the start of the request. 1 hour via
"ttl": "1h", no beta header (EXAM-LAG: older material needsextended-cache-ttl-2025-04-11). Longer TTL entries must come before shorter ones. - Minimum cacheable prompt: 512 tokens on all current 5.x models; 1,024 for Opus 4.8, Sonnet 5, Sonnet 4.6/4.5, Opus 4/4.1, Sonnet 4; 2,048 for Opus 4.7 and Haiku 3.5; 4,096 for Opus 4.5/4.6 and Haiku 4.5. Below the minimum: no error, no cache.
- Price multipliers vs base input: 5-minute write 1.25x; 1-hour write 2x; read 0.1x on most models, 0.05x on Opus 5.5 and Sonnet 5.5, 0.025x on Fable 5.1. Stacks with the Batch 50% discount and fast mode.
- Invalidation hierarchy (a change invalidates its level and every later one):
| Change | Tools | System | Messages |
|---|---|---|---|
| Tool definitions | x | x | x |
| Web search toggle, citations toggle, speed (fast vs standard) | kept | x | x |
tool_choice, images added or removed |
kept | kept | x |
Thinking parameters, output_config.effort |
model-specific | model-specific | x |
- Mid-conversation additions without invalidation: append a
{"role": "system"}message tomessages(Opus 5.5, Sonnet 5.5, Haiku 5.5, Fable 5.1 and others; not Sonnet 5; no beta header) instead of editing top-levelsystem. https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages - Usage fields:
cache_creation_input_tokens(written),cache_read_input_tokens(read),input_tokens(after the last breakpoint, uncached); total input = all three. Breakdown objectcache_creation: {ephemeral_5m_input_tokens, ephemeral_1h_input_tokens}. Both cache fields 0 = nothing cached. - Isolation: per workspace on the Claude API, Claude Platform on AWS and Foundry; per organization on Bedrock and Google Cloud; never shared across orgs.
- Thinking blocks cannot take
cache_controlbut are cached as part of earlier assistant turns. - Pre-warm:
max_tokens: 0writes the cache and returns empty content withstop_reason: "max_tokens"; you pay the write, not output. Not allowed with streaming,output_config.format, forced tool_choice, or in Batches. - Rate limits: for most models only uncached input tokens count toward ITPM, so caching raises throughput too.
5. Token counting
Source: https://platform.claude.com/docs/en/build-with-claude/token-counting
POST /v1/messages/count_tokens(client.messages.count_tokens). Accepts system, tools, images, PDFs, thinking. Errors on server tools (web search/fetch, code execution, tool search), the MCP connector, andurl/filesources (send base64).- Free, but with its own RPM limits (Start 5,000 · Build 10,000 · Scale 20,000), independent of message creation.
- Returns an estimate; does not use caching.
- Context budgeting: input alone over the window gets a 400
invalid_request_error("prompt is too long") on every model. On 4.5+ models, input +max_tokensover the window is accepted; if generation reaches the limit,stop_reason: "model_context_window_exceeded". https://platform.claude.com/docs/en/build-with-claude/context-windows
6. Streaming
Source: https://platform.claude.com/docs/en/build-with-claude/streaming
message_start: a Message with emptycontent,stop_reason: null.- Per block:
content_block_startthen one or morecontent_block_deltathencontent_block_stop. The blockindexmatches its position in the finalcontentarray. - One or more
message_delta: carriesstop_reasonand cumulativeusage. message_stop: always last.
pingevents can appear anywhere.errorevents can arrive mid-stream (for exampleoverloaded_error, which would be a 529 when not streaming). Handle unknown event types gracefully.- Delta types:
text_delta;input_json_delta(partial_jsonstrings to accumulate, parse at block stop; the finaltool_use.inputis an object);thinking_delta;signature_delta;citations_delta(citations). - Transport:
"stream": truereturns server-sent events over the same HTTP connection. - Recovering an interrupted stream: capture the partial response, then send a continuation request. Claude 4.5 and earlier: put the partial text in an assistant message (prefill). Claude 4.6 and later: prefill is rejected, so send a user message containing the partial response plus "Continue from where you left off." Tool use and thinking blocks cannot be partially recovered; resume from the most recent text block. There is no event replay.
- SDKs are thin layers over the REST API with typed errors and automatic retries. Python has
Anthropicand a separateAsyncAnthropic; the TypeScript client has no separate async class because its methods already return Promises. https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/typescript - The async-vs-batch choice: a user is waiting, or you need tokens on screen or an interactive tool loop = Messages API with an async client, bounded concurrency and streaming. Offline, latency-tolerant and cost-driven work = Message Batches (50% off, up to 24h).
- SDK helper:
stream.get_final_message()(Python) /stream.finalMessage()(TypeScript). Stream any request with long output or largemax_tokens; the SDK refuses non-streaming requests expected to run past about 10 minutes.
7. Message Batches
Source: https://platform.claude.com/docs/en/build-with-claude/batch-processing
- 50% of standard prices on input and output. Up to 100,000 requests or 256 MB per batch, whichever first. Most finish within 1 hour; anything unprocessed after 24 hours expires.
processing_status:in_progressthenended(cancelingafter a cancel). Result types:succeeded,errored,canceled,expired; the last three are not billed.- Results: a
.jsonlatresults_url, in any order: always join bycustom_id(unique,^[a-zA-Z0-9_-]{1,64}$). Available for 29 days after creation. - Not supported in a batch:
stream: true,speed(fast mode),max_tokens: 0. Supported: vision, tools (including server tools), system, multi-turn, thinking, most betas. Prompt caching works best-effort (use the 1-hour TTL). - Own rate limits: RPM on the Batches endpoints plus a cap on requests waiting in the queue (Start tier: 1,000 RPM, 200,000 queued). Batches are workspace-scoped and validated asynchronously.
- Not available on Bedrock or Google Cloud.
- Pick batch when latency-tolerant and high-volume; pick realtime when a user is waiting or you need an interactive tool loop.
8. Vision and PDF
Sources: https://platform.claude.com/docs/en/build-with-claude/vision · https://platform.claude.com/docs/en/build-with-claude/pdf-support
- Images: JPEG, PNG, GIF (first frame only), WebP. Max 10 MB per image on the API (5 MB on Bedrock and Google Cloud). Max 8000x8000 px; with more than 20 image/document blocks, each image must be at most 2000 px per side. Max 600 images per request (100 for 200K-context models). Sources:
base64,url,file(Files API); Bedrock and Google Cloud are base64 only. Put images before text. - Image tokens:
ceil(w/28) x ceil(h/28). High-res tier on Claude 4.7+: up to 2576 px long edge / 4,784 tokens; standard tier 1568 px / 1,568 tokens. EXAM-LAG: older formula wasw*h/750. - PDFs:
{"type": "document", "source": {"type": "base64"|"url"|"file", ...}}. Max 32 MB per request and 600 pages (100 when the context window is under 1M). Each page becomes an image plus extracted text (about 1,500-3,000 text tokens per page plus image tokens). No encrypted PDFs. EXAM-LAG: older docs said 100 pages.
9. Tool use, tool_choice, stop_reason
Sources: https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools · https://platform.claude.com/docs/en/agents-and-tools/tool-use/handle-tool-calls · https://platform.claude.com/docs/en/agents-and-tools/tool-use/parallel-tool-use · https://platform.claude.com/docs/en/build-with-claude/handling-stop-reasons
- Tool definition:
name(^[a-zA-Z0-9_-]{1,128}$),description,input_schema; optionalinput_examples,cache_control,strict,defer_loading,allowed_callers. "Extremely detailed descriptions" are "by far the most important factor in tool performance." Return only high-signal fields from tools. tool_choice:auto(default),any,tool(by name),none.any/toolreturn 400 on Opus 5.5, Sonnet 5.5, Fable 5.1 and with manual thinking.disable_parallel_tool_use: truegoes insidetool_choice.tool_result:tool_use_id,content, optionalis_error: true. All results for one assistant turn go in one user message,tool_resultblocks first, text after.- Client tools run in your code; server tools (web search, web fetch, code execution) run on Anthropic's side.
pause_turn= server-tool loop hit its limit (10 iterations by default): send the content back as-is to continue. - Structured outputs:
output_config.format: {type: "json_schema", schema}(GA;output_format+ beta header is legacy).strict: trueon tools for schema-valid inputs. Limits: 20 strict tools,additionalProperties: false, no recursive schemas. Incompatible with citations. https://platform.claude.com/docs/en/build-with-claude/structured-outputs
stop_reason |
Meaning | Action |
|---|---|---|
end_turn |
finished naturally | use it |
max_tokens |
hit your cap | raise or continue; output truncated |
stop_sequence |
hit one of your stop_sequences |
read stop_sequence |
tool_use |
calling a tool | run it, return tool_result |
pause_turn |
server-tool loop limit | send back to continue |
refusal |
declined (HTTP 200) | read stop_details.category; fallback model |
model_context_window_exceeded |
filled the context window | treat as truncated |
stop_details is null except on refusal (category: cyber, bio, frontier_llm, reasoning_extraction, general_harms, or null).
10. Errors, retries, rate limits
Sources: https://platform.claude.com/docs/en/api/errors · https://platform.claude.com/docs/en/api/rate-limits · https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/python
| Code | Type | Retry? |
|---|---|---|
| 400 | invalid_request_error (also a spend limit you set) |
no, fix the request |
| 401 | authentication_error |
no |
| 402 | billing_error |
no |
| 403 | permission_error |
no |
| 404 | not_found_error |
no |
| 409 | conflict_error |
SDK retries |
| 413 | request_too_large |
no; shrink (Messages 32 MB, Batches 256 MB, Files 500 MB) |
| 429 | rate_limit_error |
yes, honor retry-after (a tier spend-cap 429 has no retry-after and keeps failing) |
| 500 | api_error |
yes, backoff |
| 504 | timeout_error |
yes; use streaming or Batches for long requests |
| 529 | overloaded_error |
yes, backoff; not your limits |
- Every response has a
request-idheader (_request_idin the SDKs). - SDKs retry 2 times by default with exponential backoff: connection errors, 408, 409, 429, >=500. Default timeout 10 minutes (timeouts are retried).
- Rate limits: RPM, ITPM, OTPM per model class, token-bucket replenishment (60 RPM may be enforced as 1 per second).
max_tokensdoes not count toward OTPM. Ramp traffic gradually (acceleration limits). - Headers:
retry-after;anthropic-ratelimit-{requests,tokens,input-tokens,output-tokens}-{limit,remaining,reset}(reset is RFC 3339);anthropic-priority-{input,output}-tokens-*for Priority Tier.tokens-*shows the most restrictive limit in effect.
11. Bedrock and Google Cloud
Sources: https://platform.claude.com/docs/en/build-with-claude/claude-in-amazon-bedrock · https://platform.claude.com/docs/en/build-with-claude/claude-on-amazon-bedrock-legacy · https://platform.claude.com/docs/en/build-with-claude/claude-on-vertex-ai
| Bedrock (Opus 4.7+) | Google Cloud (Vertex) | |
|---|---|---|
| Client | AnthropicBedrockMantle(aws_region=...) |
AnthropicVertex(project_id=..., region="global") |
| Endpoint | bedrock-mantle.{region}.api.aws/anthropic/v1/messages |
...:rawPredict, model in the URL |
| Model ID | anthropic.claude-opus-5-5 |
claude-opus-5-5 (older: claude-haiku-4-5@20251001) |
| Auth | AWS SigV4 credential chain, or bearer token | GCP Application Default Credentials |
| Body version | none on Mantle (legacy InvokeModel: bedrock-2023-05-31) |
anthropic_version: "vertex-2023-10-16" |
| Pricing note | regional endpoints +10%; global no premium | regional and multi-region +10% |
| Not supported | URL/Files sources; code execution, web search, web fetch, advisor; Skills, MCP connector, programmatic tool calling; Message Batches, Models, Admin, Usage/Cost endpoints; Managed Agents; server-side fallbacks | URL/Files sources; code execution, web fetch, advisor; Skills, MCP connector, programmatic tool calling; Message Batches, Models, Admin, Usage/Cost; Managed Agents; server-side fallbacks |
- Use the platform client, never the first-party client with a
base_urloverride. EXAM-LAG: older items show Bedrock InvokeModel, ARN-style IDs andbedrock-2023-05-31; that is now the legacy page (Opus 4.6 and earlier).
12. MCP server authoring
Sources: https://modelcontextprotocol.io/specification/latest · https://modelcontextprotocol.io/specification/latest/basic/transports · https://modelcontextprotocol.io/docs/develop/build-server · https://modelcontextprotocol.io/specification/latest/changelog
- Current spec revision: 2026-07-28. JSON-RPC 2.0.
- EXAM-LAG (big): 2026-07-28 made MCP stateless. No
initialize/notifications/initializedhandshake: each request carries protocol version and client capabilities in_meta, and servers MUST implementserver/discover. Protocol sessions andMcp-Session-Idare gone. Roots, Sampling and Logging are deprecated; server-to-client requests are replaced by Multi Round-Trip Requests (InputRequiredResult). Versions 2025-11-25 and earlier are "Legacy" (handshake-based). An exam keyed to 2025 material will expect initialize, capability negotiation, and sampling/roots/elicitation as client features. - Server primitives and who controls them: tools = model-controlled (
tools/list,tools/call), resources = application-driven (resources/list,resources/read,resources/templates/list), prompts = user-controlled (prompts/list,prompts/get). Client feature still current: elicitation. - List-changed notifications (
notifications/tools/list_changed) now go to clients that opened asubscriptions/listenstream;resources/subscribewas replaced bysubscriptions/listen. - Errors: tool execution failures go in the result with
isError: true(the model can self-correct); protocol problems (unknown tool, bad args) are JSON-RPC errors (for example -32602). - Transports: stdio (client launches the server as a subprocess; newline-delimited JSON-RPC; server MUST NOT write non-MCP data to stdout; logs go to stderr) and Streamable HTTP (each message is an HTTP POST to one endpoint; validate the
Originheader; bind to 127.0.0.1 locally). HTTP+SSE is deprecated. There is no "socket" transport in the spec, although the exam guide lists "stdio, sockets" as communication patterns. - Auth: optional; HTTP transports use OAuth 2.1; stdio servers take credentials from the environment. Dynamic Client Registration is deprecated in favor of Client ID Metadata Documents.
Minimal Python server (official tutorial, current SDK):
# uv add "mcp[cli]"
from mcp.server import MCPServer
mcp = MCPServer("weather")
@mcp.tool()
async def get_alerts(state: str) -> str:
"""Get active weather alerts for a two-letter US state code."""
return f"No alerts for {state}"
if __name__ == "__main__":
mcp.run(transport="stdio")
EXAM-LAG: older tutorials import from mcp.server.fastmcp import FastMCP. TypeScript now uses @modelcontextprotocol/server with new McpServer({name, version}), server.registerTool(name, {description, inputSchema: z.object(...)}, handler) and serveStdio(...); hand-wiring server.connect(new StdioServerTransport()) "only serves 2025-era clients."
Using MCP from Claude:
- Claude Code:
claude mcp add --transport http <name> <url>(recommended for remote) orclaude mcp add <name> -- <command> [args](stdio); SSE is deprecated. Scopes:local(default, you, this project),project(shared via.mcp.json),user(you, all projects). https://code.claude.com/docs/en/mcp - Messages API MCP connector: beta
mcp-client-2025-11-20; needs anmcp_serversentry (type: "url",url,name, optionalauthorization_token) and{"type": "mcp_toolset", "mcp_server_name": ...}intools. Tools only (no resources or prompts); server must be reachable over HTTP; no local stdio. https://platform.claude.com/docs/en/agents-and-tools/mcp-connector - Choosing a customization: built-in tools for standard capabilities; custom tools for app-specific functions; Skills for procedures and bundled scripts with progressive disclosure (metadata always loaded, body when triggered) https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview; MCP for reusable connections to external systems shared across apps.
13. Agent SDK, Managed Agents, Claude Code
Sources: https://code.claude.com/docs/en/agent-sdk/overview · https://code.claude.com/docs/en/agent-sdk/python · https://code.claude.com/docs/en/agent-sdk/migration-guide · https://platform.claude.com/docs/en/managed-agents/overview
- Packages:
claude-agent-sdk(Python),@anthropic-ai/claude-agent-sdk(TS). Renamed from the Claude Code SDK (ClaudeCodeOptionsbecameClaudeAgentOptions). It "runs the Claude Code binary" in a process you operate: built-in tools, permissions, sessions, hooks. - Entry points:
query(prompt=..., options=ClaudeAgentOptions(...))yields messages (AssistantMessage,UserMessage,SystemMessage,ResultMessage,StreamEvent, ...);ClaudeSDKClientkeeps a session across exchanges. - Options:
allowed_tools= auto-approve without prompting (NOT an allowlist);disallowed_tools= a bare name removes the tool from context;permission_modeindefault,acceptEdits,plan,dontAsk,bypassPermissions,auto;system_prompt(default is minimal;{"type": "preset", "preset": "claude_code"}with optionalappend);setting_sources(omitted = loads user, project and local settings including CLAUDE.md; pass[]to isolate);mcp_servers,hooks,agents(subagents),max_turns,cwd,resume. - Custom tools:
@tool(...)+create_sdk_mcp_server(name, tools=[...])(in-process MCP server). - Hook events (Python): PreToolUse, PostToolUse, PostToolUseFailure, UserPromptSubmit, Stop, SubagentStop, SubagentStart, PreCompact, Notification, PermissionRequest. Hooks = deterministic actions; prompts = probabilistic.
- Auth:
ANTHROPIC_API_KEY;CLAUDE_CODE_USE_BEDROCK=1;CLAUDE_CODE_USE_VERTEX=1;CLAUDE_CODE_USE_FOUNDRY=1. Does not load.envfiles. - Managed Agents (beta header
managed-agents-2026-04-01): Anthropic runs the agent loop; objects are Agent (model, system, tools, MCP, skills), Environment (Anthropic cloud sandbox or self-hosted sandbox), Session, Events (SSE, history stored server-side). Not eligible for ZDR or HIPAA BAA. Not on Bedrock or Google Cloud. Choose it when you want hosted harness + deployment; choose the Agent SDK when you must run the loop yourself. - Claude Code: CLAUDE.md tiers = managed policy, user
~/.claude/CLAUDE.md, project./CLAUDE.mdor./.claude/CLAUDE.md, personal./CLAUDE.local.md(gitignore it);@pathimports up to 4 hops; AGENTS.md is read when no CLAUDE.md exists. Settings precedence: managed > command line > local project > shared project > user (list keys such aspermissions.allowmerge). Headless:claude -p "..." --output-format text|json|stream-json,--resume <id>,--barefor scripts. Hooks: PreToolUse exit code 2 blocks;matcherfilters by tool name, so aWrite|Editmatcher never sees Bash. Skills:.claude/skills/<name>/SKILL.md(onlydescriptionrecommended); custom commands merged into skills. https://code.claude.com/docs/en/memory · https://code.claude.com/docs/en/settings · https://code.claude.com/docs/en/headless · https://code.claude.com/docs/en/hooks
14. Evals and debugging (Module 3 theme, D4)
Source: https://platform.claude.com/docs/en/test-and-evaluate/develop-tests
- Grading order: code-based (fastest, most reliable; exact match, string match, schema checks) then LLM-based (detailed rubric, ask for a discrete score, grader with thinking on) then human (slow, expensive; "avoid if possible"). Prefer volume with automated grading over a few hand-graded cases. Include edge cases.
- For free-text output, assert properties (parses, fields present, values in range) and grade meaning with an LLM rubric. Exact match is still right for categorical outputs. (Course says "assert properties, not exact text"; the docs agree for free text.)
- Isolate faults: check
stop_reasonfirst (max_tokens= your cap truncated it;refusal= classifier;model_context_window_exceeded= full window) before blaming model quality; 4xx = your request; 429/529/5xx = transient, retry with backoff.
15. Docs-vs-exam watchlist (one line each)
- Opus 5.5 effort default is medium, not high.
budget_tokensandthinking: disabledare 400s on current flagship models;budget_tokensis "legacy".- Forced
tool_choice(any/tool) is a 400 on Opus 5.5, Sonnet 5.5, Fable 5.1. - Non-default temperature/top_p/top_k and assistant prefill are 400s on current models.
- Thinking
displaydefaults to omitted. - Cache: 512-token minimum on 5.x; reads 0.05x (Opus/Sonnet 5.5) and 0.025x (Fable 5.1); 1-hour TTL needs no header; workspace-level isolation.
- Vision 10 MB on the API; 28-px patch token formula. PDFs 600 pages on 1M-context requests.
- Errors list now includes 402, 409, 504.
- Bedrock: Mantle client and
anthropic.IDs for 4.7+; Vertex IDs dateless for new models. - MCP 2026-07-28: no initialize handshake,
server/discover, sampling/roots/logging deprecated, PythonMCPServernot FastMCP, no "sockets" transport. - Course says start with Sonnet; docs say start with Opus 5.5.
- Reschedule notice: guide says 24h; reported FAQ says 48h (unverified); use 48h.
- Few-shot count: course says 1-2 examples; docs say 3-5 for best results.