# /dispatch: A Claude Code Skill That Fans Tasks Out to Background AI Workers

> /dispatch is a Claude Code skill that turns your main session into a lightweight orchestrator, sending each task to a background worker with its own full context window. Workers run in parallel, ask clarifying questions when blocked, and return results without filling the main session's context.

**bassimeledath/dispatch** — A Claude Code skill that 10x's your effective context window by dispatching tasks to background AI workers.

- Repository: https://github.com/bassimeledath/dispatch
- Stars: 410 · Forks: 20
- Language: Unknown
- License: not declared
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/bassimeledath-dispatch

## The Context Window Problem This Skill Solves

/dispatch addresses a specific failure mode in long Claude Code sessions: multiple large tasks accumulate in the main context window until Claude loses track of earlier work. By task three or four, the session becomes unreliable. By task five, starting a new session is the only option.

The README frames the contrast directly: without dispatch, a session that asks Claude to review code, refactor a module, write tests, and update documentation fills its context across those tasks. With dispatch, each task goes to a background worker with a fresh, full context window. The main session retains only a checklist of what was dispatched and the results as they arrive.

The README describes the role of the main session as a mediator rather than the thinker. This distinction is the core design decision of /dispatch: all the implementation work happens in workers.

## Installing and Setting Up the Skill

The skill is installed using the `npx skills` command:

```bash
npx skills add bassimeledath/dispatch -g
```

The `-g` flag installs at the user level and makes the skill available in all projects. To install at the project level instead:

```bash
npx skills add bassimeledath/dispatch
```

After installation, Claude Code makes `/dispatch` available as a slash command. On first run, the skill auto-detects which agent CLIs are installed (`claude`, `agent`, `codex`), discovers available models, and generates `~/.dispatch/config.yaml`. No manual configuration is required for a single-Claude setup.

The README recommends running `/dispatch` with no arguments at the start of each session to pre-load the config into the dispatcher's context, making subsequent dispatches faster.

## How a Dispatch Works from Command to Results

The basic invocation is a natural-language task description after the command:

```
/dispatch use sonnet to find better design patterns for the auth module
```

When you run this, the dispatcher creates a checklist plan. A background worker picks up the checklist in a fresh Claude Code session with its own full context window and checks off items as it completes them. Your main session is immediately free after dispatch.

If the worker gets stuck or needs information, it surfaces a clarifying question to you through the dispatcher:

```
Worker is asking: "requirements.txt doesn't exist. What feature should I implement?"
> Add a /health endpoint that returns JSON with uptime and version.

Answer sent. Worker is continuing.
```

The worker continues from where it stopped, with its full context intact, after you answer. The main session does not need to restart and does not lose its orchestration state.

## Multi-Worker Dispatch and Model Mixing

A single dispatch call can fan out to multiple workers. The README provides a pre-launch sweep example with five parallel subtasks: a security audit, a performance review, a frontend accessibility check, OpenAPI spec generation, and an error handling audit. Each gets its own worker and its own model:

```
/dispatch use opus to review this PR for edge cases
/dispatch use gemini to refactor the config parser
```

The README notes that if multiple model names appear in one prompt, the last one mentioned is used. If no model is specified, the dispatcher confirms your default before proceeding.

The `config.yaml` file holds three sections: `backends` (CLI commands for each provider such as claude, cursor, codex), `models` (mapping model names to backends), and `aliases` (named shortcuts that bundle a model with a role prompt). An alias example from the README uses `opus` with a security-focused system prompt, so `/dispatch security-reviewer check the auth flow` runs that alias without repeating the prompt.

## Worktrees and Isolated Worker Contexts

Workers can run in git worktrees for tasks that modify files. The README shows `use sonnet in a worktree` as a suffix to the task description. A worktree-backed worker gets an isolated checkout of the repository, so its file changes do not affect the main working tree or other workers.

This matters for tasks like refactoring a module or applying a security fix: the worker can commit changes in the worktree, and you can review or discard them independently of other running workers. The README uses this pattern in the pre-launch sweep example for security and performance audits that need to touch files.

Workers that do not need file writes, such as generating documentation or reviewing code for issues, run without a worktree and access the repository through the standard Claude Code file tools.

## Limitations and Prerequisites

/dispatch requires Claude Code as the host session. It is a Claude Code skill and does not work in other CLIs. The README states that Cursor and Codex work as workers only, not as hosts.

The skill coordinates workers through the main session's context. A very long main session with many dispatched tasks will eventually accumulate orchestration state in the main context, though more slowly than a session that does all the work inline. There is no documented mechanism for the main session to offload its own orchestration history.

Automatic model discovery requires the CLI tools for each backend to be installed and on PATH. If a model is referenced by name and the corresponding CLI is not found, the skill auto-discovers and adds it to config, but this requires the CLI to be available. For multi-model workflows mixing Claude, Codex, and Cursor, all three CLIs must be installed.

The last push to the repository was on 2026-04-06, which is approximately six months before this review. The repository is not archived. There is no license file in the repository. The skill directory is in `.claude/` and `skills/` at the repository root.

## Conclusion

/dispatch is worth installing if you regularly run Claude Code sessions that bog down because multiple large tasks fill the context window before all of them complete. The skill works best for teams that can enumerate several independent subtasks at once. It is not useful if your tasks are tightly sequential and each depends on the previous output, since the overhead of spawning workers and waiting for results adds latency compared to a single linear session. Before using it in a new project, run `/dispatch` with no arguments to pre-load `~/.dispatch/config.yaml` into the dispatcher's context, which makes subsequent dispatches faster and skips confirmation prompts.

## FAQ

### How do I use /dispatch with Claude Code?

Install the skill with `npx skills add bassimeledath/dispatch -g`, then run `/dispatch` followed by a task description in a Claude Code session. The dispatcher creates a plan and sends it to a background worker with a fresh context window. Your main session stays free immediately.

### How do I install /dispatch for Claude Code?

Run `npx skills add bassimeledath/dispatch -g` for a user-level install available in all projects, or omit `-g` for a project-level install. On first use, /dispatch auto-detects your installed CLIs and generates `~/.dispatch/config.yaml`.

### Can /dispatch workers ask questions back to the main session?

Yes. When a worker needs clarification, it surfaces a question through the dispatcher in your main session. You answer it there, and the worker continues from where it stopped without losing its context. No restart is needed in either the worker or the main session.

## Sources

- [bassimeledath/dispatch on GitHub](https://github.com/bassimeledath/dispatch)
- [Issues](https://github.com/bassimeledath/dispatch/issues)
- [README](https://github.com/bassimeledath/dispatch/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/bassimeledath-dispatch