Documentation

Getting Started

Installation

Download Dispatch from withdispatch.dev/download for macOS or Linux. The desktop app ships as a native binary with an embedded server, so there is nothing else to install. On first launch, Dispatch sets up its data directory and is ready to use within seconds.

Dispatch is also available through package managers. Check the download page for the latest version and installation instructions for your platform. Updates are delivered automatically when enabled, or you can check for updates manually in Settings.

After installation, Dispatch creates a data directory at ~/.dispatch/ where it stores your database, configuration, and cached data. This directory is portable and can be backed up or moved between machines.

Prerequisites

Dispatch orchestrates AI coding agents. You need at least one agent CLI installed on your machine before you can start dispatching work. Each agent authenticates independently using its own credentials.

All three agents are recommended, but only one is required. The default pipeline is designed around their distinct strengths — Claude writes specs and implements, Codex reviews and critiques, Gemini handles multimodal frontend work. With all three installed Dispatch can assign each pipeline stage to its strongest agent and route around rate limits.

Install instructions live on each CLI's project page — that's the canonical source as install methods evolve. After installing any CLI, Dispatch detects it automatically on next launch.

Dispatch auto-detects CLIs from 40+ installation paths including npm, Bun, Volta, nvm, fnm, asdf, mise, Homebrew, Nix, Snap, Flatpak, Cargo, pipx, and more. If your agent CLI is installed in a non-standard location, you can register it manually in Settings under Agent Connections.

If you only install one, Dispatch will route every stage through that agent — it still works, but you lose the writer/reviewer split and the multimodal frontend advantage. Adding the others later is non-destructive: profiles automatically pick them up the next time you open Settings.

First Launch

When you open Dispatch for the first time, the setup wizard walks you through the initial configuration. You will choose your language, set your display name, and connect your accounts. Dispatch then scans for installed agent CLIs and displays their version and authentication status.

1. Open Dispatch
2. Choose your preferred language (20 languages supported)
3. Set your display name
4. Optionally sign in to Dispatch Pro for cloud model access
5. Review detected agent connections
6. Take the interactive feature tour

Setup Wizard

The setup wizard appears on first launch and guides you through connecting agents, adding projects, and choosing a plan. Each step validates your configuration before moving forward. You can re-run the wizard at any time from Settings to reconfigure agents or add new project directories.

The wizard auto-detects all installed agent CLIs and displays their version and authentication status. If an agent is installed but not authenticated, the wizard provides the exact command to run in your terminal to complete the login. The wizard also lets you set your preferred language from 20 supported locales.

The wizard steps are:

1. Language: Choose from 20 supported interface languages
2. Welcome: Overview of what Dispatch does and how it works
3. Name: Set your display name for the application
4. Sign In: Optionally connect your Dispatch Pro account
5. Plan: Choose between Free and Pro tiers
6. Agents: Review detected CLIs and their status
7. Tour: Interactive walkthrough of the main views and features

Adding Projects

Dispatch works with any directory on your machine. To add a project, use the Quick Launch dialog (Cmd+N) or go to Settings and add a project path. Dispatch scans the directory for its language, framework, and existing agent configuration files (CLAUDE.md, GEMINI.md, AGENTS.md) to tailor how agents work within that project.

You can manage multiple projects simultaneously. Each project maintains its own goal history, agent context, pipeline configuration, and learned corrections. Projects added via remote SSH hosts are also supported for distributed development workflows. Switch between projects from the Dashboard or the Command Palette.

From the CLI, register projects with:

dispatch projects add myapp /path/to/project
dispatch projects list
dispatch projects remove myapp

Each project directory is scanned for its technology stack on first use. Dispatch detects the primary language, framework, test runner, build system, and any existing agent instruction files. This information is used to configure agent prompts and environment context for every task in that project.

Core Concepts

The Director Model: IOE vs. IDE

Dispatch is an Integrated Overview Environment (IOE), not an IDE. While an IDE is built for writing code line by line, an IOE is built for directing multiple AI agents working in parallel. You describe what you want, review what they produce, and steer them when they drift off course.

The shift is from Writer to Director. Instead of typing code yourself, you define goals in natural language, review generated specifications, approve or reject completed work, and provide feedback that agents learn from. Dispatch handles the context handoff between agents, manages compaction and resumption, and enforces quality gates before any code reaches your main branch.

• Describe what you want: Write goals in plain language
• Review and approve specs: Verify the plan before implementation begins
• Steer agents mid-task: Inject corrections if an agent goes off track
• Review completed work: Full diff review with security and quality analysis before merge

Missions

Missions are the fastest way to get something done. Press Cmd+M (or Cmd+N) to open the Quick Launch dialog, type a task in natural language, and Dispatch sends it directly to an agent. Missions bypass the full spec/review pipeline, making them ideal for quick fixes, research questions, or exploratory coding.

Each mission runs in its own isolated context. You can view mission history, see token usage, and review results from the Dashboard or the Activity view. Missions support all installed agents, including Claude, Codex, Gemini, and any custom agent you have registered. For more structured work that requires planning and review, use Goals instead.

Mission examples:

• "Fix the TypeScript error in auth.ts": Quick bug fix sent to the best available agent
• "Research best practices for JWT refresh tokens": Research task with output you can review
• "Add input validation to the signup form": Small feature addition
• "Explain what this function does": Code comprehension with agent analysis

From the CLI, missions are equally straightforward:

dispatch mission "Add error handling to the API routes"
dispatch mission list
dispatch mission "Refactor the database layer" --adapter claude

Goals and the Pipeline

Goals are the primary unit of work in Dispatch. When you create a goal, Dispatch breaks it down into a structured pipeline that flows through multiple stages. Each stage has a dedicated agent, quality gates, and review checkpoints to ensure the work meets your standards before it reaches your codebase.

The pipeline stages are:

1. Spec: A functional specification generated from your goal description
2. Test Spec: Test requirements the implementation must satisfy
3. Security Spec: Security rules mapped to your project's needs
4. Implement: The agent writes the code
5. Frontend: A separate agent builds the UI (if applicable)
6. Verify: Automated bug, security, and performance checks
7. Review: Human-in-the-loop approval
8. Audit: Post-build security and quality assessment
9. Merge: Git merge to your target branch

Reverse Spec

Reverse Spec lets you import an existing codebase into Dispatch and generate a functional specification retroactively. Instead of starting from a blank slate, Dispatch analyzes what has already been built and produces a structured spec that describes the current state of the project.

Use Reverse Spec when adopting Dispatch on a project that already has code. Dispatch scans the project structure, reads key files (entry points, configuration, routes, models), and generates a specification covering the major modules, data flows, and dependencies it finds. The result becomes your baseline spec, giving Dispatch the context it needs to manage future changes accurately.

The generated spec is editable. You can refine descriptions, correct assumptions, or add details that static analysis cannot infer. Once saved, it serves as the reference point for all subsequent goals and pipeline runs on that project.

