Agent Messaging

  • Desktop app
  • All plans

What it does

The saved agents of a project are permanent members that can write to each other, whichever CLI each one runs. A message is stored in the project before anyone tries to deliver it, so an offline recipient, a crashed CLI or an app restart never loses one. Delivery waits for a good moment: it is held while the recipient is thinking or waiting on your answer. By default no console is started just to deliver mail; a setting, off by default, lets a message bring an offline recipient back in the background. What lands in the terminal is a short notice (sender, subject, preview); reading the body through the inbox tool is what marks it read. Each message shows a trail of separate states: Queued, Delivered, Read, Accepted, Declined, Answered.

An agent started while mail waits for it, by you or by the app, is told in its startup brief to read its inbox before it greets you or asks what to work on.

The human side is the Group conversation (since 2026-11-04; it replaces the Broadcast popup): one thread with every agent whose session is open. What you write goes to all of them, or only to the agents you tag with @, and their replies come back in the same thread. A copy that could not be delivered is named under your message.

Each project also has its own project inbox (since 2026-10-05): an agent can write to a project rather than to one of its agents, typically from another project of the account when it does not know who owns the subject there. Any agent of that project can read the request, take it on (only one can), decline it or answer it, and the answer goes back to the sender. Its notices go to the project's Coordinator; without one, the request waits for you at the top of the agent list.

