---
title: Coordinators
description: One agent you talk to, which hands the real work to threads and reports back.
---

A **coordinator** is an agent you talk to about a stream of work. It plans the work, hands each task to a **thread** (an ordinary agent session it starts and briefs), keeps track of them, and tells you what finished and what needs you. Because the threads do the heavy lifting, the coordinator stays free to talk while they work in parallel.

:::note
Ghostex 10.18 renamed Coordinators to Orchestrators, and a later release renamed them back. If you see "orchestrator" in an older version or in an old command, it's the same feature.
:::

## Start one

1. **Open the project's agent menu**

    Hover a project in the sidebar, open its agent menu (the arrow beside its agent button) and
    choose **New Coordinator…** at the top. The (i) next to it explains what a coordinator is for.

2. **Fill in the dialog**

    Give it a **Name** (it keeps this name in the sidebar) and pick the **Agent**, then its
    **Model** and **Effort** where the agent lets Ghostex choose them. A Claude coordinator starts
    on Opus 5.5, and the effort is **Low**, **Medium**, **High** or **XHigh** (High by default).
    Claude, Codex, Grok and Antigravity offer both Model and Effort; Cursor and ZCode offer Model
    only (Cursor's effort is part of its model). OpenCode lists every model your OpenCode has
    (search the list when it is long), with the chosen model's variants as its Effort. Its first
    row, **OpenCode's default**, keeps OpenCode's own setting. Ghostex sets the model right before
    the coordinator's first message. This is coming in the next release, and older remote
    computers refuse an OpenCode model, so pick **OpenCode's default** there. The phone's dialog and `ghostex coordinator create --model <m> --effort <e>` offer the same choices.

3. **Click Create, then write your first request**

    Its first message is a fixed line that loads the coordinator playbook. Tell it what you want in
    its chat, like you would any agent.

A coordinator can run on Claude, Codex, ZCode, Cursor, Grok, Copilot, Antigravity, Pi, OMP or OpenCode. You can also start one from the phone's agent menu.

**Already deep in a conversation?** Right-click the session and choose **Advanced > Make Coordinator**. It keeps its conversation and keeps running, gets the crown right away, and picks up the playbook once its current turn ends. You can give it a goal in the same dialog. Sessions it started earlier don't become its threads; ask it to adopt them.

## Threads

A thread is a normal agent session. You can open it, read it, and type in it like any other.

- **Where they show**: threads sit under their coordinator in the sidebar, which has a crown instead of an agent logo. Hover the crown to fold or unfold them. Threads that are working, waiting, or were active in the last two hours are listed; the rest wait behind an **N older threads** row.
- **The Workers pill**: above the coordinator's chat box, **Workers** opens a list of what's working right now. A thread blocked on a permission only you can grant gets an amber **Needs your approval** tag. **Show recent** and **N more** list the rest. Click a row to open that thread.

### Starting and following up

Just ask. The coordinator answers quick questions itself and starts a thread for anything that takes real work, named after the area it owns ("Accounts settings", "Sidebar drag and drop"). Say so if you want a particular agent, model or effort for a thread.

A follow-up in an area a thread already owns goes to that same thread, so it keeps its context. That works even after the thread was closed: the message resumes the same conversation.

### Reports

You never have to watch a thread. When it finishes a turn, Ghostex sends its final message to the coordinator. When it stops on a question, the coordinator is told what it asks. The coordinator checks the work, commits it when it's ready (it never pushes unless you ask), and tells you in a few lines what finished and what needs you.

Questions from threads come to you through the coordinator, so you only ever talk to one agent. A thread waiting on a **permission or approval** is the exception: approve it in that thread.

### Done, reopen and sleep

- When a thread's work is checked and committed, the coordinator marks it done, which closes its session and takes it out of the sidebar. It stays listed as done, with its conversation.
- Right-click a thread to **Mark Thread Done** yourself, or **Reopen Thread** to bring a done one back under its coordinator.
- Right-click the coordinator and choose **Sleep Inactive Threads** to put every idle thread to sleep. Threads that are working or waiting stay awake.

### Worktrees

By default threads work in the project folder, one after another when they need the same files. When parallel work matters, ask the coordinator to give a thread its **own worktree**: the thread then works on its own branch in its own folder. See [Git and worktrees](/workflows/git).

## Goal, instructions and memory

Right-click the coordinator to open:

- **Goal & Instructions…**: the **Goal** is one line it works toward ("Ship the new checkout by Friday"). **Standing instructions** are rules every thread follows ("Branch from main").
- **Memory…**: lasting preferences, decisions and pitfalls. When you state one in chat, the coordinator proposes the exact wording and saves it once you agree. You can add or remove notes here too.

Every new thread gets the goal, the standing instructions and the memory notes with its task, so you don't repeat yourself.

## Questions and pages

The coordinator asks its questions as a **form in the chat**: every open question at once, with its recommended choice marked, so you answer with a few clicks. When the question is about something to look at, like two layouts, it sends a **page** with the mockups and the questions right under them. Questions are numbered (Q1, Q2, …) across the whole conversation, and each tag links to its question. See [Charts, questions and pages](/skills/visuals).

## Accounts and stuck threads

If a thread can't start (no saved login, a usage limit) or gets stuck, ask the coordinator to sort it out. It can see every Claude and Codex account with its usage, move the thread to an account with room on the same conversation, or restart a hung agent. It tells you which thread it moved or restarted. See [Accounts and limits](/workflows/accounts).

## Change how coordinators work

The **coordinator playbook** is the set of rules every coordinator follows. Edit it for all projects in **Settings > Chat > Coordinator playbook**, or give one project (and its worktrees) its own copy in **Settings > Projects**. The New Coordinator dialog shows which playbook it will use, with an **Edit** button. Existing coordinators pick up your changes too. **Reset to Default** brings back Ghostex's playbook, and a switch turns your copy off without losing it.

Also in **Settings > Chat**:

- **Marked handovers in every session**: coordinators and threads already start each part of their reply with a marker like ❓ Needs you, ✅ Done or 🧪 Untested. Turn this on to have every other agent do the same.
- **Coordinators answer without markers** and **Every effort level in coordinator pickers** are advanced settings (Show Advanced). The second one adds the levels above XHigh (Max, Ultra and the like) to the effort pickers; a coordinator works best on High or XHigh.

## From the command line

Coordinators run on the `ghostex coordinator` command, which you can use too (`ghostex orchestrator` still works as an alias):

| Command                                                                  | What it does                                                  |
| ------------------------------------------------------------------------ | ------------------------------------------------------------- |
| `ghostex coordinator create --goal "<text>"`                             | Start a coordinator in this project.                          |
| `ghostex coordinator promote <session>`                                  | Turn an existing session into a coordinator.                  |
| `ghostex coordinator status --coordinator <ref>`                         | Show its goal, instructions, notes, and every thread's state. |
| `ghostex coordinator start-thread --title "<area>" --task "<brief>"`     | Start a thread. Add `--worktree` for its own branch.          |
| `ghostex coordinator resolve <thread>` / `reopen <thread>`               | Mark a thread done, or bring it back.                         |
| `ghostex coordinator link <session>` / `unlink <thread>`                 | Adopt a session as a thread, or make a thread standalone.     |
| `ghostex coordinator sleep-inactive-threads <coordinator>`               | Put its idle threads to sleep.                                |
| `ghostex coordinator set-goal`, `set-instructions`, `remember`, `forget` | Change the goal, standing instructions and memory notes.      |
| `ghostex coordinator playbook` / `set-playbook`                          | Read or edit the playbook.                                    |
| `ghostex coordinator --help`                                             | Every command and flag.                                       |

:::tip[Ask Ghostex]
Try "What's the difference between a coordinator and asking an agent to use other agents?"
:::
