Claude Code

Claude Code is Anthropic's agentic coding tool: an agent harness that pairs a Claude model — which does the reasoning and chooses tools — with the tools themselves, context management, and an execution environment (How Claude Code works). It runs in the terminal, in VS Code and JetBrains IDEs, as a standalone desktop app, and in the browser at claude.ai/code (Overview). For practitioners managing agents it doubles as a reference implementation of harness design: context-window budgeting, context-compaction, subagent delegation, and permission gating all ship here as documented, configurable features. This page describes Claude Code as of v2.1.206, the latest published version on 2026-07-10 (changelog); the project ships point releases at near-daily pace (see versioning notes below), so version-tagged details are snapshots, not stable guarantees.

Capabilities

The loop. A task cycles through three blended phases — gather context, take action, verify results — repeated until the task is done, and the operator can interrupt at any point (How Claude Code works). Built-in tools fall into five categories: file operations, search, execution (shell, tests, git), web search/fetch, and code intelligence via optional plugins — plus orchestration tools such as spawning subagents (How Claude Code works).

Context management. When the context-window fills, Claude Code runs automatic context-compaction: it clears older tool outputs first, then summarizes the conversation; detailed early instructions can be lost in the process, so persistent rules belong in CLAUDE.md rather than conversation history (How Claude Code works). On the Anthropic API, claude-sonnet-5 — the packaged default for Pro and Team Standard seats (account-type defaults below) — always runs with a native 1M-token window and auto-compacts at about 967K tokens by default, tunable via CLAUDE_CODE_AUTO_COMPACT_WINDOW (Model configuration).

Delegation. subagents run in isolated context windows with their own system prompt, tool access, and permission settings; nesting is capped at a fixed, non-configurable five levels below the main conversation (Create custom subagents). As of v2.1.198 subagents run in the background by default — a change to where they run, not what they may do: every permission prompt still surfaces in the operator's main session (Create custom subagents).

Extension mechanisms (as of 2026-07-10):

Mechanism	What it adds	Property that matters to operators
CLAUDE.md + auto memory	User-written instructions and Claude-written notes persisted across sessions	CLAUDE.md loads in full every session (recommended under 200 lines); auto memory loads the first 200 lines or 25KB of MEMORY.md (Memory)
Skills	Procedures packaged as SKILL.md files following the open Agent Skills standard; legacy .claude/commands/ merged into this mechanism	Skill body loads into context only on invocation — only descriptions cost tokens at session start (Skills)
Hooks	Shell commands, HTTP endpoints, LLM prompts, or MCP tool calls fired at lifecycle events (PreToolUse, SessionStart, PreCompact, SubagentStop, and others)	Deterministic enforcement, unlike instructions: exit code 2 blocks the triggering action; other non-zero exit codes do not (Hooks reference)
MCP	External tools and data over stdio, HTTP, or WebSocket transports (SSE deprecated), configured at local, project, and user scopes plus a managed enterprise level	Tool schemas are deferred by default: only tool names sit in context until a tool is actually used (MCP; Costs)

Safety rails. Permissions are tiered — read-only tools run without approval, Bash and file modification require it — with six permission modes (default/manual, acceptEdits, plan, auto as a research preview, dontAsk, bypassPermissions); rules evaluate deny > ask > allow, and the first match wins regardless of specificity (Permissions). Auto mode's background action-review classifier is an llm-as-judge-style gate inside the permission layer (Permissions). Checkpointing snapshots file state before every edit, and /rewind (or double-Esc) restores code, conversation, or both — or summarizes a span of conversation instead (Checkpointing). The sandboxed Bash tool adds OS-level isolation (Seatbelt on macOS; bubblewrap plus socat on Linux/WSL2): by default, writes are confined to the working directory and session temp directory, and no network domains are pre-allowed (Sandboxing).

Usage model

All surfaces drive the same engine, so CLAUDE.md files, settings, and MCP servers carry across terminal, IDE, desktop app, and web (Overview). Session state is local and inspectable: each session is a plaintext JSONL transcript stored under .claude/projects/ in the user's home directory, tied to the working directory; every new session starts with a fresh context window, --continue/--resume reopen a session, and --fork-session branches it (How Claude Code works).

Headless mode turns the loop into a scriptable Unix tool: claude -p "prompt" runs non-interactively and exits, with --output-format text|json|stream-json, stdin piping, --max-turns and --max-budget-usd caps, and JSON-schema-validated structured output — the building block for CI jobs and fan-out pipelines (CLI reference).

