Claude Certified Architect Glossary

A Claude Code CLI flag used with --output-format json to provide a JSON Schema file that Claude's output must conform to. Guarantees the CLI output matches the expected structure, making it safe to parse in automated pipelines without defensive error handling.

A Claude Code CLI flag that controls the response format. Values: 'text' (default, plain text), 'json' (structured JSON), 'stream-json' (streaming JSON events). Use with --json-schema to guarantee output matches a specific schema. Critical for CI/CD pipeline integration.

Claude Code CLI flag for non-interactive (headless) execution. Processes the prompt, outputs to stdout, and exits immediately without entering an interactive session. Essential for CI/CD pipeline integration, scripting, and automation workflows.

The Claude Code settings file that configures tool permissions, hook scripts, environment variables, and behavioral settings. Project-scoped (.claude/settings.json) checked into version control, or user-scoped (~/.claude/settings.json) for personal preferences. Hooks are defined here.

The project-scoped MCP configuration file placed in the repository root. Defines which MCP servers are available for the project, their commands, arguments, and environment variable bindings. Checked into version control to share server configuration with the team. Supports ${ENV_VAR} expansion for credentials.

A CLAUDE.md directive that includes the contents of another markdown file. Enables modular CLAUDE.md organization where large configuration is split into focused files (e.g., @import docs/api-conventions.md). Reduces duplication when multiple CLAUDE.md files share common instructions.

Comparing competing prompts, models, retrieval configurations, or parameters on the same dataset against the same defined metrics, changing exactly one variable at a time (an ablation mindset) so the effect can be attributed to that variable, then adopting or reverting based on the measured result rather than intuition.

The recurring architectural tension where an integration decision that improves accuracy (e.g., reranking, retrieving more chunks) typically adds latency and cost, and vice versa. The architect's job is not to eliminate the tradeoff but to make it explicit and justify the chosen configuration against whichever constraint the stated requirement names as dominant. Prompt caching a stable repeated context is the rare exception that improves cost and latency with no accuracy loss.

The choice of where an agent's loop and tools run: Anthropic-hosted/managed (Anthropic runs the infrastructure, lowering operational burden but reducing environment control) versus self-hosted/in-process (the developer runs the loop and tools in their own environment, maximizing control over data flow, networking, and least privilege at the cost of operating it themselves). Neither option is universally correct -- the decision trades operational burden against control over data residency and least privilege.

The Agent SDK configuration object that blueprints a reusable agent: which model it runs on, what system prompt shapes its behavior, which tools it may call, and what lifecycle hooks fire during its execution. `AgentDefinition` is defined once and can be instantiated many times — each run gets an independent agent instance from the same static configuration. For what a subagent *is*, see [Subagent](/glossary/subagent).

The core pattern for AI agents: call Claude, check `stop_reason`, if `"tool_use"` execute the requested tools and append results, then call Claude again. Repeat until `stop_reason` is `"end_turn"`. The number of loop iterations is determined dynamically by task complexity.

Anthropic's framework for effective, responsible human-AI collaboration, built around competencies including Delegation (deciding what to hand to Claude versus handle yourself), Description (framing work clearly enough to act on), and Diligence (using AI effectively, ethically, and safely, with the human owning the outcome).

A skill frontmatter field that whitelists which tools a skill can use during its execution. Enforces the principle of least privilege for skills. Use specific tool names or MCP server patterns (e.g., 'mcp__github__*' allows all GitHub MCP tools).

Anthropic's outer boundary of acceptable use for Claude, with heightened requirements for high-risk and agentic scenarios. Organizations layer their own AI policy on top of it (approved tools, allowed data types, review steps, escalation paths); both must be respected simultaneously, and neither pricing pages nor the model's own self-assessment substitute for it as the authoritative standard.

A separate, editable window in Claude's interface for substantial, self-contained deliverables -- a document, table, or piece of content -- that will be refined, reused, or shared, distinct from an inline chat reply. Matching a deliverable's lifecycle (one-off read vs. ongoing revision vs. shareable output) to the right output surface, rather than defaulting to one format, is the underlying judgment call.

