I now have comprehensive, current coverage across all requested topics. Let me synthesize into structured markdown.

Agentic LLM Tooling & Coding-Agent Workflows (2026)

A practical reference on coding agents, MCP, agent design patterns, and frameworks — as of mid-2026. Throughout, capabilities are tagged [Claude-specific] or [General/cross-vendor].

1. Claude Code

What it is. Claude Code is Anthropic's agentic coding tool that runs as a CLI (also embedded in IDEs). It doesn't just autocomplete — it reads your codebase, plans, edits files, runs commands/tests, and iterates in a loop. In 2026 its architecture is built from six composable primitives, which can be bundled into plugins as single installable units.

The six primitives:

Primitive	What it does	Scope
CLAUDE.md	Project/user memory file auto-loaded into context — conventions, commands, guardrails	[Claude-specific], but the pattern (`.cursorrules`, `AGENTS.md`) is general
Slash commands	Reusable prompt templates invoked as `/name`	[Claude-specific]
Subagents	Specialized Claude instances with their own context window	[Claude-specific]
Hooks	Deterministic scripts fired at lifecycle events	[Claude-specific]
Skills	Folders of procedural instructions loaded on demand	[Claude-specific]
MCP servers	Connections to external tools/data	[General] — open standard

Slash commands [Claude-specific]

