Glossary - Claude Code Concept Quick Reference

This glossary organizes core concepts in Claude Code architecture by topic for quick reference.

A

Adaptive Thinking

Claude 4.6 model-supported thinking mode where the model decides how much to think rather than using a fixed token budget. More flexible than enabled mode.

Agent

The core concept of Claude Code - an AI entity capable of perceiving environment, executing tools, and completing tasks. Includes main Agent, sub-Agent, Fork Agent, and other forms.

Agent Loop

Claude Code’s core execution flow: User Input → Model Reasoning → Tool Call → Result Processing → Response Generation, cycling until task completion.

Agent Memory

Persistence mechanism unique to sub-agents, supporting user/project/local three-tier scope, used for storing agent-specific preferences and knowledge.

Agent Swarm

A flat-structured agent team collaborating through message passing, with nested spawning prohibited.

Auto-Compact

Automatic mechanism that triggers conversation summarization when context approaches capacity limit, freeing up token space.

Auto-Dream

Overnight memory consolidation mechanism that periodically scans memory files, merges duplicates, eliminates contradictions, and prunes expired content.

B

Beta Header

Anthropic API experimental feature switches, such as fast-mode, caching, etc. Once a Beta Header has been sent, Claude Code latches to continue sending it to maintain cache stability.

Bash Tool

Tool for executing shell commands with built-in Git safety protocol and sandbox mechanism.

C

Cache Break Detection

Tracks state changes of 20+ fields to identify causes of prompt cache invalidation.

Cache Creation

Anthropic API billing concept - cost incurred when first sending a prompt prefix. Cache hits are 90% cheaper.

Cache Editing

Optimization technology for modifying partial content on top of existing cache prefix, more cost-effective than complete rebuild.

Circuit Breaker

Mechanism that forces stop when automated processes fail consecutively, preventing infinite retries from wasting resources.

CLAUDE.md

Project-level configuration file storing coding standards, architecture constraints, team processes, and other instructions that should not be modified automatically.

Compact

Context management technology that summarizes multi-turn conversation history into key information, used to free up token space.

Coordinator Mode

One of multi-Agent architectures where the main Agent acts as “commander-in-chief” dispatching tasks to Workers, not directly coding itself.

Context Collapse

Process where the oldest messages are removed or summarized when context exceeds capacity limit.

Context Window

Maximum token count a model can process, with Claude Code supporting 200K.

D

Denial Tracking

Safety mechanism for YOLO classifier - falls back to manual confirmation after 3 consecutive or 20 total denials.

Dynamic Boundary

Special marker in system prompts marking the division between static/dynamic content, used for cache optimization strategy.

E

Effort

Claude API reasoning depth parameter, optional values: low, medium, high, max.

Extract Memories

Mechanism that automatically analyzes and extracts information worth persisting at the end of each conversation turn.

F

Fail-Closed

Security design principle where the system defaults to the safest option, only allowing dangerous operations after explicit declaration.

Fast Mode

Mechanism that routes non-Opus model requests to Opus 4.6 for higher quality responses.

Feature Flag

Build-time code switch technology for controlling feature enable/disable, with Claude Code having 89 Feature Flags.

Fork

Experimental sub-agent spawning method that inherits the parent Agent’s complete conversation context.

G

Git Worktree

Creates isolated git working copies for Agents, protecting the main branch from accidental modifications.

GrowthBook

A/B testing and Feature Flag management platform used by Claude Code for remote configuration control.

H

Harness Engineering

Six core architecture principles extracted from Claude Code source: prompts as control plane, cache-aware design, fail-closed, A/B test everything, observe before fix, latch for stability.

Hook

Event interception mechanism during Claude Code lifecycle, supporting before/after trigger timing.

I

Isolation

Sub-agent execution isolation option, values: none, worktree.

K

KAIROS

Claude Code’s background autonomous Agent mode supporting focus awareness, timed awakening, brief communication, and other features.

L

Latch

Technology where once entering a state, it no longer changes, used to prevent cache jitter and state fluctuation.

LSP

Language Server Protocol - code intelligence protocol supported by Claude Code for symbol navigation, reference lookup, etc.

M

MCP

Model Context Protocol - open protocol launched by Anthropic for standardizing AI integration with external data sources and tools.

Memdir

