메뉴
Choose the right agent type for each task including built-in agents (Bash, Explore, Plan, general-purpose) and plugin agents (review, research, refactoring, SDLC). Use when selecting agent types, understanding agent capabilities, or matching agents to tasks.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
SOC 직업 분류 기준
| name | agent-types |
| description | Choose the right agent type for each task including built-in agents (Bash, Explore, Plan, general-purpose) and plugin agents (review, research, refactoring, SDLC). Use when selecting agent types, understanding agent capabilities, or matching agents to tasks. |
Experimental: Agent teams are disabled by default. Enable with
CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMSin your settings.json or environment.
Choose the right agent type for each role in your team. Agent types determine what tools are available and what the agent is optimized for.
Related skills:
| Need | Agent Type | Why |
|---|---|---|
| Search/read code | Explore | Read-only, fast, cheap (haiku) |
| Architecture design | Plan | Read-only, thoughtful analysis |
| Run commands/git | Bash | Shell access only |
| Multi-step implementation | general-purpose | Full tool access |
| Claude Code questions | claude-code-guide | Docs and web access |
| Security review | sdlc:security-reviewer | Vulnerability assessment, secure coding |
| Code quality review | sdlc:quality-enforcer | Formatting, linting, code style |
| Code simplification | code-simplifier:code-simplifier | Clarity, consistency, minimalism |
| Architecture analysis | refactor:architect | Design review, optimization planning |
| Best practices research | adr:adr-researcher | Codebase analysis + web research |
| Deep code exploration | feature-dev:code-explorer | Trace execution paths, map architecture |
| Code review | feature-dev:code-reviewer | Bugs, logic errors, conventions |
| Source code chunk analysis | swarm:rlm-code-analyzer | Code-aware, scope context, analysis focus |
| Data/CSV chunk analysis | swarm:rlm-data-analyzer | Column-aware, distributions, statistics |
| JSON chunk analysis | swarm:rlm-json-analyzer | Schema-aware, structural patterns |
| General chunk-level analysis | swarm:rlm-chunk-analyzer | Haiku, fast, structured JSON output |
| Synthesize chunk findings | swarm:rlm-synthesizer | Sonnet, aggregation and deduplication |
Key rule: Match the agent's tool access to the task requirements. Read-only agents (Explore, Plan) cannot edit or write files. Never assign them implementation work.
These are always available without plugins:
Task({
subagent_type: "Bash",
description: "Run git commands",
prompt: "Check git status and show recent commits"
})
Task({
subagent_type: "Explore",
description: "Find API endpoints",
prompt: "Find all API endpoints in this codebase. Be very thorough.",
model: "haiku" // Fast and cheap
})
Task({
subagent_type: "Plan",
description: "Design auth system",
prompt: "Create an implementation plan for adding OAuth2 authentication"
})
Task({
subagent_type: "general-purpose",
description: "Research and implement",
prompt: "Research React Query best practices and implement caching for the user API"
})
Task({
subagent_type: "claude-code-guide",
description: "Help with Claude Code",
prompt: "How do I configure MCP servers?"
})
Task({
subagent_type: "statusline-setup",
description: "Configure status line",
prompt: "Set up a status line showing git branch and node version"
})
Installed plugins provide specialized agent types grouped by function.
Plugin Agent Constraints: Some agent frontmatter fields are silently ignored when running as plugin agents (for security reasons). Do not rely on these in plugin agent definitions:
hooks— ignored (cannot execute arbitrary shell commands from plugins)mcpServers— ignored (MCP server injection not permitted from plugins)permissionMode— ignored (permission escalation from plugins is blocked)Fields that are supported in plugin agents:
name,description,tools,disallowedTools,model,maxTurns,skills,memory,background,isolation.
// Security review
Task({
subagent_type: "sdlc:security-reviewer",
description: "Security audit",
prompt: "Audit this PR for security vulnerabilities"
})
// Code quality
Task({
subagent_type: "sdlc:quality-enforcer",
description: "Quality check",
prompt: "Check formatting, linting, and code style"
})
// Code review (bugs, logic, conventions)
Task({
subagent_type: "feature-dev:code-reviewer",
description: "Code review",
prompt: "Review this code for bugs, logic errors, and adherence to project conventions"
})
// Code simplification
Task({
subagent_type: "code-simplifier:code-simplifier",
description: "Simplicity check",
prompt: "Check if this implementation can be simplified"
})
// Architecture review
Task({
subagent_type: "refactor:architect",
description: "Architecture review",
prompt: "Review the system architecture of the authentication module"
})
// SDLC compliance audit
Task({
subagent_type: "sdlc:compliance-auditor",
description: "Compliance audit",
prompt: "Audit this project against all SDLC standards"
})
All review agents:
sdlc:security-reviewer - Vulnerability assessment, supply chain security, secure codingsdlc:quality-enforcer - Formatting, linting, error handling, documentation standardssdlc:compliance-auditor - Full SDLC compliance auditfeature-dev:code-reviewer - Bugs, logic errors, security, code quality, conventionscode-simplifier:code-simplifier - Clarity, consistency, minimalismrefactor:architect - Architectural analysis, optimization planninghuman-voice:voice-reviewer - Content voice and tone review// Best practices and architectural research
Task({
subagent_type: "adr:adr-researcher",
description: "Research auth best practices",
prompt: "Research current best practices for JWT authentication"
})
// Deep codebase exploration
Task({
subagent_type: "feature-dev:code-explorer",
description: "Analyze auth module",
prompt: "Trace execution paths and map the architecture of the authentication module"
})
// Feature architecture design
Task({
subagent_type: "feature-dev:code-architect",
description: "Design feature architecture",
prompt: "Design the architecture for adding OAuth2 authentication based on existing patterns"
})
All research agents:
adr:adr-researcher - Codebase analysis + web search for best practicesfeature-dev:code-explorer - Trace execution paths, map architecture, understand dependenciesfeature-dev:code-architect - Design feature architectures based on existing patterns// Architecture analysis and planning
Task({
subagent_type: "refactor:architect",
description: "Plan refactoring",
prompt: "Analyze code architecture and create a prioritized optimization plan"
})
// Implementation
Task({
subagent_type: "refactor:refactor-code",
description: "Implement refactoring",
prompt: "Implement the architectural optimizations while preserving functionality"
})
// Test coverage
Task({
subagent_type: "refactor:refactor-test",
description: "Refactoring test coverage",
prompt: "Analyze coverage, add missing tests, ensure all tests pass"
})
// Code simplification (post-refactor cleanup)
Task({
subagent_type: "refactor:simplifier",
description: "Simplify refactored code",
prompt: "Simplify and refine recently changed code for clarity and consistency"
})
// Security regression check
Task({
subagent_type: "refactor:security-review",
description: "Security review of refactored code",
prompt: "Review refactored code for security regressions and vulnerabilities"
})
// CI pipeline design
Task({
subagent_type: "sdlc:ci-architect",
description: "Design CI pipeline",
prompt: "Configure GitHub Actions workflow for this project"
})
// Bug reproduction (full tool access)
Task({
subagent_type: "general-purpose",
description: "Validate bug",
prompt: "Reproduce and validate this reported bug: [description]"
})
// Test generation
Task({
subagent_type: "auto-harness:test-generator",
description: "Generate tests",
prompt: "Generate comprehensive test definitions for this component"
})
Content-aware chunk analyzers — the Team Lead selects the analyst based on detected content type.
Single-file mode: One analyst type per session (determined by content type). Multi-file mode: Different analyst types run simultaneously when a directory contains mixed content types. 1 analyst per task (fresh context each), distributed proportionally across content types, staged spawning in batches of ~15 for large workloads. See Multi-File Directory Analysis.
IMPORTANT: In actual RLM workflows, spawn these as teammates (with team_name + name) so they communicate via SendMessage instead of dumping results into the leader's context. In multi-file mode, analysts write findings to task descriptions via TaskUpdate and send only one-line summaries to team-lead. See RLM Pattern for the full team lifecycle. The examples below show the subagent_type syntax only:
// Source code analysis (code-aware boundaries)
Task({
subagent_type: "swarm:rlm-code-analyzer",
description: "Analyze code chunk",
prompt: "Query: Review for security issues\nFile: /tmp/rlm-chunks/chunk-01.py\nLanguage: python\nAnalysis focus: security\nThis is chunk 1 of 10."
})
// CSV data analysis (header-preserving chunks)
Task({
subagent_type: "swarm:rlm-data-analyzer",
description: "Analyze data chunk",
prompt: "Query: Analyze distribution by region\nFile: /tmp/rlm-chunks/chunk-03.csv\nThis is chunk 3 of 9.\nKey columns: region, plan, mrr"
})
// JSON analysis (schema-aware chunks)
Task({
subagent_type: "swarm:rlm-json-analyzer",
description: "Analyze JSON chunk",
prompt: "Query: Report schema patterns and anomalies\nFile: /tmp/rlm-chunks/chunk-02.jsonl\nFormat: jsonl\nThis is chunk 2 of 8."
})
// General chunk analysis (logs, prose, config, other)
Task({
subagent_type: "swarm:rlm-chunk-analyzer",
description: "Analyze log chunk",
prompt: "Query: What errors occurred?\nFile: /var/log/app/server.log\nStart line: 1\nEnd line: 200\nThis is chunk 1 of 10."
})
// Synthesis (higher quality)
Task({
subagent_type: "swarm:rlm-synthesizer",
description: "Synthesize findings",
prompt: "Original query: What errors occurred?\n\nFindings:\n[...findings JSON...]"
})
RLM agents (defined by this plugin):
swarm:rlm-code-analyzer — Haiku model, code-aware chunk analysis with scope context and analysis focusswarm:rlm-data-analyzer — Haiku model, CSV/TSV chunk analysis with column distributions and statisticsswarm:rlm-json-analyzer — Haiku model, JSON/JSONL chunk analysis with schema patterns and field distributions. Also used by the JSONL Log Analyzer skill for log-specific schema-aware analysisswarm:rlm-chunk-analyzer — Haiku model, general-purpose chunk analysis for logs, prose, config, markupswarm:rlm-synthesizer — Sonnet model, aggregates findings from multiple chunk analyses into coherent reportsDo NOT override analyst models. Do not pass model: "sonnet" or model: "opus" in the Task tool call when spawning analyst agents. The agent frontmatter defines model: haiku because structured counting, frequency analysis, and JSON output are well within Haiku's capability. Overriding to a more expensive model burns 10-50x the cost per chunk with no material quality gain. Only the synthesizer uses Sonnet. Leave the model parameter unset — let the agent definition's default apply.
Plugin agents use the format: {plugin}:{agent-name} or {plugin}:{category}:{agent-name}
Examples:
sdlc:security-reviewerfeature-dev:code-reviewerrefactor:architectcode-simplifier:code-simplifierBuilt-in agents use simple names: Bash, Explore, Plan, general-purpose, claude-code-guide, statusline-setup.
Swarm plugin agents follow the same convention:
swarm:rlm-code-analyzerswarm:rlm-data-analyzerswarm:rlm-json-analyzerswarm:rlm-chunk-analyzerswarm:rlm-synthesizerDebug and recover from agent team errors including common errors, hooks for quality gates, known limitations, and recovery strategies. Use when encountering team errors, enforcing quality gates with hooks, understanding limitations, or debugging agent issues.
Send messages between agents using SendMessage including direct messages, broadcasts, shutdown requests/responses, and plan approvals. Use when communicating between agents, understanding message formats, or handling structured protocol messages.
Master multi-agent orchestration using Claude Code's agent teams and task system. Use when coordinating multiple agents, running parallel code reviews, creating pipeline workflows with dependencies, building self-organizing task queues, or any task benefiting from divide-and-conquer patterns. Routes to specialized sub-skills for team management, tasks, messaging, patterns, backends, and error handling.
Apply proven orchestration patterns for agent teams including parallel specialists, pipelines, swarms, research+implementation, plan approval, and multi-file refactoring. Use when choosing a team structure, designing workflows, or implementing specific coordination patterns.
Manage shared task lists for agent teams including creating tasks, setting dependencies, claiming work, and tracking progress. Use when creating work items, building task pipelines, coordinating task ownership, or managing task dependencies.
Analyze large JSONL log files using schema-aware partitioned analysis. Discovers field schema, generates tailored jq extraction recipes, and orchestrates parallel chunk analysts with synthesis. Use when processing JSONL logs exceeding context limits, performing log analytics, or investigating incident logs.