> ## Documentation Index
> Fetch the complete documentation index at: https://docs.startamos.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Slack Conversation

> Slack is now a front end onto Amos, not a notification sink. Both Slack integrations used to be one-way — reports and approval requests posted out, and nothing came back. Now conversation goes both ways.

## What it enables

* **Talk to the bot and get an answer.** DM the Amos app, or `@Amos` in any
  channel it is invited to, and the reply comes back in the thread — routed
  through the same routing the website's "Ask anything" uses, so the answer is
  the answer, not a Slack-specific subset.
* **Threads are conversations.** One Slack thread is one Amos conversation: a
  follow-up reply continues with prior turns in context, and the same
  conversation is visible on the website, owned by the same person.
* **Mid-run questions get answered where they were asked.** When a job pauses
  on a human gate, Amos asks in the thread — buttons where one click can
  express the answer, a numbered list where it cannot — and either a click or
  a typed reply resumes the job.
* **Approval buttons work, both ways.** Approve or reject from Slack; when the
  decision happens — from Slack *or* from the web inbox — the DM updates to say
  what was decided and by whom, in plain language, and its buttons stop
  looking live. You can also answer an approval **by typing in its thread**,
  not only by clicking; if the web inbox and Slack race, the first decision
  wins and the loser is told.

## What Amos listens to

In a channel, Amos can see every message — that is how it follows a thread
it is already talking in. Seeing and acting on are two different questions.

**Amos acts on:** a DM, an `@mention`, and a reply inside a thread it already
holds a conversation in. A top-level channel message is never a follow-up.

**Amos says nothing at all** for everything else, including when something is
wrong. Two colleagues talking to each other in a thread Amos happens to be in
will not draw a reply — it only speaks when it was spoken *to*.

It also never reacts to:

| Skipped                                  | Why                                                                                                                                                                       |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Its own replies and every app post       | the self-loop guard                                                                                                                                                       |
| Slackbot posts (huddle notes, reminders) | Slackbot announces as a user, so it needs its own rule                                                                                                                    |
| File attachments                         | a canvas, transcript or screenshot arrives as boilerplate text around a link, which Amos cannot act on — the underlying content still reaches it through knowledge ingest |
| Edits and typo fixes                     | an edit would re-run a whole turn                                                                                                                                         |
| A bare `@Amos` with no message           | a mention alone is not a prompt                                                                                                                                           |
| Authors outside the workspace            | a Slack Connect channel can carry outsiders                                                                                                                               |

## One thing at a time

* **One turn per thread at a time.** A second message while the first is
  running is answered with "still working on your previous message" rather
  than queued or interleaved.
* **An ack, then the answer.** No live progress in Slack — the answer arrives
  as a message when it is ready.
* **No slash commands and no file uploads yet.** A shared file gets a spoken
  refusal explaining that, not silence.
* **Recent context only.** Amos carries the last few completed turns of a
  thread, so a very long Slack conversation will feel slightly thinner than
  the transcript looks — Amos never reads back through Slack history itself.

## Who you are in Slack

A Slack message is matched to your **existing** Amos account by your
workspace-verified email address. Amos only ever matches — it never creates an
account on your behalf — and only for authors inside the configured workspace.

## Under the hood

* [HTTP API & event stream](/developers/reference/api-and-events) — the Slack
  event and interaction endpoints, and the question/answer contract the
  in-thread gates ride on.
* [Data model](/developers/reference/data-model) — how a thread is claimed to a
  conversation and how a Slack identity maps to a user.
* [Configuration](/developers/reference/configuration) — the Slack credentials a
  deployment needs before inbound conversation turns on; without them inbound
  refuses rather than degrades.