Dispatch skill

A Claude Code skill that turns your session into a dispatcher: tasks go to background workers and their questions come back to you

  • 414 ★ on the repository
  • Last commit
Skill

Broad access

Why this level

  • Workers start without confirmation prompts by default: `--dangerously-skip-permissions`, `--full-auto`, `--force`
  • Background processes edit files and run commands in the working directory while you do something else
  • Token use grows with the number of workers and is billed under each CLI's plan
All reasons and checks

bassimeledath/dispatch

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/dispatch

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Broad accessThe tool can change data, run commands or handle secrets.

  • Workers start without confirmation prompts by default: `--dangerously-skip-permissions`, `--full-auto`, `--force`
  • Background processes edit files and run commands in the working directory while you do something else
  • Token use grows with the number of workers and is billed under each CLI's plan

This is third-party code. Review the repository files before installing.

What it does

Dispatch runs in Claude Code with the `/dispatch` command and a task description. The main session writes a checklist plan and hands it to a background worker with its own full context window. The session itself stays light: it tracks workers, reports completions and offers recovery when something fails. If a worker gets stuck on something unclear, it writes a question to an exchange directory, a monitor notices it and tells the dispatcher, which shows the question to you, and your answer goes back to the worker without losing context. You can launch tasks in a batch, for example a security audit, a load check and an accessibility review, each with its own model and, if needed, in a separate git worktree. Models are tied to commands in `~/.dispatch/config.yaml`: Claude via `claude`, GPT via `codex`, other models via Cursor CLI's `agent`. On first run the skill finds the installed CLIs and writes the configuration. You can define aliases with role prompts, such as a security reviewer.

Who it is for. Claude Code developers whose context fills up with review, refactoring and test tasks and who need to parallelize them across several models.

Good fit when

  • Before a release you need a security audit, a slow-query hunt and an accessibility check in parallel
  • The main session should stay light while workers read code and write tests
  • Different tasks need different models: Opus for security, Gemini for documentation
  • A worker may get stuck on a question and the answer has to reach it without a restart

Not a fit when

  • The task is small and fits one session: the overhead of a checklist and background processes will not pay off
  • Your main session is not Claude Code: Cursor and Codex work here as workers only
  • Background processes without confirmations are unacceptable: the default configuration turns permission prompts off
  • Tasks depend on each other through the same files: parallel workers can edit the same code, which conflicts without git worktrees

Example request

/dispatch use opus to review the auth module for vulnerabilities, work in a git worktree

Limitations

The repository was last changed in April 2026. Claude Code is the only dispatcher, and the other CLIs work as workers. The default configuration launches workers with `claude -p --dangerously-skip-permissions`, `codex exec --full-auto` and `agent -p --force`, that is, without confirmation prompts. You attach other models through installed CLIs, and usage is billed under their plans. Whether the skill works with another CLI depends on whether it accepts a prompt as an argument.

How to disable. Delete the `dispatch` folder from `.claude/skills/` or `.agents/skills/` and the `~/.dispatch/config.yaml` file. Updates run through `npx skills update`.

FAQ

How do I install Dispatch for all projects at once?

Run `npx skills add bassimeledath/dispatch -g`: the `-g` flag installs the skill at user level. Without it the skill lands in the current project only.

What does `/dispatch` with no arguments do?

It reads `~/.dispatch/config.yaml` into the dispatcher's context so later launches are faster and skip confirmation prompts. The author suggests doing it at session start.

How does a worker ask a question?

It writes the question to an exchange directory, a monitor notices the file and tells the dispatcher. You reply in the main session, the answer is relayed and the worker continues with the same context.

Can I use non-Anthropic models?

Yes, through worker CLIs: `codex` for GPT and Cursor CLI's `agent` for Gemini and others. If a named model is not in the configuration, the skill tries to discover and add it.

Where can I see how it works inside?

The `docs/` folder holds files on architecture, configuration, the exchange protocol and development. A flow diagram is in the description and in `docs/architecture.md`.

Discussion

No questions or reviews yet.

Skills

A skill that turns the main Claude Code session into a dispatcher: tasks go to background subagents and the chat never blocks.

SkillExtended access79Repository stars

