Skip to main content
Dispatch is a Claude Code skill that transforms your session into a lightweight orchestrator. Instead of filling your main session with implementation details, /dispatch fans work out to background agents—each with their own full context window.

​
The Problem

Without dispatch: You ask Claude to review code, refactor a module, write tests, and update docs. Each task fills the context window. By task 3, Claude is losing track. By task 5, you’re starting a new session.

​
The Solution

With dispatch: You describe all 5 tasks. Workers execute in parallel with fresh contexts. Your main session stays lean. Questions surface to you when needed—no polling, no context lost. 
/dispatch use sonnet to find better design patterns for the auth module

​
Key Features

Your Session Stays Lean

The main session becomes a mediator, not the thinker. It writes a checklist and hands it off. Implementation happens in fresh worker contexts.

AI Carries the Cognitive Load

The dispatcher tracks all workers, surfaces questions, reports completions, handles errors, and offers recovery. You just describe what you want and answer questions when asked.

Workers Ask Questions Back

When a worker gets stuck, it asks a clarifying question. You answer, and the worker continues without losing context. No restart, no re-explaining, no lost work.

Non-Blocking Execution

The moment a worker is dispatched, your session is free. Dispatch another task. Ask a question. Write code. Results arrive as they complete.

Any Model, One Interface

Mix models per task. Claude for deep reasoning, GPT for broad generation, Gemini for speed. If a model isn’t in your config, dispatch auto-discovers and adds it.

Parallel by Default

Multiple tasks run concurrently with their own fresh contexts. A 5-task workflow that would take 45 minutes sequentially completes in the time of the longest task.

​
How It Works

1

You run /dispatch with a task description

/dispatch do a security review of the auth module
2

A checklist plan is created

The dispatcher writes a plan file at .dispatch/tasks/<task-id>/plan.md—the only context your main session needs.
3

A background worker picks it up

The worker executes in a fresh, full context window and checks off items as it goes.
4

Questions are handled without context loss

If the worker needs clarification, it asks—you answer—it continues. No restart required.
5

You get results when it's done

Or ask for status anytime. Your main session is still lean and available for other work.

​
Simple Example

/dispatch use sonnet to add error handling to the login endpoint
Dispatch creates a plan, spawns a worker, and immediately returns control. You can:
  • Dispatch another task
  • Continue working on something else
  • Check progress with “status”
  • Answer questions if the worker gets stuck

​
Complex Example

Pre-launch sweep for a fullstack SaaS app: 
/dispatch we launch Thursday, need a full pre-launch sweep:

1) security audit the auth flow (JWT, sessions, password reset) and the
   stripe payment integration. use opus, do it in a worktree

2) performance - load test the top 5 API endpoints, find N+1 queries,
   check db indexes on users/orders/products tables. sonnet in a worktree

3) frontend audit - accessibility (WCAG 2.1 AA), bundle size, flag any
   components missing error boundaries. dispatch sonnet

4) generate OpenAPI specs for every endpoint that's missing one. use gemini

5) error handling audit - find uncaught exceptions, missing try/catch,
   inconsistent error response formats across all API routes. sonnet, worktree

ask me if anything is unclear. security is highest priority - flag
anything critical immediately
Dispatch reads the prompt, creates 5 plans, and fans out: 
All 5 workers dispatched. Here's the summary:

Security (worktree):
  ● security-audit — Opus (worktree): Full auth + payment security review

Performance (worktree):
  ● perf-audit — Sonnet (worktree): API load testing + DB index review

Frontend (single worker):
  ● frontend-audit — Sonnet: Accessibility, bundle size, error boundaries

Docs (single worker):
  ● api-docs — Gemini 2.5 Flash: Generate missing OpenAPI specs

Error handling (worktree):
  ● error-handling — Sonnet (worktree): Uncaught exceptions + error format audit

All running in background. Five workers, three models, three worktrees.
Requires Claude Code as host. Dispatch runs inside Claude Code—the host plans tasks and spawns workers. Other CLIs like Cursor and Codex work as workers (background agents that execute subtasks).

​
Next Steps

Installation

Install Dispatch and set up your first worker

Quickstart

Get to a working example in under 5 minutes

Build docs developers (and LLMs) love

Get started for freeTalk to us