Reverse Spec is accessible from the project dashboard whenever a project has no existing spec. You can also trigger it manually from the command palette.

Plans

Plans provide a higher-level view of multi-step work. When a goal is too large for a single agent pass, Dispatch can decompose it into a sequenced plan with ordered steps, dependencies, and resource assignments. Plans are visible in the Plans view and link back to the goals and tasks that implement each step.

You can create plans manually or let Dispatch generate them from a research paper, a long feature description, or a complex refactoring request. Each plan step becomes a trackable unit with its own status, assigned agent, and review checkpoint. Plans help you maintain oversight of large projects that span multiple goals.

A plan consists of ordered steps, each with:

• Title and description: What this step accomplishes
• Dependencies: Which other steps must complete first
• Assigned agent: Which agent will execute this step
• Status tracking: Pending, in progress, completed, or blocked
• Linked goal: The goal this step contributes to

Human-in-the-Loop Review

Every piece of agent-produced work passes through Dispatch's review system before it reaches your codebase. The review workspace shows the full diff, security scan results, blast radius annotations, quality gate summary, and token usage. You can approve, request changes with inline comments, or reassign to a different agent.

Dispatch classifies every task into one of three review tiers based on risk:

• Auto: Low-risk, easily reversible changes (lint fixes, documentation updates). Auto-approved with no human intervention required.
• Notify: Medium-risk work. Proceeds automatically, but you receive a notification and can review after the fact.
• Block: High blast radius, irreversible, or cross-boundary changes. The agent stops and waits for your explicit approval in a full-screen review modal.

When you request changes, your feedback is injected directly into the agent's next attempt as context. The agent sees exactly what you said and why, leading to more accurate corrections on subsequent runs. Multiple pending reviews queue serially, and the review modal shows how many more are waiting.

The review workspace consolidates everything you need to make a decision. Agent output flows through the diff view, blast radius analysis, and security scan before reaching you for a final verdict.

Auto Model Selection

When Auto Model is enabled (the default), Dispatch automatically chooses the best agent and model for each task based on the task's domain, complexity, and your pipeline profile. Simple formatting fixes might go to a fast model, while complex architectural changes are routed to the most capable one available.

If an agent fails or hits a rate limit, Dispatch can automatically escalate to a more powerful model or fall back to a different adapter entirely. This keeps your pipeline moving even when individual providers experience downtime or throttling. You can see which model was selected for each task in the review modal and the Observatory.

The auto model system considers several factors when making routing decisions:

• Task domain: Backend, frontend, testing, security, or infrastructure
• Complexity estimate: Based on the scope of changes required
• Historical performance: How each agent has performed on similar tasks
• Current availability: Rate limit status and agent health
• Cost profile: Token efficiency for the expected task size

You can disable Auto Model at any time in Settings and manually assign agents to each pipeline stage through Pipeline Profiles.

Auto Model for Goals

Goals have their own Auto Model toggle in the Goal Composer (enabled by default). When enabled, implementation and frontend tasks in the pipeline are routed per-task based on the task content, not the single adapter assigned in your pipeline profile. So if your goal decomposes into a database migration, a React component, and an API endpoint, each task can go to the best-suited agent even though they share a profile.

Spec, test spec, security spec, review, and verify stages always use the agents assigned in the pipeline profile. These stages benefit from consistency, so they are not auto-routed. This gives you a predictable spec and review experience while letting implementation tasks flow to the best-equipped agent.

When Auto Model is disabled for a goal, every task uses the exact adapters defined in the pipeline profile. Use this when you want deterministic routing, for example in CI or automated workflows.

Autonomy: Autopilot & Unsafe CLI Mode

Dispatch defaults to a conservative posture: low-risk changes auto-approve, everything else surfaces a review, and destructive or high-impact changes always require explicit human approval. Two Settings toggles let you trade review time for speed when you trust the work.

Autopilot

Autopilot (Settings > Autonomy) expands what Dispatch will auto-approve on your behalf. Off, only trivial changes like lint fixes and small reversible edits auto-approve. On, more substantial-but-contained changes such as refactors and test additions also auto-approve, while Dispatch keeps surfacing them in the Activity log so you can review after the fact.

Autopilot never auto-approves a destructive, cross-boundary, or otherwise high-impact change. Anything Dispatch cannot verify stays behind an explicit approval gate. This is a hard stop and cannot be turned off in Settings.

Unsafe CLI Mode

Unsafe CLI Mode is a second, independent toggle. When enabled, Dispatch starts each CLI agent with its own permission-skip flag so the tool never pauses to ask before running a shell command or editing a file. Claude Code runs with --dangerously-skip-permissions, Gemini CLI with --yolo, and Codex with its never-ask approval policy.

Use this when you are working inside a sandboxed worktree and want an agent to move at full speed. Dispatch still isolates writes to the worktree, so even with CLI prompts disabled, changes cannot leak outside the per-task sandbox. Pair this with Autopilot for the most autonomous experience, but understand that you are trusting the agent inside its sandbox — review the sandbox diff before merging.

Observability

Both toggles surface in the Observatory's Activity & Permissions tab. When Autopilot or Unsafe CLI is on, the top of the tab shows a colored banner so you always know the current posture. The tab also lists recent tool calls, audit events, and any out-of-scope or destructive matches so you can audit what happened while the agents were running unattended.

Sandbox and Workspace Isolation

Every agent task runs in its own isolated workspace. Dispatch creates a separate git worktree for each task so that agents cannot interfere with your working directory or with each other. When a task completes and passes review, its changes are merged cleanly into your target branch.

The sandbox system enforces write boundaries, preventing agents from modifying files outside their assigned scope. If an agent attempts to write to a restricted path, the operation is blocked and logged in the Security view. You can manage active workspaces from the Command Palette (Cmd+K, then "Manage Workspaces") to apply or discard pending changes.

Configure workspace isolation settings in Settings under Workspace Isolation. Choose between git worktree isolation (the default and recommended option) or container-based sandboxing for environments that require stronger isolation guarantees.

Worktree Isolation

Dispatch uses git worktrees to give each agent task a completely separate copy of your project. This means three agents can work on three different features simultaneously without merge conflicts or interference. Each worktree has its own branch, its own file state, and its own agent context.

When a task completes and passes all quality gates, Dispatch merges the worktree's branch into your target branch. If the task is rejected, the worktree is discarded cleanly with no leftover branches. You never have to manually manage these branches. Dispatch handles the full lifecycle from creation through merge or cleanup.

Worktree lifecycle:

1. Creation: Dispatch creates a new branch and worktree when a task is dispatched
2. Execution: The agent works in its isolated worktree
3. Verification: Changes are verified within the worktree
4. Review: You review the diff between the worktree branch and the target branch
5. Merge or discard: Approved work is merged; rejected work is discarded
6. Cleanup: The worktree directory and branch are removed

Features

Multi-Adapter Orchestration

