Glossary — AIGuide

Agent core

A model that can take actions — read files, run commands, edit code, search the web — not just produce text. Brain (the model) plus hands (tools). Full page →

Augmented LLM core

Anthropic's term for the foundation of an agent: a language model wrapped with tools, retrieval, and memory. The building block you compose into workflows and agents.

Autonomy spectrum core

The range from chatbot (one reply) to workflow (you script the steps) to agent (the model picks its own steps). Claude Code is an interactive agent.

Headless mode system

Running the agent non-interactively with claude -p "…" so it prints a result without prompts — used for scripts and CI/CD.

Agentic loop core

The repeating cycle an agent runs: gather context → reason → act with a tool → observe the result → decide the next move, over and over until the goal is met.

Loop engineering core

The discipline of designing that loop well — defining the goal, the feedback signals, the verification steps, and the condition that tells the agent to stop.

Subagent core

A specialised assistant the main agent delegates a task to. It runs in its own isolated context, does the work independently, and returns only a summary. Full page →

Orchestrator / main agent role

The top-level agent that owns the overall plan, makes high-level decisions, delegates to subagents, and assembles the final answer.

Context window memory

Everything the model can see on a given turn — conversation, files read, tool outputs, memory, tool definitions. It's finite, so keeping it lean keeps the agent sharp.

Context isolation memory

Giving each subagent its own separate context window. The subagent can't see the parent's history, and only its summary crosses back — keeping the main context clean.

Context engineering memory

Deciding what information the model sees each turn — which files, tools, instructions and memory to include. The layer beneath loop engineering.

Harness engineering system

Building the whole system around the model: tools, sandbox, memory, and permissions. The loop runs inside this harness.

Auto-compaction memory

When the context window fills up, Claude Code automatically trims old tool outputs and summarises older conversation so the loop can keep running.

Tool call action

A single action the agent takes — e.g. Read a file or run a Bash command. Multiple tool calls can fire in parallel within one turn.

Fan-out / fan-in pattern

Splitting independent work across several parallel subagents (fan-out), then merging their results in one synthesis step (fan-in).

Pipeline pattern

Chaining specialised subagents so each one's output feeds the next — e.g. Explore → Plan → Implement → Review → Test.

Verification loop pattern

Doing work, then having a read-only checker review it, feeding the critique back and repeating until the result is clean.

Adversarial verification pattern

Using independent skeptics whose job is to refute a finding. A claim survives only if it withstands them — filtering out plausible-but-wrong results.

Loop-until-done pattern

A subagent retries the same task, self-checking each pass, until a clear stopping condition is satisfied.

Stopping condition core

The rule that tells the loop it's finished — tests pass, the checker approves, a turn cap is hit. Without one, a loop can wander forever.

Frontmatter config

The YAML block at the top of a subagent's Markdown file that configures it — name, description, tools, model, and more.

CLAUDE.md config

A project file of persistent instructions that Claude Code loads into context automatically, so guidance carries across sessions.

MCP (Model Context Protocol) system

A standard for connecting external tools and data sources to the agent. The VS Code extension uses a local ide MCP server to talk to the editor.

Permission mode config

How much the loop is allowed to do without asking — from Manual (confirm everything) to Auto (run freely within limits).

Worktree isolation config

Running a subagent in its own git worktree — a separate copy of the repo — so parallel agents editing files don't collide.

Extended thinking system

A mode where the model reasons more deeply before acting, useful in the plan phase of the loop for hard problems.

Skill skills

A reusable folder of expertise Claude can load on demand — a SKILL.md file plus optional supporting files — that teaches it how to do a specific task your way. Full page →

SKILL.md skills

The required entry-point file of a skill: YAML frontmatter (name + description) followed by Markdown instructions. The filename is always capitalized exactly this way.

Progressive disclosure skills

How skills stay cheap: only names + descriptions load at startup; the full body loads when a skill is triggered; bundled files load one-by-one only when needed.

Model-invoked skills

The default way a skill fires — Claude reads its description and decides to use it automatically, with no command. Contrast with user-invoked (/skill-name).

Dynamic context injection skills

The !`command` syntax in a SKILL.md that runs a shell command and drops its live output into the skill before Claude reads it.

No terms match that filter.