# Dispatch

> Pick the model tier for every subagent before spawning it, so cheap work runs on cheap models: Opus for anything that writes, runs, implements, designs, or carries consequence; Sonnet for read-only work like research, reading, and summarizing; a Haiku swarm when fanning out more than five agents on a breadth sweep or brainstorm; and grok, on the separate Cursor meter, for token-heavy work whose answer you can check cheaply. Also checks the remaining Claude 5-hour and 7-day allowance and shifts checkable work to grok when either window runs low. TRIGGER — read BEFORE any subagent spawn, including agents you decided to spawn on your own initiative and `agent()` calls inside a Workflow. Do not skip it because the task "looks obvious" — the lane is a two-second check and the default is wrong half the time. Also fires on /dispatch, "spawn subagents", "fan out", "run these in parallel", "use a swarm of agents", "which model should this agent use", "route this to a smaller model".

- Skill: `mehdiforoozandeh/dispatch` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add mehdiforoozandeh/dispatch`
- Raw SKILL.md: https://api.skillmd.com/api/skills/mehdiforoozandeh/dispatch/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- License: MIT
- Author: mehdiforoozandeh (https://skillmd.com/u/mehdiforoozandeh)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/mehdiforoozandeh/dispatch

---


# dispatch — the right worker for the job

A subagent inherits the main loop's model unless you say otherwise. That means a `grep`
across a directory and a database migration both run on Opus, and you pay Opus rates for
both. Most delegated work does not need the best model in the lineup.

The output-token spread is 10× end to end: Haiku $5/M, Sonnet $15/M, Opus $25/M, Fable
$50/M. That spread pays off on volume, not on any single call — so route every spawn, and
never agonize over one.

## The lanes

Ask one question: **does this agent write or run anything?**

| Lane | `model` | When |
|---|---|---|
| **Build** | `opus` | Writes files, edits code, runs commands, implements, designs, works through complex logic, or produces a judgment you'll act on directly |
| **Read** | `sonnet` | Read-only. Search, research, market research, reading, extracting, summarizing, mapping a codebase. **Sonnet never writes.** |
| **Swarm** | `haiku` | Only inside a fan-out of **more than five read-only agents dispatched in one batch**, on a breadth sweep or brainstorm — where coverage matters more than any single agent's answer |

A judgment the parent will act on is Build-lane even when nothing gets written — reconciling
conflicting sources, picking between options, deciding whether something is sound. Plain
extraction and summary stay in Read.

"One batch" means spawned together in a single dispatch. Eight agents run two at a time
across a task are eight Read-lane agents, not a swarm.

**Opus is the ceiling.** Never auto-route to `fable`; a subagent smarter than the parent
means judging output the parent could not have produced. It unlocks only when the user
writes the word — *fable*, or a specific model ID. A capability request ("use the best
model", "this one's hard, go all out") is **not** naming it: that caps at `opus`.

**Haiku exists only in the swarm lane.** A lone Haiku agent is never the right call — if
it's worth one agent, it's worth Sonnet.

## The grok lane — a different meter

`grok` is not a fourth tier. It is a Grok 4.6 subagent on the **Cursor** subscription,
spawned through Bash, not through the Agent tool. Its work never touches the Claude
allowance; only the answer it hands back enters context. Measured on a whole-repo read:
291k tokens spent there, 4.7k returned here.

So route this lane by **verifiability, not by strength**. Send grok anything token-heavy
whose answer you can check cheaply — however hard it is:

- whole-repo or whole-directory reads
- log, output and test-failure sweeps
- broad multi-file searches where only the conclusion comes back
- first-draft implementations that ship with tests you will run

Keep on the Claude lanes anything you **cannot** cheaply check: design judgment, research
verdicts, anything writing to a crux vault, and any call where being subtly wrong costs
more than the tokens saved. Grok output is untrusted input — verify before acting.

```
grok -r -e high "..."          read-only analysis   (the default posture)
grok -e high "..."             write and run enabled
grok -r -b brief.md "..."      splice a written brief in
```

Effort per task: `xhigh` for deep analysis where the answer is the deliverable, `high`
by default, `medium` for mechanical sweeps, `low` for smoke tests only. Higher effort
spends the other meter, so when in doubt go up.

Grok runs in its own process and **cannot see this conversation**. A thin answer almost
always means a thin brief. Mechanics, brief format and failure modes are in
`references/grok.md` — read it before the first grok call of a session.

## Quota gate

Before a batch that will spend real tokens, check what is left:

```
~/.claude/bin/claude-quota
```

| Reading | Route |
|---|---|
| Fresh · 5-hour < 80% **and** 7-day < 75% | By the lanes above |
| Fresh · 5-hour ≥ 80% **or** 7-day ≥ 75% | Send every checkable Claude-lane agent to grok instead, and say why |
| **Stale · missing · `NO DATA`** | By the lanes above, and say "quota unknown" out loud |

Gate at 80 rather than 95: the turn that checks the quota also spends it. The 7-day window
gets the tighter gate because it refills over days, not hours.

**Never read a missing cache as "near the limit."** `NO DATA` is the normal state on this
machine — the cache is only written when Claude Code invokes the custom `statusLine`
command, and the desktop app does not. Treating absence as a limit signal would route
everything to grok forever, silently.

## Escalations

Four conditions override the lane and send the work to `opus`:

1. **A lower lane already came back thin, wrong, or hedged.** Retry one lane up. Do not
   re-prompt the same tier with a firmer instruction — the tier was the problem. **This
   escalation stops at `opus`** — it never reaches for `fable`. When an Opus agent comes
   back thin, the model was not the bottleneck: rewrite the brief, split it into narrower
   briefs, or do the work inline. Re-spawning on a *sharper* brief is fine — re-spawning
   the *same* brief is what never works.
2. **You can't tell which lane it is.** Ambiguity resolves upward.
3. **The brief is ambiguous or underspecified.** An agent that must infer the goal needs
   the judgment to infer it well.
4. **A read feeds something security- or correctness-critical you won't re-verify.**
   Read-only does not mean low-stakes.

Everything else stays in its lane. Don't invent a fifth condition mid-task.

## Depth

**Do not set an effort parameter** — subagents inherit the session's effort, and that's
correct. Shape depth through the prompt instead, which costs nothing:

- Swarm agents: *"Answer from the first solid match. Don't verify, don't survey alternatives."*
- Build agents on design or root-cause work: *"Verify by a second method before returning."*
- Read agents: neither — let them work at their natural depth.

This rule is about the Agent tool. `grok -e` is a different knob on a different
meter — set it per task, as the grok lane says.

## Say what you routed

Two things, both cheap:

- **One line before a batch**, before the spawn calls: *"7 haiku for the sweep, opus for
  the implementation."* When an escalation fired, name it in the same line: *"opus — the
  sonnet pass came back hedged."*
- **A model tag in every agent's `description`**, e.g. `review:auth [opus]`, so the routing
  is visible in the agent list without opening anything. Grok calls get the same tag in
  the Bash description: `sweep crux engine [grok:xhigh]`.

## Mechanics

Per call on the Agent tool — `model` takes the bare tier name, not a full model ID:

```
Agent({ description: "map auth flow [sonnet]", model: "sonnet", prompt: "..." })
```

Inside a Workflow, the same lanes apply to each `agent()` call:

```js
agent(prompt, { model: 'haiku', label: 'sweep:api [haiku]' })
```

Omitting `model` inherits the main loop. That is a routing decision too — make it on
purpose, not by forgetting.

## What this is not

- **Not for the main loop.** Dispatch routes subagents. Your own model is the user's choice.
- **Not a reason to spawn.** If the work is faster done inline, do it inline. Routing a
  subagent you shouldn't have spawned saves nothing.
- **Not a swarm generator.** Five-plus agents is a *precondition* for Haiku, not a target.
  Don't inflate a fan-out to unlock the cheap tier.

## Quick reference

```
writes / runs / implements / designs / consequential   → opus
judgment you'll act on, even with nothing written      → opus
read-only, single agent                                → sonnet
>5 read-only agents in one batch, breadth sweep        → haiku
unclear · underspecified · read feeding critical
  unverified work                                      → opus
sonnet/haiku came back thin                            → same task, one lane up
opus came back thin                                    → sharpen the brief, same lane
"use the best model" (fable not named)                 → opus

token-heavy AND you can check the answer cheaply       → grok  (Cursor meter)
token-heavy but you cannot check it                    → opus
5h ≥ 80% or 7d ≥ 75%, reading fresh                    → shift checkable work to grok
quota reading stale / missing / NO DATA                → route normally, say so
```