A parameter within the extended thinking configuration that sets the maximum tokens Claude can use for its internal reasoning process. Higher budgets allow more thorough reasoning but increase cost and latency. Must be at least 1024.

The five categories -- efficiency, transformation, productivity, cost, and performance/SLAs -- that an architect maps every architectural tradeoff to when justifying a design decision in the language of the business. A decision the architect cannot trace back to one of these pillars is not yet justified.

The time-to-live for cached prompt content in Claude's prompt caching system. The cache entry is refreshed (TTL resets) each time the cached content is used. If unused beyond the TTL window, the cache entry expires and the content must be re-processed and billed at full rate.

The design flaw of giving an agent more, or more powerful, tools than its role genuinely requires. Capability bloat harms security (a hijacked agent can invoke a capability it never needed), reliability (tool-selection accuracy drops as the tool set grows and descriptions overlap), and cost (every tool definition consumes context tokens on every request). The fix is least privilege by removal -- eliminating the capability entirely -- not adding logging or confirmation prompts around it.

A prompting strategy that instructs Claude to reason step-by-step before providing a final answer. Improves accuracy on complex reasoning tasks by making intermediate steps explicit. Can be triggered by instructions like 'think step by step' or via extended thinking.

Anthropic's Python SDK for building agentic applications with Claude. Provides primitives for agentic loop management, subagent orchestration, tool integration, and lifecycle hooks. Imported as `claude_agent_sdk`. Removes the boilerplate of raw-API agentic loops so architects can focus on design rather than plumbing.

The fastest and most cost-effective Claude model tier, optimized for high-throughput, low-latency tasks like classification, extraction, and simple Q&A. Carries a 200K-token context limit (vs 1M on Sonnet/Opus) and is the recommended first-pass router in tiered pipeline architectures.

The most capable Claude model tier, excelling at complex multi-step reasoning, nuanced analysis, and high-stakes creative tasks. Highest accuracy but most expensive and slowest. Best suited for tasks where output quality outweighs cost and latency concerns.

A persistent workspace in claude.ai that bundles standing Instructions (role, tone, format, rules) and Project Knowledge (uploaded reference documents) so every conversation inside it draws on the same configuration without re-supplying it each time. Scales beyond a single context window because large Project Knowledge is retrieved rather than loaded in full on every turn.

The balanced Claude model tier offering the best trade-off between capability, speed, and cost for most production applications. The recommended default for new systems — handles the majority of complex tasks effectively without Opus-level expense.

A markdown configuration file read by Claude Code at startup that injects persistent context, project conventions, and tool guidance into every session — without re-prompting. Claude Code supports CLAUDE.md files at the global, project-root, and subdirectory levels (see /glossary/path-specific-rules for the hierarchy). Uses @import for modular organization.

The practice of having Claude estimate and report its confidence in its output, then using that estimate to determine whether to proceed autonomously or escalate. Requires explicit confidence scoring in prompts and defined thresholds for escalation vs. auto-approval.

A security risk pattern in which an agent acting with broad service credentials on behalf of a low-privilege user can leak or change data the user should not be able to touch. The fix is to scope tool permissions to the calling user's entitlements rather than the service account's broader credentials, so the agent can never do more on the user's behalf than the user could do directly.

Integrations that let Claude work with content in an external source (e.g., Google Drive, Gmail) where it already lives, rather than requiring a manually exported and uploaded copy. Distinct from uploads (static files added directly); connector availability depends on the plan/pricing tier and is not universal.

The structured units that make up Claude's response. Types include: `text` (plain text response), `tool_use` (a request to call a tool with specific inputs), `tool_result` (the caller's response to a tool request), and `thinking` (internal reasoning when extended thinking is enabled). A single response can contain multiple content blocks of mixed types.

The practice of actively reducing a conversation's token footprint so it fits within the model's context window without silent truncation. Encompasses multiple strategies — rolling window eviction, progressive summarization, external storage with retrieval, and prompt caching — each with different loss profiles and complexity trade-offs. Understanding this menu of options, and knowing what must never be compressed, is a core Domain 5 skill.