Dispatch natively supports Claude Code, Codex, and Gemini CLI as first-class agents. Each adapter handles authentication, streaming output, session management, and compaction recovery for its respective platform. You can run all three simultaneously, with each agent assigned to the pipeline stage where it performs best.

Beyond the built-in adapters, you can register any command-line tool as a custom agent in Settings. Custom agents participate in the same pipeline, review flow, and quality gates as built-in ones. Dispatch also supports cloud-hosted models through Dispatch Pro, giving you access to additional models without local CLI installation.

Each built-in adapter provides full lifecycle management: process spawning, output streaming, session tracking, token counting, compaction detection, and graceful shutdown. When an agent is stopped (either by you or by the pool manager), Dispatch sends a clean termination signal and waits for the process to exit before cleaning up.

GitHub Integration

Connect your GitHub account in Settings to enable automatic pull request creation, branch management, and repository syncing. When a goal completes and passes review, Dispatch can create a PR on your behalf with a structured description that includes the goal summary, spec details, and verification results.

GitHub integration also enables collaborative workflows. Team members can review Dispatch-created PRs through GitHub's normal review interface, and status updates flow back into Dispatch's dashboard. You configure which repositories Dispatch has access to, and all operations use your personal access token with the permissions you choose.

Supported GitHub operations:

• PR creation: Automatic pull requests with structured descriptions on goal completion
• Branch management: Create, track, and clean up feature branches
• Repository syncing: Keep Dispatch's project state in sync with remote changes
• Status integration: View PR review status and CI results within Dispatch

Configure GitHub access from Settings or the CLI:

dispatch config show                    # View current GitHub configuration
dispatch github status                  # Check connection and permissions

Adversarial Verification

Dispatch runs automated verification on every completed task before it reaches human review. The verify stage checks for bugs, security vulnerabilities, performance regressions, and adherence to the original spec. When dual-agent verification is enabled, a second agent independently reviews the first agent's work, catching issues that a single pass might miss.

Verification results are displayed in the review workspace alongside the diff, so you can see exactly which checks passed, which generated warnings, and whether any blocking issues were found. Secret detection scans every changeset for accidentally committed credentials, API keys, and tokens before the code can be approved.

The verification pipeline includes:

• Spec adherence: Does the implementation match the specification?
• Security scan: Secret detection, vulnerability patterns, and unsafe operations
• Scope check: Did the agent stay within its assigned boundaries?
• Quality gates: Code quality signals and common error patterns
• Dual-agent review: Optional second opinion from a different agent

Enable dual-agent verification in Settings under Pipeline Automation. When enabled, the verify stage runs two independent agents, and both must pass before the task proceeds to human review.

Managed and Custom Agents

Beyond the three built-in agents, Dispatch lets you register any CLI tool as a custom agent adapter. If you have a specialized code generator, a linter that produces structured output, or a proprietary AI tool, you can integrate it into Dispatch's pipeline. Custom agents receive the same context injection, sandbox isolation, and review treatment as built-in ones.

Each custom agent is configured with a command template, output format, and capability tags. Dispatch uses capability tags to determine which pipeline stages a custom agent is eligible for, so your specialized tools only get assigned to tasks they can handle.

Available capability tags:

Register custom agents in Settings under Custom Agents, or configure them from the Command Palette (Cmd+K, then "Settings: Custom Agents").

Predictive Routing

Dispatch learns from the outcomes of previous agent runs to make better routing decisions over time. When a particular agent consistently produces high-quality results for a specific type of task, Dispatch will prefer that agent for similar future tasks. Conversely, if an agent struggles with a certain domain, Dispatch routes those tasks elsewhere.

Predictive routing works alongside your pipeline profiles. Your profile sets the default assignments, and the routing system fine-tunes within those boundaries based on observed outcomes. You can view routing decisions and their reasoning in the Observatory's insights panel, and override any individual routing decision at the task level.

Routing signals that Dispatch tracks:

• First-pass approval rate: How often each agent's work is approved without changes
• Domain performance: Agent effectiveness by task domain (backend, frontend, testing)
• Token efficiency: Cost-effectiveness relative to output quality
• Retry frequency: How often tasks need to be re-run after corrections
• Verify pass rate: How often each agent's work passes automated verification

View routing data from the CLI:

dispatch routing show                   # View current routing weights and signals

Cloud Tool Execution

With Dispatch Pro, agents can execute cloud-hosted tools for tasks that benefit from additional compute. This includes running large test suites, performing analysis that would be slow locally, or accessing models not available as local CLIs. Cloud tools integrate seamlessly with the local pipeline, and results flow back into the same review and verification process.

All cloud execution is opt-in and clearly labeled. You can see when a task used cloud resources in the Observatory and review modal. Token usage and cost estimates for cloud runs are tracked separately so you always know what you are spending. Cloud execution does not replace local agents. It supplements them for specific tasks.

Cloud tool execution is transparent in the UI. When a task uses cloud resources, the agent card and review workspace display a cloud indicator. The Observatory's economics panel shows cloud vs. local cost breakdowns so you can optimize your spending across both execution environments.

Performance Corrections

Dispatch monitors agent performance across runs and generates correction signals when patterns of failure emerge. If an agent repeatedly makes the same type of mistake (such as missing error handling or inconsistent naming), Dispatch injects targeted guidance into future prompts to prevent recurrence. These corrections accumulate into a project-specific memory that improves results over time.

You can view the correction history in the Performance view, which shows which corrections have been applied, their measured effectiveness, and how agent quality has trended across runs. Corrections are always transparent. You can see exactly what guidance was injected and why, and disable any individual correction if it is no longer relevant.

The performance correction lifecycle:

1. Detection: Dispatch identifies a pattern of similar failures or rejections
2. Correction creation: A targeted correction is generated from the rejection feedback
3. Injection: The correction is included in future prompts for similar tasks
4. Effectiveness tracking: Dispatch measures whether the correction actually reduces failures
5. Refinement: Ineffective corrections are flagged for your review

Corrections are project-specific. A correction learned in one project does not affect another unless you are using team memory sharing. You can view, edit, and disable corrections from the Performance view or from Settings.

Remote SSH Execution

Dispatch can execute agent tasks on remote machines over SSH. Add remote hosts in Settings with their connection details (hostname, port, user, identity file), and Dispatch will probe each host for available agent CLIs and system capabilities. Once connected, you can run tasks on the remote machine's hardware while monitoring and reviewing everything locally.

Remote execution is useful when your project requires specific hardware (GPU servers, high-memory machines), when you want agents to run on a dedicated build server, or when collaborating across machines. Host key verification ensures secure connections, and all remote operations are audited. You can browse remote project directories and add them just like local projects.

Remote host configuration includes:

After adding a host, Dispatch probes it to detect available agents, OS version, and system resources. The host status is displayed in Settings and updated periodically. You can browse remote project directories and add them from the project browser within the host settings panel.