Where to find it

  • Organization panel (the Agent organization modal: members on the left with their status, Available, Working, Needs you, Blocked, Rate limited, Offline, and the selected member's correspondence on the right): its button in the agents panel has been hidden since 2026-08-28, so it cannot be opened from the interface at the moment. Read and answer mail through the envelope button (see Your mail below).
  • Since 2026-10-08 the agents sidebar no longer groups agents that write to each other into conversation boxes: every agent stays in its usual place in the list, and the mail is read through the envelope button (see Your mail below).
  • Project inbox: a box at the top of the agents sidebar, shown only while requests sent to the project wait for someone. It says which coordinator they are announced to (by default the project's chief of staff, see Project assistant (chief of staff)); click a request to read it in full. It sits under the chief of staff's section.
  • A colleague's mail in the conversation view: when an agent receives mail, its conversation shows it as a message from the sender (face, name, Mail badge, time, subject and full text) instead of a block of text under your name. Click Reply under the message, or the sender's name: a card lets you Reply to them (your reply reaches their mailbox like a teammate's message, without interrupting them) or Open the agent, in its own project if it lives in another one.
  • Your mail: the envelope button in an agent's pane header (terminal and conversation views) opens on To <agent>, the mail that agent received, or on To you when an agent wrote to you and you have not read it yet. To you (shown when an agent wrote to you) and All mail (everything the agents exchanged) sit next to it. A small count in the corner says how many arrived since you last opened that agent's envelope. Each mail has a Reply button that opens the card to answer its sender; the sender's name opens the same card, which can also open the agent. While the agent has mail it has not read, a Mark all as read button (double check, next to the close button) marks all of it read in one click (since 2026-11-16): the agent's unread count drops to 0 and it is not notified or reminded again about these messages, which stay readable in the box. The receipt says it was you, not the agent. It covers only that agent's mail, never the project inbox nor another computer's box. Each message (also in the project inbox) shows its full id with a copy button, the same id agents_read_inbox({ messageId }) accepts: paste it to an agent to point it at one message among several with the same subject.
  • Group conversation: the megaphone Group conversation in the agents toolbar, shown as soon as one console is open. It takes the center of the window, like an agent's own conversation; closing it (or opening an agent or a terminal tab) brings back what was there. The megaphone keeps a small indicator: grey while nobody is in the conversation, then the agents' colors (green free, orange working, red waiting for you), with the count of unread replies. In the Open Space, the Everyone action still writes to every open agent.
  • The two switches: Settings > Agents & AI > Agent behavior, Inter-agent messaging and, right under it, A message may start the recipient.

How to use it

Agents message each other on their own through the MCP tools; you set nothing up. To intervene:

  1. To write to one agent: open an envelope button, click Reply on a mail that agent sent, or simply type in its console. (The Organization panel, which also lets you write to any member, has no visible button at the moment.)
  2. To stop one agent: Pause coordination freezes it in both directions, nothing deleted, and Resume coordination hands over what was held; Cancel pending erases the messages nobody has read yet (confirmed, irreversible). These three controls live in the Organization panel, which has no visible button at the moment; to stop all mail instead, turn off Inter-agent messaging (below).
  3. To talk to the whole room: click the megaphone, the header shows who is present and what each agent is doing. Type and send: every open agent receives it. To write to just one, type @ and pick it (the menu shows each agent's face, status and latest activity), or click its face in the header (click again to remove the tag); the line above the field always says who the message goes to. Each copy tells the agent whether others received the same message, so nobody assumes the work is theirs alone. Replies land in the thread, each with the agent's face on the left as in a group chat; click a reply's face or name to open that agent's console.
  4. To let mail reach a member that has no console: turn on A message may start the recipient. From then on a message queued for an offline member opens its console in the background, in its own project, without moving anything on your screen: resumed on its previous conversation when one is recorded and session restore is allowed, fresh otherwise. The agent reads its inbox first, then the notice is handed over as soon as the console is ready. The same switch decides what a message does to an agent that came back blank after a restart, with its previous conversation still offered on the Restore past agent card: on, the message resumes that conversation first; off, it waits until you click Resume or Ignore on the card. Either way it never reaches the blank console.
  5. To let the agent that directs the others coordinate without hitting the rate limit: open its Edit agent modal and turn on Coordinator (Capabilities). Its sends then use a raised rate budget (36 messages reaching 90 recipients per 10 minutes, instead of 12 and 30). Only the volume is raised: conversation ceilings, checkpoints and every anti-loop guard are unchanged.

Without the switch, the shortest path is to ask the agent that wrote to start the recipient: it opens it in the background with agents_resume, in its own project even when that is another one, so you never switch projects to open it (since 2026-11-03). You can also start the recipient yourself: either way its brief tells it the inbox is waiting and it reads it before asking you for a task.

  1. To handle a request in the Project inbox: click it in the box at the top of the agents sidebar, then Hand over to an agent of the project (it gets the request as a message from you, takes it on for the project and answers the sender), New agent (a quick agent starts with the request as its first prompt), or Decline with an optional reason the sender reads. To have requests announced automatically, mark the agent that directs the project as Coordinator (Edit agent > Capabilities).

Settings

  • interAgentMessaging (global, Settings > Agents & AI > Agent behavior > Inter-agent messaging, default on): off refuses agents_send and agents_reply and stops queued agent messages from being written into any console. Nothing is deleted; your own messages from the Organization panel still go through, and so do the mails a team run sends to its callback agent at each stop (sender AgentsRoom (team run), never counted in any budget, cannot be replied to; see Agent Teams), and the panel shows a banner saying messaging is off.
  • agentMailWakesRecipients (global, same place, A message may start the recipient, default off): a queued message may start the recipient's console when it has none. It also governs an agent restored blank after a restart behind its Restore past agent card: on, the message resumes its previous conversation first; off, the message waits for your Resume or Ignore. Greyed out and without effect while interAgentMessaging is off. Starting a console costs a model turn, which is why it is opt-in. Exception: an agent you paused on its own (right-click > Pause this agent, see Agent pause) is woken by its mail even when this is off, since it was paused to be woken on demand. Never in a project that is closed (not in the row of opened projects): there the message waits until you open the project again.
  • agentMailUnparkAfterMinutes (global, same place, Deliver mail to an agent waiting for an answer, default 0 = never; a project can override it in Project settings > Capabilities): when an agent waits for you (it asked you a question, or only ended its turn saying it needs you) and nobody answers, mail from other agents is held. Set a number of minutes and it is delivered anyway once the question has been open that long; the notice tells the agent its question is still open and must not be taken as answered. A dialog of the agent's CLI (permission, menu), a draft in the message box or recent typing still hold it. A CLI dialog is never answered for you: when one holds mail longer than this delay, you get one desktop notification (and a phone notification, with the usual phone rules) saying the agent's CLI is asking something, so you can answer it in its terminal. The notification never contains the console's text. Writable through settings_set (global or project scope). Greyed out while interAgentMessaging is off.
  • teamAgentMail (project scope, Project settings > Team access > Team Agent Mail, default off): this person's agents exchange mail with colleagues' agents on this project. Both sides must turn it on. Shown only in a live team. Readable through settings_get, not writable by an agent.
  • agentMailConversationLimit (global, same place, Messages per conversation, default 12, from 12 to 100, synced to your account): how many messages one conversation between two agents (same pair, same subject, both directions) may hold before the next one is refused and waits for you. Raise it for long autonomous development and review cycles. The checkpoint stays mandatory at 80 % of the value you choose (10 of 12, 80 of 100), every send reports the messages left from half of it, and Extend still reopens a single conversation. Greyed out while interAgentMessaging is off. Agents can read it; they may change it with settings_set only when you tell them to.
  • coordinator (agent scope, Edit agent > Capabilities > Coordinator, default off): this agent directs the others, so its agents_send calls use a raised rate budget, 36 messages reaching 90 recipients per 10 minutes instead of 12 and 30. Read on saved agents only (a throwaway clone of a marked prototype keeps the default budget). Writable through agents_save and settings_set with scope agent. The conversation ceiling, its checkpoint and the duplicate-subject refusal are unchanged on purpose. The project's requests sent to its inbox (to: "inbox") are announced to this agent too: it is the project's point of contact. It also gets agents_questions_list / agents_question_answer (since 2026-10-23): it reads the questions the other agents of its project are waiting on and hands over the answer you gave it, never one it picks (Structured Questions). The chief of staff every project gets is created with it on (Project assistant (chief of staff)). Since 2026-10-28 it also gets agents_recover: it can interrupt the current turn of a teammate whose console is stuck, or restart that console on its previous conversation, and you see a notice each time (see Agent tools).
  • agentMailDeliverWhileHidden (global, Settings > Agents & AI > Agent behavior > Inter-agent messaging, Keep delivering while the window is hidden, default off): when the AgentsRoom window is hidden or minimized it normally checks its agents only about once a minute, so statuses lag and mail between agents waits until the window comes back to the front. On, the main window keeps its normal pace while hidden, at the cost of more CPU. Meant for unattended work (overnight runs). Greyed out and without effect while interAgentMessaging is off. Also settable with settings_set.

Agent tools (MCP)

  • agents_list_live: the project roster with each member's live state, unread count, current ticket and what it says it is doing. Its sessionTitle is the title the member's tab shows in your sidebar while its console runs (the last title of its session file once it is offline), so an agent finds the tab you name. A member in waiting_input also carries waitingSince (ISO time it started waiting on its human). The agent a trigger starts for one run is listed while its console is open; once that console has closed, the run belongs to the trigger's history and leaves the list (the organization panel still names it in old threads). The only tool of the family usable without an agent identity.
  • agents_send: write to one member, several, or * to broadcast; returns the message id and the state of each recipient's console. For a recipient with no console, the answer says whether the app is opening one (switch on) or the message waits until that agent runs again (switch off), and in that case how the sending agent starts it itself when you want that agent on it now (agents_resume with allowFresh, see below). Refuses a duplicate of a subject already sent to the same member within the hour and still unanswered.
  • Another project of the account (since 2026-10-02): agents_list_live({ project }) lists the agents of a sibling project and agents_send({ project, to, ... }) writes to one of them, for example to report a bug found in a shared library to the agent that maintains it, without opening a console there or filing a duplicate ticket. The target project must be open in the desktop (its mailbox lives in its folder). Same rate limits, same ceilings, same pause (a member paused in its own project cannot write elsewhere, and what it already sent is held too). * is refused across projects. The message is stored in the recipient's project; the recipient sees the sender as "name · project", and agents_reply sends the answer back to the sender's own inbox. agents_message_status finds a message sent to another project by its id.
  • Another computer of the account (since 2026-10-31): when the same project is open on two of your computers, agents_list_live marks a member whose console runs on the other computer with machine (that computer's name) and its real status there, and lists the agents known only over there (a temporary agent started with agents_spawn({ machine }), for example). agents_send and agents_reply hand the message to that computer through your account's fleet: it lands in that agent's inbox with the same id, so replies, threads and agents_message_status (replied) work across the two machines. Since 2026-11-13 this also covers a message from ANOTHER project (the personal assistant's, typically): the agent's agents_reply goes back to the computer the message came from, into the sender's inbox, even though that project is not open on the agent's computer. Each such recipient comes back with machine and relayed: true; when that computer cannot be reached, relayed: false and a warning say the message waits on the sending computer. A console open on THIS computer always wins; when the same agent also has a console on the other computer, its row carries alsoOn with that computer's name (two separate conversations of one saved agent). A message to an agent running on the other computer never starts a second copy of it on this one (since 2026-11-16). The recipient sees the sender as "name · computer".
  • A teammate's agents (since 2026-11-04): between two people of the same team, on a project both have, once EACH has turned on Team Agent Mail for it (Project settings > Team access, off by default). agents_list_live then adds teammates: their saved agents and their project inbox, each with a team~... id for agents_send, and a note naming the colleagues who have not turned it on. agents_reply, agents_ack, agents_message_status work as usual, with the same limits and checkpoints; * never reaches them, and neither does agents_send with project. The sender shows as agent · member. The message waits on AgentsRoom's servers, stored in clear like Team Chat, until the recipient's computer picks it up, then its text is erased (after 14 days at the latest). If the recipient's console is closed, their A message may start the recipient setting decides. An agent cannot turn the feature on: only the person can. Not on the phone.
  • Personal assistant (since 2026-10-14): agents_send({ to: "assistant" }), without project, writes to your account's personal assistant from any project, for example when the assistant started the agent with a task and expects a report. The assistant's own id works too. Refused with a clear message when the assistant is not set up or never started on this machine.
  • Relaying your answer (since 2026-11-13): agents_send({ ..., resumeWaiting: true }), accepted only from your account's personal assistant itself (never one of its specialists, a coordinator or another agent: they are refused). It lets that one message through an agent that ended its turn waiting for you with no question open (mailHeld: "awaiting_user"), and the agent reads it as your reply relayed by the assistant. It lifts nothing else: an open question card, a CLI dialog, a draft in its message box or you typing in its console still hold the message. The assistant only uses it to carry an answer you gave it. It also works for an agent running on your other computer.
  • Project inbox (since 2026-10-05): agents_send({ to: "inbox" }), with or without project, writes to the PROJECT instead of a named agent. agents_list_live returns projectInbox (waiting, coordinators). An agent of the project reads it with agents_read_inbox({ projectInbox: true }) (unreadOnly keeps the requests nobody handled; each entry carries outcome and handledBy), takes one on with agents_ack "accepted" (exclusive: refused, naming who, when a teammate already has it), declines it for the project with agents_ack "rejected" and a reason, and answers with agents_reply, which any member of the project may do. agents_message_status describes the inbox as one recipient with actedBy (who read, took or answered it). Only an agent of the project reads its inbox.
  • agents_message_status: where a sent message stands per recipient (queued, delivered, read, accepted, rejected, replied) and what to do about it. For a queued message, whatItMeans says what holds it, from what the recipient's console is doing (recipientRuntime): offline, mid-turn, waiting on its user, or idle while something on the user's side of that console holds the notice (an unsent draft in its message box, a team run, a line being typed).
  • agents_resume (since 2026-11-03 for this use): brings a saved agent with no console back in the background, in this project or another open one, on its previous conversation. With allowFresh: true, an agent with nothing to resume is opened on a NEW conversation instead of refused, exactly like a click on its row, and reads the mail waiting for it first; the answer says started: "fresh". Still refused when its console is live, when it waits blank behind its Restore past agent card, or when its recorded conversation sits on an SSH host that could not be checked. Agents start a colleague only when you want it working now (you asked them to hand it the work, or said yes when they offered), never just because a message waits. agents_spawn is not the way: its copy is a different agent and never gets that agent's mail.
  • agents_read_inbox: read the caller's mailbox (unreadOnly, threadId, limit); a peek mode marks nothing. Reading is what marks a message read, with one exception since 2026-09-15: a message that comes back in a batch before any notice announced it in the console is not marked read, is counted as unannounced in the response, and stays unread until the agent replies to it, acknowledges it, or is reminded of it by a notice when its console is next free. agents_read_inbox({ messageId }) reads one message alone, whatever else is waiting, and gives it its read receipt: the way to read a message named by a notice or listed as unannounced; unreadOnly, threadId and limit are then ignored.
  • agents_reply: answer in a thread and mark the parent replied.
  • checkpoint (on agents_send and agents_reply, since 2026-10-03): { state, decisions, evidence, blockers, nextAction }, state and nextAction required, 1,500 characters per field. Required from 80 % of the conversation limit (message 10 of the default 12), accepted any time before. The result of both tools carries conversation (count, ceiling, remaining, checkpointAt, warnAt) and, from half of the limit, a budgetNote saying how many messages are left. The checkpoint is also added to the Comments of the linked ticket.
  • agents_ack: accept, decline or report done, with a note.
  • agents_report_status: declare a work phase, a blocker or a rate limit.
  • assignments_create, assignments_list, assignments_mine, assignment_update (since 2026-10-23): delegated work put on record, with a state, a result and the delegator's next step computed by fixed rules. The brief and its notices are messages of one conversation, under the same limits. See Delegation ledger.

The sender is never an argument: the server stamps it from the calling CLI's identity. Since 2026-09-15 that identity is also recovered from the desktop's own record of which console the CLI runs in, so an agent whose shell or CLI dropped the environment variable still reads its mail and reports its status; a server started by hand outside a console stays anonymous.

  • Coordinator recovery (since 2026-10-28): agents_recover({ to, action, reason }), listed only to the agent marked Coordinator. action: "interrupt" sends the teammate's CLI the key that stops its current turn (Esc; Ctrl+C for Aider), action: "restart" restarts its console on its previous conversation (nothing is forgotten). reason is shown to you on a notice (an in-app card with Open, plus a system notification when the window is in the background). Rate limited per teammate (one recovery every 2 minutes, 6 per hour). The answer gives a recoveryId; agents_recover({ recoveryId }) reads where it stands. It reaches the saved agents and, since 2026-10-29, the temporary ones too (quick, backlog and spawned agents listed by agents_list_live). Refused for the coordinator itself, the personal assistant, a team-run step, a QA run, a paused project, a console you are typing in, and a teammate waiting on a question to you. agents_list_live gives busySince (when the current turn started, while busy) and lastTurnEndedAt, so a coordinator can tell a long turn from a hung one.

Providers

All providers: the tools live on the AgentsRoom MCP server registered with every agent. A message from a Claude Code agent to a Codex agent is an ordinary message. The startup reminder reaches every provider (through the system prompt when the CLI has one, through the first message otherwise), and a wake resumes the previous conversation only on providers that know how to resume; the others get a fresh console.

Mobile

Group conversation only. The mobile companion has the same megaphone above the agents list, with its indicator and unread count: a full page with the same thread, the same faces, the same @ menu and the same words. The desktop does the sending and reads the conversations, so the computer must be on. The Organization panel and the two switches stay on desktop.

Limits

  • No blocking wait: an agent sends, finishes its turn, and is woken by the notice when the answer arrives.
  • A message to an agent engaged in a live team run waits for the run to stop: the run's own delivery owns that console. Two exceptions, always after the step has received its brief: the run's callback agent, the agent that started the run and the project's lead agent reach the step while it works, and so do you from the mailbox (since 2026-10-22); a run flagged as stalled lets every message through. A step waiting for your answer to its question still keeps every message.
  • Agent-to-agent sending is rate limited on purpose, so a chain of agents relaying each other cannot become a message loop. Default: 12 messages started reaching 30 recipients per 10 minutes; an agent you marked as Coordinator (Edit agent) gets 36 reaching 90, because directing a whole room legitimately reaches 4-6 members per ruling.
  • An agent cannot start a second message under a subject it already used with the same teammate in the last hour while the first one has no reply. The second message is refused and not delivered: the sender is told it was not sent, and the teammate is told once that an attempt was made, without its text. A reply to the first message reopens the subject.
  • One conversation (the same two agents, the same subject, both directions, replies or not) holds at most 12 messages by default, up to 100 if you raise Messages per conversation (agentMailConversationLimit). From half of the limit, every send tells the agent how many messages are left. From 80 % of it (message 10 of 12), a send is refused unless it carries a checkpoint (state of the work, decisions, evidence, blockers, next action); one checkpoint covers the rest of the conversation. It is saved in the project's mailbox, added to the Comments of the linked backlog ticket when the conversation is about one (since 2026-10-15; it used to be appended to the description), and handed back to the agent if the conversation reaches the limit. The envelope of each agent taking part (Your mail) shows, above its tabs, how many messages are left and the next action from the checkpoint. At the limit, it offers Extend, which gives that conversation a fresh budget: only you can do it, no agent tool can. Since 2026-10-18, the agent RECEIVING a conversation also sees how many messages are left in the notice of each of its last 2 messages, and when a message to it is refused at the limit it gets a short notice from AgentsRoom (not the refused text, not counted, no reply possible) saying that a message was blocked and where the result was to be left (the linked ticket), so it does not wait for something that will never arrive.
  • The group conversation never boots a console: agents without a live session are simply not present. An agent still starting keeps its copy queued, and the thread says so.
  • The thread is rebuilt from the conversations the CLIs keep, nothing is stored apart: it shows the current sessions of the open agents, plus those closed since the app started. An agent's reply is the last text of its turn (a direct message in its console ends that turn). A CLI that keeps no readable conversation still receives your messages, but its replies stay in its console, and the panel says so. It is not a channel agents write to each other in: they keep using their mail.
  • The agent's own message box has no sticky "to everyone" mode, on purpose: it stays a message to that agent. Writing to the group happens in the panel, which you opened for that.
  • A wake is bounded: it respects your plan's parallel-agent limit (checked silently, no upgrade prompt, the message just keeps waiting), it is attempted at most once every ten minutes per member (so a console that dies at boot is not relaunched on every sweep), it never starts the assistant agent, and it never starts an agent of a paused project or of a closed one (closed with the cross of its tile, or not opened since launch). The startup reminder is not added to a console offloaded over SSH, where the mail tools are not connected.
  • The greeting a fresh console ends with ("what would you like to work on?") no longer holds the mailbox: during the first 90 seconds after the CLI is ready, a question written in prose counts as free for delivery. A prompt owned by the CLI (permission, model choice) still blocks it.
  • A message is also held while you are typing in the recipient's console (its prompt or the message box), so it never merges with your half-written line: it goes out once you send or clear what you typed. Recent typing holds it 30 seconds after your last key; since 2026-11-08, text still sitting unsent at the agent's prompt holds it up to 10 minutes after your last key, so a pause to think mid-sentence no longer lets the mail land inside your sentence, and a line left half-typed for good only delays the mail. This applies even when that console is not on screen, when you type in a detached window, and when you type in the agent's terminal from the mobile app.
  • Messages never become backlog tickets and are never promoted to the project memory automatically.
  • Two members with the same name are told apart by a short id shown next to duplicate names.
  • A message that lands during an outage of the AgentsRoom tools (more than 10 seconds) is announced to the agent once more, 10 seconds after they come back (since 2026-11-06), so it is not left unread.
  • A message the agent never opened with agents_read_inbox (it acted on the notice alone, or the notice was lost) is announced once more when its console is next free. Since 2026-11-08 that second notice says so on its subject line ([REMINDER of a message already announced]) and asks the agent to check the current state and acknowledge it if it already acted, instead of doing the work again. Acknowledging a message already opened no longer records a second read, and replying to a message records it as read once (an agent that answered from the notice alone used to leave it unread). When the agent already took a turn on the first notice (it started right after the notice and ran like a real turn), that second notice is not sent at all: the mailbox records it as skipped. It is still sent when the agent's tools were cut around the first notice.

Common questions

  • My personal assistant wrote to an agent running on my other computer, and the message never arrived. Fixed on 2026-11-09 (reported by a user): a message sent to another project now crosses to the computer that runs the agent, like a message inside the project.

  • The agent on my other computer answered, but my personal assistant never got the reply. Fixed on 2026-11-13 (reported by a user): the agent's answer to the assistant's message now travels back through your account's fleet and lands in the assistant's inbox on the computer it runs on, so the assistant can report the result without you opening that console. The assistant can answer again and the thread goes on both ways. Both computers must be online and signed in to the same account; if the assistant's computer cannot be reached, the agent is told its answer did not get through.

  • My agents receive mail late, sometimes only after I type in their console. The usual reason: the agent ended its turn with a question for you, and mail from other agents waits until you answer, so it never takes your answer's place. To let it through anyway after a while, set Deliver mail to an agent waiting for an answer (Settings > Agents & AI > Agent behavior) to a number of minutes. A draft in the agent's message box also holds its mail until you send or clear it.

  • Several agents show "busy" for hours and their mail stays queued; my coordinator sees it but does nothing. Two causes, two fixes (since 2026-10-28). If the AgentsRoom window was hidden or minimized, it only checked its agents about once a minute: turn on Keep delivering while the window is hidden (Settings > Agents & AI > Agent behavior) before leaving agents to work unattended. If a console is really stuck (a command that never returns), the agent marked Coordinator can now recover it with agents_recover: interrupt its turn, or restart it on its previous conversation, without you opening the tab. You get a notice with its reason each time. Since 2026-10-29, consoles that had finished their turn no longer flip back to "busy" while the window stays hidden, and a restart finds the conversation the console wrote last, even when the project folder sits behind a symbolic link or a very long path.

  • I named an agent by its tab title and the coordinating agent could not find it. Fixed on 2026-10-22. After a restart, or on a new conversation, the tab kept or took a title that the agent's latest session file did not hold, and agents_list_live used the file, so it listed that agent under an older title or none at all for as long as the agent waited on you. It now returns the title the tab shows while the console runs. If two agents still look alike, give the agent name shown on the card as well.

  • Where did the Conversations boxes of the agents sidebar go? Removed on 2026-10-08: they duplicated the envelope button of each agent's pane. Agents stay in their usual place in the list; open an agent's envelope to read what it exchanged, and to Extend a conversation that reached its limit.

  • After an app restart, my agents answered a teammate's (or the assistant's) message without remembering their work, and their conversation view only showed that message and the reply. Fixed on 2026-10-20. A restored agent runs on a blank conversation while its previous one waits on its Restore past agent card, and the message used to reach that blank console, either through its notice or through the instruction, given to a console that starts while mail waits, to read its inbox first. Now a message never reaches it. With A message may start the recipient on, the message resumes the previous conversation first (like a click on Resume) and is delivered there; with it off (the default), the message waits until you click Resume (delivered to the resumed conversation) or Ignore (delivered to the new one). agents_list_live marks such an agent resumeOffered: true, and agents_message_status tells the sender why its message waits. The personal assistant is left out: its conversation restarts every day on purpose. To get an agent's previous conversation back, click Resume on its card.

  • I closed a project, and a notification showed that one of its agents was still working. Fixed on 2026-10-20. Closing a project ends its consoles, but with A message may start the recipient on, a message from another agent (often from another project) brought the recipient back in the background, where nothing showed it. A message now never starts an agent of a closed project: it waits in its inbox and is delivered once you open the project again, and agents_message_status tells the sender the project is closed. What you set up yourself still runs in a closed project: scheduled tasks and triggers, an agent started from the phone or by the personal assistant, agents_spawn and agents_resume. To freeze those too, use Pause on the project (see Project pause).

  • The same project is open on my two computers: my agents see each other but a message to the other computer never arrived. Fixed on 2026-10-31. The mailbox is a folder on each computer, so a message to an agent running on the other one was kept on the sending computer, shown as offline, and waited there forever without any warning. It now travels through your account's fleet (the connection that shows your other machines in the sidebar) to the computer where that agent runs, and the answer comes back the same way. Both computers must be online and signed in to the same account. If the other computer cannot be reached, the sending agent is told the message waits on its own computer. The receiving computer keeps its own Inter-agent messaging switch.

  • An agent running on my other computer disappeared from this computer's agent list, and a new console of it opened here on a reminder of an old message. Fixed on 2026-11-16 (reported by a user). A message that crossed to the other computer stays marked as announced on the sending computer, because the agent reads it over there. This computer took that for a message still unread, sent a reminder, found no console here for that agent and, with A message may start the recipient on, opened one. The list keeps one row per agent and a console here wins, so the original disappeared behind the copy. Now a message that crossed gets its reminder only from the computer that runs the agent, and a message never starts an agent whose console runs on another computer of your account. If you already have two consoles of the same agent, agents_list_live marks the row with alsoOn (the other computer's name): close the one you do not want and the other comes back in the list.

  • My agent wrote to an agent of another project that was offline, and told me to go and open it in that project. Fixed on 2026-11-03. The sending agent had no way to start it: bringing an agent back only worked on a previous conversation, and a new agent would have been a copy that never gets the message. Now the answer of agents_send tells the sending agent how to start the recipient itself, and agents_resume with allowFresh opens the same agent in the background in its own project, on a new conversation when it has none, where it reads the message first. You stay where you are: just tell your agent to start it (or say yes when it offers). By default a message alone still starts nothing (A message may start the recipient stays off).

  • What if the recipient is offline? The message waits, shown as waiting; it is delivered the next time that member is in a state where reading it makes sense. With A message may start the recipient on, the app opens that member's console in the background instead of waiting for you.

  • My teammate is offline. Will my message start it? Only if A message may start the recipient is on (Settings > Agents & AI > Agent behavior); it is off by default because a console start costs a model turn. When it is on, the console opens in the background on the previous conversation when there is one, the agent reads its inbox first, and the sender's agents_send answer says the launch is under way. If the member is still reported offline several minutes later, the launch failed (missing CLI, exhausted quota, parallel-agent limit) and only you can fix it. When it is off, ask the agent that wrote to start it (it uses agents_resume, in another project too), or start the teammate yourself: it reads its inbox before asking you anything.

  • An agent sent a STOP to a team-run step that had already finished, and waited for nothing. Since 2026-11-08 a temporary agent (team-run step, trigger run, quick agent) whose console is closed is described as such when mail is sent to it: nothing will read the message unless it is reopened. And when such a console closes with mail still waiting for it, each agent that sent some gets a short Not delivered message, so it can send the request to whoever owns the work now or tell you.

  • My message to an agent that looks free stays queued for minutes, until I type in its console. Since 2026-11-08 the sender is told the exact reason: agents_message_status names the hold the desktop applies (an unsent draft in its message box, you typing or a half line left at its prompt, a question it asked you, a prompt of its CLI waiting for a key, a team run driving it), and agents_list_live shows it as mailHeld. You see it too in the organization panel, under the member's "messages not handed over yet" line (for example Held: an unsent draft sits in its message box). Since 2026-11-09 the recipient's own pane says it as well: a card above its message box, A message for this agent is on hold, with the same reason line, shown while mail really waits behind a question, a prompt of its CLI, a draft or a team run, and gone as soon as the mail goes out. The mobile app shows the same card on the agent's screen, above its message box, with the same words. Since 2026-11-10 the card also lists the waiting messages (subject and From sender, oldest first, up to five plus "Other messages waiting"): Read unfolds one, Cancel sending erases it after a confirmation, without it ever being delivered (no undo); a message another recipient already read has no cancel button. Same on the phone. Ask your agent which one it is: a forgotten draft is sent or cleared, a CLI prompt is answered in that console, and for a question you can let mail through after a delay with Deliver mail to an agent waiting for an answer.

  • A teammate I can see running shows as offline in agents_list_live, and its mail stays queued. Fixed on 2026-10-12. When the AgentsRoom window is hidden, asleep or overloaded, it stops observing its consoles for a while, and the directory used to read that silence as offline. A console that is still running now stays listed, with its last known status and observedSecondsAgo (how long ago the window last saw it). Mail sent to it is stored, and its notice is written once the window sees that console again: if notices seem stuck, bring the AgentsRoom window back to the front. The recipient can read its inbox at any time with agents_read_inbox.

  • An agent of another project shows offline from here although it is running (agents_resume says it already has a live console), and my message to it stays queued. Fixed on 2026-10-19. When that project's folder was recorded with a trailing slash, or on Windows with / instead of \ (a workspace created by AgentsRoom), the app kept its consoles and its message receipts under two spellings of the same folder, and the other projects read the wrong one: the agent looked offline with heartbeatAt: 0, and a message it had already received still read queued. Both spellings now share one record. A message that really is waiting says why in agents_message_status (see Agent tools above).

  • Agents started by my triggers still show in agents_list_live after their run ended. Fixed on 2026-10-16. A run whose console has closed (for example with Close after inactivity on the trigger) used to stay in the list as an offline member until the trigger's history dropped it, so an agent watching the list concluded the runs were never closed. It now leaves the list as soon as its console closes, like in the sidebar; its output stays in the trigger's history. A run still listed as idle or busy has a console that is really open: see Close after inactivity in the Scheduled Tasks help.

  • Can a message interrupt an agent mid-work? No. Delivery is held while it thinks or waits on you, and only a short notice lands.

  • An agent asked me a question overnight and all its mail waited for me. By design a question the agent asked you holds its mail, so a message never answers in your place. If your agents run unattended, set Deliver mail to an agent waiting for an answer (Settings > Agents & AI > Agent behavior, or per project in Project settings > Capabilities) to a number of minutes: past that delay the mail is delivered and the agent is told its question is still open. agents_list_live shows waitingSince for a member in waiting_input, so a coordinator can see how long a colleague has been waiting and tell you. When you are away from that agent but talking to the coordinator (the project assistant, or any agent marked Coordinator), give it your answer: it reads the waiting question with agents_questions_list and hands your answer over with agents_question_answer, AgentsRoom cards and Claude Code's own question dialog alike, and the held mail follows once the agent goes on.

  • A message from another agent got glued to what I was typing and went out with it. Fixed on 2026-09-26: delivery now waits until you send or clear your line. Since 2026-11-08 an unsent line at the prompt holds the mail up to 10 minutes (it was 30 seconds, too short for a pause mid-sentence), and typing in a detached window or from the phone holds it too.

  • An agent the assistant started cannot send its result back to the assistant. Fixed on 2026-10-14: the agent writes with to: "assistant" (no project needed). The assistant lives in a workspace of its own that is not listed as one of your open projects, which is why naming it as a project failed.

  • Can an agent write to a project rather than to one of its agents? Yes: agents_send with to: "inbox" (and project for another project of the account). The request waits in that project's inbox, is announced to its Coordinator when it has one, and shows at the top of its agent list for you. The first agent of the project to take it on owns it; the answer comes back to the sender's inbox.

  • Can an agent write to an agent of another project? Yes, with the project argument of agents_send (and agents_list_live to find the recipient), as long as both projects belong to your account and the target is open in the desktop. The answer comes back to the sender's own inbox. Adding text to another project's existing ticket is still not possible: a message to the agent that owns it is the way to pass the finding along.

  • An agent says its message was refused as a duplicate, or another agent got "Mail refused". The sender reused a subject it had already sent to that teammate within the hour, with no reply yet. The new text was not delivered. The recipient answers the earlier message and the sender can write again; a sender with something new to say uses a subject that names it.

  • An agent waits for a colleague's message, but the message stays queued and nothing is asked. The agent ended its turn saying it needs you (for example: merge this request, then a watcher agent tells it), with no question card open. Mail from other agents then waits until you write to that agent, so it never wakes up on its own. Since 2026-11-09 this is named for what it is: mailHeld: "awaiting_user" in agents_list_live, a sentence in agents_message_status that says no question is open, and the card above its message box, Held: it ended its turn saying it needs you, with no question open; write to it to let the message in. Write a word in its tab, or set Deliver mail to an agent waiting for an answer. Agents are also told to end such a turn as "waiting on an agent" rather than "needs input", so the colleague's message wakes them.

  • I gave my personal assistant my answer for an agent that waits on me, but its message stays queued until I type in that agent's tab. Since 2026-11-13 (reported by a user), the assistant sends your answer with resumeWaiting: true and the agent takes it as your reply, on this computer or on your other one, with nothing to type in its tab. It only works for an agent waiting with no question open (awaiting_user): a question card is answered through the assistant's question relay, and a draft or your typing in that console still hold the message. Only the personal assistant can do it, and only with an answer you gave it; mail from other agents keeps waiting for you as before.

  • Two agents stopped talking: "the ceiling" or "limit reached". A conversation holds 12 messages by default. Since 2026-10-03 the agents must save a checkpoint at 80 % of the limit, so the state of the work is not lost: read it in the Comments of the linked ticket, or at the top of either agent's envelope (Your mail), and click Extend there if the exchange should go on. On the phone, Extend is on the Conversation limit reached card above the message box of either agent's screen. The agent the refused message was meant for is told too (a notice from AgentsRoom pointing it at the ticket), and the sender is told to write a finished result in the ticket.

  • Can my agents exchange more than 12 messages without me clicking Extend? Yes, since 2026-10-15: Settings > Agents & AI > Agent behavior > Messages per conversation, from 12 to 100. Raise it for long autonomous development and review cycles (a reviewer reporting its verdict to a product manager after many rounds). There is always a limit, so two agents can never loop forever; the checkpoint moves with it (80 % of the value), and agents are told how many messages are left from half of it. An agent never raises it on its own: it may only change it with settings_set when you ask it to.

  • How is this different from Agent Teams? Lifetime. A team run's members are ephemeral nodes addressed by role and their inbox dies with the run; messaging is between permanent saved agents addressed by name, for as long as the project exists.

  • Where do I read the messages agents sent to me? In Your mail, the envelope button of an agent's pane header: To <agent> for what that agent received, To you for what was addressed to you, All mail for everything. Click Reply on a mail to answer its sender from there; the sender's name also lets you open its pane.

  • An agent's mailbox is full of unread messages I already handled. How do I clear them? Open Your mail on that agent's pane and click Mark all as read (the double check next to the close button). Every unread message of that agent is marked read, its unread count drops to 0, and the agent is not notified about them again. Nothing is deleted.

  • A message in an agent's conversation is signed by another agent. Can I answer it? Yes: click Reply under the message (or the sender's name), type your answer in the card and send it. It goes to that agent's mailbox, it does not type into its terminal.

  • An agent runs on another provider than the one it was saved with, and its conversation view only shows my messages. Fixed on 2026-10-05: the view now reads the transcript of the CLI actually running (for example Codex started by a quota rule on an agent saved as Claude).

  • Can I turn it off? Yes, one switch in Settings (see above), plus Pause coordination per member.

  • My coordinator agent keeps hitting "Coordination budget reached" while it is just doing its job. Open its Edit agent modal and turn on Coordinator (Capabilities). A coordinator that rules ~20 builders, reviewers and dispatchers legitimately reaches 4-6 members per decision, which exhausts the default 30 recipient slots in a few rulings; marked, it sends 36 messages reaching 90 recipients per 10 minutes instead. The refusal it saw told it to stop and report to you, on purpose: that is the anti-loop behaviour, and the marking is your explicit say-so that this agent's volume is legitimate. The conversation ceiling and the checkpoint rule stay exactly the same for a marked coordinator.

  • Does the identity survive a model or provider change? Yes, the member is the saved agent, not the session.

  • My message says delivered or queued, but the agent never got it. Fixed in 1.175.0. Before, a message that arrived while the recipient was already reading its inbox for another notice was marked read together with that batch, so it left the unread list and was never announced, and the sender saw it as read and ignored. Now only a message the agent was told about, or read on its own, gets a read receipt; the others stay unread and are announced when the console is free. If a message still looks stuck, agents_message_status with its id says where it stands, and the recipient can call agents_read_inbox with unreadOnly.

  • An agent launched by another agent says it has no identity and cannot read its inbox. Fixed in 1.174.0. Some environments (a shell profile or a CLI that rebuilds the environment of its MCP servers) dropped the identity variable, so agents_read_inbox, agents_ack and agents_report_status refused. The identity is now also found from the console the CLI runs in. capabilities_get with the runtime topic shows which identity an agent has.