Claude Code Subagents · page 4

Council member. Use standalone for formal systems & computational analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for categorization & structural analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for resilience & moral clarity analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for first-principles debugging & explanation testing, or via /council for multi-perspective deliberation.

Council member. Use standalone for cognitive bias detection & decision science analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for neural network intuition & empirical ML analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for emergence & non-intervention analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for power dynamics & incentive analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for systems thinking & feedback loop analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for multi-model reasoning & economic analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for strategic timing & situational awareness analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for user-centered design & simplicity analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for assumption destruction & dialectical analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for adversarial strategy & competitive analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for scaling frontier & AI safety analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for antifragility & tail risk analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for pragmatic engineering & shipping analysis, or via /council for multi-perspective deliberation.

Council member. Use standalone for perspective dissolution & reframing analysis, or via /council for multi-perspective deliberation.

>

>

>

Backend architect. Delegate only when the user explicitly starts an Octopus workflow.

Cloud architect. Delegate only when the user explicitly starts an Octopus workflow.

Code reviewer. Delegate only when the user explicitly starts an Octopus workflow.

Database architect. Delegate only when the user explicitly starts an Octopus workflow.

Debugger. Delegate only when the user explicitly starts an Octopus workflow.

Documentation architect. Delegate only when the user explicitly starts an Octopus workflow.

Frontend developer. Delegate only when the user explicitly starts an Octopus workflow.

Performance engineer. Delegate only when the user explicitly starts an Octopus workflow.

Security auditor. Delegate only when the user explicitly starts an Octopus workflow.

TDD orchestrator. Delegate only when the user explicitly starts an Octopus workflow.

Security vulnerability analysis and testing

Build Python agents using Agentica SDK - spawn agents, implement agentic functions, multi-agent orchestration

Unit and integration test execution and validation

Feature planning, design documentation, AND integration planning

End-to-end and acceptance test execution

Analyze Claude Code sessions using Braintrust logs

Session analysis, precedent lookup, and learning extraction

Query the artifact index for precedent and guidance

Feature and implementation code review

Investigate issues using codebase exploration, logs, and code search

Release prep, version bumps, changelog generation

Refactoring and code transformation review

Implementation and refactoring agent using TDD workflow

Integration and API review

Multi-agent coordination for complex patterns

Extract perception changes from session thinking blocks and store as learnings

Analyze brownfield codebase and create initial continuity ledger

External research - web, docs, APIs with optional LLM

External repository research and analysis

Refactoring planning AND migration planning

Create implementation plans using research, best practices, and codebase analysis

Reviews feature plans (from architect) and change plans (from phoenix)

Performance profiling, race conditions, memory issues

Document the codebase comprehensively

Review implementation by comparing plan (intent) vs Braintrust session (reality) vs git diff (changes)

Codebase exploration and pattern finding

Documentation, handoffs, session summaries, and ledger management

Analyze Claude Code sessions using Braintrust logs

General bug investigation and root cause analysis

Lightweight fixes and quick tweaks

Migration and upgrade review

Validate plan tech choices against current best practices and past precedent

Use this agent when CLAUDE.md files or .claude/rules/ files may have drifted from the actual codebase state. This includes after significant refactors, feature additions, file renames, directory restructuring, or when you suspect documentation no longer matches reality. Use proactively after any large code change.\\n\\nExamples:\\n\\n- Example 1:\\n user: \"Refactor the services directory to split analysis into separate modules\"\\n assistant: \"I've completed the refactoring of the services directory. Let me now launch the claude-md-auditor agent to ensure all CLAUDE.md files reflect these structural changes.\"\\n <commentary>\\n Since a significant refactor was performed that likely changed file paths, exports, and directory structure documented in CLAUDE.md files, use the Task tool to launch the claude-md-auditor agent.\\n </commentary>\\n\\n- Example 2:\\n user: \"Add a new notifications feature with hooks, components, and a store slice\"\\n assistant: \"The notifications feature is now implemented. I'll use the claude-md-auditor agent to update the documentation to include the new files and patterns.\"\\n <commentary>\\n A new feature was added with multiple new files across components, hooks, and store slices. The CLAUDE.md files likely need updating to document these additions. Use the Task tool to launch the claude-md-auditor agent.\\n </commentary>\\n\\n- Example 3:\\n user: \"Rename isRealUserMessage to isParsedRealUserMessage across the codebase\"\\n assistant: \"The rename is complete across all source and test files. Now I'll launch the claude-md-auditor agent to update any documentation references to the old function name.\"\\n <commentary>\\n A function was renamed which is likely documented in CLAUDE.md type guard tables and conventions sections. Use the Task tool to launch the claude-md-auditor agent to fix stale references.\\n </commentary>\\n\\n- Example 4:\\n user: \"Can you audit the CLAUDE.md files to make sure they're up to date?\"\\n assistant: \"I'll launch the claude-md-auditor agent to systematically verify all documentation against the actual codebase.\"\\n <commentary>\\n The user explicitly requested a documentation audit. Use the Task tool to launch the claude-md-auditor agent.\\n </commentary>

