Claude Certified Developer - Foundations key terms

The primary HTTP endpoint for Claude, where you send an ordered list of user and assistant messages plus parameters such as system, max_tokens, and temperature, and receive the model's next assistant message with metadata.

A top-level request parameter holding standing instructions, persona, and constraints that apply to the whole conversation; it sits apart from the user and assistant turns and is a natural candidate for caching.

The hard cap on how many tokens Claude may generate in a single response; generation stops when the cap or a stop sequence is reached, and the stopping cause is reported in the response.

A typed element inside a message's content array, such as text, image, tool_use, or tool_result, letting one turn carry several kinds of data at once.

A response field explaining why generation ended, for example end_turn for natural completion, max_tokens for hitting the output limit, or tool_use when Claude is waiting on a tool result.

The atomic unit of text a model reads and writes, roughly a sub-word fragment, and the basis for billing, context limits, and throughput quotas.

A sampling parameter controlling randomness: lower values make output more deterministic and repeatable, while higher values make it more varied and exploratory.

Delivering a response incrementally as server-sent events so partial text can be shown before the full answer finishes, improving perceived latency in user-facing applications.

A tiered lineup of Claude models, such as Haiku, Sonnet, and Opus, trading speed and cost against capability so you can choose the cheapest model that meets quality needs.

Including a small number of worked input-output examples in the prompt so the model infers the desired format, tone, or reasoning pattern without any fine-tuning.

Asking the model to reason step by step before stating a final answer, which usually improves accuracy on multi-step problems and makes mistakes easier to spot.

Wrapping instructions, documents, examples, and questions in clearly named tags so the model can tell sections apart and reference specific parts of a long prompt reliably.

Specifying the exact shape of the wanted answer, such as a JSON object with named fields, so downstream code can parse the response programmatically instead of guessing.

Splitting a complex task into several sequential prompts where each model output feeds the next step, improving reliability and allowing validation between stages.

Placing the opening of Claude's reply into a final assistant turn so the model continues from that text, useful for forcing a format like JSON or skipping pleasantries.

A JSON-schema description of a function exposed to Claude, including its name, purpose, and parameters, which tells the model when and how it may call that function.

A request parameter governing tool use: auto lets the model decide, any forces some tool call, and a named tool forces that specific tool to be used.

The content block Claude returns when it wants to call a tool, carrying the tool name and a JSON input object; your application must execute it and reply.

The content block you send back in a user turn containing a tool call's output, matched to the originating tool_use identifier so the model can continue reasoning.

Claude requesting several independent tool calls within one assistant turn, which the application may execute concurrently before returning all the results together.

The repeating cycle of sending context to Claude, executing any requested tools, appending the results, and calling the model again until a stopping condition is satisfied.

An architecture where a lead model breaks a task into subtasks, delegates them to worker calls or agents, then merges their outputs into one coherent result.

A separate model invocation with its own focused prompt and limited context, used to isolate a subtask and keep the main conversation's context small.

An explicit rule, such as a final answer, a token budget, or a maximum iteration count, that ends an agent loop and prevents runaway cost or infinite cycles.

A design where a person reviews or approves consequential agent actions, such as sending email or deleting data, before the system executes them.

The maximum number of tokens a model can consider in one request, covering the system prompt, conversation history, retrieved documents, and the generated response.

Reusing a previously processed prompt prefix so repeated requests skip recomputation, cutting cost and latency for stable system prompts or large attached documents.

A marker placed on a prompt section indicating where caching should begin or extend, so everything before it can be reused across calls while the cache is valid.

Retrieval-Augmented Generation: fetching relevant passages from a knowledge store and inserting them into the prompt so answers are grounded in current or private data.

Summarizing or trimming older conversation content as the context limit approaches, preserving essential facts while freeing tokens for new turns and tool results.

A curated set of representative inputs with known correct outputs or labels, used as a stable benchmark for comparing prompt, model, or code changes.

Using a model to grade another model's outputs against stated criteria, a scalable evaluation method that needs calibration and periodic spot checks against human ratings.

Scoring outputs against explicit written criteria and scales rather than a single pass or fail, making evaluations more consistent, comparable, and actionable.

Recording each step of a request, including prompts, model calls, tool calls, latency, and token counts, so failures and cost hot spots can be diagnosed after the fact.

A set of automated evaluation cases rerun on every prompt, model, or code change to catch quality drops before they reach production users.

An attack in which untrusted text, such as a retrieved document or web page, contains instructions attempting to override the developer's real instructions.

A deliberate attempt to bypass a model's safety behavior through framing, role-play, or obfuscation so it produces content it should otherwise refuse.

Systematically probing an application with adversarial and edge-case inputs to surface harmful, biased, or unsafe behavior before real users encounter it.

A check outside the model itself, such as input filtering, output validation, or permission limits on tools, that blocks unsafe or out-of-policy actions.