Paper Import

Import research papers from arXiv URLs, uploaded PDFs, or pasted abstracts directly into Dispatch. The paper import system extracts key contributions, generates implementation plans, and can automatically create goals to implement the paper's ideas in your codebase. Each imported paper tracks its status from analysis through implementation.

Imported papers are tracked in the Papers library with their analysis status, key contributions, linked goals, and implementation progress. This is designed for teams that implement academic research, turning papers into working code through Dispatch's standard goal pipeline. The Command Palette (Cmd+K) provides quick access to import new papers.

Paper import workflow:

1. Import: Paste an arXiv URL, upload a PDF, or paste an abstract
2. Analysis: Dispatch extracts the title, authors, abstract, and key contributions
3. Plan generation: An implementation plan is created with ordered steps
4. Goal creation: Optionally create goals from the implementation plan
5. Implementation: Goals flow through the standard pipeline
6. Tracking: Monitor progress from the Papers library

Paper statuses: pending, analyzing, analyzed, planned, implementing, done, or archived. Each paper links to its generated plan and any goals created from it.

Environment Bootstrap

When Dispatch first encounters a project, it scans the directory to understand the language, framework, package manager, and build system in use. This environment scan informs how agents interact with the project, choosing the right test commands, build steps, and code style conventions automatically.

The environment scan runs automatically when you add a project and can be triggered again from Settings. Results are cached for performance and refreshed when the project structure changes significantly. Agents receive environment context at the start of every run so they understand the full technical landscape of the project they are working in.

The environment scan detects:

• Primary language: TypeScript, Python, Rust, Go, Java, and many more
• Framework: React, Next.js, Django, Rails, Express, FastAPI, etc.
• Package manager: npm, yarn, pnpm, pip, cargo, go modules, etc.
• Build system: Vite, Webpack, esbuild, Makefile, etc.
• Test runner: Jest, Vitest, pytest, cargo test, go test, etc.
• Existing agent configs: CLAUDE.md, GEMINI.md, AGENTS.md
• Git configuration: Remote URLs, branch structure, worktree compatibility

Decision Tracking

Every decision an agent makes during a task is recorded in a structured decision trail. This includes which files were modified, what alternatives were considered, and why specific approaches were chosen. The complete decision history is browsable in the Vault view, organized by task, goal, or file path.

Decision tracking powers the Lore system, a per-file history of constraints, rejections, and prior decisions. When an agent works on a file, Dispatch can surface relevant past decisions so the agent does not repeat mistakes or contradict earlier architectural choices. This institutional memory grows with every completed task, making your entire team's knowledge available to every agent.

Each decision record includes:

• Files affected: Which files were created, modified, or deleted
• Reasoning: The agent's explanation for its approach
• Alternatives considered: Other approaches the agent evaluated
• Constraints applied: Rules from past rejections or corrections that influenced the decision
• Review outcome: Whether the work was approved, rejected, or modified
• Correction feedback: Any comments you provided during review

The Lore Decision Query in the Vault lets you search by file path to see the complete decision history for any file. This is especially powerful for files that have been modified by multiple agents across many goals, giving you a full audit trail of every change and the reasoning behind it.

Token Efficiency

Dispatch actively monitors token usage across all agent runs and provides tools to optimize spending. The Observatory shows per-adapter token usage, per-task costs, retry overhead, and identifies the most expensive runs. You can set per-task token budgets in Settings to prevent runaway consumption.

The context management system detects when an agent's context window is getting large and handles compaction intelligently. When an agent's context is compacted by its platform, Dispatch captures a snapshot of the current state and injects a resumption prompt that preserves the critical context. This prevents the quality degradation that typically follows context compaction, keeping agents effective across long-running tasks.

Token efficiency features:

• Per-task budgets: Set maximum token limits per task to control spending (0 for unlimited)
• Compaction recovery: Automatic context preservation when agent platforms compact their context
• Resumption prompts: Injected on resume to restore critical context after compaction
• Cost tracking: Per-adapter, per-task, and per-goal cost breakdowns in the Observatory
• Overhead analysis: Visibility into retry and compaction token overhead
• Most expensive runs: Quick identification of high-cost tasks for optimization

In-App Preview

For frontend tasks, Dispatch can launch an in-app preview of the agent's work so you can see visual changes before approving them. The preview runs the project's dev server and displays the result alongside the code diff in the review workspace, giving you a complete picture of what changed both visually and in the code.

Previews are managed automatically. Dispatch starts the preview server when you open a review and cleans it up when you close it. This works with any framework that has a dev server command, including React, Vue, Svelte, Next.js, and others. Preview settings are configured per-project in Settings.

The preview system supports:

• Auto-detection: Dispatch identifies the dev server command from your project configuration
• Side-by-side view: See the visual result next to the code diff
• Hot reload: Preview updates as you review changes
• Cleanup: Server processes are stopped when you close the review

Team Features

Dispatch supports team workflows where multiple developers share a project's agent history and learned corrections. Team memory aggregates insights from all team members, so corrections discovered by one developer benefit everyone on the team. Shared review queues allow team-based assignment and status tracking.

Team features require Dispatch Pro. Each team member runs Dispatch locally but shares a project-level memory layer. All personal data stays on your machine. Only project-level learnings, correction histories, and review status are shared across the team. This gives you the benefits of collective intelligence without compromising individual privacy.

Team capabilities include:

• Shared corrections: Corrections learned by one team member apply to everyone's agent runs
• Team review queue: Shared review queue with assignment and status tracking
• Aggregated insights: Observatory metrics that span all team members' activity
• Memory consolidation: Periodic reports that summarize learnings across the team

Agent Swarm

For large goals that can be parallelized, Dispatch's Swarm mode splits the work across multiple agents running simultaneously. A single goal is decomposed into independent tasks, each assigned to a separate agent working in its own isolated worktree. All agents work in parallel, and results are merged together after verification.

Swarm mode is especially effective for goals that involve multiple independent files or components. Dispatch handles the coordination, conflict resolution, and merge verification automatically. You review the combined result as a single coherent changeset, regardless of how many agents contributed.

Trust and Consequences

Dispatch maintains a trust score for each agent based on its track record within your projects. Agents that consistently produce clean, approved work earn higher trust, which can reduce the review burden for their future tasks. Agents that produce rejected work or trigger security findings see their trust decrease, resulting in more stringent review requirements.

The consequences system enforces rules at the task level. If an agent violates a defined constraint, such as writing to protected files, exceeding scope, or ignoring security rules, consequences are applied automatically. These can range from adding extra verification steps to blocking future tasks until the issue is acknowledged.

All consequence actions are logged and visible in the Security view. Trust scores and consequence history help you understand which agents are most reliable for which types of work, informing both manual assignments and the predictive routing system.

Project Rules