Use this agent when the user wants to fix all code quality issues in the project, including linting, formatting, and unused code detection. This agent runs `pnpm fix` followed by `pnpm quality` in a loop, delegating each iteration to a subagent, until all issues are resolved.\\n\\nExamples:\\n\\n- User: \"Fix all the quality issues\"\\n Assistant: \"I'll launch the quality-fixer agent to iteratively fix all linting, formatting, and quality issues.\"\\n (Uses Task tool to launch quality-fixer agent)\\n\\n- User: \"Run quality checks and fix everything\"\\n Assistant: \"Let me use the quality-fixer agent to handle that.\"\\n (Uses Task tool to launch quality-fixer agent)\\n\\n- User: \"Make sure the code passes all checks\"\\n Assistant: \"I'll use the quality-fixer agent to ensure all quality checks pass.\"\\n (Uses Task tool to launch quality-fixer agent)\\n\\n- After completing a large refactor or feature implementation:\\n Assistant: \"Now that the changes are complete, let me launch the quality-fixer agent to ensure everything passes quality checks.\"\\n (Uses Task tool to launch quality-fixer agent)

Simple greeting agent, use proactively when greeting the user. If they say 'hi claude' or 'hi cc' or 'hi claude code' use this agent.

AI research specialist that proactively gathers latest news and developments in LLMs, AI agents, and engineering. Use for staying current with AI/ML innovations, finding actionable insights, and discovering new tools and techniques.

Generates a new, complete Claude Code sub-agent configuration file from a user's description. Use this to create new agents. Use this Proactively when the user asks you to create a new sub agent.

Proactively triggered when work is completed to provide concise audio summaries and suggest next steps. If they say 'tts' or 'tts summary' or 'audio summary' use this agent. When you prompt this agent, describe exactly what you want them to communicate to the user. Remember, this agent has no context about any questions or previous conversations between you and the user. So be sure to communicate well so they can respond to the user. Be concise, and to the point - aim for 2 sentences max.

Periodic consolidation pass — fold narrow agent-created skills into class-level umbrellas. Proposes intents only, never writes to disk.

Distill a finished episode into skill changes aligned with the existing library. Compare-first preference, generation stays open; proposes intents only, never writes to disk.

Proactive methodology guidance agent. Monitors note creation and provides real-time quality advice. Suggests connections, flags quality issues, recommends MOC updates. Activates when the user creates notes, asks about methodology, or needs architectural advice.

Use this agent when you need to run the Ralph orchestrator end-to-end test suite, analyze diagnostic outputs, and generate comprehensive reports of findings. This includes validating backend connectivity, orchestration loop behavior, event parsing, hat collections, memory systems, and error handling. Invoke this agent after making changes to core orchestration logic, before releases, or when debugging integration issues.\\n\\nExamples:\\n\\n<example>\\nContext: User has made changes to the event parsing logic and wants to verify nothing is broken.\\nuser: \"I just modified the event parsing in ralph-core, can you verify everything still works?\"\\nassistant: \"I'll use the ralph-e2e-verifier agent to run the full E2E test suite and analyze the results.\"\\n<Task tool invocation to launch ralph-e2e-verifier>\\n</example>\\n\\n<example>\\nContext: User is preparing a release and needs validation.\\nuser: \"We're preparing to release v0.5.0, please run the E2E tests\"\\nassistant: \"I'll launch the ralph-e2e-verifier agent to run comprehensive E2E tests across all backends and generate a release readiness report.\"\\n<Task tool invocation to launch ralph-e2e-verifier>\\n</example>\\n\\n<example>\\nContext: User notices orchestration issues and wants diagnostics analyzed.\\nuser: \"Ralph seems to be selecting the wrong hats, can you investigate?\"\\nassistant: \"I'll use the ralph-e2e-verifier agent to run E2E tests with diagnostics enabled and analyze the hat selection decisions.\"\\n<Task tool invocation to launch ralph-e2e-verifier>\\n</example>

Use this agent when you need to execute a Ralph orchestration loop end-to-end and verify its completion. This includes testing prompts against the Ralph system, validating that orchestration completes successfully, and capturing both results and any runtime issues. Examples:\\n\\n<example>\\nContext: User wants to test if a prompt works correctly with Ralph orchestration.\\nuser: \"Test if Ralph can handle the prompt 'create a hello world function'\"\\nassistant: \"I'll use the ralph-loop-runner agent to execute this prompt through Ralph and verify completion.\"\\n<Task tool call to ralph-loop-runner agent>\\n</example>\\n\\n<example>\\nContext: User is debugging why a Ralph run failed.\\nuser: \"Run this spec through Ralph and tell me what went wrong\"\\nassistant: \"Let me use the ralph-loop-runner agent to execute this and capture any runtime problems.\"\\n<Task tool call to ralph-loop-runner agent>\\n</example>\\n\\n<example>\\nContext: User wants to validate Ralph behavior after code changes.\\nuser: \"I just modified the event parser, can you run a test loop?\"\\nassistant: \"I'll use the ralph-loop-runner agent to run a complete orchestration loop and verify the changes work correctly.\"\\n<Task tool call to ralph-loop-runner agent>\\n</example>

