claude-auto-route

auto-route

Smart dual-axis model & reasoning router with parallel subagent execution for Claude Code.

auto-route automatically selects the optimal Claude model (haiku, sonnet, or opus) and reasoning effort (low to xhigh) for each task. It delegates work to isolated subagents, executes independent multi-step plan items in parallel, and runs pure conversational questions inline with zero overhead.

• Overview
• Key Benefits
• Quickstart (Install, Test, Uninstall)
  • Installation
  • First Test Run
  • Enable Always-On Mode
  • Clean Uninstall
• Usage & Command Reference
  • Command Table
  • Smart Filtering (Always-On Mode)
• Parallel Subagent Execution
  • How Parallel Execution Works
  • Parallel Workflow Diagram
  • Interactive Walkthrough: Parallel Plan
• How It Works (Under the Hood)
  • Decision & Routing Architecture
  • Dual-Axis Routing Rubric
  • Phase Guidelines
  • Adaptive Retries & Escalation
  • Prompt Cache Preservation
• Cost Transparency: Real Pricing vs. Modeled Savings
  • 1. Real Anthropic API Token Pricing
  • 2. Modeled Scenario (Simulated 100-Task Workload)
  • 3. Your Real Telemetry
  • Why Not Claude Fable?
• Troubleshooting & FAQ
• Contributing & Testing
• License

---

Overview

By default, Claude Code runs every prompt with the primary session's active model and effort level. This means:

• Mechanical renames, regex changes, or simple grep searches burn expensive Opus tokens at maximum effort.
• Complex multi-file refactoring runs sequentially one step at a time.
• Toggling effort levels mid-session invalidates prompt caches.

auto-route solves this by classifying each task before delegating:

> Rename variable 'clientSecret' to 'apiSecret' across auth services
Route: sonnet + low (mechanical rename across many files)

Pure chat inquiries and tiny contextual tasks run immediately inline with zero overhead:

> What is the difference between TCP and UDP?
Route: inline (pure chat question)
TCP is connection-oriented and ensures reliable, ordered data delivery...

---

Key Benefits

