Conversation

An agent answers a direct message, an @mention, a reply under one of its own messages, and messages in a channel it watches; other channel talk is ignored.

The workspace, channel and thread are the conversation: two threads in one channel are two conversations with separate memory, and an answer lands where it was asked.

Two agents in one thread hold two conversations: each has its own memory, order, steering, !new and settings, and a rename keeps them. Nothing one agent does changes the other's.

e.g. Echo and Golf answer in the same thread; !new to Echo, or steering Echo, changes nothing for Golf.

In a workspace with several agents, a message goes to the agents it addresses: each one @mentioned answers once, a reply under an agent's own message goes to that agent, and a channel two agents both watch is answered only when a message names one of them. A !command with no mention in a shared thread goes to the agent that last answered there.

An agent never answers a message another bot posted, so two agents never talk to each other on their own.

A reply under something the agent posted reaches it without an @mention; a thread somebody else started still needs one.

One message is answered exactly once, however many ways Slack delivers it.

e.g. the first direct message of a new thread → one answer, not two.

A thread runs one turn at a time, in the order the messages arrived, however many people are typing.

A new message while the agent is answering stops that answer; what was written stays, marked interrupted, and the next answer is told.

A thread continues one session, so the agent remembers what was said earlier in it, on Claude and on Codex alike; a memory it cannot reopen is started afresh rather than failing the thread.

!new drops the thread's memory and says so; the next message starts over and nothing is deleted.

While the agent works, a line under the composer says what it is doing, and it is cleared however the turn ends.

While a turn works, what is on screen keeps showing time passing, on Claude and on Codex, held or not, until the answer lands.

A turn that does real work shows a note above the answer with the tools it ran and how long it has taken, settling into one line at the end.

The note and its clock are there for the whole turn even when the agent's first act is to say something: the note goes up before the agent's first words do, so it sits above them, and it keeps time at its usual pace while the tools run. A held turn gets the same clock and, as ever, none of its tools or words. Found Sep 20 in production: an agent that opened with a sentence inside the first two and a half seconds never got a note at all, and the turn looked stuck for minutes.

What the agent has said so far is on screen within a few seconds of it being said, when Slack accepts the update, whether or not more words follow. A sentence the agent finished before going to its tools is shown whole, never frozen at its first word. The answer's message has one writer at a time, so it is never posted twice and older words never replace newer ones. A held turn is the exception it always was: none of its words show until delivery is decided.

e.g. the agent says "I'll look at last week's meetings." and then reads for two minutes → the screen shows the whole sentence, not "I".

A turn cut short because the worker is stopping says exactly that, when it can still reach Slack, and asks the person to send the message again — also when it had not yet said a word. It is never marked as interrupted by a new message, because there is none. A worker killed outright says nothing; that is not promised.

Under each answer sits one line: the model, the tokens the turn used, how full the context is, and how much of the plan's allowance is left.

The footer reads the same on Codex as on Claude: the model, the tokens, the context, the model calls the turn took (at least 1), and the 5-hour and weekly allowance used on the speaker's own login, with when each resets.

e.g. a Codex turn of 3 model calls, 4% of the 5-hour window used → terra · 253k tok · ctx 63% · ⟳ 3 · 5h 4% ⏳4h10m · 7d 10% ⏳6d.

In a conversation that carries on from earlier turns, the tokens and model calls in the footer are this turn's alone, never the conversation's running total; the context is how full the last call of this turn was.

e.g. the 34th turn of a DM, 6 model calls → ⟳ 6 and that turn's tokens, not ⟳ 88 · 5.1M tok for everything since the conversation began.

!statusline none|small|full chooses how much of that line shows, for this thread only.

!status reports the same numbers and which account and provider the agent answers on, without spending a turn.

An answer too long for one Slack message continues in further messages in the same thread rather than stopping mid-sentence.

Files attached to a message are handed to the agent to read; one over 25 MB is skipped and the turn runs on the text.

What a person sent earlier in a conversation is still there in its later turns — a few files, for a day — for that person only, with that agent: the agent is told their names, and a file sent two messages ago can still be filed.

e.g. a photo, then "what was it for?", then "a client lunch" with no photo → the photo is filed on that third message.

A file someone attaches is placed in that person's turn folder, where the agent can open it, and the folder is gone when the turn ends; a file that cannot be placed there is reported to the agent as not openable, never handed over by a path it may not read. Downloads are removed after a day. (Other turns share the worker's filesystem:.)

Typed as an ordinary message, !help, !status, !usage, !statusline, !model, !connect, !connections, !disconnect, !new and !skill are answered without spending a turn.

Commands are answered even when the agent has no inference login yet, so !help and !connect claude work on an agent that cannot answer anything else. This is about someone the agent answers: on an agent that is allowed only, being allowed comes first (AGENTACCOUNT-ONLY-THE-ALLOWED).

Where an app HAS slash commands, they reach the same command handlers as ! under the app's prefix (SLACK-COMMAND-PREFIX), and they differ in how the answer comes back: a slash answer is shown only to whoever typed it and joins no thread, where a ! command is an ordinary message, addressed as any message is (CONVO-WHO-IS-ADDRESSED) and as visible as the channel it is in. An app with them switched off keeps the handlers and loses that private reply.

A command still works when it is pasted back with the formatting it was shown in.

Anything starting with ! is never handed to the model: an unknown one says so, suggests the nearest, and lists the rest.

e.g. !conections → "Did you mean !connect?", with the list.

!model <name> changes the model for this thread from the next message, leaving every other thread and person alone.

Where each person brings their own inference login, the speaker's own answers and pays for their turns; somebody not signed in is asked to instead of having a turn spent.

Everyone who speaks in a thread shares its history, and each message carries its sender (AGENTACCOUNT-AGENT-KNOWS-SPEAKER). (under review:)

An agent never reports the machine it runs on — its account, environment or file paths — as a fact about the person it is talking to.

A turn that fails says so in the thread in one short sentence, and the working cue is taken down — never a message that simply stops.

A turn that fails for want of an inference login says which provider to sign in to, and the Hub's picture of that login is corrected.

An agent works within the step limit on its row; reaching it ends the answer with "reply continue to keep going".

A turn may take up to twenty minutes of quiet thinking, while a worker that has really died is noticed within about a minute.

The platform can start a conversation nobody asked for, and it becomes an ordinary message in an ordinary thread with the same memory and interruption.

Waking an agent is reachable only from inside the platform and only with its token; with no token it is not served at all.