Claude Certified Architect — Foundations

Claude Certified Architect — Foundations glossary

91 terms the exam expects you to know, defined in plain language.

#

/compact Command(/compact): A Claude Code command to summarize and reduce context window size during conversations.
/go Slash Command(/go): A slash command that returns Claude Code to direct execution mode.
/memory Command(/memory): A Claude Code command to store key decisions for later reference.
24-hour processing window(24-hour window, processing window of up to 24 hours): The maximum time allotted for batch processing, after which results are available.
50% cost reduction(50% cost savings, 50% cost reduction): The cost savings achieved by using Message Batches compared to individual API calls.

A

AgentDefinition(agentdefinition): A configuration object defining a subagent with name, description, system prompt, and allowed tools.
Agentic loop(agentic loop): A cycle of sending a message to Claude, checking stop_reason, and executing tools until a terminal stop_reason is received.
Agentic workflow(agentic workflow): A pattern where an application orchestrates a loop of message exchanges and tool executions with Claude.
asynchronous result retrieval(poll for results, retrieve results after completion): The method of obtaining batch results by polling or retrieving after processing completes.

B

Balancing Automation and Escalation(balancing automation and escalation): The principle of exhausting deterministic safeguards before escalating to humans.
batch status endpoint(batch status endpoint): An endpoint used to monitor the progress of a batch and check its status.

C

Claude API(claude api): The API used to send messages to Claude and receive responses with stop_reason and content blocks.
Claude Code Direct Execution(direct execution): The default mode where Claude immediately uses tools to read files, write code, and run commands without a separate planning step.
Claude Code Planning Mode(planning mode): A mode where Claude produces a structured plan for user approval before executing any tool calls.
Claude Code Slash Commands(slash commands): Predefined, immutable chat shortcuts in Claude Code, such as /compact and /memory.
Content array(content array): A response field containing an array of content blocks such as tool_use and tool_result.
Context Window Bloat(context window bloat): The problem of a conversation growing too large, requiring periodic summarization or compaction.
Context window token limit(context window size, token limit): The maximum number of tokens that can be sent in a single API request, e.g., 200K for Claude 3.5 Sonnet.
Coordinator(coordinator): An entity that manages and delegates tasks to parallel subagents.
Coordinator agent(coordinator): An agent that spawns subagents using the Task tool and orchestrates their execution.
Coordinator-Subagent Orchestration Pattern(coordinator-subagent orchestration, hub-and-spoke pattern): A hub-and-spoke design where a coordinator agent delegates subtasks to isolated, specialized subagents via the Task tool.
cost-effective for high-volume workloads(cost-effective choice for high-volume workloads): The suitability of Message Batches for large-scale data processing due to cost savings.
custom_id(custom_id): A unique identifier assigned to each request within a batch for result correlation.

D

Data contract(data contract): A clear specification of what context is passed between coordinator and subagent, enforced by explicit passing.
Deterministic Guardrails(deterministic mechanisms): Mechanisms that guarantee behavior, such as hooks, preconditions, schemas, and tool constraints.
Deterministic Safeguards(deterministic vs probabilistic, deterministic safeguards): Mechanisms that guarantee behavior, such as hooks, preconditions, schemas, and tool constraints.
Dynamic context retrieval via tools(dynamic context fetching, tool-based context retrieval): Using tools or MCP resources to fetch only relevant context instead of stuffing a long prompt.

E

Escalation Triggers(escalation triggers): Specific conditions that cause an LLM to hand off to a human.
Explicit Context Passing(explicit context passing): A design principle requiring the coordinator to pass all necessary context to subagents in the Task call, as subagents inherit nothing automatically.
Explore Subagent(explore subagent): A Claude Code component that researches options and gathers information before committing to a solution.
end_turn(end_turn): A stop_reason value indicating the model has naturally finished its response.

F

Failure Categories(failure categories): Distinct types of errors, such as timeout vs empty result, syntax vs semantic errors, drift vs overflow.
Flat Coordination(flat coordination, avoid over-nesting): A design preference for a single level of subagents to avoid deep hierarchies that increase latency and complexity.

H

Hard context window cap(hard token limit, context window hard cap): The context window size is a hard limit; exceeding it causes request rejection, not automatic truncation.
Headless CI/CD Mode(headless mode, -p): A non-interactive Claude Code mode where complete instructions must be provided upfront.
Human-in-the-Loop (HITL)(hitl, human-in-the-loop): A reliability pattern that pauses the agentic loop for human approval.

I

Input Validation(input validation): A mechanism that checks user inputs to an LLM using schemas, rules, or semantic checks before accepting a response.
Interview Pattern(interview pattern): A workflow where Claude asks clarifying questions to uncover requirements before starting, reducing rework.
Iterative Refinement(iterative refinement): A structured approach of iterative loops (action, review, feedback) to improve output quality in Claude Code.

L

LLM Failure Categories(failure categories): Distinct types of errors in LLM systems, including timeout vs empty result, syntax vs semantic errors, drift vs overflow.
Least privilege tool allocation(least privilege): Principle of providing only the tools necessary for a task, especially when using subagents.
Least-Privilege Principle for Subagents(least-privilege principle): A design guideline that subagents should have a minimal set of tools and a narrowly scoped system prompt.
Lifecycle Hooks(lifecycle hooks, pretooluse, posttooluse): Deterministic mechanisms (PreToolUse, PostToolUse) that enforce behavior in subagent execution, unlike probabilistic prompt instructions.
Lost-in-the-middle effect(lost-in-the-middle effect): The phenomenon where information placed in the middle of a long context is less reliably used by the model compared to information at the start or end.