Storage layer for cross-session memory, containing MEMORY.md index and topic files.

Microcompact

More granular context cleanup mechanism than auto-compact, including timestamp cleaning, cache-aware cleaning, and API Context Management.

Model Routing

Mechanism that routes requests to different model providers (Anthropic, Bedrock, Vertex, etc.) based on configuration.

O

OpenSpec

Change management specification used by Claude Code for planning, implementing, and verifying architecture changes.

P

Permission Mode

Claude Code security levels: default, acceptEdits, plan, bypassPermissions, auto, dontAsk.

perToolHashes

Fields used to precisely detect which tool description change caused cache invalidation.

Post-Compact Restoration

Selectively restores recently used files and skills after auto-compaction, preventing model from starting from scratch.

Prompt Cache

Anthropic API feature where identical prompt prefixes can be reused, significantly reducing costs.

R

Read Before Edit

Design pattern that forces the model to first read current file content before editing.

Remote Control

Ability to remotely control Claude Code instances via network protocol, based on BRIDGE_MODE.

S

Schema

Structured description of a tool including name, parameters, return values, and other metadata used by the model to understand tool usage.

SendMessage

Tool for inter-Agent communication supporting point-to-point, broadcast, UDS, Bridge, and other addressing methods.

Session Memory

Rolling conversation summary providing “what’s important” signals for the compression system.

Skill

Reusable Agent capability unit containing prompts, tools, workflows, etc., dynamically loaded through the skills system.

Soft/Double/Hard Interrupt

Three levels of user cancellation supported by Claude Code: soft interrupt (graceful stop), double interrupt (force stop), hard interrupt (immediate termination).

SubAgent

Independent Agent instance spawned by the main Agent, used for parallel task processing.

System Prompt

Collection of instructions sent to the model defining AI behavior guidelines, output format, security rules, etc.

System Reminder

Temporary system messages inserted mid-conversation for passing current-turn-specific instructions.

T

Teammate

Member Agent in Agent Swarm, collaborating through flat structure.

Thinking

Claude API feature allowing the model to explicitly output reasoning process. Modes include: adaptive, enabled, disabled.

Token

Processing unit of large language models, approximately 1/4 of an English word or 1/2 of a Chinese character.

Token Budget

Context management strategy setting token upper limits for various content types.

Tool

Capability units callable by AI Agents including file operations, command execution, code search, etc.

Tool Description

Natural language description of a tool telling the model what the tool does and how to use it.

Tool Result

Content returned after tool execution, injected into context for model reference.

Transcript

Complete conversation persistence in JSONL format supporting session resume.

Tree Sitter

Incremental parsing library used by Claude Code for code syntax analysis.

U

Ultrathink

Claude Code interaction design where including ultrathink keyword in message automatically raises Effort to high.

V

Verification Agent

Agent type specifically for verifying implementation correctness, prohibited from modifying projects, read-only verification.

W

Whitelist

First gate of YOLO classifier where explicitly allowed operations are directly permitted.

Worktree

Git feature creating independent working directories, based on which Agent isolation mode is implemented.

Y

YOLO Classifier

Claude Code permission classifier with four-layer architecture: whitelist, input filtering, Stage 1 fast classification, Stage 2 deep reasoning.

Abbreviation Reference

Concept Relationship Diagram

Agent Loop (Core Loop)
    ├── Agent (Intelligence)
    │   ├── Main Agent
    │   ├── SubAgent
    │   ├── Fork Agent
    │   └── Coordinator
    ├── Tool
    │   ├── File Tools
    │   ├── Bash Tool
    │   ├── Agent Tool
    │   └── Skill Tool
    └── Context
        ├── System Prompt
        ├── Tool Results
        ├── Memory
        │   ├── Memdir (Long-term)
        │   ├── Session Memory (Short-term)
        │   └── Extract Memories (Extraction)
        └── Compact
            ├── Auto-Compact
            └── Microcompact

Security
    ├── Permission Mode
    ├── YOLO Classifier
    ├── Hooks
    └── Git Safety Protocol

Optimization
    ├── Prompt Cache
    ├── Token Budget
    ├── Feature Flags
    └── Model Routing

This glossary covers the main concepts in Claude Code architecture. If you encounter unfamiliar terms while reading the series articles, you can quickly look them up here.