bosskuai-ai-model-selection git:20261010.cd73169A

Immutable. This exact content never changes and is served at /api/v1/blob/6857bf98fc4aef0f.

---
name: bosskuai-ai-model-selection
description: Use when recommending which AI model fits a specific task, weighing reasoning depth, speed, tool use, coding needs, multimodality, cost sensitivity, and reliability tradeoffs.
---

# BosskuAI AI Model Selection

Use this skill when the user wants to know **which AI model fits a specific task**, or when BosskuAI needs to select a model for a handoff (pair with `bosskuai-context-limit-continuation`).

## How this differs from nearby skills

- **`bosskuai-context-limit-continuation`**: handles the handoff mechanics when context runs out; this skill picks *which model* finishes the work. Load both at handoff.
- **`bosskuai-cross-model-escalation`**: decides *when* to bring in another model because the current one is blocked; this skill chooses the helper once that call is made.
- **`bosskuai-cost-optimization`**: sets the spend envelope; this skill picks the model that fits inside it.

## Verify before quoting

Model rosters move faster than this file. For anything Claude/Anthropic — model ids, pricing, context windows, thinking and effort behavior — **load the `claude-api` skill rather than answering from memory**; it carries the current cached table and a live Models API lookup. For OpenAI, Google, or other vendors, check the vendor's own docs. Never invent a version number: a confidently wrong model id costs more than saying "verify this".

## Claude roster

Checked 2026-10-06: ids, context windows and prices match Anthropic's current model table; the "Best for" notes were not re-checked. Newer models may exist. Load `claude-api` for the live roster. Ids are complete as written - never append date suffixes.

| Model | Id | Context | $/1M in | $/1M out | Best for |
|---|---|---|---|---|---|
| Claude Fable 5.1 | `claude-fable-5-1` | 1M | 10.00 | 50.00 | The most capable widely released model: the hardest reasoning and longest-horizon agentic runs (succeeds `claude-fable-5`, same price) |
| Claude Opus 5.5 | `claude-opus-5-5` | 1M | 4.00 | 20.00 | **Default Opus.** Agentic coding, architecture, deep analysis. Effort defaults to `medium`, and thinking cannot be disabled |
| Claude Sonnet 5.5 | `claude-sonnet-5-5` | 1M | 2.00 | 10.00 | High-volume production work. This repo's benchmarks ran it |
| Claude Haiku 5.5 | `claude-haiku-5-5` | 1M | 0.10 | 0.50 | Extraction, classification, summarization at volume |

The Haiku 5.5 prices apply to prompts up to 100K tokens; ask `claude-api` for the price above that.

Earlier models, from the 2026-09 check and not re-checked on 2026-10-06, so confirm before quoting them:

| Model | Id | Context | $/1M in | $/1M out | Best for |
|---|---|---|---|---|---|
| Claude Opus 5 | `claude-opus-5` | 1M | 5.00 | 25.00 | Agentic coding, architecture, deep analysis |
| Claude Sonnet 5 | `claude-sonnet-5` | 1M | 2.00 | 10.00 | High-volume production work at near-Opus quality |
| Claude Haiku 4.5 | `claude-haiku-4-5` | 200K | 1.00 | 5.00 | Extraction, classification, summarization at volume |

Default to `claude-opus-5-5` unless the user names another model. Never downgrade for cost on the user's behalf - that is their call.

## The controls that matter more than the model

Picking a bigger model is the expensive lever. Reach for these first:

- **Effort** (`output_config: {effort: ...}`): `low` | `medium` | `high` | `xhigh` | `max`, default `high`. This is the primary intelligence/latency/cost dial. `xhigh` suits coding and agentic work; `low` and `medium` are unusually strong on current models and are the main cost saving. Sweep it on real tasks — defaults carried over from an older model rarely transfer.
- **Adaptive thinking** (`thinking: {type: "adaptive"}`): the model decides depth per request. Fixed `budget_tokens` is removed on current models and returns a 400.
- **Prompt caching**: repeated context bills at roughly a tenth of input price. Often a larger saving than switching model tier.
- **Batch processing**: half price for work with no latency requirement.

A Sonnet-tier model at `xhigh` with caching frequently beats an Opus-tier model at default effort on both quality and cost. Test before assuming the tier is the bottleneck.

## Task profile

Score the request on these before recommending:

- **Reasoning depth**: shallow (extraction, formatting) / medium (structured analysis) / deep (ambiguous, multi-step, novel)
- **Speed sensitivity**: latency-critical / interactive / async batch
- **Cost sensitivity**: high-volume / exploratory / one-off
- **Modality**: text / code / vision / long document
- **Context needed**: fits comfortably / near the window / needs compaction
- **Tool use**: none / function calling / multi-step agentic
- **Reliability**: production-critical / experimental

Then name the **primary failure mode** if the choice is wrong — low quality, too slow, too expensive, or cannot handle the modality. That failure mode, not the benchmark, decides the tier.

## Guardrails

- Do not recommend the top tier for mechanical work where a cheaper model plus higher effort suffices.
- Do not recommend the cheapest model where reasoning quality directly affects correctness — money, auth, data integrity, medical, or legal output.
- Use the strongest model for execution too, not only planning and audit, when the work touches auth, sessions or secrets (including authorization and tokens); payments, billing, refunds or financial data; privacy, PII, data retention or user safety; destructive migrations, data loss or queue/idempotency; multi-service or deployment changes; security-sensitive integrations and webhooks; repeated failures of the cheaper model; or unclear requirements with a high cost of being wrong.
- Always give a fallback: availability, rate limits, and refusals all happen. Rate limits are per-model, so a fallback in the same tier may not have headroom.
- Do not present benchmark scores as decisive for a specific task. Test on the actual workload.
- Date any claim that depends on current pricing or capability.

## Output format

```text
Task profile:
  Reasoning: [shallow / medium / deep]
  Speed: [latency-critical / interactive / async]
  Modality: [text / code / vision / long-doc]
  Context needed: [estimate]
  Tool use: [none / function calling / agentic]

Primary failure mode if wrong: [what breaks]

Primary: [model id] at effort [level] - [one-line reason]
Fallback: [model id] - [when it takes over]

Cheaper levers tried first: [effort / caching / batching]
Tradeoff: [capability / latency / cost / reliability]
Verified against: [claude-api skill / vendor docs / not verified]
```

## References

- `../../references/playbooks/model-selection-playbook.md`
- `../../references/checklists/model-selection-checklist.md`