Attention degradation caused by a context window filling with irrelevant, stale, or low-signal content, even when technically there is still room left in the window. Distinct from running out of space (a hard context-window limit) and from position effects (attention bias by location within the window) -- context rot is specifically about signal-to-noise degrading as low-value tokens accumulate.

The maximum amount of text (measured in tokens) that Claude can process in a single request. Includes both input tokens (prompt, history, tool results) and output tokens. Exceeding the context window causes an error or requires context management strategies.

A skill frontmatter option in Claude Code that launches the skill inside a fresh, isolated context window — separate from the parent session's conversation history. The forked context accumulates its own tool calls and intermediate reasoning without touching the parent window; only the skill's final output is returned. The forked history is discarded when the skill completes.

Anthropic's RAG technique of prepending a short, chunk-specific context blurb to each chunk before embedding and indexing it (as both contextual embeddings and contextual BM25), so an isolated chunk retains the surrounding document context it would otherwise lose. Combined with reranking, it substantially reduces retrieval-failure rates versus naive embedding-only RAG, and prompt caching keeps generating per-chunk context economical at scale.

A multi-agent architecture where a central coordinator manages specialized subagents using hub-and-spoke communication. The coordinator handles task decomposition, routing, and result aggregation. Subagents never communicate directly with each other, keeping the system auditable.

A field in the Message Batches API request body that lets you correlate each batch request with its response. Must be unique within a batch. Essential for matching asynchronous results back to originating requests when processing thousands of items.

A stop_reason value indicating Claude finished its response naturally without hitting a limit or requesting a tool. In agentic loops, this signals the loop should stop and the final response should be presented to the user.

The risk in multi-agent systems where an error or incorrect output from one subagent contaminates downstream agents, amplifying the mistake. Mitigated by validating subagent outputs before passing them forward and designing subagents to return structured error types rather than silent failures.

The five recognizable buckets a Claude application failure falls into -- transport/HTTP (429/529/5xx), request error (400/401), parsing/validation (a code-level exception reading the response), model-output error (well-formed but wrong content), and tool-loop error (wrong tool, malformed arguments, or a mis-fed tool_result). The bucket a failure falls into dictates the correct fix, and misclassifying it sends the fix to the wrong layer.

A reliability pattern where the agent recognizes conditions it cannot handle autonomously and escalates to a human or higher-capability system. Escalation triggers include: conflicting data sources, low confidence scores, ambiguous requirements, or irreversible high-stakes actions.

A two-pass architecture where a generator produces output and a separate evaluator assesses it against explicit criteria. For true quality assurance, the evaluator must be a separate Claude instance with independent context — using the same instance creates confirmation bias.

A Claude capability that allows the model to reason through complex problems step-by-step in a dedicated thinking block before producing its final response. Controlled via the 'thinking' parameter with a 'budget_tokens' limit. Thinking tokens are billed but improve accuracy on hard reasoning tasks.

The Federal Risk and Authorization Management Program, a US government standard for security assessment and authorization of cloud services used by federal agencies. Design implication: use authorized cloud environments and controls appropriate to the workload's authorization level for any Claude deployment serving government workloads.

A prompting technique that supplies concrete (input, output) example pairs to guide Claude’s behavior. With the Claude API the idiomatic approach is to encode examples as alternating `user`/`assistant` turns in the `messages` array rather than cramming them into the system prompt — this mirrors the conversation format Claude is trained on and keeps cached system-prompt content stable.

An Agent SDK operation that creates a copy of the current session state, allowing parallel exploration of different solution paths without affecting the original session. Each fork can proceed independently; results can be compared and the best chosen.

A modern spaced repetition algorithm used in Claude Architect Lab to schedule concept reviews. Tracks four parameters per card: stability (how long memory persists), difficulty (how hard the card is), retrievability (current recall probability), and due date. More accurate than older algorithms like SM-2.

The EU General Data Protection Regulation, governing the protection of personal data for EU data subjects. Design implications include data minimization, establishing a lawful basis for processing, honoring data-subject rights, and respecting data-residency requirements.