Benefit	Without auto-route	With auto-route
Optimized Costs	Simple tasks run at full session rates (e.g. Opus rates for typo fixes).	Routes mechanical work to haiku + low and standard code to sonnet + medium, reserving opus for architecture and high judgment.
Parallel Execution	Multi-file tasks execute sequentially one by one in the main thread.	Independent plan steps across disjoint files execute concurrently across parallel subagents, cutting turnaround latency by up to 50%.
Cache Preservation	Changing reasoning effort mid-session invalidates the prompt cache and alters global settings (issue #95347).	Subagents run in isolated contexts with dedicated frontmatter effort levels, keeping the main session cache warm.
Zero-Overhead Chat	Pure questions either run unnecessarily through heavy pipelines or need manual switching.	Instantly detected and answered inline (Route: inline).
Automated Escalation	If an agent is underpowered, you must manually restart with higher params.	Automatically retries once on the deficient axis (effort or model).

[!TIP] Minimal Token Footprint: ~290 tokens per session (plugin registration), ~40 tokens per prompt (always-on hook), ~850 tokens on initial skill invoke (0 extra tokens on subsequent turns via session cache reuse), and ~70 tokens per launched subagent. Pure chat questions cost 0 extra tokens.

---

Quickstart (Install, Test, Uninstall)

Installation

Inside Claude Code:

/plugin marketplace add Sagor31h2/claude-auto-route
/plugin install auto-route@auto-route

(Or from your terminal without the leading slash: claude plugin marketplace add Sagor31h2/claude-auto-route && claude plugin install auto-route@auto-route)

[!IMPORTANT] Restart Claude Code after installing to register the effort subagents and hooks into your session.

First Test Run

Verify the installation by routing a single task on demand:

/auto-route:auto-route Find where database connection pooling is configured

You will see the route decision line before the matching subagent runs:

Route: haiku + low (symbol lookup in codebase)

Enable Always-On Mode

To automatically route every prompt without typing the /auto-route:auto-route command prefix:

/auto-route:auto-route on

Claude Code will confirm: Auto-route: ON. From then on, every eligible task is routed automatically.

Clean Uninstall

If you ever wish to remove the plugin, you can uninstall it cleanly with no residual files left behind:

# 1. Uninstall the plugin inside Claude Code
/plugin uninstall auto-route@auto-route

# 2. (Optional) Remove local configuration flag and telemetry logs from terminal
rm -f ~/.claude/auto-route.on ~/.claude/auto-route.log ~/.claude/auto-route.stats
# If CLAUDE_CONFIG_DIR is set:
rm -f "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/auto-route.on" "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/auto-route.log" "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/auto-route.stats"

---

Usage & Command Reference

Command Table

Command	Action	Description
/auto-route:auto-route <task>	Route single task	Manually evaluates and routes a specific task.
/auto-route:auto-route on	Enable always-on	Creates flag file and routes every prompt automatically.
/auto-route:auto-route off	Disable always-on	Removes flag file, returning to manual routing mode.
/auto-route:auto-route status	Check status	Shows whether always-on mode is currently ON or OFF.
/auto-route:auto-route stats	View telemetry	Displays a compact table of runs, token usage, and durations (off by default; says so if disabled).
/auto-route:auto-route stats on	Enable stats logging	Creates flag file; each routed run is appended to ~/.claude/auto-route.log.
/auto-route:auto-route stats off	Disable stats logging	Removes flag file; the log itself is kept.
/auto-route:auto-route reset	Reset stats	Clears ~/.claude/auto-route.log.

Smart Filtering (Always-On Mode)

When always-on mode is active, the UserPromptSubmit hook prompts Claude to route tasks before running tools. To prevent annoying interruptions, it automatically skips:

• Slash commands: /help, /exit, /compact, /plugin, etc.
• Acknowledgements: ok, okay, yes, yep, sure, continue, proceed, done, lgtm, looks good.
• Greetings & pleasantries: hi, hello, hey, good morning, thanks, thank you, bye.
• Cancellations: stop, cancel, wait, hold on, nevermind.
• Greeting-prefixed tasks: hi, please fix the bug in auth.py $\rightarrow$ Correctly identified as a task and routed!

---

Parallel Subagent Execution

How Parallel Execution Works

When a task requires multiple steps across a codebase:

1. Decomposition: The Plan phase produces 3–5 coarse, actionable steps with designated file targets.
2. Dependency & Disjoint Check: Steps that are independent and modify disjoint files or directories are flagged for concurrent execution.
3. Parallel Dispatch: auto-route dispatches matching subagents simultaneously, each configured with its own optimal model and effort tier.
4. Context Aggregation: As subagents finish, their outputs and modifications are assembled in the orchestrator before dependent sequential steps run.

Sequential Execution (Standard):
[Step 1: 30s] ────────> [Step 2: 25s] ────────> [Step 3: 35s] ────────> [Step 4: 20s] = 110s total

Parallel Execution (auto-route):
┌── [Step 1: Frontend Components (30s)] ──┐
├── [Step 2: API Client SDK (25s)] ───────┼──> [Aggregator] ──> [Step 4: DB Migration (20s)] = 50s total
└── [Step 3: Background Worker (35s)] ────┘
                                               ▲ Slashing latency by >50%

Parallel Workflow Diagram

flowchart TD
    Task["Complex Task / Feature Request"] --> Planner["Plan Phase (scored route) - Read-only"]
    
    Planner --> PlanOutput["Decomposed Plan (3-5 Steps with File Targets & Route)"]
    
    PlanOutput --> DepAnalysis{"Dependency & Disjoint File Analysis"}
    
    subgraph ParallelWave ["Parallel Execution Wave (Concurrent Subagents)"]
        direction LR
        Step1["Step 1: Frontend Components (src/components/*)<br/>sonnet + low"]
        Step2["Step 2: API Client SDK (src/sdk/*)<br/>haiku + low"]
        Step3["Step 3: Background Worker (src/workers/*)<br/>sonnet + medium"]
    end
    
    DepAnalysis -- "Independent on Disjoint Files" --> ParallelWave
    
    ParallelWave --> Aggregator["Context Aggregator (Combine outputs & state changes)"]
    
    Aggregator --> SequentialStep["Step 4: Integration & DB Migration (src/db/*)<br/>sonnet + high"]
    
    SequentialStep --> FinalReview["Review Phase (scored route) - Read-only Verification"]
    
    FinalReview --> FinalDone["Final Verified Deliverable"]

Interactive Walkthrough: Parallel Plan

Here is what the terminal output looks like when parallel subagent execution runs:

> Add webhooks support for invoice payments and update SDK and docs

Route: opus + effort-high (multi-file architecture and feature design)

[auto-route:effort-high subagent started with model: opus]
  Plan generated:
    Step 1: Webhook emitter & dispatcher (src/events/webhook.ts) -> sonnet + medium
    Step 2: Webhook payload types in SDK (sdk/types.ts)          -> haiku + low
    Step 3: Webhook schema documentation (docs/webhooks.md)      -> haiku + low
    Step 4: Connect payment processor (src/billing/invoice.ts)   -> sonnet + high (depends on Step 1)
    Step 5: Security review of webhook signing & HMAC validation -> opus + high
[Plan complete. Steps 1, 2, and 3 target disjoint files with no mutual dependencies.]

⚡ Dispatched parallel execution wave:
  ├── [Subagent 1: sonnet + medium] Working on src/events/webhook.ts ...
  ├── [Subagent 2: haiku + low]     Working on sdk/types.ts ...
  └── [Subagent 3: haiku + low]     Working on docs/webhooks.md ...

  ✓ Subagent 2 finished in 5.1s (420 tokens)
  ✓ Subagent 3 finished in 6.2s (610 tokens)
  ✓ Subagent 1 finished in 14.8s (1,850 tokens)

Dispatched sequential Step 4:
  [Subagent 4: sonnet + high] Wiring invoice.ts to webhook emitter ...
  ✓ Subagent 4 finished in 18.2s (2,410 tokens)

Dispatched final Review:
  [Subagent 5: opus + high (read-only)] Auditing HMAC signing and replay attack mitigations ...
  ✓ Verified: Constant-time comparison used for signature checks. No vulnerabilities detected.

Feature complete! Webhooks dispatcher, SDK types, documentation, and invoice wiring finished and reviewed.

---

How It Works (Under the Hood)

Decision & Routing Architecture

flowchart TD
    Start["User Prompt Submitted"] --> HookCheck{"Always-On Hook Enabled?"}
    
    HookCheck -- "No (Manual Mode)" --> DirectCmd{"Invoked via /auto-route?"}
    HookCheck -- "Yes" --> FilterCheck{"Matches Skip Filter?<br/>(Greetings, Acks, Slashes)"}
    
    FilterCheck -- "Yes" --> InlineExec["Direct Session Execution"]
    FilterCheck -- "No" --> EvaluateTask["Analyze Task & Work Scope"]
    DirectCmd -- "No" --> InlineExec
    DirectCmd -- "Yes" --> EvaluateTask

    EvaluateTask --> PureChatCheck{"Pure Chat or Tiny Context?"}
    PureChatCheck -- "Yes" --> InlineRoute["Execute Inline:<br/>Route: inline (reason)"]
    PureChatCheck -- "No" --> DeterminePhase["Determine Phase:<br/>Plan, Research, Implement, Debug, Review"]

    DeterminePhase --> DualAxis["Score Dual Axes:<br/>Model (haiku/sonnet/opus) + Effort (low to xhigh)"]
    
    DualAxis --> AgentCheck{"Plugin Agents Installed?"}
    AgentCheck -- "Yes" --> EffortAgent["Delegate to auto-route:effort-* with target model"]
    AgentCheck -- "No (Skill-only)" --> FallbackAgent["Delegate to general-purpose with model only"]
    
    EffortAgent --> SubagentRun["Execute Subagent Task"]
    FallbackAgent --> SubagentRun
    
    SubagentRun --> OutcomeCheck{"Result Status?"}
    OutcomeCheck -- "Success" --> Complete["Return Brief Result & Log Telemetry"]
    OutcomeCheck -- "Capability Failure" --> RetryCheck{"Already Retried?"}
    OutcomeCheck -- "Environment / Tool Error" --> ReportError["Report Blocker Immediately (No Retry)"]
    
    RetryCheck -- "No" --> StepUp["Step Up Failed Axis (Effort +1 or Model +1)"]
    StepUp --> EffortAgent
    RetryCheck -- "Yes" --> ReportFail["Report Blocker to User"]

Dual-Axis Routing Rubric

Tasks are scored on signals (not task type) on two orthogonal axes. The default is a cheap-first cascade: when tests exist and risk is low/medium, the lowest viable tier is picked, and a capability failure escalates only the failed axis by one level (single retry). A trivial/small change with no tests stays cheap-first. It starts high only by axis: concurrency = opus + xhigh; security/auth = opus + high (xhigh only for subtle crypto/proofs); irreversible migration = opus + high; no tests AND non-trivial (3+ files, even if the approach is already chosen, or unclear approach) = raise effort first (high), model stays sonnet unless another risk signal applies. Unknown-cause debugging starts at high effort (model per rubric); known-location bugs follow cheap-first. When unsure on an axis, it tie-breaks to the cheaper tier. The router scores from the request and what it already knows and never explores the repo just to route (subagents explore); an unknown signal counts as the cheaper tier. A Plan step runs first only for 3+ files with high risk (auth, migrations, concurrency) or an approach unclear across modules. The announce line carries the bare effort level (Route: sonnet + high (...)), not the agent name.

1. Model Axis (Capability & Knowledge), driven by risk surface (auth, crypto, concurrency, migrations), domain novelty, tests present, and prior failure:

   • haiku: Mechanical, well-specified, small scope (typos, lookups, regex changes, running commands).
   • sonnet: Standard engineering workhorse (features, localized bugs, unit tests, explanations).
   • opus: High judgment, broad architectural scope (subsystem design, multi-file migrations, security analysis, unfamiliar domains).
   • Never fable: Excluded due to high pricing without granular per-turn reasoning controls.

2. Effort Axis (Reasoning Depth), driven by diff size, file count, fan-out, and trace depth: Claude Code configures effort via agent frontmatter. auto-route includes 5 pre-configured effort agents:

Effort Level	Agent Name	Ideal For
low	auto-route:effort-low	Obvious changes once code is seen (typos, formatting, renames).
medium	auto-route:effort-medium	Standard multi-step changes (typical controller endpoints, component logic).
high	auto-route:effort-high	Tracing complex logic, unknown-cause bugs, cross-module flows.
xhigh	auto-route:effort-xhigh	Concurrency race conditions, distributed consistency, memory leaks.
max	auto-route:effort-max	Single retry reserved exclusively after opus + effort-xhigh falls short.

[!NOTE] Skill-Only Fallback: If installed via npx skills add without agent definitions, auto-route delegates to subagent_type: general-purpose with the target model specified, reporting: Route: sonnet (effort not set: plugin agents missing). Full dual-axis routing requires the Claude Code plugin installation.

Phase Guidelines

Work is partitioned into 5 phases. A phase sets behavior only (read-only or not, handoff prefix, auto-review); it does not limit the route. Any phase may route haiku..opus and low..xhigh, scored per task by the rubric above:

Phase	Read-Only?	Purpose & Guidelines
Plan	Yes	Produces 3–5 coarse, actionable steps with What, Target Files, Dependencies, Route, and Done When.
Research	Yes	Finds definitions, inspects call hierarchies, verifies library APIs. Reports concrete file:line locations without edits.
Implement	No	Modifies files. Exactly one plan step per delegation.
Debug	No	Isolates intermittent bugs and deadlocks. Requires establishing root cause before proposing fixes.
Review	Yes	Audits code after risky or multi-file plans. Reports critical defects, correctness bugs, and security risks only.

Every delegation prompt starts with a metadata line, which the stats hook logs:

Route-meta: phase=<plan|research|implement|debug|review> risk=<low|med|high> files=<n> tests=<y|n> retry=<0|1> escalated_from=<model+effort|none>

[!TIP] Explicit Override: pin a task's effort level instead of letting it score by prefixing it with the level: low: / medium: / high: / xhigh: / max: (e.g. high: plan the auth refactor). Works for every phase, and for any named skill that takes its own level argument (e.g. code-review) — the pinned level is passed straight through as that skill's argument. Pin the model too with <model>+<level>: (e.g. opus+xhigh: ...). An explicit pin always wins over the scored level or a skill's own default/last-used level.

[!TIP] Split (only when it saves tokens): a heterogeneous task can be broken into independent sub-tasks routed at different model/effort levels instead of one flat rate for everything. Splitting only pays off when 3+ independent concerns exist (disjoint files, review dimensions, plan steps) and scoring them separately would spread across 2+ effort or model levels — otherwise the per-sub-task handoff overhead costs more than it saves, so a uniform or small task stays a single route. When it does split, each part is scored and routed independently, disjoint parts run in parallel, and results are merged in one pass (no second full-effort review of the merged output).

Adaptive Retries & Escalation

• Retry Budget: At most one retry per task.
• Capability Failures Only: Defined as: tests fail, the Done-when check is unmet, or the subagent reports it could not complete.
• Single-Axis Escalation:
  • If reasoning fell short: Step up effort (low $\rightarrow$ medium $\rightarrow$ high $\rightarrow$ xhigh).
  • If capability fell short: Step up model (haiku $\rightarrow$ sonnet $\rightarrow$ opus).
• No Retries on Environment Errors: Missing files, permission errors, shell syntax errors, and tool failures are reported directly to the user to avoid wasting tokens.

Prompt Cache Preservation

Why route through subagents instead of changing effortLevel inside the primary conversation?

1. Anthropic Cache Keys: Reasoning effort is part of the API prompt cache key. Switching effort levels mid-conversation invalidates the prompt cache and forces a cold re-read of entire conversation history.
2. Global Setting Pollution: Claude Code reads effortLevel globally from ~/.claude/settings.json. Modifying it mid-session alters settings for all open sessions on the machine (issue #95347).
3. Subagent Isolation: Subagents run with isolated context windows and fixed frontmatter effort levels, preserving the primary session's cache state.

---

Cost Transparency: Real Pricing vs. Modeled Savings

1. Real Anthropic API Token Pricing

These are the official Anthropic API list prices per million tokens:

Model	Input / 1M Tokens	Output / 1M Tokens	Cache Read / 1M Tokens
Claude Haiku 4.5	$1.00	$5.00	$0.10
Claude Sonnet 5	$2.00	$10.00	$0.20
Claude Opus 5.5	$4.00	$20.00	$0.20
Claude Fable 5.1	$10.00	$50.00	$0.25

(Source: Anthropic Pricing Documentation)

2. Modeled Scenario (Simulated 100-Task Workload)

[!NOTE] Illustrative Simulation Notice: The table below represents a modeled scenario based on estimated token volumes across a hypothetical distribution of 100 development tasks. It demonstrates how routing tasks away from a flat Opus baseline produces structural savings. Actual savings will vary based on your specific prompts and workflow.

Task Category	Volume	Unmanaged Baseline	auto-route Selection	Baseline Cost (Est.)	Auto-Route Cost (Est.)	Estimated Savings
Quick Lookups / Typos / Tests	40 tasks	opus + high ($0.12/task)	haiku + low ($0.006/task)	$4.80	$0.24	-95%
Localized Features / Unit Tests	40 tasks	opus + high ($0.14/task)	sonnet + medium ($0.045/task)	$5.60	$1.80	-68%
Tricky Debugging / Refactoring	15 tasks	opus + high ($0.18/task)	sonnet + high ($0.085/task)	$2.70	$1.28	-53%
Architecture Plans & Deep Reviews	5 tasks	opus + high ($0.26/task)	opus + xhigh ($0.28/task)	$1.30	$1.40	+8%
TOTALS	100 tasks	Flat Opus Usage	Dynamic Dual-Axis Routing	$14.40	$4.72	~67% Estimated Savings

3. Your Real Telemetry

Stats logging is off by default, 100% offline, and purely local — nothing ever leaves your machine. Enable it anytime with:

/auto-route:auto-route stats on

Then run /auto-route:auto-route stats to inspect your actual measured token consumption and runtimes. Once enabled, the plugin logs real usage from subagent transcripts into ~/.claude/auto-route.log after each run and displays a summary table. Inline turns (Route: inline (...)) are logged too — via a Stop hook — so the table shows the full picture, not just delegated subagent runs:

haiku + low      18 runs   24190 tokens   median 4s p90 7s   out 6100   ~$0.04 (approx)
sonnet + low     12 runs   18400 tokens   median 8s p90 15s   out 4200   ~$0.08 (approx)
sonnet + medium  24 runs   64280 tokens   median 17s p90 35s   out 15800   ~$0.31 (approx)
sonnet + high     8 runs   32150 tokens   median 40s p90 90s   out 9900   ~$0.17 (approx)
opus + high       3 runs   19800 tokens   median 65s p90 80s   out 5200   ~$0.15 (approx)
inline           31 turns  median 41200 tokens (context size, not cost); top reasons: pure chat question (14), trivial lookup (9), tiny edit (4)
escalation: 4/50 delegated runs with retry (8%)
escalated away: sonnet+low 3/12 (25%)
mismatch: high-risk on low/medium effort 2, low-risk on high/xhigh effort 5
slow (>10min): sonnet+high 1/8 (13%)
debug: sonnet+high 5
implement: haiku+low 10, sonnet+medium 20
plan: opus+high 3
research: haiku+low 8, sonnet+low 4
meta: 50/65 delegated runs carry Route-meta

Each delegated row is one JSON line in ~/.claude/auto-route.log: ts, model, effort, resolved_model, tokens (final-turn context size), out_tokens (summed output), new_tokens (summed input + cache creation), cache_read_tokens (summed cache reads), duration_ms, plus the parsed Route-meta fields phase, risk, files (number), tests (y/n), retry (bool), and escalated_from (string or null). Values are matched case-insensitively and leading whitespace before Route-meta: is tolerated; escalated_from must be none or model+effort. Missing or malformed meta logs these as null. Inline rows use effort: "inline", phase: "inline", null for the other meta fields, and a reason (text of Route: inline (<reason>), capped at 80 chars, or null).

[!NOTE] Inline rows record the whole-session context size (including cache reads) of the final turn, not cost, so they are excluded from the per-route token totals and shown on their own line. Durations are median and p90 per route. The escalation and per-phase route lines count only rows that carry Route-meta (older log rows without it are still shown in the table); the meta: line shows how many delegated rows carry it, so a low ratio means the model forgot the line.

Outcome signals: escalated away is, per route, the share of its runs that needed a retry on a higher tier; a high percentage (above roughly 15-20%) means that cheap tier is taking tasks it shouldn't. mismatch flags high-risk tasks sent to low/medium effort and low-risk ones sent to high/xhigh. Costs are approximate: ~$ prices new_tokens at the model's input rate (cache creation is billed at the plain input rate, since the table has no cache-write rate, so the cache-write premium is not counted), out_tokens at its output rate, and cache_read_tokens at its cache-read rate from the table above; the rates in stats.sh go stale. Rows logged before cache_read_tokens existed are costed with cache reads as 0, and the estimate is then tagged old rows lack cache reads. Rows logged before out_tokens/new_tokens existed are left out of out and ~$. slow (>10min) shows, per route, delegated runs that took over 10 minutes; it is omitted when there are none.

Why Not Claude Fable?

Claude Fable is billed at $10 / $50 per million input/output tokens—2.5× the cost of Opus 5.5—while offering equivalent or lower coding benchmark performance and lacking granular per-turn reasoning controls. auto-route explicitly avoids routing to Fable.

---

Troubleshooting & FAQ

Prompt runs inline instead of delegating

• Always-on mode directs pure chat inquiries and tiny contextual tasks to run inline to avoid subagent spin-up latency and token overhead.
• To force delegation, call directly: /auto-route:auto-route <your task>.

Always-on mode appears inactive

• Verify the flag file exists: cat ~/.claude/auto-route.on (or check /auto-route:auto-route status).
• Verify that jq is installed on your system PATH (command -v jq). The hooks require jq to parse input JSON.

Local code changes are not reflected

• Running Claude Code sessions cache plugins in ~/.claude/plugins/cache/auto-route/auto-route/<version>.
• Update the plugin and restart Claude Code:

  claude plugin update auto-route@auto-route
  

No statistics logged

• Stats logging is off by default. Enable it with /auto-route:auto-route stats on.
• Telemetry requires jq. If jq is missing, hooks exit without logging.
• Check permissions on ~/.claude/auto-route.log.

The Agent-tool subagent list shows more entries after installing

• This is not the model picker (/model) — it's the list of subagent_type values for the Agent tool, and it always includes every agent shipped by every enabled plugin, on top of Claude Code's own built-ins (general-purpose, Explore, Plan, statusline-setup, claude).
• auto-route ships 5 agents (effort-low, effort-medium, effort-high, effort-xhigh, effort-max), so the total list grows by 5 once the plugin is enabled — e.g. from ~5 built-ins to ~10+.
• All 5 use model: inherit; none of them register a new model. No entries are added to /model.
• There is currently no per-agent visibility setting to hide these from the list while keeping the plugin functional — disable/uninstall the plugin, or delete unwanted agents/effort-*.md files from the installed copy, are the only ways to shrink the list, and both remove that agent's routing tier too.

---

Contributing & Testing

Contributions and test improvements are welcome!

Running the Test Suite

Run the automated test harnesses (requires bash and jq):

bash tests/always-on.test.sh
bash tests/log-route.test.sh
bash tests/log-inline.test.sh
bash tests/manage.test.sh

Validating the Plugin Manifest

claude plugin validate .

Running Evals

claude plugin eval . --runs 1 --ablation none --scaffold --trust-plugin --no-publish

Repository Layout

.
├── .claude-plugin/
│   └── plugin.json                 # Manifest, hooks registration, version
├── agents/                         # Effort subagent definitions
│   ├── effort-low.md               # effort: low, model: inherit
│   ├── effort-medium.md            # effort: medium, model: inherit
│   ├── effort-high.md              # effort: high, model: inherit
│   ├── effort-xhigh.md             # effort: xhigh, model: inherit
│   └── effort-max.md               # effort: max, model: inherit (retry only)
├── hooks/
│   ├── always-on.sh                # UserPromptSubmit hook for prompt routing
│   ├── log-route.sh                # SubagentStop hook for delegated-run telemetry
│   └── log-inline.sh               # Stop hook for inline-route telemetry
├── skills/
│   └── auto-route/
│       ├── SKILL.md                # Core router prompt & rubric logic
│       ├── manage.sh               # Deterministic admin command handler
│       └── stats.sh                # Telemetry aggregator script
├── tests/
│   ├── always-on.test.sh           # Test suite for skip patterns and triggers
│   ├── log-route.test.sh           # Test suite for delegated-run log aggregation
│   ├── log-inline.test.sh          # Test suite for inline-route log aggregation
│   └── manage.test.sh              # Test suite for admin command management
├── evals/                          # Evaluation benchmarks
├── LICENSE                         # MIT License
└── README.md                       # Documentation

---

License

MIT © sagor