Explore agents

Reviews completed features or project steps against the original plan and coding standards, checking plan alignment, code quality, architecture, and documentation.

Software architecture specialist for system design, scalability, and technical decision-making. Delegate proactively for planning new features, refactoring large systems, or architectural decisions. Restricted to read/search tools.

Expert planning specialist that generates detailed, phased implementation plans with steps, dependencies, risks, and testing for complex features, refactoring, and architectural changes. Proactive delegation for implementation requests.

Expert code reviewer that inspects git diffs and surrounding code for security vulnerabilities, quality issues, and maintainability problems using a prioritized checklist. Invoke after all code changes.

Resolves TypeScript type errors, build failures, dependency issues, and config problems with minimal diffs only—no refactoring or architecture changes. Use proactively on build errors for quick fixes.

Deeply analyzes specific codebase features: traces execution paths/entry points/call chains, maps architecture layers/patterns, documents dependencies/transformations to inform modifications/extensions.

Designs feature architectures by analyzing codebase patterns and conventions, providing implementation blueprints with files to create/modify, component designs, data flows, and build sequences.

Dead code cleanup specialist that identifies/removes unused exports, dependencies, duplicates via knip, depcheck, ts-prune. Verifies references, runs tests, refactors safely in batches.

E2E testing specialist using Vercel Agent Browser (preferred) or Playwright fallback. Delegate for generating, maintaining, running tests; quarantining flaky tests; uploading screenshots, videos, traces for critical user flows.

Detects and remediates OWASP Top 10 vulnerabilities, secrets, SSRF, injections, unsafe crypto in code handling user input, auth, APIs, sensitive data. Delegate proactively for scans after writing such code.

Python code reviewer for PEP 8 compliance, Pythonic idioms, type hints, security vulnerabilities, error handling, and performance in git diffs. Runs static tools like ruff, mypy, pylint, bandit.

Documentation specialist that generates codemaps from TypeScript codebase structure, analyzes dependencies and AST, updates READMEs and guides. Use proactively to keep docs current.

PostgreSQL specialist for query optimization, schema design, security with RLS, and performance. Incorporates Supabase best practices. Delegate proactively for SQL reviews, migrations, schemas, and DB troubleshooting.

TDD specialist enforcing tests-first Red-Green-Refactor cycle for new features, bug fixes, refactoring. Writes unit/integration/E2E tests, covers edge cases, targets 80%+ coverage.

Reviews code changes for bugs, logic errors, security vulnerabilities, code quality issues, and project conventions using confidence-based filtering (≥80 only) to report high-priority issues.

Triages messages across email, Slack, LINE, Messenger, and calendar into 4 tiers, generates tone-matched draft replies, cross-references events, and tracks follow-through. Delegate for multi-channel inbox workflows.

Go specialist that fixes build errors, go vet warnings, linter issues, and module problems with minimal changes. Delegate when Go builds fail.

Safely operates autonomous agent loops: tracks checkpoints, detects stalls/retry storms, intervenes with scope reduction or escalation on no progress, failures, or cost drift.

Expert Go code reviewer for idiomatic style, concurrency patterns, error handling, security issues, and performance. Delegate for all Go code changes and projects.

Autonomous error handling auditor that scrutinizes catch blocks, fallback logic, and logging quality in PRs to eliminate silent failures.

Analyzes code comments for accuracy, completeness, and maintainability by cross-referencing against code logic, signatures, and behavior. Delegate after docstring generation, before PRs, or for reviewing comment rot.

Reviews pull requests for test coverage quality and completeness. Identifies gaps in behavioral coverage, edge cases, error handling, and critical business logic for new functionality.

Optimizes local agent harness configs for reliability, cost, and throughput. Runs audits, identifies leverage in hooks/evals/routing/context/safety, proposes/applies minimal changes, and reports deltas.

Expert type design analyzer for codebases. Reviews new types, PR-added types, and refactors, providing ratings on encapsulation, invariant expression, usefulness, and enforcement.

Reviews Kotlin code in Android/KMP projects for idiomatic patterns, coroutine safety, Compose best practices, clean architecture violations, and common pitfalls. Restricted to read/grep/glob/bash tools.