M

Message Batches API(message batches api): An API that allows sending up to 10,000 requests asynchronously with a 50% cost reduction.
Multiple tool calls(multiple tool calls): The possibility of multiple tool_use blocks in a single Claude response requiring all to be executed.
max_tokens(max_tokens): A stop_reason value indicating the response was cut off due to reaching the max_tokens limit.
maximum of 10,000 requests per batch(10,000 requests per batch, maximum of 10,000 requests): The upper limit on the number of requests that can be included in a single batch.

N

no streaming support(do not support streaming): A constraint of Message Batches that does not allow streaming of responses.

O

Orchestrated exchange(orchestrated exchange): The coordinator's explicit management of sharing intermediate results between subagents via subsequent Task calls.

P

Parallel Subagent Execution(parallel subagents, concurrent task calls): The ability for a coordinator to issue multiple Task calls in one turn, enabling concurrent subtask execution.
Parallel subagents(parallel subagents): Sub-agents that run concurrently, created from multiple Task calls issued in one turn.
Personal Skill Precedence(skill override): The rule that a personal skill with the same name as a project skill overrides the project skill.
Probabilistic Guardrails(probabilistic mechanisms): Mechanisms that merely encourage behavior, such as prompts and examples.
Probabilistic Safeguards(probabilistic safeguards): Mechanisms that merely encourage behavior without guarantee, such as prompts, examples, and post-processing filters.
Programmatic Enforcement(programmatic enforcement): The use of code-based constraints to ensure LLM outputs meet safety or correctness requirements.
Prompt structuring for lost-in-the-middle mitigation(prompt structuring, mitigating lost-in-the-middle): Placing critical instructions and data at the beginning or end of the prompt to avoid the lost-in-the-middle effect.
Prompt-Level Fixes(prompt-level fixes): Adjustments to prompts to address issues, considered a lightweight solution compared to infrastructure changes.
planning_mode Configuration(planning_mode: true): A project or skill setting that forces Claude Code to always use planning mode.

R

Recoverable vs Unrecoverable Errors(recoverable errors, unrecoverable errors): Errors that can be resolved programmatically versus those requiring human escalation.
Retry Mechanism(retries): A technique that re-prompts the model with failure context to recover from transient errors.
Right-Sized Solutions(right-sized solutions): Choosing the simplest effective fix, such as a description rewrite, over overengineered infrastructure.
retry logic for failed requests(retry logic, retry logic for failed requests): The practice of implementing retries for individual requests within a batch that may fail.

S

Self-Correction(self-correction): A method that uses the model's own reasoning to improve outputs, often in a multi-pass review architecture.
Session Management for Workflows(session management, resume, fork_session): Capabilities like resume and fork_session that manage long-running coordinator workflows, though subagents do not persist state across sessions.
Skill Discovery: The automatic detection of SKILL.md files placed in project or user directories, making skills available for invocation.
Skill Execution Context(context, fork): The runtime environment where a skill runs, either in the main process or a forked sub-agent when context: fork is set.
Skill Frontmatter(frontmatter): Metadata fields in SKILL.md (e.g., context, allowed-tools, argument-hint) that control skill execution behavior.
Skill Invocation: The action of running a skill by typing /skill-name in the Claude Code chat interface.
Skills with context:fork(context: fork): A Claude Code skill configuration that runs in an isolated sub-conversation to avoid polluting main session context.
Slash Command Immutability: The property that built-in slash commands cannot be modified, renamed, or overridden by user configuration.
Specific Error Messages(specific error messages, detailed error messages, informative error messages): Error messages that contain actionable details enabling automated recovery decisions, unlike generic failure strings.
Stateless full-history contract(stateless full-history contract, messages api statelessness): The API requirement that every request must include the entire conversation history up to that point.
Structured Error Responses (MCP)(structured errors, mcp structured errors): Error objects containing category, retryability, and partialResults for automated recovery decisions.
Subagent(subagent): An agent spawned by a coordinator that starts with an isolated context and runs its own agentic loop.
Subagent Description as Selection Mechanism(description as selection mechanism): The subagent's description field serves as the primary deterministic selector for the coordinator to choose the correct subagent.
Subagent context isolation(context isolation): The property that each subagent operates in its own isolated context, preventing side effects between them.
System prompt(system prompt): A mechanism to set high-priority rules and instructions that are placed at the start of the conversation.
stateless requests(stateless, independent and stateless): Each request in a batch is independent and does not support multi-turn tool calling.
stop_reason(stop_reason): A field in the Claude API response that indicates why the model stopped generating.
stop_sequence(stop_sequence): A stop_reason value indicating the model encountered a custom stop sequence specified in the request.

T

Task Tool(task tool, task): A tool in the Claude Agent SDK used by a coordinator to spawn subagents with explicit context.
Task call(task calls): A request to execute a specific task, with multiple calls in one turn spawning parallel subagents.
Token limits(token limits): A constraint that overloading a single Task call with too much context can exceed available tokens.
Tool use block(tool_use block, tool_use blocks): A content block in the API response containing the id, name, and input for a tool call.
tool_choice: Configuration that determines how an agent selects tools from a set, with three modes.
tool_choice any mode(any): Tool selection mode that requires the agent to call a tool from the available set.
tool_choice auto mode(auto): Flexible tool selection mode where the agent can decide whether to call a tool.
tool_choice forced mode(forced): Tool selection mode that requires the agent to call a specific designated tool.
tool_result block(tool_result block): A content block used to return the result of a tool execution to Claude.
tool_use(tool_use): A stop_reason value indicating the model wants to call one or more tools.