Project Rules let you declare constraints specific to a project: which files are protected, which commands are blocked, what domains an agent is allowed to reach, and so on. Rules are evaluated every time an agent runs a tool or writes a file; a match surfaces a consequence according to the rule's severity.

Edit rules directly from the Security view in Dispatch — click Manage Rules in the Project Rules section. The editor lets you add, edit, and delete rules without leaving the app. Each rule has a name, a pattern, a category (file, command, network), and a consequence level. Rules live in your project so they travel with the codebase, and they take effect immediately for the next agent run.

Consequences Log

The Consequences Log is a chronological record of every rule evaluation and every consequence Dispatch applied. Each entry shows what triggered, which rule matched, which agent was involved, and what action Dispatch took. Use the log to tune rules: if you see too many false positives, adjust the pattern; if a real violation slipped through, add a tighter rule.

The log is searchable and filterable by agent, rule, severity, and time range. Entries are append-only within a project so you have a complete audit trail of agent behavior over time.

Natural Language CLI

The Dispatch CLI accepts natural language commands in addition to structured ones. Type dispatch "what's running right now" and Dispatch translates your question into the appropriate API call, returning a formatted answer. This makes the CLI accessible even if you do not remember the exact command syntax.

Natural language mode supports both queries ("show me pending reviews") and actions ("approve the auth task"). Read-only queries can be auto-executed with the --auto flag, while write operations always require confirmation before execution. Use --dry-run to see what command would be executed without running it.

Natural language examples:

The natural language parser is intentionally conservative. Write operations always show you what will happen and ask for confirmation. Use --auto only with read-only queries, and --dry-run to preview any command without executing it.

Views

Dashboard (Home)

The Dashboard is your home screen when you open Dispatch. It shows a project-level overview with active goals, recent agent activity, and quick action buttons. The Agent Status Strip at the top displays each connected agent's current state (idle, working, or errored) so you can see system health at a glance.

From the Dashboard you can launch a new mission (Cmd+M), create a goal (Cmd+N), or navigate to any project. The Dashboard adapts to your project count, showing a project picker for multi-project setups or diving straight into the active project if you only have one. Goal progress, pending reviews, and recent completions are all visible from this single screen.

Dashboard components include:

• Agent Status Strip: Real-time agent availability and current task assignments
• Active Goals: Goals in progress with pipeline stage indicators
• Recent Missions: Quick missions with their status and results
• Pending Reviews: Tasks waiting for your approval, with one-click access
• Quick Actions: Buttons for common operations like new goal, new mission, and settings
• Project Selector: Switch between registered projects

Floor (Cmd+1)

The Floor is a live monitoring view with horizontal swimlanes organized by pipeline stage (Spec, Implement, Frontend, Verify, Review). Each active agent task appears as a card in its corresponding lane, showing the agent identity, current status, token count, and elapsed time. Cards animate between lanes as tasks progress through the pipeline.

Click any card to open the Focus Panel, which shows detailed information including the agent's live output stream, reasoning steps, file changes, and intervention controls. From the Focus Panel you can send a correction to the agent, stop the task, or reassign it to a different agent. The Floor updates in real time via WebSocket, so you see changes the moment they happen.

Floor 3D Command Center (Cmd+2)

The Floor 3D view is an immersive command center rendered with Three.js. It displays your pipeline as a spatial environment where agents are represented as stations in a 3D workspace. HUD overlay panels show pipeline overview, agent activity, pool status, security findings, goal progress, and performance metrics in a cockpit-style layout.

Keyboard controls let you navigate the 3D space: WASD for camera movement, H to toggle the HUD, F for fullscreen, and number keys 1-8 to focus on specific pipeline stages. You can dispatch missions directly from the 3D view with M, and open reviews with R. This view is designed for extended monitoring sessions where you want a complete operational picture of all agent activity.

HUD panels in the 3D Command Center:

• Pipeline Overview: Stage-by-stage progress for all active goals
• Agent Activity: Live output from running agents with token counts
• Pool Status: Current utilization, queued tasks, capacity
• Security: Active findings and gate status
• Goal Progress: Completion percentage and stage breakdown
• Performance: Real-time metrics and quality signals
• Quick Actions: One-click mission dispatch and review access
• Command Input: Direct mission dispatch from within the 3D view

Agentflow / Pipeline (Cmd+3)

The Agentflow view displays your goals, specs, and tasks as a directed acyclic graph (DAG). Each node represents a pipeline artifact: goals at the top, specs in the middle, tasks at the bottom, with edges showing the dependency relationships between them. Click any node to see its details, status, assigned agent, and token usage.

This view is especially useful for understanding how a complex goal was decomposed into specs and tasks. Completed nodes are dimmed while active ones are highlighted, giving you a clear picture of where your pipeline stands. You can zoom and pan to navigate large graphs spanning multiple goals.

Node types in the Agentflow graph:

• Goal nodes: Top-level objectives with overall completion status
• Spec nodes: Functional, test, and security specifications with review status
• Task nodes: Individual implementation units with agent assignment and pipeline stage
• Verify nodes: Verification checkpoints with pass/warn/fail status

Task Board (Cmd+4)

The Task Board is a Kanban-style view that organizes all tasks into columns by status: Pending, In Progress, In Review, and Completed. Each task card shows the assigned agent, pipeline stage, token usage, and elapsed time. The board gives you a high-level view of workload distribution and bottlenecks across all active goals.

You can filter by goal, agent, status, or pipeline stage to focus on specific work. The Task Board is particularly useful when multiple goals are in flight and you want to see aggregate progress. Click any task card to jump to its review workspace or focus panel depending on its current status.

Vault (Cmd+5)

The Vault is Dispatch's decision archive. It stores the complete decision trail for every completed task, including which files were modified, what alternatives were considered, and why specific approaches were chosen. You can browse decisions by task, goal, or file path to understand the reasoning behind any change in your codebase.

The Lore Decision Query lets you search for all decisions and constraints that have been applied to a specific file. This is invaluable when working on heavily-modified files. You can see every past rejection, correction, and architectural decision, giving both agents and human reviewers the full historical context. Replay files and compaction snapshots are also stored here.

Vault contents include:

• Decision trails: Complete record of agent reasoning for each task
• Replay files: Structured replay data for reproducing agent sessions
• Compaction snapshots: Context snapshots taken before platform compaction
• Lore queries: Per-file constraint and decision history
• Correction records: Your review feedback linked to the decisions they corrected

Observatory (Cmd+6)

The Observatory (formerly "Ledger") is your metrics and analytics dashboard. It tracks token usage by adapter, estimated costs per task, pipeline velocity metrics, quality signals, and actionable insights. The economics panel shows cost per adapter, per-task token averages, overhead from retries and compaction, and mission-level spending.

The velocity panel tracks goal lead time, review turnaround, first-attempt completion rate, stage duration, and parallel utilization. Quality metrics include verify pass rate, first-pass approval rate, rejection rate by adapter, and scope deviation. Insights are generated automatically to help you optimize your pipeline, such as suggesting adapter changes for tasks with high rejection rates.