For programmatic products, the agent-sdk (Python and TypeScript) exposes the same agent loop, built-in tools, hooks, subagents, and MCP support as a library; it sits between the low-level Client SDK, where you implement the tool-call loop yourself, and Managed Agents, a hosted REST API running on Anthropic-managed infrastructure (Agent SDK overview).

Configuration resolves through five precedence levels — managed (organization) settings, then command-line arguments, then project .claude/settings.local.json, then project .claude/settings.json, then user-level .claude/settings.json in the home directory — and a deny at any level cannot be re-allowed at a lower one (Permissions).

Limitations and constraints

• Instructions are context, not policy. CLAUDE.md is delivered as a user message after the system prompt; compliance is best-effort, and hard guarantees require hooks or permission rules instead (Memory).
• Compaction loses detail. Early-conversation instructions may not survive summarization, and nested CLAUDE.md files in subdirectories are not automatically re-injected after /compact — only the project-root file is re-read (Memory).
• Argument-level Bash permission rules are bypassable. The vendor docs mark patterns like Bash(curl http://github.com/ *) as fragile — redirects, protocol switches, extra options, and shell variables slip past them — and recommend denying Bash network commands outright, then using WebFetch domain allow-rules or a PreToolUse hook (Permissions).
• Sandbox boundaries. Native Windows is unsupported (WSL2 required), and the network proxy allow-lists by hostname without terminating or inspecting TLS by default; the docs warn that broad allowlists can be escaped via domain fronting, flagging stronger TLS-aware isolation as an active area of development (Sandboxing).
• Checkpoints have blind spots. File changes made through Bash commands (rm, mv, cp) are not tracked, external side effects cannot be rewound, and checkpoints are explicitly a complement to git, not a replacement (Checkpointing).
• The harness itself is a moving quality surface. Anthropic's postmortem documents three overlapping bugs that degraded output quality from early March to April 20, 2026: a reasoning-effort default silently lowered from high to medium (March 4, reverted April 7), a caching bug that wiped the model's thinking history every turn instead of once (March 26, fixed April 10 in v2.1.101), and a verbosity-limiting system-prompt change that hurt coding quality (April 16, reverted April 20) (Anthropic Engineering). The operator takeaway: agent quality can regress without any model change, so track harness versions alongside model versions in evals.
• Multi-instance cost blow-ups. Experimental agent teams (disabled by default; opt-in via CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1) use roughly 7x the tokens of a standard session when teammates run in plan mode, because each teammate holds its own full context window (Costs).

Versioning and pricing notes

Release cadence is high: v2.1.116 shipped on April 20, 2026 (Anthropic Engineering) and the changelog stood at v2.1.206 by 2026-07-10 — about 90 point releases in under three months (changelog). Native installers auto-update in the background; Homebrew offers a stable cask claude-code (typically about a week behind, skipping releases with major regressions) and claude-code@latest, neither of which auto-updates, and WinGet installs also require manual upgrades (Overview). For fleet deployments, the stable channel trades freshness for protection against known-regression releases.

The default model depends on account type (as of 2026-07-10): Max, Team Premium seats, Enterprise pay-as-you-go, and Anthropic API accounts default to claude-opus-4-8, while Pro, Team Standard, and Enterprise subscription seats default to claude-sonnet-5 (Model configuration); Sonnet 5 arrived as the packaged default in v2.1.197 (changelog).

Prices as of 2026-07-10:

Item	Price	Source
Pro subscription	$17/month billed annually; $20/month billed monthly	claude.com/pricing
Max subscription	from $100/month	claude.com/pricing
Team	$20/seat/month billed annually; $25/month billed monthly	claude.com/pricing
Enterprise	seat price plus usage at API rates	claude.com/pricing
Sonnet 5 API tokens	$2/$10 per MTok in/out introductory through 2026-08-31; $3/$15 standard	Models overview
Opus 4.8 API tokens	$5/$25 per MTok in/out	Models overview

Claude Code is included with Pro, Max, Team, and Enterprise subscriptions — not the Free plan — and on API accounts it bills by token consumption (claude.com/pricing; Costs). Across enterprise deployments, Anthropic reports an average of about $13 per developer per active day and $150–250 per developer per month, with 90% of users staying under $30 per active day, as of 2026-07-10 (Costs). Recommended per-user rate-limit budgets shrink with organization size: roughly 200k–300k TPM per user for teams of 1–5 down to 10k–15k TPM per user at 500+ users, applied at the organization level rather than per individual (Costs).