Reviews code changes for CLAUDE.md guidelines, style violations, bugs, best practices, and quality issues. Defaults to unstaged git diff; specify files for custom scope.

Documentation agent that resolves library IDs and fetches current docs via Context7 for usage, setup, API, and code example questions.

Kotlin/Gradle specialist that resolves build failures, compiler errors, dependency conflicts, and code style issues (detekt/ktlint) with minimal changes. Delegate when builds fail.

Expert C++ code reviewer for memory safety, security, concurrency issues, modern idioms, performance, and best practices in code changes. Delegate for all C++ projects.

C++ specialist that resolves build errors, CMake issues, linker problems, and template errors with minimal changes. Delegate when C++ builds fail.

Verifies TypeScript Agent SDK apps for SDK installation/config, TypeScript setup, correct usage/patterns, type safety/compilation, build scripts, env/security, best practices, and functionality. Invoke after app creation/modification for deployment readiness.

Verifies Python Agent SDK apps for proper configuration, SDK best practices, documentation adherence, code quality, security, and deployment readiness. Invoke after creation or modification.

Rust specialist that resolves cargo build errors, borrow checker issues, lifetimes, traits, and Cargo.toml dependencies with minimal changes. Runs diagnostics and verifies fixes. Delegate on Rust build failures.

Fixes Java compilation errors, Maven/Gradle build failures, and dependency conflicts with minimal changes. Use for failed Java or Spring Boot builds requiring diagnostics and targeted edits.

Expert Rust code reviewer for ownership, lifetimes, error handling, unsafe usage, concurrency issues, and idiomatic patterns. Delegate all Rust code changes, diffs, and PR reviews.

Expert reviewer for Java and Spring Boot code changes, focusing on security (SQL injection, secrets), error handling, layered architecture, JPA patterns, and concurrency. Delegate for all Java diffs.

Elite code reviewer for modern AI-powered code analysis, security vulnerability detection, performance optimization, and production reliability. Masters static analysis tools and security scanning.

TypeScript/JavaScript code reviewer for type safety, async correctness, Node/web security, and idiomatic patterns. Delegate for PRs, local diffs, or changes in TS/JS projects to inspect via git/typecheck/eslint.

Flutter/Dart code reviewer for widget best practices, state management patterns, idioms, performance pitfalls, accessibility, architecture violations, and security issues. Analyzes git diffs, pubspec.yaml, and project structure.

PyTorch specialist resolving runtime errors, CUDA issues, tensor shape mismatches, device errors, gradient failures, DataLoader problems, and mixed precision issues with minimal changes. Delegate for training/inference crashes.

Analyzes conversation transcripts in Claude Code sessions to detect user frustrations, problematic tool patterns, and generate regex for preventive hooks. Restricted to read-only Read/Grep tools.

Expert backend architect for scalable APIs (REST/GraphQL/gRPC/WebSocket), microservices, distributed systems, and event-driven designs. Delegate proactively for new backend services, API contracts, service boundaries, resilience, and observability.

Simplifies recently modified code for clarity, consistency, and maintainability using project best practices while preserving all functionality. Delegate after coding tasks like implementing features, fixing bugs, or optimizing.

Simplifies recently modified code for clarity, consistency, and maintainability while preserving all functionality and following project best practices. Delegate after coding tasks like feature implementation, bug fixes, or optimizations.

Frontend expert for building React components, implementing responsive layouts, and handling client-side state management. Masters React 19, Next.js 15, and modern frontend architecture. Use proactively when creating UI or fixing frontend issues.

Performance specialist for profiling bottlenecks, optimizing slow code/bundle sizes/runtime efficiency, fixing memory leaks, React render optimization, and algorithmic improvements.

Reviews healthcare application code for clinical safety, CDSS accuracy, PHI compliance, and medical data integrity. Specialized for EMR/EHR, clinical decision support, and health information systems.

Audits open-source forks for sanitization before release: scans files/git history for leaked secrets, PII, internal refs/dangerous patterns via 20+ regex. Verifies .env.example; outputs PASS/FAIL report. Read-only.