A Claude Code skill that hands implementation-heavy work to Codex CLI while Claude keeps planning, review and acceptance.

PluginBroad access62Repository stars
Needs a VPN

The /codex-workflows skill: Claude Code writes a script, dozens of Codex agents run it, and the run shows on a map

SkillBroad access330Repository stars

One agent launches others in the background: Claude Code, Codex, Copilot CLI, Grok Build and Pi, with a model chosen per stage.

SkillBroad access119Repository stars

A personal ~/.claude for Claude Code: twelve subagents, review commands, worktree and goal skills and a Go status line.

WorkflowExtended access602Repository stars

A skill that makes Claude a manager: it writes tickets, hands code to cheaper agents, verifies and asks another vendor to review.

SkillBroad access63Repository stars

Comparison with similar tools

Cards that share the main search query, and how they differ.

ToolOfficialRepository starsMain difference
Dispatch (this card)no414
pi-subagentsno1,449an extension for the Pi agent, while Dispatch runs inside Claude Code
Codex Astra + Luna Orchestratorno1,748Codex profiles where one model supervises, while here Claude Code dispatches to models from different CLIs

README in short

The description opens with the problem of an overfilled context and a comparison with running without a dispatcher, then explains four ideas: a light session, a dispatcher that carries the load, workers that ask questions and no waiting. Installation, a large task example, configuration and an architecture diagram follow.

README badge

Original SKILL.md

---
name: dispatch
description: "Dispatch background AI worker agents to execute tasks via checklist-based plans. Use when the user says 'dispatch' to delegate work to background agents, e.g. 'dispatch sonnet to review this', 'dispatch opus to fix the bug', 'dispatch a worker to research X'."
license: MIT
version: "3.0.0"
last_updated: "2026-04-06"
user_invocable: true
---

# Dispatch

You are a **dispatcher**. Your job is to plan work as checklists, dispatch workers to execute them, track progress, and manage your config file.

## Routing

First, determine what the user is asking for:

- **Warm-up (no prompt)** — `/dispatch` with no task description, or just the word "dispatch" → Read `~/.dispatch/config.yaml`, confirm it loaded successfully (e.g., "Config loaded. What would you like me to dispatch?"), and **stop**. Do NOT ask for a task or proceed to planning.
- **Config request** — mentions "config", "add agent", "add ... to my config", "change model", "set default", "add alias", "create alias", etc. → **Modifying Config**
- **Task request** — anything else → **Step 0: Read Config**

**Never handle task requests inline.** The user invoked `/dispatch` to get non-blocking background execution. Always create a plan and spawn a worker, regardless of how simple the task appears. The overhead of dispatching is a few tool calls; the cost of doing work inline is blocking the user for the entire duration.

## Situation → Reference

| Situation | Read | Contains |
|-----------|------|----------|
| `~/.dispatch/config.yaml` doesn't exist | `references/first-run-setup.md` | CLI detection, model discovery, config generation |
| Config request (add model, change default, create alias) | `references/config-modification.md` | Adding/removing models, creating aliases, changing defaults |
| Need IPC file naming, atomic writes, or reconciliation details | `references/ipc-protocol.md` | File naming, atomic write pattern, sequence numbering, startup reconciliation |
| Worker fails to start or auth error | `references/proactive-recovery.md` | CLI checks, fallback model selection, config repair |
| Need config file format reference | `references/config-example.yaml` | Example config with backends, models, and aliases |

> **First-run?** If `~/.dispatch/config.yaml` doesn't exist, read `references/first-run-setup.md` for CLI detection, model discovery, and config generation, then continue with the original request. This is also the reference for model discovery when auto-adding unknown models in Step 0.

> **Config request?** To add/remove models, create aliases, or change the default, read `references/config-modification.md` for the full procedure, then stop — do NOT proceed to the dispatch steps below.

---

**Everything below is for TASK REQUESTS only (dispatching work to a worker agent).**

**CRITICAL RULE: When dispatching tasks, you NEVER do the actual work yourself. No reading project source, no editing code, no writing implementations. You ONLY: (1) write plan files, (2) spawn workers, (3) read plan files to check progress, (4) talk to the user.**

## Step 0: Read Config

Report a problem