Work with multiple agents

Several sessions, one piece of work

You can open multiple sessions on a thread, using the same agent or different supported agents. For example, one session can implement a change while another reviews the requirements.

Give each session a specific task and expected result. “Review the accessibility of this form and write findings in out/accessibility.md” is easier to coordinate than “help with the feature.”

Example prompts

Describe the work you want to delegate. The agent can use Haicue to organize the threads and sessions around it.

Create a thread and start a session

Create a thread for reviewing our onboarding flow. Add context with
the goal and links to the relevant files, then open a Codex session
there. Ask it to review the flow and save its findings in that thread.

Split a task between two sessions

Open two sessions on the website thread. Have one review the docs
for accuracy and the other check navigation and accessibility.
Give them separate output files. Bring their findings back here
with a recommended order for addressing them.

Choose how a session runs

Start a Claude Code session on the onboarding thread, label it
“design review,” and use an available model suited to a careful review.
Give it the brief and ask it to identify gaps before we implement.

Steer an existing session

Find the session working on the website docs. Tell it to keep the
changes local and focus on the getting-started guide first.
Ask it to report any missing information before continuing.

Give a session a browser check

Open a review session on the website thread. Ask it to use the
DevTools browser to check the local site on desktop and mobile,
try the navigation and forms, and report console or network errors.
Have it save screenshots and findings in that thread.

Collect the results

Check the review sessions we started. Read their saved findings,
combine duplicates, and write one action list in this thread.
Record any decisions that need me as Awaiting items.

Name the destination thread, the task, and the result you expect. For work across several threads, send these requests from the Index thread.

Delegate from an agent

An agent can use hai session open to launch another session on an existing thread. Haicue records the calling session as its parent. The session picker shows the relationship, and child sessions on other threads can be opened from the parent’s session tab.

hai session open projects/onboarding --agent codex --label accessibility
hai list sessions

Find the new session’s full ID before sending its task:

hai session send SESSION_UUID "Review the form accessibility. Save findings in out/accessibility.md."
hai session inspect SESSION_UUID

Replace SESSION_UUID with the actual ID. Tell the child what to read, what it owns, where to write, and how to report back. Opening a child does not copy the parent’s entire conversation.

Configure and drive another session

When opening a session, the coordinating agent can choose its runtime, label, model, and effort using --agent, --label, --model, and --effort. Available choices depend on the runtime and account. These are launch options; they do not reconfigure an already-running session.

For an existing session, discover its ID, inspect it, and send a specific instruction with hai session send. The same command can deliver a correction, a new constraint, or a request for progress. Ask the recipient to save a result and report back so the coordinating session has something concrete to review.

Use the Index thread when this coordination spans projects. A session can also manage Haicue features such as automations, Awaiting, skills, and LiveApps through their supported commands.

Avoid overlapping edits

Sessions on the same folder share its files. Haicue does not create an isolated Git worktree just because you start another session. Give agents separate files or set up separate worktrees when their changes could collide.

Use one session to combine the results and verify the final change. The parent/child relationship helps you navigate the work; it does not guarantee conflict-free edits.

Runtime subagents are separate

An agent may also use its own subagent tools. Those follow the runtime’s rules. A Haicue child session is a separately managed session with its own thread association and lifecycle.