executor が返した advisor-request.v1 に対して方針だけ返す非実行 advisor

sprint-contract と review artifact を基準に verdict を返す read-only reviewer

実装、preflight 自己点検、検証、commit 準備を 1 タスク単位で進める統合ワーカー

Reviews diffs for bugs, regressions, missing tests, and safety issues

Read-only researcher for docs, source, schemas, and implementation context

Runs project verification commands and summarizes failures

Use this agent for code quality review of completed implementations — assessing maintainability, performance, test coverage, and standards compliance as the final quality gate before security review. For example: reviewing a finished frontend/backend feature and producing prioritized findings (Blocker/High-Priority/Medium/Nitpick) with actionable fixes.

Use this agent to implement user-facing features — transforming UX designs and technical specifications into responsive, accessible, high-performance user interfaces with API integration and tests. Delegate frontend build work such as UI components, styling, client-side state and data handling, or web performance optimization.

Use this agent for comprehensive project planning, cross-functional team coordination, progress tracking, and delivery management of development initiatives. For example: planning a 6-week user authentication project across a UX designer, backend developer, and QA tester, or regaining control of a project facing delays and scope creep.

Use this agent for technical architecture design, technology stack decisions, and system design specifications — engage after UX/design requirements are established but before detailed implementation begins. For example: planning the architecture for an event management dashboard from completed UX designs, choosing the stack and patterns for a new microservices project, or recommending scaling strategies for performance issues under load.

Use this agent for UX and UI design work — user research, journey maps, wireframes, interactive prototypes, design systems, and WCAG-compliant design specifications ready for development handoff. Delegate when designs need to be created or validated before technical architecture and implementation begin.

Analyzes and optimizes context window usage across sessions. Use when context feels bloated, sessions run slow, or approaching compaction limits.

Analyze session token usage and cost patterns. Identify expensive operations and recommend optimizations. Use to understand and reduce session costs.

Specialized debugging agent. Use when facing hard bugs, test failures, or runtime errors that need systematic investigation.

Multi-phase development agent. Research > Plan > Implement with validation gates. Use PROACTIVELY when building features that touch >5 files or require architecture decisions.

Analyze permission denial patterns and generate optimized alwaysAllow/alwaysDeny rules. Use when permission prompts slow down workflow.

Break down complex tasks into implementation plans before writing code. Use when task touches >5 files, requires architecture decisions, or has unclear requirements.

Code review specialist that verifies every finding against actual code before reporting. Use before committing, for PR reviews, or after major changes.

Confidence-gated exploration that assesses readiness before implementation. Scores 0-100 across five dimensions and gives GO/HOLD verdict.

Email inbox search specialist, takes in appropriate context for the email and a goal of what to search for. Return the answer to the question.

Guard the beads execution record: enforce the write-flush-verify discipline that defeats the bd rapid-write race, audit epic dependency graphs for cycles and orphans, catch closures whose title overstates what shipped, flag open beads carrying no disposition or a disproven premise, and reconcile bd against its GitHub and Plane projections. Owns RECORD INTEGRITY; delegates graph analysis to bead-dependency-mapper and epic-closure drift to bead-epic-auditor rather than duplicating them. Use before closing an epic, after any batch of bd writes, when a bead premise looks stale, or when auditing whether the record matches reality. Trigger with "audit beads", "check the bead DAG", "did that close actually land", "bead hygiene".

Verify every factual assertion in a diff, PR body, commit message, bead note, or governing doc against the actual repository, and fail anything that cannot be substantiated by a command. Use before merging any PR that makes claims about counts, coverage, consumers, enforcement, provenance, or certification, and when auditing standing docs for rot. Trigger with "verify claims", "check this PR body", "is this claim true", "claim audit".

Design and build Omarchy (Quickshell/QML) bar-widget, panel, and service plugins that actually work on a stock install. Knows the hard runtime constraint (no node on the graphical session PATH), the first-party contracts (BarWidget, Panel, KeyboardPanel, PanelKeyCatcher, Service), the curl-from-QML data pattern, FileView persistence, and the marketplace submission bar. Use when starting a new Omarchy plugin, porting a plugin off an external runtime, wiring a service to a bar widget, or deciding how a widget should fetch and persist. Trigger with "build an omarchy plugin", "omarchy widget", "quickshell plugin", "port this plugin to QML".

Audit an Omarchy plugin before it reaches the marketplace: prove it installs and runs on a stock box (no node/python on the session PATH), run the omarchy-submit gate lane, validate on the rig with omarchy-plugin-validate and qmllint, and check the QML security invariants and first-party idiom contracts. Read-only: it reports and blocks, it does not rewrite the plugin. Use before submitting an entry, after any data-layer change, or when a plugin works on the dev box and you need to know whether it works for a real user. Trigger with "audit this omarchy plugin", "is this plugin submission ready", "will this plugin work when installed".

Audit and fix Claude Code SKILL.md files against enterprise compliance standards: frontmatter completeness, required body sections, and style. Use when validating or repairing skills in a plugin directory. Trigger with "audit skill", "fix skill compliance".

Code review specialist — analyzes code quality and suggests improvements