agent-detector
CRITICAL: MUST run for EVERY message. Detects agent, complexity, AND model automatically. Without this, tasks route to wrong agents and use wrong models, degrading quality and wasting tokens.
Best use case
agent-detector is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
CRITICAL: MUST run for EVERY message. Detects agent, complexity, AND model automatically. Without this, tasks route to wrong agents and use wrong models, degrading quality and wasting tokens.
Teams using agent-detector should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/agent-detector/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How agent-detector Compares
| Feature / Agent | agent-detector | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
CRITICAL: MUST run for EVERY message. Detects agent, complexity, AND model automatically. Without this, tasks route to wrong agents and use wrong models, degrading quality and wasting tokens.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
> **AI-consumed reference.** Optimized for Claude to read during execution.
> Human-readable explanation: see [docs/architecture/HIERARCHICAL_PLANNING.md](../../../docs/architecture/HIERARCHICAL_PLANNING.md)
> or [docs/getting-started/](../../../docs/getting-started/) depending on topic.
# Agent Detector
**Runs FIRST for every message.**
## Complexity
```toon
complexity[4]{level,criteria,approach}:
Quick,"Single file / simple fix / clear scope","Direct implementation"
Standard,"2-5 files / feature / some unknowns","Scout then implement"
Deep,"6+ files / architecture / vague scope","run-orchestrator"
Project,"Multi-feature / multi-session / weight ≥ 3 on bridge heuristic AND no active plan","/aura-frog:plan bootstrap then per-task /run anchored"
```
**Project (v3.7.2+):** Emitted when `rules/workflow/run-plan-bridge.md` triggers sum to weight ≥ 3 AND `.claude/plans/active.json` is absent. `run-orchestrator` Step 0 owns the user prompt (`plan` / `deep` / `details`) and the scratch-file handoff. Otherwise Quick/Standard/Deep classification is unchanged.
## Model Selection
Quick→haiku, Standard→sonnet (opus for architecture/design), Deep→sonnet (opus for planning).
## Detection (Priority Order)
1. **Task content** (highest): Analyze task keywords — backend repo may have frontend tasks. Score ≥50 overrides repo detection.
2. **Explicit tech** (+60): User mentions react-native/flutter/angular/vue/react/next/node/python/go/laravel → agent.
3. **Intent** (+50): Action keywords: implement/fix/test/design/database/security/deploy → agent.
4. **Project context** (+40): Package files/configs. Use cached detection when valid (<24h).
5. **File patterns** (+20): Recent file naming: *.vue→frontend, *.go→architect, etc.
## Scoring
Primary ≥80 (leads), Secondary 50-79 (supports), Optional 30-49, Skip <30.
**tester:** Always secondary unless explicit test request.
## Cache
`.claude/cache/agent-detection-cache.json` — reuse within workflow (phase >1). Invalidate on new workflow, phase 1, or user override.Related Skills
extension-detector
Detects when a new project-level skill / rule / command would reduce friction. Asks the user for confirmation before creating anything. NEVER writes plugin-level files — only `.claude/skills/`, `.claude/rules/`, `.claude/commands/` in the user's project.
conflict-detector
L1-L4 conflict detection between a proposed T4 task and pending-confirm sibling tasks. L1 (file overlap) + L2 (function/region overlap) ship in v3.7.0-beta.2 as deterministic bash. L3 (semantic LLM) + L4 (architectural LLM) are stubbed for v3.7.0-rc.1.
vue-expert
Vue 3 gotchas and decision criteria. Covers reactivity traps, Composition API pitfalls, and Pinia patterns.
typescript-expert
TypeScript gotchas and decision criteria covering nullish coalescing pitfalls (|| vs ??), strict tsconfig settings (noUncheckedIndexedAccess, exactOptionalPropertyTypes), type guard patterns, discriminated unions, and as const vs enum. Use when writing TypeScript, configuring tsconfig, implementing type guards, or debugging null/undefined errors.
tree-of-thoughts
Branch, evaluate, prune, expand — structured search over solution space. Use for architecture with multi-step decisions, refactor planning, or complex debug hypothesis trees. Paper: Yao et al. 2023.
test-writer
Write tests with TDD following structured patterns. Ensures consistent AAA structure, proper coverage targets, and framework-specific conventions. Without this skill, tests lack consistent naming, miss coverage targets, and skip anti-pattern checks.
stitch-design
Generate UI designs using Google Stitch AI with optimized prompts
session-continuation
Manage workflow state across sessions with handoff and resume. TOON-based state persistence.
sequential-thinking
Structured thinking process for complex analysis. Supports revision, branching, and dynamic adjustment.
self-improve
Apply learned improvements to the Aura Frog plugin. Updates rules, adjusts agent routing, modifies workflow configurations, and generates knowledge base entries.
self-healing-orchestrator
Proposes patches for F2 (local-logic) and F3 (local-design) failures. NEVER applies without user approval. Confidence ≥0.7 to propose; below that, escalates raw findings. Counts toward replan_budget. Per-task: max 1; per-session: max 5.
self-consistency
Generate N independent reasoning paths and vote on the answer. Use for architectural trade-offs, ambiguous design decisions, or when single-path reasoning risks locking onto the first plausible answer. Paper: Wang et al. 2022.