A system design principle where partial failures result in reduced functionality rather than complete failure. In multi-agent systems, if one subagent fails, the coordinator produces a partial result with a clear explanation of what is missing rather than returning an error to the user.

Confident, plausible-looking content that Claude generates which is false or fabricated -- an invented statistic, citation, source, or quote. Delivered with the same fluent tone as accurate content, which is what makes it hard to detect by tone alone. Concentrates in specific-looking details, at the edge of the model's knowledge, and inside long outputs.

A representative set of test cases -- including edge cases and known failure modes -- that the system design has not been tuned against, used to give an honest read of quality. An eval built only from examples the design was tuned on only measures fit to those examples, not performance on new input; automating the eval to run on every prompt change and model-version bump is what actually catches regressions.

The US Health Insurance Portability and Accountability Act, governing the protection of protected health information (PHI). Design implications include using HIPAA-eligible services and business associate agreements, and restricting or redacting PHI across the pipeline rather than assuming the model alone is compliant. Compliance is a property of the whole system -- data handling, access, retention, and contracts -- not of the model in isolation.

Shell scripts or commands configured in .claude/settings.json that run at defined lifecycle points: PreToolUse (before tool execution), PostToolUse (after tool execution), Stop (before ending), SubagentStop (when subagent finishes). Used for code quality gates, notifications, logging, and safety checks.

A design pattern that interrupts the agentic loop at defined checkpoints to request human review or approval before proceeding. Used for high-stakes decisions, irreversible actions, or cases where confidence is below threshold. Balances automation with oversight.

The tracking of which source each piece of information in an agent's output came from. Critical for multi-source agents where conflicting data must be attributed. Preserved via claim-source mappings that travel with data through the pipeline.

A Claude Code workflow pattern that builds solutions incrementally through small, verifiable steps rather than attempting complete implementation in one pass. Each step produces testable output; failures are caught early. Pair with test-driven iteration for maximum reliability.

A security principle applied to agent tool design: give each agent and subagent only the minimum tools required to complete its specific task. Reduces blast radius if an agent is compromised or makes an error. Implemented via AgentDefinition tool lists and skill allowed-tools.

The observed phenomenon where Claude (and other LLMs) give less attention to content in the middle of a long context window compared to content at the beginning and end. Critical information should be placed at the start (system prompt) or end (most recent user turn) of the context.

API parameter that sets the maximum number of tokens Claude will generate in a single response. If generation would exceed this limit it is truncated and `stop_reason` is set to `"max_tokens"`. This is a required parameter — omitting it returns a 400 error.

An application that connects to MCP servers to access their tools, resources, and prompts. Responsible for tool-list filtering, tool_use_id routing, and enforcing which capabilities the model can call. Claude Code is the canonical MCP client in the CCA-F curriculum.

An official Anthropic debugging tool for MCP server development. Provides a UI to connect to any MCP server, list its tools/resources/prompts, execute calls, and inspect responses. Essential for testing MCP server implementations during development.

The three fundamental building blocks of the MCP protocol: Tools (model-controlled actions Claude can invoke), Resources (application-controlled data Claude can read), and Prompts (user-controlled templates for common interactions). Each serves a distinct control model.

The user-controlled MCP primitive. Pre-defined prompt templates that users explicitly trigger via the application UI (e.g., a '/summarize' command). The user chooses when to apply them. Prompts can be parameterized and support autocomplete via the MCP completion endpoint.

The application-controlled MCP primitive. The host application determines what data to provide to Claude by reading resources. Resources are identified by URIs and can be text, JSON, binary data, or template-generated content. Claude reads but does not autonomously request resources.

A client-declared filesystem scoping mechanism. The MCP client specifies which file:// URI paths (roots) a server may access. Servers declare which roots they need; clients grant a subset. Roots are a protocol-level declaration enforced by server compliance, not by OS sandboxing.

An advanced MCP capability that allows MCP servers to request LLM completions through the client, enabling servers to use AI without direct API access. The client controls model selection, permissions, and billing. Used for AI-powered tool implementations that need their own Claude calls.

