Update (2026-07-25): the default is now Claude Opus 5 (claude-opus-5, launched 2026-07-24), which became Claude Code's default in v2.1.219. It keeps the 1M context window and Opus-tier pricing ($5/$25 per Mtok, same as Opus 4.8 — the Claude Code changelog line citing $10/$50 conflicts with Anthropic's own launch page and is treated here as an error). On Artificial Analysis it tops the Intelligence Index at 61 (max effort), just ahead of Fable 5 at 60 — "Fable-level performance at Opus price." fast mode now covers Opus 5 and Opus 4.8 (Opus 4.7 was dropped). The April snapshot below is preserved as written.

• Opus 4.6 with 1M context. The default model for substantive work. The 1M context window changes the shape of agent tasks: entire repositories, long research threads, and multi-day sessions fit without summarization. Compaction still happens but is less frequent.
• /fast mode. Same Opus 4.6 model, faster output path. Tradeoff: slightly less deliberation for much lower latency. Useful for exploratory edits and interactive pair-programming.
• Haiku 4.5 (claude-haiku-4-5-20251001). The lightweight option when you know the task is mechanical.

Hooks are shell commands wired to lifecycle events in settings.json. They run in the harness, not the model, which means they are deterministic and auditable. Common uses:

• SessionStart to prime beads, gossip, or telemetry
• PreToolUse / PostToolUse to enforce policy (reject rm -rf, log writes, attach attribution)
• UserPromptSubmit to inject repo-specific context

The important property: hooks are the correct primitive for "from now on whenever X do Y" rules. Asking the model to remember a behavioral rule is fragile; a hook is not.

User-invocable skills (/commit, /review, /security-review, etc.) are prompt templates with tool scopes. They expand to full prompts at call time and are discoverable at startup. The pattern:

• Named, composable prompts that encode workflow conventions
• Tool-list restriction per skill
• Discoverable through / completion

Skills are the bridge between "I have a convention I follow" and "the agent follows it too."

MCP servers provide tools over a local or remote transport. In 2026 Q1 we see:

• Cloudflare Developer Platform MCP (D1, R2, KV, Hyperdrive, Workers)
• Hugging Face MCP (models, datasets, spaces, papers)
• Gmail / Calendar / Drive MCPs for personal workflow
• Atlassian, Slack, Linear for team workflow
• Local MCPs for filesystem, git, and project-specific tooling

The interesting shift: MCPs are becoming the standard way to hand an agent an API, replacing ad-hoc tool definitions in the harness.

The Agent tool with subagent_type lets a parent agent delegate to a specialized child. Observed patterns in practice:

• Explore / Plan for research-heavy tasks that would pollute the parent context
• Role-based agents (code-reviewer, security-expert, sre, debugger) for perspectives
• Isolation via worktree: the child operates on a git worktree and returns the branch name

Subagents are most valuable as context firewalls. Their findings compress into a single message in the parent conversation instead of hundreds of tool calls.

git worktree add inside the repo under worktrees/ (gitignored) lets multiple Claude sessions run in parallel without stepping on each other. Combined with isolation: worktree on subagents, this becomes the basic unit of speculative work.

The file-based memory system at ~/.claude/projects/{project}/memory/ persists across sessions. MEMORY.md is the loaded index; individual memory files are fetched lazily. Types:

• user — role, preferences, knowledge
• feedback — corrections and validated approaches
• project — initiatives, deadlines, why decisions were made
• reference — pointers to external systems

The harness loads MEMORY.md automatically. The model's job is to keep it curated.

Skills that reference skills. /release calling /test then /commit then /push as a deterministic pipeline, with model judgment gated at decision points only.

MCPs return more structured resources — not just tool results. Think application/json+schema resources that agents can introspect before calling tools.

Worktree isolation is a start. The next step is process or network-level isolation for untrusted operations (web fetch, package install, build). This is where Cloudflare Sandbox GA becomes interesting — a persistent sandbox primitive that a subagent can inhabit.

