# Conversation one thread with an agent — a message becoming an answer, and what the agent remembers of that thread. **Has:** one agent · one workspace, channel and thread, which name it · the people who speak in it · one session it continues in · the last turn's numbers · a model and a footer setting of its own. An agent has many. The session lives on the worker serving it; a restart forgets it and nothing in Slack is deleted. ## Where an agent listens - 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, one answer - 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. ## What a person sees - 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:.) ## Commands - 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](https://tonoman.com/docs/agent-account#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](https://tonoman.com/docs/slack-app#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](https://tonoman.com/docs/conversation#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 ` changes the model for this thread from the next message, leaving every other thread and person alone. ## Who is speaking - 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](https://tonoman.com/docs/agent-account#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. ## When something goes wrong - 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 speaking first - 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.