A process that implements the MCP protocol and exposes tools, resources, and prompts to MCP clients. Built with official SDKs (Python, TypeScript). Deployed locally via stdio or remotely via StreamableHTTP. Claude Code auto-discovers servers configured in .mcp.json.

The model-controlled MCP primitive. Claude autonomously decides when to invoke MCP tools based on task requirements. Distinct from Resources (app-controlled) and Prompts (user-invoked). The invocation path mirrors the API's native tool_use → tool_result exchange.

An asynchronous Claude API for processing multiple requests in a batch with 50% cost savings versus synchronous requests. Processing takes up to 24 hours with no guaranteed latency SLA. Does not support iterative tool use, streaming, or prompt caching. Best for scheduled, non-blocking analysis.

An open standard protocol for connecting Claude to external tools and data sources. Defines a client-server architecture where MCP servers expose capabilities that MCP clients discover and use. Supports project-scoped (.mcp.json) and user-scoped configurations.

The practice of directing requests to different Claude model tiers based on assessed complexity and requirements. A common pattern uses a fast, cheap model (Haiku) to classify task complexity, then routes to Sonnet or Opus accordingly.

A workflow composition pattern where a central LLM decides subtasks dynamically at runtime and delegates them to workers, in contrast to parallelization sectioning where the subtasks are already known in advance. It is still a workflow, not an agent, as long as the fact that delegation happens is fixed in code -- only the content of the subtasks is decided at runtime. This is the point where a workflow shades most closely into an agent, and the classic exam trap is confusing it with parallelization sectioning.

Claude's ability to request multiple tool calls in a single response by returning multiple tool_use blocks. All requested tools can be executed concurrently, then all tool_result blocks are returned together. Significantly reduces the number of API round-trips for independent operations.

CLAUDE.md files placed in subdirectories that extend or refine root-level configuration for that directory subtree. Enables per-team ownership in monorepos: different rules for tests/, src/auth/, and docs/ without one massive root config. Files compose (stack) from root down to the current directory — they do not replace each other.

A Claude Code execution mode for exploration and analysis before making changes. Claude reads and analyzes but does not write files or execute commands. Use when requirements are ambiguous, multiple valid approaches exist, or decisions have significant architectural implications.

An Agent SDK lifecycle hook that intercepts tool results before the agent processes them. Can normalize, enrich, or transform results from multiple tools into a consistent format. Works with both custom and third-party MCP tools without modifying their source code.

An Agent SDK lifecycle hook that intercepts tool calls before execution. Can inspect, modify, or block the call. Used for access control, parameter sanitization, rate limiting, and audit logging. Runs synchronously before the tool executes.

An agent-environment interface design where a lean surface is exposed up front and the agent fetches additional detail on demand, rather than front-loading every tool, schema, and document into context (monolithic context). Progressive discovery is the scalable pattern for large integrations; monolithic context is acceptable only when the full set is small and stable.

A Claude API feature that caches frequently-used prompt content (system prompts, large documents, tool definitions) to reduce cost and latency on repeated API calls. Cached tokens are billed at a discounted rate. Cache has a TTL that resets on each use. Must be enabled by marking content with cache_control.

An attack where malicious content in external data (web pages, documents, user input) attempts to override the system prompt or hijack Claude's behavior. Mitigation: use XML tags to separate untrusted content from instructions, validate outputs, apply least-privilege tool access.

A technique where you begin Claude's response by adding a partial assistant turn before the API call. Claude continues from that starting point, allowing precise control over response format, structure, and starting content. Useful for forcing JSON or specific syntax.

A pattern that dynamically retrieves relevant information from an external knowledge base and injects it into the context window based on the current query. Allows Claude to reason over large document sets without fitting everything in context at once.

The practice of defining Claude's identity and expertise in the system prompt to anchor its behavior. Roles like 'You are an expert security auditor' improve response quality for domain-specific tasks by activating relevant knowledge and behavioral patterns.

A context management technique that retains only the N most recent conversation turns, evicting older turns as new ones arrive. Simple to implement with zero summarization overhead. Best deployed as a rolling-window+summary-header hybrid to prevent silent loss of early constraints or decisions. One specific technique under the broader umbrella of [context compression](/glossary/context-compression).