Typed shortcuts starting with / that insert a prompt template into the conversation. Built-ins include /init, /compact, /context, /review, /security-review. Custom commands are just Markdown files in .claude/commands/. Good for repeatable, human-triggered workflows (e.g. the user's own /작업시작, /머지, /배포확인).

Hooks [Claude-specific]

Deterministic shell scripts that fire at fixed points in the agent lifecycle — the key distinction from prompting is that hooks always execute (they're code, not a request the model may ignore). Configured in settings.json. The five events used in nearly every production setup:

SessionStart — inject context, check prerequisites, init logging
UserPromptSubmit — validate/augment prompts before the model sees them
PreToolUse — the most powerful; can approve, deny, or modify a tool call (e.g. block reading .env, block rm -rf)
PostToolUse — react to a completed action (auto-lint, run tests, log)
Stop — fire when the agent finishes a turn

The 2026 SDK exposes ~30 events total (SubagentStart/Stop, PreCompact, FileChanged, PermissionRequest, etc.), but those five cover most needs. Use hooks for anything that must happen every time — formatting, secret-blocking, test gates.

Subagents [Claude-specific]

Specialized Claude instances, each with its own separate context window and persona, spawned for a scoped task (code review, debugging, architecture exploration). Benefits: the main conversation stays focused, and you save tokens because the subagent's exploration doesn't pollute the parent context. Built-in types include Explore (read-only codebase search), Plan (planning without executing), and general-purpose. (This very research task is running as a subagent.)

Skills [Claude-specific]

Folders containing a SKILL.md (instructions) plus optional scripts/resources. Progressive disclosure is the point: only ~30–50 tokens per skill sit in context until the skill is actually triggered, then the full instructions load. Skills are procedural knowledge — checklists, workflows, code-gen patterns — and run in the current session. They cannot make API calls or query databases on their own; for that a skill calls MCP tools.

MCP in Claude Code [General]

Claude Code is an MCP client. It's how Claude talks to GitHub, Slack, databases, browsers, design tools — anything with an MCP server. Configured per-project or globally; most developers run 2–3 servers (e.g. GitHub, filesystem, one domain-specific).

How they fit together (mnemonic): MCP is the pipe, Skills are the instructions, Subagents are the workers, Hooks are the guardrails, Plugins are the box that wraps them all.

2. MCP — Model Context Protocol [General, vendor-neutral]

What it is. An open standard (originated by Anthropic, now cross-vendor) that lets any AI application plug into any data source or tool without custom wiring. The canonical analogy: "USB-C for AI." Before MCP, every AI-tool integration was bespoke (M models × N tools = M×N connectors); MCP collapses this to M+N.

Architecture. A host/client (the AI app, e.g. Claude Code) connects to one or more MCP servers, each exposing three primitive types: - Tools — functions the model can call (query a DB, open a PR) - Resources — data the model can read (files, records) - Prompts — reusable templates the server provides

Why it matters. It turned tool integration into a network-effect ecosystem. A single MCP server written once works with every MCP-compatible client.

Adoption (2026): - ~97M monthly SDK downloads by March 2026 (≈970× growth over 18 months) - Official registry held ~9,650 server records (May 2026) - ~28% of Fortune 500 had production MCP deployments - OpenAI, Google, Microsoft, Salesforce all shipped support within ~13 months — this cross-vendor buy-in is what made it a de facto standard rather than an Anthropic feature

Related standard: A2A (Agent-to-Agent) — where MCP connects an agent to tools/data, A2A connects agents to other agents (e.g. a Google ADK agent invoking a LangGraph agent through a standardized task interface). Think of MCP and A2A as complementary layers.

3. Agent Design Patterns [General]

The vendor-neutral patterns every agent developer should know. The seven core ones: Tool Use, ReAct, Reflection, Plan-and-Execute, Multi-Agent Collaboration, Memory Management, Human-in-the-Loop.

Tool Use (function calling)

The foundation: the model is given a set of tools (name + schema) and decides which to call with what arguments. Sufficient on its own when a task resolves in a single LLM call plus tools. Reliability improved by clear schemas and separating reasoning tokens from the invocation.

ReAct (Reason + Act)

Interleaves think → act → observe → repeat in one loop. The safe default for open-ended tool-use agents — the model reasons about what to do, takes an action, sees the result, and adjusts. Reduces hallucinated actions. Always pair with an explicit iteration limit to prevent runaway loops.

Plan-and-Execute

Separates the phases: generate a complete plan first, then execute steps sequentially, re-planning only on failure. Use this when you need a guaranteed execution sequence; use ReAct when the path can't be pre-specified. (Claude Code's Plan Mode is a concrete instance.)

Reflection

The agent critiques its own output and revises — a generate → evaluate → refine loop. Big quality gains on reasoning/coding tasks, at the cost of extra tokens.

Multi-Agent Orchestration

One orchestrator LLM manages specialized sub-agents (planner, researcher, coder, verifier), decomposing a task into subgoals and assigning each to a role. Two flavors: - Supervisor/specialist (hierarchical) — orchestrator delegates and aggregates - Handoff-based — agents explicitly transfer control, carrying context (OpenAI Agents SDK's model)

Powerful but expensive and harder to debug. Decision rule: only reach for multi-agent when a task genuinely needs specialized roles that exceed a single context window. Otherwise prefer ReAct or plain tool use.

RAG → Agentic RAG

Traditional RAG: fixed, one-shot retrieval before generation. Fast and cheap, but answers even when retrieved chunks only partially cover the question.
Agentic RAG: the agent decides when, what, and how to retrieve, can decompose queries, assess retrieved evidence, refine, and loop until confident. Canonical patterns: iterative retrieval, query decomposition, hypothesis-driven retrieval, cross-corpus triangulation, evidence-weighted synthesis.
Trade-off: agentic RAG buys accuracy on hard/multi-hop questions at 3–10× the token cost and higher latency. Use it for legal research, complex support, knowledge management — not simple lookups.

Pattern-selection cheat sheet: | Situation | Use | |---|---| | One call + tools resolves it | Tool Use | | Open-ended, path emerges as you go | ReAct (with iteration cap) | | Need a guaranteed, ordered sequence | Plan-and-Execute | | Output quality needs self-correction | Reflection | | Genuinely distinct roles > 1 context | Multi-Agent | | Answers need external knowledge | RAG; Agentic RAG if multi-hop |

4. Agent Frameworks (2026) [General]

Five frameworks matter for production; pick by team size and control needs.

Framework	Vendor	Model	Best for	Notes
LangGraph	LangChain	Graph of nodes/edges	Enterprise, auditable, complex control flow	Adoption leader (~34.5M monthly downloads); passed CrewAI in stars early 2026. Graph maps cleanly to audit trails / rollback points
CrewAI	CrewAI	Role-based "crews"	Fastest idea→demo (2–4h setup)	~44.6k stars; used at ~60% of Fortune 500 for prototypes
OpenAI Agents SDK	OpenAI	Handoffs between agents	OpenAI-centric production stacks	Replaced the experimental Swarm; agents transfer control explicitly, carrying context
Google ADK 2.0	Google	Multi-language + A2A	Cross-framework agent interop	Can discover/invoke LangGraph or CrewAI agents via A2A
Microsoft Agent Framework 1.0	Microsoft	Merged Semantic Kernel + AutoGen	.NET / enterprise Microsoft shops	AutoGen is now maintenance-only; folded into this in April 2026

Guidance: LangGraph when you need explicit control and auditability; CrewAI for the fastest multi-agent prototype; the vendor SDKs (OpenAI / Google / Microsoft) when you're already committed to that ecosystem. Note the distinction: these frameworks are for building agents in code; Claude Code is an end-user coding agent product. They overlap only in that Claude Code's headless mode / Agent SDK can also be used as a building block.

5. The Practical Day-to-Day Coding-Agent Workflow [General principle, Claude-flavored examples]

The consensus 2026 loop is a hybrid: plan interactively, let the agent execute in a sandbox, gate on CI + human PR review before merge. The canonical stages:

1. Spec — Write a clear, bounded description of what you want. Vague specs are the #1 cause of agent drift.

2. Context — Package what the agent needs to know before it starts: CLAUDE.md/AGENTS.md/.cursorrules with conventions, key commands, architecture notes, and guardrails. This is the single highest-leverage setup step.

3. Plan — Have the agent produce a plan before editing (Claude Code's Plan Mode; ReAct/Plan-and-Execute under the hood). Review and correct the plan — cheap to fix here, expensive later. Break work into file-level tasks.

4. Implement — Let the agent edit and run tests with self-correction, in small diffs. Small, reviewable changes beat large ones.

5. Verify — The tight loop write → run tests → fix is where agents excel if tests exist. Teams with strong testing get the most from agents. Enforce with hooks/CI (same linters and tests as human code).

6. Review — Never merge agent code without human review. Independent review (a review subagent, or a second model as adversary) catches what the author model misses.

7. Commit / Ship — Commit atomically, open a PR, gate on CI.

Operational habits that matter: - Stop the agent when it drifts — don't let a confused loop run. (Karpathy's rule: when you don't know what's confusing, stop and name it, don't guess.) - Manage context — /compact or fresh sessions before the window fills; subagents to isolate exploration. - Safety scoping — restrict edit scope, warn on destructive commands, block secret files (via hooks or careful/freeze-style modes). - Simplicity first — the smallest diff that solves the problem; agents over-engineer by default, so review for scope creep.