Forks private projects into open-source-ready copies: copies files excluding secrets/generated dirs, strips credentials (20+ patterns), replaces internal refs with placeholders, generates .env.example, cleans git history, outputs FORK_REPORT.md.

Debugging specialist for root cause analysis of errors, test failures, and unexpected behavior. Captures repro steps, isolates failures, implements minimal fixes, verifies solutions, and recommends preventions.

Expands one-line app prompts into ambitious product specs with features (12-16), sprints, design direction, eval criteria, and tech stack for GAN harness Generator implementation. Writes to gan-harness/spec.md.

Iterative generator agent that builds React/TypeScript frontend apps from specs, incorporates evaluator feedback via git commits, runs dev servers, and refines until quality thresholds met.

GAN harness evaluator: tests live web apps via Playwright browser automation, scores functionality/design against rubrics, delivers strict QA feedback.

Generates open-source packaging for projects: CLAUDE.md (Claude Code context), setup.sh (one-command bootstrap), README.md, LICENSE, CONTRIBUTING.md, GitHub issue templates. Analyzes stack and structure.

Test automation engineer that builds AI-powered, self-healing test suites with modern frameworks and CI/CD integration. Delegate for test generation, TDD, and quality engineering.

Performance engineer for modern observability (OpenTelemetry, tracing, metrics), app profiling (CPU/memory), load testing (k6, JMeter), caching (Redis), Core Web Vitals, and scalability patterns. Delegate for optimization and monitoring.

Deeply analyzes existing codebase features by tracing execution paths, mapping architecture layers, recognizing patterns, and documenting dependencies to inform new development.

Simplifies code for clarity, consistency, and maintainability while preserving exact behavior. Targets recently modified code: extracts functions, simplifies conditionals/ternaries, removes dead code/unused imports.

C# code reviewer specializing in .NET conventions, async patterns, security, nullable reference types, error handling, performance, and code quality. Delegate for reviewing all C# code changes in projects.

Designs feature architectures by analyzing existing codebase patterns and conventions, providing implementation blueprints with files, interfaces, data flow, and build order.

Dart/Flutter specialist fixing dart analyze errors, compilation failures, pub dependency conflicts, and build_runner issues with minimal changes. Delegate for Dart/Flutter build failures.

Validates Claude Code plugin structure, plugin.json manifest syntax and fields, directory organization, commands, agents, skills, and hooks for correctness, naming conventions, and common issues.

Security auditor for DevSecOps, vulnerability assessment, threat modeling, and compliance (GDPR/HIPAA/SOC2). Delegates security audits and compliance implementation.

Expert planning specialist for complex features, refactoring, and architectural changes. Delegate proactively for detailed step-by-step implementation plans, dependency analysis, risks, and testing strategies. Read-only tools.

Creates tailored subagent configurations from user requests, defining expert personas, system prompts, tools, and instructions for tasks like code review, test generation, or config validation.

Reviews Claude Code skills for structure, description triggering/specificity, content quality, progressive disclosure, and best practices. Provides targeted improvements. Trigger proactively after skill creation/modification.

Safe, incremental legacy modernization specialist using strangler fig pattern. Handles framework migrations, dependency updates, and technical debt with full backward compatibility.

Detects error patterns, stack traces, and anomalies in logs and codebases. Correlates issues across systems to pinpoint root causes. Delegate proactively for debugging, log analysis, and production error investigations.

Expert code reviewer that analyzes recent git changes for security vulnerabilities, code quality issues, performance problems, and best practices. Provides prioritized feedback with fix examples and merge approval status.

Analyzes code comments for factual accuracy, completeness, misleading elements, low-value restatements, and comment rot risk like stale info or TODO debt.

Reviews pull request test coverage for quality, completeness, behavioral coverage, edge cases, error paths, integrations, and bug prevention. Rates gaps by impact with suggestions.

Reviews code for silent failures, swallowed errors, inadequate logging, dangerous fallbacks, error propagation issues, and missing error handling. Reports findings with location, severity, impact, and fix recommendations.

Analyzes type designs for encapsulation (hiding internals, protecting invariants), invariant expression (encoding rules, unrepresentable states), usefulness (bug prevention, domain alignment), and enforcement (type system rigor, no escapes). Scores types with suggestions.

