
Use when a task needs an opinionated, low-friction golden path for service creation, deployment, or operations.
Use when a task needs Expo / React Native mobile work — navigation, native modules, performance, EAS builds, or store deployment.
Use when a task needs model risk analysis, failure mode prioritization, and mitigation planning for AI behavior.
Use when a task needs Node.js backend work — APIs, CLIs, workers, or services that depend on event loop, stream, and runtime behavior.
Use when a task needs a maintainer-ready README built from exact repository reality, with zero hallucinated commands, flags, or config keys.
Use when a task needs RL environment design, policy training, reward engineering, or deployment of decision-making agents.
Use when a project needs production-ready visual assets: app icons, favicons, OG images, logos, or wordmarks. Routes prompts across 30+ image generation models via the prompt-to-asset MCP. Zero API key required for first run via free tiers.
Use when a task needs evaluation design for prompts, retrieval, tools, or multi-step agent workflows.
Use when a task needs GDPR or CCPA/CPRA compliance review of data practices, consent flows, or data-subject rights handling.
Use when a task needs platform roadmap, adoption strategy, success metrics, and stakeholder alignment for internal platform work.
Use when a task needs evidence-grounded answers from published research, including methods, results, sample sizes, and quality-weighted synthesis.
Use when a task needs exhaustive UI and UX functional testing driven by documented user flows, with structured defect reporting.
Use when a task needs an AI governance review covering controls, accountability, risk ownership, and deployment readiness.
Use when a task needs an idea pressure-tested with brutal honesty — competitor teardown, market validation, fatal-flaw hunting, and clear go or no-go guidance before building.
Use when a task needs AI-native traces, metrics, logging, and debugging signals for LLM or agent systems in production.
Use when a task needs to surface and prioritize risky assumptions in a product idea, feature, or strategy before engineering invests in building it.
Use when a task needs prose to be checked for AI writing patterns and rewritten to sound natural and human.
Use when a task needs regression coverage for prompt, model, tool, or workflow changes in an AI system.
Use when a task needs review of fairness, transparency, misuse risk, and human-oversight design in AI features.
Use before publishing AI-generated content — blog posts, READMEs, release notes, commit messages, PR descriptions, docs, or social posts. Strips AI patterns and applies a final quality pass.
Use when a task needs a product backlog groomed, refined, or cleaned up — sprint readiness, estimation, and zombie-story cleanup.
Use when a task needs Backstage architecture, catalog, plugin, template, or adoption guidance for an internal developer platform.
Use when a task needs software licensing architecture — OSI selection, dependency compliance, dual-licensing, or risk and liability strategy.
Use when a task needs repository-wide refactor governance with weighted risk prioritization, diff previews, and explicit approval gates before execution.
Use when a task needs Symfony-specific work across routing, controllers, services, Doctrine, security, and application structure.
Use when a task needs HIPAA compliance review for a healthcare product — Business Associate scope, BAA needs, PHI handling, safeguards, or breach response.
Use when a task needs growth loop design, PLG mechanics analysis, or diagnosis of why acquisition is linear instead of compounding.
Use when a task needs FastAPI implementation — async endpoints, Pydantic v2 contracts, dependency injection, or ASGI deployment behavior.
Use when a task needs enforceable prompt, tool, workflow, or approval guardrails for AI systems.
Use when a task needs root-cause analysis for factuality failures, unsupported claims, or context breakdowns in AI outputs.
Use when a task needs internal developer platform architecture, service boundaries, and self-service control-plane design.
Use when a task needs C# or .NET application work involving services, APIs, async flows, or application architecture.
Use when a task needs data interpretation, metric breakdown, trend explanation, or decision support from existing analytics outputs.
Use when a task needs operational database administration review for availability, backups, recovery, permissions, or runtime health.
Use when a task needs database performance analysis for query plans, schema design, indexing, or data access patterns.
Use when a task needs ETL, ingestion, transformation, warehouse, or data-pipeline implementation and debugging.
Use when a task needs source gathering and synthesis around datasets, metrics, data pipelines, or evidence-backed quantitative questions.
Use when a task needs deep bug isolation across code paths, stack traces, runtime behavior, or failing tests.
Use when a task needs deployment workflow changes, release strategy updates, or rollout and rollback safety analysis.
Use when a task needs CI, deployment pipeline, release automation, or environment configuration work.
Use when a task needs rapid operational triage across CI, deployments, infrastructure automation, and service delivery failures.
Use when a task needs Dockerfile review, image optimization, multi-stage build fixes, or container runtime debugging.
Use when a task needs Elixir and OTP expertise for processes, supervision, fault tolerance, or Phoenix application behavior.
Use when a task needs IoT system work involving devices, telemetry, edge communication, or cloud-device coordination.
Use when a task needs network-path analysis, service connectivity debugging, load-balancer review, or infrastructure network design input.
Use when a task needs internal platform, golden-path, or self-service infrastructure design for developers.
Use when a task needs fast, high-signal searching of the codebase or external sources before deeper analysis begins.
Use when a task needs infrastructure and platform security engineering across IAM, secrets, network controls, or hardening work.
Use when a task needs search-focused technical review across crawlability, metadata, rendering, information architecture, or content discoverability.
Use when a task needs SQL query design, query review, schema-aware debugging, or database migration analysis.
Use when a task needs Swift expertise for iOS or macOS code, async flows, Apple platform APIs, or strongly typed application logic.
Use when a broad task needs to be broken into concrete sub-tasks with clear boundaries for multiple agents or contributors.
Use when a task needs Terraform module design, plan review, state-aware change analysis, or IaC refactoring.
Use when a task needs Terragrunt-specific help for module orchestration, environment layering, dependency wiring, or DRY infrastructure structure.
Use when a task needs implementation of automated tests, test harness improvements, or targeted regression coverage.
Use when a task needs internal developer tooling, scripts, automation glue, or workflow support utilities.
Use when a task needs trend synthesis across technology shifts, adoption patterns, or emerging implementation directions.
Use when a task needs strong TypeScript help for types, interfaces, refactors, or compiler-driven fixes.
Use when a task needs concrete UI decisions, interaction design, and implementation-ready design guidance before or during development.
Use when a UI issue is already reproduced and the parent agent wants the smallest safe patch.
Use when a task needs UI feedback synthesized into actionable product and implementation guidance.
Use when a task needs Vue expertise for component behavior, Composition API patterns, routing, or state and rendering issues.
Use when a task needs Windows infrastructure administration across Active Directory, DNS, DHCP, GPO, or Windows automation.
Use when a task needs WordPress-specific implementation or debugging across themes, plugins, content architecture, or operational site behavior.
Use when the parent agent needs an explicit Codex subagent workflow for a complex task with multiple stages.
Use when a task needs .NET Framework 4.8 expertise for legacy enterprise applications, compatibility constraints, or Windows-bound integrations.
Use when a task needs JavaScript-focused work for runtime behavior, browser or Node execution, or application-level code that is not TypeScript-led.
Use when a task needs requirements clarified, scope normalized, or acceptance criteria extracted from messy inputs before engineering work starts.
Use when a task needs reliability engineering work involving SLOs, alerting, error budgets, operational safety, or service resilience.
Use when multiple agents have returned findings and the parent agent needs a distilled, non-redundant synthesis.
Use when a task needs help with branching strategy, merge flow, release branching, or repository collaboration conventions.
Use when a task needs API contract design, evolution planning, or compatibility review before implementation starts.
Use when a task needs help selecting, copying, or organizing custom agent files from this repository into Codex agent directories.
Use when the parent agent needs help choosing subagents and dividing a larger task into clean delegated threads.
Use when a task needs technical documentation that must stay faithful to current code, tooling, and operator workflows.
Use when a task needs a Python-focused subagent for runtime behavior, packaging, typing, testing, or framework-adjacent implementation.
Use when multiple errors or symptoms need to be grouped, prioritized, and assigned to the right debugging or review agents.
Use when a task needs technically accurate solution positioning, customer-question handling, or implementation tradeoff explanation for pre-sales contexts.
Use when a task needs dependency upgrades, package graph analysis, version-policy cleanup, or third-party library risk assessment.
Use when a task needs Django-specific work across models, views, forms, ORM behavior, or admin and middleware flows.
Use when a task needs support-pattern synthesis, adoption risk analysis, or customer-facing operational guidance from engineering context.
Use when a task needs statistical reasoning, experiment interpretation, feature analysis, or model-oriented data exploration.
Use when a task needs product-adjacent content strategy or messaging that still has to stay grounded in real technical capabilities.
Use when the parent agent needs a high-confidence map of code paths, ownership boundaries, and execution flow before changes are made.
Use when a task needs adversarial review of an application path for exploitability, abuse cases, or practical attack surface analysis.
Use when a task needs NLP-specific implementation or analysis involving text processing, embeddings, ranking, or language-model-adjacent pipelines.
Use when a task needs payment-flow review or implementation for checkout, idempotency, webhooks, retries, or settlement state handling.
Use when a task needs release notes, migration notes, onboarding material, or developer-facing prose derived from real code changes.
Use when a task needs test strategy, acceptance coverage planning, or risk-based QA guidance for a feature or release.
Use when a task needs a React-focused agent for component behavior, state flow, rendering bugs, or modern React patterns.
Use when a task needs work on MCP servers, MCP clients, tool wiring, or protocol-aware integrations.
Use when a task needs market landscape, positioning, or demand-side research tied to a technical product or category.
Use when a task needs app-level mobile product work across screens, state, API integration, and release-sensitive mobile behavior.
Use when a task needs mobile implementation or debugging across app lifecycle, API integration, and device/platform-specific UX constraints.
Use when a task needs practical machine learning implementation across feature engineering, inference wiring, and model-backed application logic.
Use when a task needs ML system implementation work across training pipelines, feature flow, model serving, or inference integration.
Use when a task needs model deployment, registry, pipeline, monitoring, or environment orchestration for machine learning systems.
Use when a task needs Kubernetes manifest review, rollout safety analysis, or cluster workload debugging.
Use when a task needs Laravel-specific work across routing, Eloquent, queues, validation, or application structure.
Use when a task needs coordinated operational planning across infrastructure, incident response, identity, endpoint, and admin workflows.
Use when a task needs Go expertise for concurrency, service implementation, interfaces, tooling, or performance-sensitive backend paths.
Use when a task needs GraphQL schema evolution, resolver architecture, federation design, or distributed graph performance/security review.
Use when a task needs Java application or service architecture help across framework boundaries, JVM behavior, or large codebase structure.
Use when a task needs financial systems engineering across ledgers, reconciliation, transfers, settlement, or compliance-sensitive transactional flows.
Use when a task needs scoped frontend implementation or UI bug fixes with production-level behavior and quality.
Use when a task needs Flutter expertise for widget behavior, state management, rendering issues, or mobile cross-platform implementation.
Use when one bounded feature or bug spans frontend and backend and a single worker should own the entire path.
Use when a task needs Electron-specific implementation or debugging across main/renderer/preload boundaries, packaging, and desktop runtime behavior.
Use when a task needs embedded or hardware-adjacent work involving device constraints, firmware boundaries, timing, or low-level integration.
Use when a task needs log, exception, or stack-trace analysis to identify the most probable failure source quickly.
Use when a task needs Erlang/OTP and rebar3 expertise for BEAM processes, testing, releases, upgrades, or distributed runtime behavior.
Use when a task needs developer-experience improvements in setup time, local workflows, feedback loops, or day-to-day tooling friction.
Use when a task needs documentation-backed verification of APIs, version-specific behavior, or framework options.
Use when a task needs product framing, prioritization, or feature-shaping based on engineering reality and user impact.
Use when a task needs PowerShell-based UI work for terminals, forms, WPF, or admin-oriented interactive tooling.
Use when a task needs PowerShell module structure, command design, packaging, or profile architecture work.
Use when a task needs PowerShell-focused hardening across script safety, admin automation, execution controls, or Windows security posture.
Use when a task needs modern PowerShell 7 expertise for cross-platform automation, scripting, or .NET-based operational tooling.
Use when a task needs PostgreSQL-specific expertise for schema design, performance behavior, locking, or operational database features.
Use when a task needs Windows PowerShell 5.1 expertise for legacy automation, full .NET Framework interop, or Windows administration scripts.
Use when a task needs ongoing performance-signal interpretation across build, runtime, or operational metrics before deeper optimization starts.
Use when a task needs Next.js-specific work across routing, rendering modes, server actions, data fetching, or deployment-sensitive frontend behavior.
Use when a task needs performance investigation for slow requests, hot paths, rendering regressions, or scalability bottlenecks.
Use when a task needs Slack platform work involving bots, interactivity, events, workflows, or Slack-specific integration behavior.
Use when a task needs Rust expertise for ownership-heavy systems code, async runtime behavior, or performance-sensitive implementation.
Use when a task needs process facilitation, iteration planning, or workflow friction analysis for an engineering team.
Use when a task needs real-time transport and state work across WebSocket lifecycle, message contracts, and reconnect/failure behavior.
Use when a task needs legal-risk spotting in product or engineering behavior, especially around terms, data handling, or externally visible commitments.
Use when a task needs PHP expertise for application logic, framework integration, runtime debugging, or server-side code evolution.
Use when a task needs focused security review of code, auth flows, secrets handling, input validation, or infrastructure configuration.
Use when a task needs dependency mapping, milestone planning, sequencing, or delivery-risk coordination across multiple workstreams.
Use when a task needs Spring Boot expertise for service behavior, configuration, data access, or enterprise API implementation.
Use when a task needs a structured investigation of a technical topic, implementation approach, or design question.
Use when a task needs explicit risk analysis for product, operational, financial, or architectural decisions.
Use when a task needs PR-style review focused on correctness, security, behavior regressions, and missing tests.
Use when a task needs broad production incident triage, containment planning, or evidence-driven root cause analysis.
Use when a task needs a low-risk structural refactor that preserves behavior while improving readability, modularity, or maintainability.
Use when a task needs Kotlin expertise for JVM applications, Android code, coroutines, or modern strongly typed service logic.
Use when a task needs a modernization path for older code, frameworks, or architecture without losing behavioral safety.
Use when a task needs architecture review for prompts, tool use, retrieval, evaluation, or multi-step LLM workflows.
Use when a task needs Microsoft 365 administration help across Exchange Online, Teams, SharePoint, identity, or tenant-level automation.
Use when a task needs service-boundary design, inter-service contract review, or distributed-system architecture decisions.
Use when a task needs prompt revision, instruction design, eval-oriented prompt comparison, or prompt-output contract tightening.
Use when a task needs quantitative analysis of models, strategies, simulations, or numeric decision logic.
Use when a task needs Ruby on Rails expertise for models, controllers, jobs, callbacks, or convention-driven application changes.
Use when a task needs a concrete multi-agent plan with clear role separation, dependencies, and result integration.
Use when a task needs game-specific implementation or debugging involving gameplay systems, rendering loops, asset flow, or player-state behavior.
Use when a task needs an accessibility audit of UI changes, interaction flows, or component behavior.
Use when a task needs Active Directory security review across identity boundaries, delegation, GPO exposure, or directory hardening.
Use when a task needs modern .NET and ASP.NET Core expertise for APIs, hosting, middleware, or cross-platform application behavior.
Use when a task needs implementation or debugging of model-backed application features, agent flows, or evaluation hooks.
Use when a task needs Angular-specific help for component architecture, dependency injection, routing, signals, or enterprise application structure.
Use when a task needs consumer-facing API documentation generated from the real implementation, schema, and examples.
Use when a task needs architectural review for coupling, system boundaries, long-term maintainability, or design coherence.
Use when a task needs Azure-specific infrastructure review or implementation across resources, networking, identity, or automation.
Use when a task needs scoped backend implementation or backend bug fixes after the owning path is known.
Use when a task needs blockchain or Web3 implementation and review across smart-contract integration, wallet flows, or transaction lifecycle handling.
Use when a task needs browser-based reproduction, UI evidence gathering, or client-side debugging through a browser MCP server.
Use when a task needs build-graph debugging, bundling fixes, compiler pipeline work, or CI build stabilization.
Use when a task needs resilience analysis for dependency failure, degraded modes, recovery behavior, or controlled fault-injection planning.
Use when a task needs a command-line interface feature, UX review, argument parsing change, or shell-facing workflow improvement.
Use when a task needs cloud architecture review across compute, storage, networking, reliability, or multi-service design.
Use when a task needs a broader code-health review covering maintainability, design clarity, and risky implementation choices in addition to correctness.
Use when a task needs a grounded comparison of tools, products, libraries, or implementation options.
Use when a task needs compliance-oriented review of controls, auditability, policy alignment, or evidence gaps in a regulated workflow.
Use when a task needs a compact project context summary that other subagents can rely on before deeper work begins.
Use when a task needs C++ work involving performance-sensitive code, memory ownership, concurrency, or systems-level integration.