A pattern where Claude reviews its own output before finalizing it. Useful for catching obvious errors but limited: Claude tends to confirm its own reasoning due to anchoring bias. For high-stakes verification, use a separate Claude instance with independent context.

A stateful container in the Claude Agent SDK that holds an agent's conversation history, accumulated tool results, and metadata across multiple turns. Sessions can be persisted to durable storage, resumed after a process restart, and forked into independent branches. Session lifecycle management — not the model or tools — is what makes long-running agentic tasks recoverable.

YAML configuration at the top of a Claude Code skill file (SKILL.md) that controls how the skill is triggered and executed. Key fields: 'description' (natural language trigger for automatic activation), 'allowed-tools' (whitelist of permitted tools), 'context' (fork/current/none).

Reusable markdown instruction files with YAML frontmatter that define custom slash commands in Claude Code. Invoked with /skill-name. Frontmatter configures: description (for trigger matching), allowed-tools (tool restrictions), and context (fork for isolation). Stored in .claude/skills/.

A commitment about a system's latency and reliability that must be grounded in what the chosen model tier, retrieval steps, and infrastructure can actually deliver, not in aspiration. A common exam trap is promising sub-second latency on a multi-step agentic pipeline with reranking -- both add latency the SLA must account for. Re-alignment is continuous: a model version, data change, or scaling need can shift what's feasible.

Named, explicitly invoked instructions in Claude Code -- built-in (e.g., /clear, /init, /help) or custom commands authored as Markdown prompt files in .claude/commands/. Distinguished from Skills by invocation: a Command is called by name; a Skill loads automatically when Claude judges it relevant.

A learning technique that schedules review of concepts at increasing intervals based on recall performance. Highly effective for long-term retention. Claude Architect Lab implements spaced repetition via the FSRS algorithm across all 150+ exam concepts in the review queue.

An MCP transport mechanism where the client launches the server as a subprocess and communicates via stdin/stdout pipes. Ideal for local development and trusted single-user environments. Simple to set up but limited to same-machine deployment.

An Agent SDK lifecycle hook that runs when the agent reaches an end_turn stop condition. Can inspect the final response and decide whether to allow the stop or inject additional instructions to continue the loop. Used for output validation and quality gates.

A field in the Claude API response indicating why the model stopped generating. Values: 'end_turn' (natural completion), 'max_tokens' (hit limit), 'stop_sequence' (hit custom stop), 'tool_use' (wants to call a tool). The primary signal for controlling agentic loops.

An API parameter that provides a list of up to four strings that, when encountered in Claude's output, cause generation to halt immediately. The matched string is stripped from the response. When a stop sequence fires, `stop_reason` is set to `"stop_sequence"`. Useful for enforcing structured output boundaries or workflow step delimiters.

An MCP transport that communicates over HTTP with Server-Sent Events (SSE) for streaming. Runs as an independent network service — not a subprocess. Enables multiple simultaneous clients, per-request authentication, and remote deployment. The correct transport for shared, cloud-hosted, or containerised MCP servers.

An API mode where Claude sends partial response tokens as they are generated, rather than waiting for the full response. Reduces perceived latency for users. Use server-sent events (SSE) to consume the stream. Not available with the Message Batches API.

The practice of eliciting a business outcome and its non-functional constraints (latency/SLA, volume, criticality, data sensitivity, cost ceiling, quality bar) through deliberate, structured questions rather than open-ended ones, separating must-have needs from preferred-implementation wants, and validating the result by reflecting it back to stakeholders before design begins.

The practice of returning structured, actionable error information from tools rather than generic error strings. Well-designed error responses include: error type, what went wrong, what Claude should try next. Prevents Claude from retrying the same failing approach repeatedly.

Guaranteed formatted output (typically JSON) from Claude. The most reliable method is to define a schema as a tool and set tool_choice to force its use — Claude's tool_use blocks are always valid JSON. Alternatively, use --output-format json with --json-schema in Claude Code CLI.

