The transcript is the conversation as your users see it: their messages, the agent's replies, every tool the agent uses, the approvals and questions it raises, and work it hands off. The built-in surfaces draw all of it, and most of it needs nothing from you. This page explains what users see, so you know what to expect and which parts you can shape.

## What a reply is made of

Each message a user sends starts a turn: the agent's work on that message, from the first word to the end. A turn can contain:

| Part            | What users see                                                                                                                                               |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Reply text      | The agent's answer, streaming in as it's written                                                                                                             |
| Reasoning       | The model's visible thinking, collapsed once the answer starts                                                                                               |
| Tool calls      | One row per tool or action the agent uses, with a short label, an icon and an expandable body. You can draw the body yourself; see [Tool views](/tool-views) |
| Approvals       | A card asking the user to approve an action before it runs, if the action's policy says so                                                                   |
| Questions       | A card where the agent asks the user up to five questions and waits for answers                                                                              |
| Delegated work  | A group of tasks the agent has handed to sub-agents, and their results when they finish                                                                      |
| Memory notices  | A line saying the agent saved a memory. The notice never shows the memory itself                                                                             |
| Failure notices | Sentences explaining why a reply failed, when it fails for a reason outside any single tool call                                                             |

A user can press Stop at any time. Stopping ends the reply, but it doesn't undo anything already done, such as an action that has run.

## Approvals and questions

When an action needs approval, the agent pauses and the assistant shows a card with what the agent wants to do. The user approves or denies it, and can add a note to a denial. For actions that allow it, they can also approve and stop being asked about that action for the rest of the conversation. These cards are always the assistant's own: a [tool view](/tool-views) can show that a decision is pending, but it can't make one.

If nobody answers for long enough, the agent stops waiting and the card shows as parked. A late answer still resumes the reply.

When the agent needs information, it can ask the user a set of questions, each with suggested answers and room for their own. They answer all of them together or dismiss the set. If they dismiss it, the agent carries on without asking again.

## Delegated work

When the agent delegates, it hands tasks to sub-agents that work in the background. The transcript groups them, for example "Running 3 subagents", and keeps the group open while they work. A user can open a sub-agent's row to watch what it's doing. When the work finishes, the agent starts a new reply on its own to report the results, marked with a divider and no user message.

A sub-agent finishing and its results reaching the conversation are separate moments, so read the agent's follow-up reply before treating the whole request as done. Delegation is a capability you turn on for the agent, under [Agents](/agents). The transcript only reports it.

## History and resuming

Every conversation is kept, and what a user can get back depends on whether they're identified:

|                   | Anonymous visitor             | Identified user                                                      |
| ----------------- | ----------------------------- | -------------------------------------------------------------------- |
| On reload         | The open conversation resumes | The open conversation resumes                                        |
| On another device | A new conversation            | Their history is there                                               |
| History menu      | None                          | Their past conversations, up to 200, opened from the surface's title |

Resuming depends on the browser's storage. Private windows and restricted embeds may not keep it.

New conversation starts a fresh, empty conversation. It doesn't delete the old one. Its title comes from the first line of its first message.

For shared computers, see sign-out in [Identity](/identity).

## Attachments

If attachments are turned on for the agent, users can attach files in the message box: images, documents (PDF, text, Markdown, CSV, HTML), video, audio and other files, as your attachment policy allows. A message can carry up to 10 files, or fewer if your policy sets a lower limit. Each file uploads straight from the browser to storage and has to finish before the message can be sent.

In the transcript, images show as previews and other files as their name and size. Download links are short-lived, so a copied link stops working after a while. A file being accepted doesn't mean every model can read its contents. What the policy allows and what the answering model understands are separate.

If your page sends a Content Security Policy, attachments need the upload address in `connect-src` and `blob:` in `img-src`. See [Install](/install).

## Showing activity elsewhere in your interface

To show the assistant's state outside the conversation, such as a dot on your help button while it works or a badge counting approvals, use `useAssistantActivity`. It's npm only. Call it anywhere inside `TeaflaskAssistant` or a `TeaflaskAssistantProvider` with the same key and identity:

```tsx
import { useAssistantActivity } from "@teaflask/assistant";

export function HelpButtonBadge() {
  const activity = useAssistantActivity();
  if (activity.pendingApprovalCount > 0) return <span>Needs you</span>;
  return activity.busy ? <span>Working…</span> : null;
}
```

| Field                  | Meaning                                                                                                                                                                        |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `busy`                 | A message is being sent or the agent is working on a reply                                                                                                                     |
| `pendingApprovalCount` | Approvals waiting for the user                                                                                                                                                 |
| `newestTurnStatus`     | The latest turn's status: `queued` and `working` are in progress, `awaiting_input` is waiting on the user, `parked` stopped waiting for an approval, and the rest are finished |
| `lastResult`           | How the most recent finished turn ended: `succeeded`, `failed`, `stopped` or `superseded`                                                                                      |

For a page that shows only an indicator and no conversation, import `TeaflaskAssistantProvider` and `useAssistantActivity` from `@teaflask/assistant/activity`. That's a lighter entry point that leaves out the transcript.

## More resources

- [Tool views](/tool-views) – drawing a tool call's body with your own components
- [Identity](/identity) – history across devices, and clearing the conversation on sign-out
- [Actions](/actions) – which actions need approval
- [Delegation](/delegation) – letting the agent hand work to sub-agents
- [Memory](/memory) – what the agent remembers between conversations
- [Headless](/headless) – rendering the transcript yourself