Reverse-engineers legacy codebases: traces data flows, uncovers hidden dependencies, maps architecture, identifies technical debt, generates documentation and refactoring graphs.

Optimizes queries, indexes, caching, and architectures for SQL (PostgreSQL, MySQL), NoSQL (MongoDB, DynamoDB), and cloud databases. Delegate for performance tuning, N+1 fixes, execution plan analysis, and monitoring.

Analyzes conversation transcripts to identify problematic Claude Code behaviors like explicit corrections, frustrations, repeated mistakes, and reverted changes. Outputs prioritized YAML hook rules to prevent them.

Dead code cleanup specialist that detects and removes unused exports, files, dependencies, and duplicates using knip, depcheck, ts-prune, eslint. Ensures safe refactoring via risk assessment, tests, and git commits.

TDD specialist enforcing tests-first methodology for new features, bug fixes, and refactoring. Guides Red-Green-Refactor cycle, writes unit/integration/E2E tests, ensures 80%+ coverage.

Designs high-level system architecture: component diagrams, service boundaries, data flows, integration patterns, scalability, and fault tolerance. Creates blueprints for new projects or major changes.

Security specialist detecting and remediating OWASP Top 10 vulnerabilities, secrets, SSRF, injections, unsafe crypto in code handling user input, authentication, APIs, or sensitive data.

Expert in CI/CD pipelines (GitHub Actions, GitLab, Jenkins), GitOps (ArgoCD/Flux), Docker containers, Kubernetes deployments, zero-downtime strategies, security scanning, and platform engineering. Delegate for CI/CD design, GitOps implementation, deployment automation.

Resolves TypeScript type errors, build failures, compilation issues, and config problems with minimal code changes. Invoke proactively on failed builds to quickly pass without architectural edits.

SEO specialist for technical audits, on-page optimization, structured data, Core Web Vitals, and keyword mapping. Delegate site audits, meta tag reviews, schema markup, sitemaps/robots issues, and remediation plans.

Expert mobile developer specializing in React Native, Flutter, and native iOS/Android. Handles cross-platform architecture, native integrations, offline sync, and performance optimization. Delegate mobile features and app store optimization.

Specialist in creating step-by-step tutorials and educational content from code. Transforms complex concepts into progressive learning experiences with hands-on examples. Use for onboarding guides, feature tutorials, or concept explanations.

Investigates codebase using Read, Glob, Grep, Bash tools to return raw structured context on files, patterns, architecture for planner agents in coding tasks.

TDD orchestrator that enforces red-green-refactor discipline, coordinates multi-agent testing workflows, and generates AI-assisted tests across unit, integration, and E2E levels.

Analyzes codebases to produce long-form technical documentation, architecture guides, and ebooks covering design decisions, data models, and deployment.

Context engineer for dynamic context management using vector DBs, knowledge graphs, memory systems, and RAG. Delegate for multi-agent orchestration, semantic retrieval, context optimization, and enterprise AI workflows.

Developer Experience specialist that optimizes environment setups, workflows, tooling, and documentation. Delegate proactively for new projects, friction reduction, or team feedback.

Expert Terraform/OpenTofu specialist for advanced IaC automation, state management, complex module design, multi-cloud deployments, GitOps workflows, policy as code, and CI/CD integration.

Researches external documentation for libraries, APIs, and topics. Gathers official sources, working code examples, full API signatures, versions, best practices, pitfalls. Returns raw structured context for planner agents.

DevOps troubleshooter for incident response, log analysis, distributed tracing, Kubernetes debugging, performance optimization, and root cause analysis in production outages.

Kubernetes architect for cloud-native infrastructure, GitOps (ArgoCD/Flux), managed clusters (EKS/AKS/GKE/OKE), service mesh (Istio/Linkerd), security, and platform engineering. Delegate for architecture, GitOps setup, and scalable orchestration.

Expert backend architect for scalable APIs (REST/GraphQL/gRPC/WebSocket), microservices, distributed systems, event-driven designs, resilience, and observability. Delegate proactively for new backend services or APIs.

FastAPI subagent for building high-performance async APIs, microservices, and WebSocket backends with SQLAlchemy 2.0 and Pydantic V2.