Threads working together

Let threads message each other and start helper threads, and follow the subagents an agent runs.

Agents in different threads of a project can talk to each other. One agent can ask another what it knows, tell it something its work depends on, or start a helper thread to take on part of the job. You ask for this in the conversation, and the agents do it with OpenOrc's thread tools. When an agent runs subagents of its own, each one gets a thread too.

How it works

A thread's agent has four tools for reaching the other threads of its project:

Tool	What the agent does with it
`thread_list`	Sees the project's active threads: what each one is doing and its last reply.
`thread_read`	Reads the latest messages of another thread.
`thread_send`	Sends a short message to another thread.
`thread_start`	Starts a helper thread that works beside it, in the same folder.

A thread reaches only the threads of its own project. An Orcling can reach threads in all your projects.

Ask in plain words

Say what you want in your message. You don't need to name a tool. For example:

"Start a Codex thread to write tests for the parser while you finish the refactor."
"Hand the icons to Claude in a separate thread."
"Ask the API thread whether the new endpoint is ready."
"Tell the docs thread that the flag is now called --quiet."

When you ask for a helper thread, OpenOrc tells the agent to start it without checking with you again. The agent asks first only when it's unclear what to start or which agent should do it.

Helper threads

A helper thread is a regular thread in the project. In the sidebar it sits under the thread that started it. It starts with these settings from that thread:

Folder: The same folder: the project checkout, or the starting thread's worktree when it has one.
Mode: The same mode and permissions.
Agent and model: The same agent and model, unless you name others. You can name a model the way you'd say it. If the name fits no model or several, the agent gets the list to choose from.

The helper's first message is a notice saying which thread started it and how to reach that thread. Click Show details under the notice to read the task it was given. In the thread that started it, a card shows the helper's title, whether it's Working, Needs you or Idle, and its project. Click the card to open the helper.

The two threads keep in touch with messages. The helper is told to message the thread that started it when it has results or needs something.

A thread can have up to three helpers working at once. Idle helpers don't count.
A helper can't start helpers of its own. OpenOrc tells it to ask the thread that started it instead.
A thread in Plan can't start helpers until you switch it to another mode.
Starting a helper doesn't ask for your approval.

Helpers share the folder

A helper and the thread that started it edit the same files, so give each a separate part of the work. Undo on either thread's change card rolls back the whole folder, including the other thread's changes.

Messages between threads

A message goes to one thread. If that thread's agent is working, the message joins its current turn. Otherwise the message starts a new turn.

In the receiving thread, the message appears as a notice from OpenOrc that names the sender:

Message from the thread "API work" (id …):

Click Show details to read the message. In the sending thread, the agent's work shows a Sent message row.

The receiving agent acts on a message with its own thread's permissions, which can be more than the sender has. So a message to a thread in the same or a stricter mode goes straight through. A message to a more permissive thread, such as from Review everything to Autonomous, asks you first. From Plan, an agent can message only threads that are also in Plan. See Modes and permissions.

Subagents

Each agent can hand part of a turn to subagents of its own: Claude Code's agents and workflows, Codex's collaboration agents, and OpenCode's child sessions. OpenOrc gives every subagent a thread, so you can watch it work.

Claude Code runs subagents only in Autonomous, because its subagents follow permission rules of their own rather than the thread's mode. Codex runs none in Plan.

In the parent's conversation, the turn shows a card with a row for each subagent: its title, kind, model, and how long it ran. Under the title is what the subagent is doing now or the first sentence of what it found. Click the chevron to read what it was Asked and what it Reported.
Click a row to open the subagent's thread. Its conversation reads like any other, but a status bar takes the composer's place. The bar shows the model, the status, such as Working, Done, or Failed, and how long it ran. While the subagent works, Stop ends it when its agent allows that.
In the sidebar, subagents sit under their parent thread, newest first.

You can't write to a subagent's thread. Once a subagent has finished, Delete thread in its menu removes it. Subagents don't count toward the three helpers a thread may have working.

How exchanges end

OpenOrc tells agents to message another thread only when its work depends on theirs or they need something from it, and never just to say thanks. An exchange ends when one side has nothing to send back.

As a backstop, OpenOrc counts agent messages in a row with no person writing in between. After 50, it refuses to send more and tells the agent to ask you to continue. When you write in a thread, its count starts over.

The count is kept in memory while OpenOrc runs, so quitting OpenOrc also starts it over.

Next steps

Modes and permissionsDecide how much an agent may do on its own, from planning only to editing and running commands.Following the workRead what an agent is doing while it works, see what it changed, and undo a turn.OrclingsCompanions you design, each with its own conversation, instructions, and private memory. Think something through with one, or bring it into project work.

Checked against OpenOrc's source on November 9, 2026.