Conversation and threads
Every task has an “Activity” section where people and agents talk. Each comment you post opens a thread; inside a thread you can call an agent with @name so it reads the task (and the code, if a project is linked) and answers right there. When the thread reaches a decision, you send it to the stage’s agent to carry out, or you resolve it so it folds away.
Comments are the task’s record: every agent run receives them in its brief (for each thread, the root and the last 6 replies). The task’s “Chat” tab is something else, a conversation with the agent that is working, and it is explained below.
Before you start
Section titled “Before you start”For an agent to answer a mention you need:
| Requirement | Where it is configured |
|---|---|
| The agent has the “Mention” stage checked (or “Chat”, or has no stage checked at all) | Agents → the agent → “Settings” tab, “Valid stages” section |
It has a prompt: prompts/mention.md (or prompts/chat.md if it answers by chat), or prompts/main.md as a fallback |
Agents → the agent → “Prompts” tab |
| There is an LLM credential for its engine in the workspace | Credentials and engines |
| To read code: the task has a linked project | Projects |
If any is missing, the mention does not start and the thread says so: “@reviewer could not answer: …”, with a link to Agents or to AI engines depending on the cause (see Common problems).
Recommended flow: ask an agent and carry the decision to the stage
Section titled “Recommended flow: ask an agent and carry the decision to the stage”-
Open the task from the board and scroll down to “Activity”. The box at the bottom (“Write a comment…”) opens a new thread. With the task open, the
Ckey takes you to that box. -
Type
@and choose the agent in the list that opens, with its name and description. The list shows the workspace’s agents that answer mentions: the ones with the “Mention” or “Chat” stage, and the ones with no stage checked.
Typing @ shows the list of agents that can answer. -
Write the question and click “Post” (or ⌘Enter / Ctrl+Enter). Below the box, the audience line says who will answer: “Visible to the workspace. @reviewer replies to it.”
-
Wait for the answer in the same thread. While the agent works, the thread shows “<agent> is replying…”. The answer arrives as a comment from the agent, marked “agent”.
reviewer is working on the mention. When it finishes, its answer replaces this line. -
Keep the conversation going with “Reply”. If you mention no one, the reply goes to the last agent that spoke in that thread; the placeholder and the audience line say so before you post.
The thread's reply box. Without @, the last agent that spoke answers (here, reviewer). -
When there is a decision, click “Send to <agent>” in the thread’s actions (it appears when the thread has at least one reply). A box opens, “Instruction (optional): what to do with what was decided”; write something if needed and click “Send to <agent>” again. Thulu hands the whole thread to the agent, with the instruction to carry out what was concluded. A notice at the bottom left says what happened; see Send the thread to the stage’s agent.
-
Click “Resolve thread”. The thread folds into one line with its first sentence, who resolved it and how many replies it had.
Who gets each message
Section titled “Who gets each message”| Where you write | What you write | Who receives it |
|---|---|---|
| “Activity” box (new thread) | Text without @ |
No one is launched. It stays in the record and goes into the next run’s brief |
| “Activity” box | @agent |
That agent, which answers in the thread |
| “Reply” in a thread | Text without @ |
The last agent that spoke in that thread. If none spoke, no one |
| “Reply” in a thread | @agent |
The named agent. You can name several in the same message |
| Reply under an agent’s question | Any text | It is the answer to that question: the run that asked receives it and no one else is launched |
| “Send to <agent>” | (the whole thread, with your instruction if you wrote one) | The agent the button names, through the same path as the “Chat” tab |
| “Chat” tab | Text | The agent that is working or the one that worked last (see below) |
Mentions run separately from stage runs: the same agent can answer in two threads at once, and a full board does not leave agents unable to answer. If you mention the same agent several times in the same thread while it works, it answers everything together in its next turn. By default up to 3 mentions run at a time (key mention.max_containers, see Settings). Each mention counts as a run in the workspace’s quota.
The agent reads the code read-only: the task’s branch if it already has one, or the linked project’s default branch if not yet. That way it can answer “where is this handled?” before the task starts.
Agents that consult each other
Section titled “Agents that consult each other”An agent can mention another in its answer and that other one is launched in the same thread. An agent is never launched by itself.
So that two agents do not talk endlessly on the workspace’s tokens, a thread accepts up to 3 agent messages in a row since the last time a person wrote. On the fourth call, Thulu leaves in the thread the line “Agents have already spoken 3 times in a row in this thread: @developer won’t be launched until a person writes” and launches no one. To unblock it, reply in the thread yourself: your message resets the count.
Resolve, reopen and hide
Section titled “Resolve, reopen and hide”“Resolve thread” appears when the thread has at least one reply. A resolved thread folds into a line “Resolved: “<first sentence>” by <person>, N replies” with a “Show” button. When you open it you see all the replies and the actions “Reopen” and “Hide”.
If a person replies in a resolved thread, the thread reopens on its own; a late reply from an agent does not reopen it. In the agents’ brief, a resolved thread goes folded down to its root and the last reply.
With focus on a thread, R opens the reply and X resolves or reopens it.
Send the thread to the stage’s agent
Section titled “Send the thread to the stage’s agent”The “Send to <agent>” button carries the name of whoever will receive it: the agent of the live run if there is one, or the one that ran last if not. The thread enters as a message in the task’s conversation, and what happens depends on whether something is running:
| Task situation | What happens |
|---|---|
| There is a live run that accepts messages | It reads it when the current turn ends |
| There is a live run that does not accept messages | It waits and starts a continuation when that run ends |
| Nothing is running but it ran before | A new run resumes the last session: the same agent, in the stage of that session, with its branch. When it ends, the task does not change stage |
| It never ran | The button appears off. On hover it says “This task has not run yet, so there is no session to hand the thread to. The first agent reads the thread in its brief.” |
| The agent that ran last no longer exists | The button appears off and explains why on hover |
The thread does not write code by itself. The agents that answer mentions read the repo and the task; the changes are made by the stage’s agent, with its commit, its push and its auditor.
Make a subtask from a thread
Section titled “Make a subtask from a thread”“Make subtask” turns the thread into a subtask without asking for confirmation: the first line of the root comment is the title, and the description links to the source task and quotes up to 12 lines of the comment. A notice confirms “Subtask created: <title>”. If the thread is on a subtask, the new one lands beside it, under the same parent. To edit the title or the description, open the subtask afterward; see Tasks.
Write to the agent that is working: the “Chat” tab
Section titled “Write to the agent that is working: the “Chat” tab”The task’s “Chat” tab shows the conversation with the agents that ran on it: your messages and a collapsible section per run with its transcript. The run in progress shows live.
-
Open the task’s “Chat” tab, next to “Task”.
-
Type in “Write to the agent…” and click “Send”. Enter also sends; Shift+Enter adds a line break.
-
If there is a live run and you want it to drop what it is doing, check “interrupt” before sending.
Next to the button you see what happened to the message, with the same cases as Send the thread. What you write here does not go into the next agent’s brief. If the task never ran, the message is marked “Nobody has read it yet.” with a “Move it to comments” link, which copies it to Activity.
While a run is live, the “Activity” box also shows “Notify <agent>”: with that checked, your new comment also reaches that run, which reads it when the current turn ends, instead of waiting for the next one. If the run does not accept messages, the checkbox appears off with “<agent> can’t be notified”.
| Engine and runtime | Message to a live run |
|---|---|
| Claude Code on Docker | It enters the conversation; with “interrupt” it cuts the current turn |
| Any engine on Kubernetes | It waits for the run to end and starts a continuation |
If in the “Chat” tab you write @agent, the message goes to that agent and not to the run. If the agent has the “Chat” stage, a chat of its own about the task opens (or is reused) in the sidebar, and the message shows “@agent answers in its chat →”. If it does not, the message is posted as a comment and the agent answers in Activity (“@agent answers in comments”). See Chat.
Chat-only agents inside a thread
Section titled “Chat-only agents inside a thread”An agent that has the “Chat” stage and not the “Mention” stage answers a thread’s mentions from a chat of its own for that thread. The chat appears in the sidebar, under “Chats”, with the agent’s name, the task title and “thread”; the answer is posted in the thread just like any agent’s. The second mention of the same agent in the same thread reuses that chat.
The context the agent received stays folded under “Context the agent received”. What you write in that chat stays there and does not go back to the task’s thread; to continue the thread’s conversation, reply in the thread.
Who signs each message
Section titled “Who signs each message”Thulu signs every comment, reply, resolution and message according to the credential it was sent with; there is no way to choose the author:
| Credential | Signature |
|---|---|
| Your session | Your email |
| An operator API key | key:<key name> |
| A run’s key | The agent it was issued for |
| An automation | automation |
An agent cannot write as a person, and a run’s key cannot send threads, resolve them or write in the “Chat” tab. Who launches whom also comes from the signature: a person’s comment launches the agents it mentions, an agent’s launches others within the cap, and system, auditor or automation comments launch no one. That is why user, system, auditor and automation cannot be used as agent names. More detail in Security and audit.