A Claude instance spawned by an orchestrator to handle one bounded subtask in complete context isolation. Each subagent starts with a fresh context window — the orchestrator's history is never inherited — and is invoked via the [Task tool](/glossary/task-tool). The subagent runs its own full [Agentic Loop](/glossary/agentic-loop), then returns a single structured result to the orchestrator.

An Agent SDK lifecycle hook that fires at the **child→parent boundary** — the precise moment a subagent finishes its task and hands its result back to the orchestrator. Unlike the [Stop hook](/glossary/stop-hook), which is an inward-facing gate on a single agent's own final response, SubagentStop is an outward-facing interface contract: it intercepts what crosses from a subagent's isolated context into the parent session.

A context management approach that condenses older conversation turns or completed task phases into compact summaries, preserving essential conclusions while freeing token budget. Inherently lossy — never summarize active tool results, in-flight constraints, or partially completed tasks. One specific technique under the broader umbrella of [context compression](/glossary/context-compression).

The initial instruction set provided to Claude that defines its behavior, role, constraints, and operational context for an entire conversation. Set via the 'system' parameter in the API. Processed before the user turn and shapes all subsequent responses.

The process of breaking a complex task into smaller, independently executable subtasks that can be assigned to specialized subagents or processed sequentially. Good decomposition creates subtasks with clear boundaries, independent execution, and verifiable outputs.

The built-in Agent SDK tool used to invoke a subagent. Takes a task description, available tools, and optional context. The subagent runs its own agentic loop in an isolated context and returns its final result. The primary mechanism for multi-agent delegation.

API parameter (0.0-1.0) that controls the randomness of Claude's output. Lower values (0.0) produce deterministic, consistent responses ideal for classification and extraction. Higher values increase creativity and variety for generative tasks.

A Claude Code workflow where tests are written or identified before implementation, and each iteration is verified by running the test suite. Claude uses test failures as feedback to correct its approach. The 'interview pattern' involves asking clarifying questions before writing any code.

The availability of Claude models through Amazon Bedrock and Google Vertex AI in addition to Anthropic's direct API, with a largely consistent message format across all three. Differences are limited to authentication, endpoint/region, and model-ID naming -- not model behavior. Vendor choice is driven by existing cloud footprint, data-residency requirements, and procurement constraints.

The fundamental unit of text processing for Claude. Roughly 3-4 characters or about 0.75 words in English. Used for measuring input, output, and context window size. Costs are calculated per input and output token.

The practice of writing tool definitions (name, description, input schema) that enable Claude to reliably select and use tools correctly. Key principles: precise descriptions that distinguish similar tools, explicit input format requirements, clear boundary examples, and documented error return formats.

API parameter controlling how Claude selects tools. 'auto' (default): Claude decides whether to use tools. 'any': Claude must use at least one tool. 'none': Claude cannot use tools. '{type: tool, name: X}': Claude must use the specific named tool. Used to force structured output via a schema tool.

A content block type in the user message that returns the output of a tool execution back to Claude. Must include the 'tool_use_id' matching the original tool_use block. Can be text, images, or error messages. Claude processes the result and continues reasoning.

A content block type in Claude's response indicating the model wants to call a specific tool. Contains 'id', 'name', and 'input' fields. The agent must execute the tool and return results in a tool_result content block for the conversation to continue.

A debugging technique for multi-step agents and workflows: logging every model call, tool call and its arguments, tool result, and intermediate message, then walking that sequence to find the earliest step that deviated -- rather than debugging only the final failing output.

The core stakeholder-communication skill of naming an architectural decision's gain and cost explicitly ("we gain X, we pay Y") in the stakeholder's own language, anchored on the constraint that matters most to them, and presented as options with a recommendation rather than a single unquestionable verdict.

A pattern where structured output that fails validation is sent back to Claude with the specific error, requesting a correction. More effective than silent retries because Claude uses the error feedback to understand and fix the problem. Typically capped at 2-3 retries.

A Claude-native prompting pattern using XML-style tags (e.g., <document>, <instructions>, <example>) to clearly delimit sections of a prompt. Helps Claude unambiguously identify context, instructions, and data. Reduces prompt injection risk by separating instructions from untrusted input.