Bookmark this page
The comparison matrix
The one table to return to whenever a new feature lands and you’re not sure where it fits. Read a row left-to-right to understand a primitive; read a column top-to-bottom to compare them on one dimension. Reviewed 2026-06-06.
All ten primitives, side by side
“Soft” = the model chooses whether to follow it. “Hard” = the client enforces it regardless of the model. “Who holds the plan” is the single best discriminator for the coordination primitives.
| Primitive | What it is | Coordination | Enforcement | Who holds the plan / invokes | Where it lives | Scale | Context | Cost & footprint | Reach for it when… | Pairs with | Watch out for | Status |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Conventions |
Markdown facts & conventions the model reads every session. | Foundations | Soft | You write it; model reads & may follow. | ./CLAUDE.md, ~/.claude/CLAUDE.md, .claude/rules/*.md |
1 session | Main context — injected into every turn’s prompt. | Loaded into every turn’s context — no extra calls, but a bloated file taxes every prompt. | Claude keeps getting a fact/convention wrong. | Hooks & policies — turn the soft rule into a hard one. | It’s soft: Claude may ignore it, and bloat dilutes attention. Not a guarantee. | GA |
| Policies |
Admin/config governance: allow / ask / deny, sandbox, forced model. | Orchestrate | Hard | Client enforces; model can’t override. | managed-settings.json, settings.json → permissions |
Fleet / org | Neither — a config gate outside the model; never enters context. | ~Zero runtime cost — a config gate checked before each action, no tokens. | Something must be blocked or required for everyone, always. | Hooks for the enforcement that needs to run code, not just gate. | Managed settings can’t be user-overridden — too strict blocks legit work; mind the merge precedence. | GA |
| Hooks | Your shell/HTTP/prompt command, fired automatically on lifecycle events. | Extend | Hard | Event fires it; runs deterministically. | settings.json → hooks (event→matcher→handler) |
1 session | Neither — runs as your own process; only its injected output (if any) returns to main context. | Adds your script’s runtime as latency on each event; no tokens unless it injects output back. | You want something to happen every time, guaranteed (lint, block, log). | Conventions & skills — enforce the soft guidance they describe. | A slow or failing hook blocks every action; a non-zero exit can halt the session. | GA |
| Skills |
Reusable instructions/procedures + optional scripts, loaded on demand. | Extend | Soft | You via /name, or model auto-loads by description. |
.claude/skills/<name>/SKILL.md, ~/.claude/skills/ |
1 session | Main context — description always in; body loads into the main thread on demand. | Cheap: only the one-line description sits in context; the body loads on demand when invoked. | You paste the same procedure/checklist repeatedly. | Subagents & MCP — a skill can drive both; hooks can fire one. | A vague description means it never auto-loads; even loaded, it’s soft — the model can skip it. | GA |
| MCP | A protocol; servers expose new tools, resources & prompts from external systems. | Extend | Soft | Model calls the tools when relevant. | .mcp.json (project), ~/.claude.json (local/user) |
1 session | Main context — tool schemas & call results live in the main context. | Tool schemas eat context (can be large); each call adds network latency. | You copy data into chat from a system Claude can’t see. | Skills that call its tools; subagents with a restricted tool profile. | Many servers bloat the tool list & context; auth can be missing in headless/cron runs. | GA |
| Subagents | Delegated worker in its own fresh context; only a summary returns. | Extend | Soft | The main conversation, turn by turn. | .claude/agents/*.md; /agents |
A few per turn | Own context — a fresh, isolated window; only a summary returns to main. | A full model run in its own context — extra tokens, but it spares yours; only a summary returns. | A side task would flood your context; or you want a restricted tool profile. | Workflows orchestrate them; skills & MCP shape what they can do. | Summary-only return drops detail; it can’t talk back mid-task; over-delegating burns tokens. | GA |
| Agent teams | A lead + peer sessions that share a task list and message each other. | Orchestrate | Soft | The lead agent (+ peers self-claim tasks). | env flag CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1; created in natural language |
3–5 peers (rec.) | Own context per peer — each peer is a separate full session, sharing only a task list & messages. | High: N concurrent full sessions plus inter-agent messaging — the priciest of the soft primitives. | Parallel work where the workers need to talk to each other. | Worktrees to isolate each peer; a shared task list to divide work. | Experimental; coordination overhead is real, and peers can clobber files without worktrees. | experimental |
| Dynamic workflows | A JS script Claude writes that orchestrates many subagents & cross-checks results. | Orchestrate | Soft | The script — the plan lives in code, not a context window. | script under ~/.claude/projects/; /workflows; ultracode |
Dozens–100s |
Own context per subagent — the plan lives in the script (code), outside any context window. | Highest ceiling — spends tokens across dozens–100s of subagents; budget it deliberately. | A task needs more agents than one conversation can coordinate. | Subagents are its unit of work; worktrees isolate parallel file edits. | Token blow-up if unbounded; must be opted into (ultracode); preview API still churns. |
research preview |
| Worktrees + Agent view | Git checkout isolation per session + a dashboard to dispatch & watch many sessions. | Orchestrate | Soft | You — hand off independent sessions, check back. | claude agents; claude --worktree; .claude/worktrees/ |
Many sessions | Own context per session — each worktree runs a fully separate session you supervise. | Disk per checkout + setup time; the real cost is your attention supervising, not tokens. | Several independent tasks you can hand off and review later. | Subagents, teams & workflows — gives each an isolated checkout. | Stale/uncleaned worktrees pile up; you still owe the merge/rebase reconciliation later. | preview |
| Routines |
A saved config (prompt + repos + connectors) run automatically on Anthropic’s cloud on a trigger. | Operate | Soft | A trigger — a schedule, a GitHub event, or an API /fire call. |
cloud (Anthropic-managed); claude.ai/code/routines, Desktop, CLI /schedule |
1 cloud run / trigger | Own context — a fresh autonomous cloud session, off your machine entirely. | Draws down subscription usage like an interactive session, plus a per-account daily run cap (one-offs exempt). | You want Claude to run unattended on a schedule / GitHub event / API call, laptop closed. | Skills & MCP — bundled into the saved config the run uses. | No permission prompts during a run — scope repos/branches/connectors tightly; it acts as you. | research preview |
Coordination groupings (not a ladder)
The same ten, grouped by how much coordination they add — from steering one session to orchestrating many and running unattended. It’s a map, not a ladder: go broad or deep wherever a real trigger appears. Most everyday work lives in the first two groups.
| Group | Goal | Primitives | What changes | The trigger to reach further |
|---|---|---|---|---|
| Foundations | Drive one session well. | CLAUDE.md / memory · slash commands · the Explore→Plan→Code→Commit loop | You shape soft context; no parallelism, near-zero new concepts. | You keep re-typing a prompt, or pasting a multi-step playbook. |
| Extend a session | Customize, connect, guarantee, and delegate — still within one session. | Skills · MCP · Hooks · Subagents | You add know-how, external reach, hard guarantees, and isolated delegation. | Subagents hit context limits, or need to communicate. |
| Orchestrate / Operate | Coordinate many agents, govern across repos — and run unattended in the cloud. | Agent teams · Dynamic workflows · Worktrees + Agent view · plugins · policies · Routines (cloud) | The plan leaves your single context — into a lead, a script, many sessions, or a saved cloud config a trigger runs; plus org governance. | — (the widest group; here you optimize cost & trust) |
“Make Claude keep working” — see Decide
Choosing among /loop, /goal, hooks, routines and cron is a decision, not a
dimensional comparison — so the two-axis table that separates them (where it runs: open session
vs independent × what starts the next unit: clock / condition / event) lives on the
Decide page → Keep running. /loop and /goal
aren’t rows in the matrix above; Routines is.
Breadth vs depth
The scored view of Axis 3. The axis itself — what breadth and depth mean and how to choose — is explained on the mental model page; this table scores every primitive on it. Breadth = how many things run in parallel. Depth = how much sustained, single-thread reasoning & shared context a unit of work keeps.
How to read the bars
Each bar is a relative score, not a line graph — it just shows how much of that one quality a primitive
has. A short bar = low, a full bar = high. So under Breadth,
“One session” is nearly empty (it does one thing at a time) while “Dynamic workflows” is full
(it fans out to many tasks at once). Compare bars down a column to rank primitives on that axis; compare a
row’s two bars to see whether that primitive leans breadth or depth.
| Primitive | Breadth (parallelism) | Depth (sustained context) | Sweet spot |
|---|---|---|---|
| One session | Iterative, interconnected work that needs full shared context. | ||
| Subagents | A few isolated side-quests whose summaries feed the main thread. | ||
| Agent teams | A handful of deep, long-running peers that must coordinate. | ||
| Agent view | Many independent full sessions you supervise loosely. | ||
| Dynamic workflows | Massive fan-out of shallow, well-scoped tasks + cross-check. |
The soft / hard split (memorize this for the exam)
Soft · model-mediated
The model reads it and tries to comply. No guarantee. Great for guidance, terrible for guardrails.
Hard · client-enforced
Happens (or is blocked) regardless of what the model decides. The only real guardrails.
The trap
Writing “never run
curl” in CLAUDE.md is a request. To actually block it, use a
permissions.deny rule or a PreToolUse hook. Soft text cannot enforce; only the client can.
Terminology fixes
Three pairs that sound like the same thing under different names. Two of three are not — and one word now names two different things.
“Conventions or policies — same thing?” → No.
| Conventions (CLAUDE.md) | Policies (managed settings) | |
|---|---|---|
| What | Markdown you write that Claude reads | Admin-deployed config the client enforces |
| Enforcement | Soft — no compliance guarantee | Hard — cannot be overridden |
| Example | “Use 2-space indentation” | permissions.deny: ["Bash(curl *)"] |
“Routines” → Two different meanings — don’t conflate them.
The word now points at two things:
→
Colloquial — a saved, repeatable procedure you call “a routine” → a skill (custom slash commands were merged into skills). Orchestration across many agents → a dynamic workflow; a default voice/format → an output style.
→
Official — the feature literally named Routines: a saved config run unattended on Anthropic’s cloud on a schedule / GitHub event / API call. Not a saved procedure — a different primitive entirely.
“Rules or hooks — all the same?” → No — three things wear the word “rule.”
| Term | What it actually is | Nature |
|---|---|---|
| Hooks | Your code, run on a lifecycle event (PreToolUse…) | Deterministic code that runs |
| Permission rules | allow/ask/deny strings in settings.json | Declarative config (deterministic), not code |
| Project rules | .claude/rules/*.md — path-scoped CLAUDE.md-style memory | Soft guidance (just modular memory) |
“Tool call, MCP, skill, function call — four things?” → No — one mechanism with specializations.
Tool use is the umbrella API capability; a tool call is one instance of it (the model
emits a tool_use block → you return a tool_result). The rest are special cases or synonyms:
| Term | What it actually is | Is it a tool call? |
|---|---|---|
| Tool call | One tool_use → tool_result cycle (client tool you run, or server tool Anthropic runs) | It is the thing |
| MCP call | A tool exposed by an MCP server; same tool_use JSON, routed via the MCP client | Yes — an ordinary tool call |
| Skill invocation | The model calls the Skill tool, which loads a SKILL.md into context | Yes — a Skill tool call (but a skill isn’t a tool — it’s knowledge) |
| Function call | OpenAI’s older name for the same capability | Synonym — Anthropic says “tool use” |