A2A (agent-to-agent) in Anthropic's framing, MCP-over-network, and Cloudflare's direction around agent-readiness (see Cloudflare Agent Readiness) all point at the same thing: standard ways for agents to discover and invoke each other. Expect Claude Code to consume these standards as first-class MCP transports.

Task tracking outside the conversation (beads, Linear, Jira) is strictly better than TodoWrite for multi-session work. Expect the harness to lean harder on external trackers as the source of truth.

Checking the February/April predictions against the Claude Code changelog through v2.1.220 (2026-07-24), the direction was right but the mechanisms landed as concrete harness features, not patterns:

• Subagent isolation and nesting got first-class. The 3.3 prediction resolved: isolation: "worktree" subagents are real, and as of 2.1.219 subagents spawn nested subagents up to depth 3 — with a concurrency cap (default 20) and a per-session spawn cap (default 200) to bound the fan-out. That is the "orchestration layer as a harness feature" the March gap already flagged, now with guardrails.
• Auto mode. A permission tier that runs without per-tool dialogs, with a classifier gating dangerous operations (defaults to Sonnet). Neither the hooks nor the permissions framing here anticipated a model-in-the-loop permission mode.
• Background sessions and remote control. Sessions that keep running across turns, attachable from other clients — an execution-model shift the worktree/tmux section treats only as filesystem isolation.
• EndConversation tool (2.1.214). The harness can now end a session on sustained abuse or jailbreak attempts — a safety primitive, not a capability one.
• /fork (2.1.212) copies a conversation into a new background session; a cheaper checkpoint than the worktree dance this note describes.
• Accessibility: a screen-reader mode (--ax-screen-reader, 2.1.208). Not on the radar of any prediction here, and the right kind of thing to have missed.

The through-line the speculative section got wrong: it expected capability to arrive as composition of existing primitives. Most of it arrived as new harness primitives with their own semantics (auto mode, background sessions, nested subagents), which is exactly the "runtime primitives, not patterns" correction above — now with three more months of evidence.

• Claude Code Workshop 2026 — hands-on tutorial covering the full CLI, slash commands, hooks, skills, and agent surface this note speculates about. The workshop is the reference; this note is the forecast.
• CLI Coding Agents — 2026 Q2 Comparison — how Claude Code's surfaces compare against Copilot CLI, Gemini CLI, Codex CLI, Kiro, and OpenCode. Useful for reading which of the features here are convergent (every agent has them) vs divergent (Claude Code's bet).
• Claude Code + Ollama — configuring alternative backends, relevant to the model-portability discussion in §2.1 and the multi-provider direction in §2.4.

• Agentic Workflow with Claude Code — the daily workflow that hooks, skills, and worktrees enable.
• Sandboxing AI Coding Agents with FreeBSD Jails — the DIY isolation counterpart to the "stronger subagent isolation" speculation in §2.3.
• Elenctic Vibe Code Review — what to do with the code once Claude produces it; the review discipline that complements the generation harness.

• Cloudflare Agents Week 2026 — where Claude Code's MCP/A2A direction intersects managed-agent infrastructure (Sandbox GA, Agent Memory, Managed OAuth).
• Terminal AI Agents 2025 — the prior landscape survey; this note picks up where that one left off.
• AI Agent Tool Systems — how MCP tools compose into agent workflows, relevant to §2.4 and §2.5.
• Multi-Agent Workflow Frameworks — LangGraph / CrewAI / AutoGen comparison, relevant to the subagent and agent-teams discussion.
• Evolution of LLM and AI Agent Frameworks — the long arc from prompt engineering to agent harnesses.
• beads/bd — the git-native task tracker referenced in §2.6 as the complement to TodoWrite.

• Diagram Generation on FreeBSD 15 — how dot/graphviz generates diagrams natively during org-publish, relevant to anyone extending this note with architecture visuals.