Observatory metrics panels:

Security

The Security view provides a centralized dashboard for all security-related findings across your projects. It aggregates results from secret detection, adversarial verification, and post-build security audits. Findings are categorized by severity (critical, high, medium, low) and can be acknowledged with a reason to prevent re-alerting on known issues.

The security gate status for each task is displayed alongside its history, showing whether verification passed, warned, or blocked the work. EDR (Endpoint Detection and Response) anomalies are also surfaced here, tracking unusual agent behavior like unexpected file access patterns, scope violations, or suspicious tool usage. Every security event is logged for audit purposes.

Security view sections:

• Summary: Aggregate finding counts by severity with overall gate status
• Active Findings: Unacknowledged findings requiring attention
• Task Breakdown: Per-task security status and finding counts
• History: Timeline of all security checks and their outcomes
• EDR Anomalies: Behavioral anomalies detected during agent execution
• Acknowledged: Previously reviewed findings with their acknowledgment reasons

From the CLI, access security information with:

dispatch security findings               # List all active security findings
dispatch security summary                 # View aggregate security status

Activity

The Activity view is a unified, chronological timeline of everything happening in Dispatch. It shows agent starts and stops, task status changes, review decisions, goal completions, mission results, and system events. Every entry is timestamped and linked to its relevant goal, task, or agent run for quick navigation.

The timeline is searchable and filterable by event type, agent, goal, or time range. This is your audit trail. If you need to understand what happened and when, the Activity view provides the complete record. It is especially useful for debugging pipeline issues, reviewing what occurred overnight, or tracing the history of a specific agent run.

Sessions

The Sessions view discovers and imports agent sessions running outside of Dispatch. If you have Claude Code, Codex, or Gemini CLI running in a terminal, Dispatch can detect those sessions and import their transcripts. This lets you bring ad-hoc agent work into Dispatch's tracking and review system retroactively.

You can view session transcripts, follow live sessions as they stream output, and retroactively associate sessions with goals or tasks. The Sessions view bridges the gap between Dispatch-managed work and the agent sessions you run manually in your terminal, giving you a unified view of all agent activity.

Learning Mode (Cmd+L)

Learning Mode is a side panel that shows agent decisions in real time. Activate it from the Command Palette (Cmd+K, then "Learning Mode") or press Cmd+L. While open, the panel streams a running commentary of what each active agent is doing: its reasoning, tool calls, file reads and writes, and the decisions it makes at each step.

Learning Mode is designed for developers who want to understand how agents work, not just what they produce. It surfaces the internal decision-making process that is normally hidden behind the final output. This is especially useful when onboarding to Dispatch, when debugging an agent that keeps making the same mistake, or when you want to learn how a specific agent approaches a type of problem.

The panel updates live as agents run. When no agents are active, it shows a summary of the most recent decisions. Learning Mode is a Dispatch Pro feature.

Learning Mode shows:

• Agent reasoning: The agent's internal thought process as it works through a task
• Tool calls: Every tool invocation with arguments and results
• File operations: Reads, writes, and edits with before/after context
• Decision points: Where the agent chose between alternatives and why
• Context usage: How much of the context window is consumed and what is being prioritized

Toggle Learning Mode on or off from Settings > Model Selection > Learning Mode. When enabled, agents produce explanations alongside their work.

Learning Reports

When Learning Mode is enabled, Dispatch generates a structured markdown report after every completed task. The report captures what the agent built, the approach taken, files changed, and key decisions. Reports accumulate over time so you can review what has been built across a project without re-reading transcripts.

Learning reports are written to .dispatch/learning-report.md in each project, which means you can follow along in any terminal:

tail -f .dispatch/learning-report.md

Each entry includes a timestamp, the agent that produced it, and the task context. Reports are also streamed in-app in real time as tasks complete, and are available via the Observatory for browsing historical entries. Reports stay local to your machine.

Dark Code Tracking

Dark code is agent-generated code that made it into the codebase without thorough human review. Dispatch tracks this automatically so you always know what portion of your code has been carefully checked and what has not.

A change is marked as dark when any of the following apply:

• The change was auto-approved based on low-risk criteria
• The reviewer was only notified, not required to block
• The review was approved in under 10 seconds (rubber-stamp detection)

When a file receives a thorough block-tier review, prior dark entries for that file are cleared. The dark code ratio reflects currently-unreviewed agent code, not historical churn.

View dark code metrics in the Observatory under the Dark Code tab:

• Overall ratio: percentage of agent-authored lines that are currently unreviewed, with color-coded thresholds
• Top dark files: files with the most unreviewed agent changes
• Per-adapter breakdown: which agents produce the most unreviewed code
• 30-day trend: how the ratio changes over time

Dark code tracking is available in all tiers. Pro users get the full dashboard with per-file and per-adapter breakdowns. Team admins additionally get configurable alert thresholds, a status bar warning when unreviewed code exceeds the threshold, and CSV export for compliance reporting.

Reflection

Reflection is a periodic background process that consolidates your project's memory. It reviews recent agent outcomes, detects patterns, generates insights, and prunes stale information. Free users get basic pruning (no LLM required). Pro users get full LLM-powered synthesis that generates reports with actionable recommendations.

Reflection runs automatically after every 10 completed tasks or 24 hours since the last reflect, whichever comes first. You can also trigger it manually from the Command Palette (Cmd+K, then "Reflect") or from the CLI:

dispatch reflect                        # Trigger memory consolidation now
dispatch reflect --report               # Show the latest reflect report

The five phases of reflection:

1. Scan: Review recent task outcomes and agent decisions
2. Gather: Collect patterns, corrections, and recurring decisions
3. Synthesize: Detect contradictions and generate new insights (Pro)
4. Consolidate: Merge related memories and remove duplicates
5. Prune: Remove stale or redundant entries

Reflect reports are viewable in the app via the Command Palette or in the CLI. Each report shows what was learned, what changed, and what patterns are emerging across your project.

Configuration

Settings Reference

Dispatch's Settings panel (Cmd+,) is organized into sections covering every configurable aspect of the application. Each section can also be accessed directly from the Command Palette (Cmd+K) by typing "Settings:" followed by the section name. Below is a summary of all settings areas.

Settings sections accessible from the Command Palette:

Agent Connections

View the status of all detected agent CLIs. Each agent shows its installed version, authentication status, and binary path. If an agent is missing or not authenticated, instructions are provided to resolve the issue. Dispatch scans for new agents on startup and when you open this section.

Custom Agents

Register any command-line tool as a Dispatch agent adapter. Configure the command template, output format, and capability tags that determine which pipeline stages the agent is eligible for. Custom agents appear alongside built-in ones in pipeline profiles and task assignment dropdowns.

Model Selection

The Model Selection settings control how Dispatch picks agents and models for each task:

• Auto Model: When enabled (default), Dispatch automatically selects the best AI model for each task based on intent, available adapters, and historical performance. When disabled, you manually choose the adapter and model for every mission and goal.
• Model Escalation: When a task fails verification or an agent errors out, automatically retry the task with a stronger model in the same adapter (for example, Haiku to Sonnet to Opus for Claude).
• Max auto-escalations: The maximum number of times a task can be automatically escalated before it requires manual intervention. Default is 2.
• Dual-Agent Verification: When enabled, a second agent adversarially verifies the output of the first agent before the task is marked complete. Catches subtle bugs at the cost of additional agent time. Recommended for production code paths.
• Rate limit behavior: When an agent hits a rate limit, Dispatch can automatically fall back to another available agent, wait for the limit to reset, or fall back to a specific configured agent.
• Agent Output Style: Concise (default) produces results without explanation. Verbose instructs agents to explain their reasoning and approach as they work.

Learning Mode

Toggle Learning Mode to have agents explain their reasoning, tool calls, and decisions as they work. When enabled, a structured markdown report is generated after each task and appended to .dispatch/learning-report.md in your project. See the full Learning Mode section below.

Workspace Isolation

Configure the sandbox engine and worktree settings. Git worktree isolation is the default, creating a separate branch and directory for each agent task. Manage active workspaces, view their status, and set cleanup policies for completed or rejected tasks.

Project Instructions

Edit the agent context files for each project directly within Dispatch. See the full Project Instructions section below for details on what to include, sync modes, and how agents consume these files.

Desktop Preferences

Configure desktop application behavior including window management, system tray settings (macOS), startup behavior, auto-update preferences, and notification preferences. Dispatch runs as a tray application on macOS by default. Notifications are off by default and can be enabled here.

Browser Access

Enable or disable network access for remote monitoring. When disabled (the default), Dispatch only accepts connections from the local machine. When enabled, you can access Dispatch from a browser on the same network, protected by password authentication that you set during initial configuration.

Server Mode

View server status, port, uptime, and mode. Configure TLS settings for production deployments where Dispatch serves multiple users. Server mode enables authenticated remote access with auto-provisioned certificates for your domain.

Internationalization

Dispatch supports 20 languages: English, Japanese, Spanish, French, German, Chinese, Korean, Portuguese, Russian, Italian, Dutch, Polish, Turkish, Arabic, Hindi, Thai, Vietnamese, Indonesian, Ukrainian, and Swedish. Change your language at any time in Settings or during the setup wizard.

Pipeline Profiles

Pipeline profiles define which agent handles which stage of the pipeline. The default profile assigns agents based on their observed strengths, but you can create custom profiles for different project types, team preferences, or cost optimization strategies.

Spec review loop. The writer drafts the spec, the reviewer critiques it, and the writer revises until the reviewer signs off (with a sensible upper bound to avoid runaway iteration). Today that's Claude (writer) ↔ Codex (reviewer). Both sides are configurable per profile.

Create multiple profiles for different scenarios. For example, a "speed" profile that uses the fastest model everywhere, a "quality" profile that uses the most capable models, or a "cost" profile that minimizes token usage. Per-task override is always available regardless of the active profile, so you can reassign any individual task to any agent.

Cloud Models (Dispatch Pro)

Pro and Team subscribers can assign hosted models to any pipeline stage in addition to local CLIs. The lineup spans large general-purpose models, dedicated reasoning models, and small fast models, so you can match the model to the stage's intent without leaving Dispatch.

When are cloud models used?

Cloud models are an opt-in addition to local CLIs, not a replacement. They run in three situations:

1. You select one explicitly — Mission bar dropdown, Pipeline Profile per-stage assignment, or a per-task override.
2. Auto-routing picks one — when "Auto Model" is enabled in Settings and the router decides a cloud model best fits the task's intent (e.g. a long-context spec task may pick the 1M-context Qwen 3 30B reasoning model).
3. Local-CLI fallback / rate-limit recovery — if a local adapter (Claude / Codex / Gemini) hits its provider rate limit and rate-limit fallback is enabled in Settings, Dispatch transparently retries the same task on a comparable cloud model so the run finishes instead of stalling. The original adapter is restored on the next task.

Free-tier users never contact cloud models — the cloud-fallback path requires an active Dispatch Pro or Team subscription.

Industry Templates

Industry templates inject domain-specific compliance rules into every agent prompt for a project. When enabled, agents automatically follow regulations and best practices relevant to your industry without manual prompt engineering.

Enable industry templates in Settings under Pipeline Profiles. Select one or more templates per project. Templates compose with each other, so a healthcare SaaS can enable both HIPAA and SOC 2 templates simultaneously. The rules are injected as system-level instructions that agents cannot override.

Project Instructions

Project instructions are per-project context files that live in your project's root directory. They tell agents about your codebase: its architecture, conventions, testing requirements, and any decisions that should guide their work. Every agent reads the relevant instruction file before starting a task, so the instructions act as persistent system context across all runs.

Instruction Files

Each agent CLI has its own instruction file format:

Dispatch only creates instruction files for agent CLIs that are actually installed on your machine. If you only have Claude Code and Gemini CLI installed, Dispatch will create CLAUDE.md and GEMINI.md but not AGENTS.md. Files are created when you add a project to Dispatch for the first time, and they are placed in the project root directory alongside your existing source code.

What to Include

Good project instructions typically cover:

• Project overview: what the project does, its core value proposition, and the technology stack
• Architecture: how the codebase is organized, key directories, and the relationship between modules
• Coding conventions: naming patterns, preferred libraries, style rules, and formatting expectations
• Testing requirements: what test framework to use, minimum coverage expectations, and how to run tests
• Architectural decisions: important choices that have already been made and should not be revisited (e.g., "we use Bun, not Node" or "all state is local-first")
• Forbidden patterns: things agents should never do in your project, such as using specific deprecated APIs or adding certain dependencies

Keep instructions concise and actionable. Agents perform best with clear, direct rules rather than long explanations. A good instruction file is typically 50 to 200 lines.

How Agents Use Them

Before every task, Dispatch injects the contents of the relevant instruction file as system-level context for the agent. The agent reads these instructions before it sees the task prompt, so the instructions shape its behavior from the very first line of output. This means you do not need to repeat project conventions in every goal or task description: agents already know them.

Instruction files also work outside of Dispatch. If you run an agent CLI directly from the terminal (e.g., claude or gemini), the agent will still read its instruction file from the project root. This makes instruction files a good place for context that should apply regardless of how the agent is invoked.

Sync Modes

Dispatch supports two sync modes for managing instruction files:

• Managed: Dispatch writes and maintains the instruction files. Edits you make in the Settings panel are saved directly to the files on disk. This is the default mode and works well for most projects.
• Passthrough: Dispatch reads the instruction files but does not write to them. Use this mode if you manage instruction files manually (e.g., they are checked into version control and edited alongside your code). Dispatch will still inject them as context, but the Settings editor becomes read-only.

Switch between modes in Settings under Project Instructions for each project.

Unified Instructions

When unified instructions are enabled, Dispatch keeps all instruction files in sync. Edits to any one file are propagated to the others, adjusted for each agent's format. This is useful when you want a single source of truth for project context without maintaining three separate files. Unified mode can be toggled per project in Settings.

Industry Templates

Industry templates can inject additional rules into your instruction files automatically. When you enable a template (e.g., HIPAA, SOC 2, PCI-DSS), the relevant compliance rules are appended to the instruction context for every agent run. See Industry Templates for the full list of available templates.

Agent Pool

The agent pool controls how many agents can run simultaneously. Configure the maximum concurrent runs across all goals and the maximum runs per individual goal. These limits prevent resource exhaustion and ensure your machine stays responsive while agents work in the background.

Pool settings are available in Settings under Agent Pool. Typical configurations range from 2-3 concurrent runs on a development laptop to 8-10 on a dedicated server. The pool is visible in the Floor 3D command center and the Observatory, showing current utilization, queued tasks, and historical usage patterns.

When the pool is full, new tasks are queued and dispatched in order as slots become available. The pool status is always visible in the Floor 3D HUD and the Status Rail at the bottom of the application window. From the CLI, check pool status with:

dispatch pool                           # View pool status and queued tasks

CLI Reference

The Dispatch CLI provides full control over your pipeline from the terminal. All commands are thin wrappers over the local HTTP API, so they work whether or not the desktop app is open. The CLI also supports natural language input for convenience.

The full list of CLI commands:

Getting Started

dispatch init                           # Initialize a project
dispatch start                          # Start the Dispatch server
dispatch status                         # Check server health and agents

Agent Management

dispatch agents                         # Show running agents
dispatch watch                          # Real-time agent activity dashboard
dispatch pool                           # View agent pool and concurrency
dispatch logs <run-id>                  # View agent run transcript
dispatch logs <run-id> --follow         # Stream live agent output

Sessions

dispatch session list                   # List recent agent sessions
dispatch session show <run-id>          # View session transcript
dispatch session follow <run-id>        # Stream live session output

Goals and Tasks

dispatch goals create "Build auth"      # Create a new goal
dispatch goals list                     # List all goals
dispatch tasks pending                  # List tasks awaiting review
dispatch diff <task-id>                 # Show task worktree diff

Missions

dispatch mission "Research JWT auth"    # Run a quick mission
dispatch mission list                   # List recent missions

Review and Approval

dispatch approve <task-id>              # Approve a pending task
dispatch reject <task-id> --reason "x"  # Reject with feedback

Configuration and Tokens

dispatch config show                    # View all settings
dispatch token create --name phone      # Create API token
dispatch token create --readonly        # Read-only token for monitoring
dispatch projects add myapp /path       # Register a project

Advanced Commands

dispatch swarm <goal-id>                # Run goal in swarm mode
dispatch verify <task-id>               # Manually trigger verification
dispatch routing show                   # View predictive routing data
dispatch security findings              # List security findings
dispatch reflect                        # Trigger memory consolidation

Natural Language

dispatch "what's running"               # NL status query
dispatch "approve everything pending"   # NL action (with confirmation)
dispatch "show cost breakdown" --auto   # Auto-execute read-only query
dispatch "stop the auth task" --dry-run # Preview without executing

Architecture

High-Level Overview

Dispatch runs as a desktop application with an embedded server. The server handles all agent orchestration, database management, and API routing. The client is a React application rendered inside a native window. Communication between client and server uses a local HTTP API for requests and WebSocket for real-time streaming of agent output.

The architecture is modular: agent adapters, context management, verification, replay recording, template resolution, and git operations are each implemented as independent packages. The server imports these packages, and the client communicates exclusively through the API layer. This separation means each component can be tested and evolved independently.

The core components are:

Local-First Design

All of your data lives on your machine. Dispatch stores goals, tasks, agent transcripts, decision trails, trust scores, corrections, and configuration in a local database. No data leaves your machine unless you explicitly enable remote features like browser access or Dispatch Pro cloud models.

This design means Dispatch works offline (with locally-authenticated agents), starts instantly, and does not depend on any external service to function. Your agent CLIs authenticate with their respective providers directly. Dispatch never sees or stores those credentials. The local-first approach also means there is no vendor lock-in: your data is always accessible and portable.

What stays local:

• Database: All goals, tasks, specs, runs, and transcripts
• Decision trails: Every agent decision and your review history
• Corrections: Learned corrections and performance memory
• Configuration: Pipeline profiles, pool settings, project paths
• Agent credentials: Dispatch never accesses agent authentication tokens

What can optionally leave your machine (only when you enable it):

• Browser access: UI served over local network (password-protected)
• Cloud models: Tasks sent to cloud-hosted models via Dispatch Pro
• Team memory: Project-level learnings shared across team (Pro only)
• Telemetry: Anonymous usage analytics (enabled by default, toggle in Settings). See /privacy for the full list of events collected.

CLI Access

The Dispatch CLI communicates with the local server over HTTP. Every operation available in the desktop UI is also available from the command line, including goal creation, task management, review, and configuration changes. The CLI supports structured commands, natural language queries, and a real-time watch mode for monitoring agent activity in your terminal.

For remote access, the CLI can connect to a Dispatch server running on another machine using API tokens. Create tokens with dispatch token create --name "my-phone" and use them to authenticate from remote machines, CI pipelines, or mobile devices. Tokens can be scoped as read-only for monitoring or full-access for management.

Token management commands:

dispatch token create --name laptop      # Full-access token
dispatch token create --name ci --readonly  # Read-only monitoring token
dispatch token list                      # List all active tokens
dispatch token revoke <token-id>         # Revoke a specific token

Each token has a unique name and can be individually revoked without affecting other tokens. Read-only tokens can access GET endpoints and WebSocket streams but cannot create goals, approve tasks, or modify configuration. This is ideal for monitoring dashboards or mobile notification setups.

Browser Access

When browser access is enabled in Settings, Dispatch serves its full UI over HTTP so you can monitor and control your agents from any browser on the same network. Browser access is disabled by default and requires setting a password when first enabled. All browser sessions are authenticated.

For production server deployments, Dispatch can run with TLS enabled, automatically provisioning certificates for your domain. This is intended for teams running Dispatch on a shared server where multiple developers connect remotely to monitor and review agent work.

Browser access configuration:

• Disabled (default): Dispatch only accepts connections from localhost. No network exposure.
• Enabled with password: Dispatch serves on the local network. Password required for all connections.
• Server mode with TLS: For production deployments. Auto-provisioned certificates, full authentication.

To enable browser access from the CLI:

dispatch start --server                  # Enable network access
dispatch start --server --domain example.com  # With TLS

Reference

Keyboard Shortcuts

Global Shortcuts

View Navigation

Floor 3D Command Center Controls