The thread is the surface.
Chat is where intent meets capability. A thread is not a transcript — it is the connective tissue between what the user said, what the agent decided, what tools it reached for, and what the workspace now contains. Every other surface in the product is reached through conversation or informed by one. The thread persists, references context-map nodes, holds inline CTAs that stand in for whole flows, and survives transitions (onboarding → studio, studio → workflow authoring) without losing its history.
Three zones, sharp seams.
A thread is head, transcript, composer — stacked, full height, no drawers. The head carries identity (toolbox, title), the transcript is the scrolling log, the composer anchors user intent. Seams between them are hairline borders, not shadows.
Six shapes. Each one does one job.
The transcript composes a small number of message shapes. Every shape has a role strip (you / assistant / error), a body, and — when the agent called tools — an attached tool-call group above the body. Streaming messages animate in; finished messages don't. Situation changes, capability swaps, and toolbox rebinds are background machinery — they never render in the transcript.
Four zoom levels. No surprises.
When the agent uses a tool, the transcript renders a drill-down, not a dump. Four levels of disclosure, each earning its keep. The outer bar is a receipt at a glance; the next layer groups calls by what touched what; the next lists the individual calls; the innermost reveals the raw result for the one call a user actually wants to read. Nothing is hidden — it is arranged.
Calls group per integration, not per call, so one turn with
five Gmail reads and one Notion write shows as two groups under one outer
bar, not six equal rows. When an integration has an identity concept (Gmail,
Slack, GitHub) and a single identity was touched, the identity rides inline
in the group header. Touch two identities and a mono 2 accts
badge replaces it, with sub-groups revealed on expansion. Identity-free tools
stay flat.
N tool call(s) · total duration · ▾ — pulse dot while
streaming, red fail-count when any call errored. Tap to expand the
whole turn.
Integration tools carry their vendor logo. Built-in tools — the ones Figments ships itself — carry a small geometric glyph keyed to their family, so the transcript never shows a missing-logo placeholder.
{
"document_id": "doc_01hv4ab…",
"filename": "prospect-pa-brief.md",
"byte_size": 4312,
"mime_type": "text/markdown",
"content": "# Prospect · Personal assistant brief\n\nHi Mira — here's the one-pager we talked about on Tuesday…"
}
Ordering. Inside an assistant turn, the message text renders
first; the tool-call bar sits after it, with a paragraph break between. When
the agent emits text → tool call → text, the renderer preserves the
break so the second beat of prose never runs into the first. Errors and
retries attach to the message, not the tool call: if the whole turn
errored, the message body shows the error and a ↻ Resend
affordance — not the tool-call bar.
Five states. One frame.
The composer stays put. What changes is its border (hairline → signal on focus or drag), its button (send ↔ stop), and the attachments row above it. Pasting, dragging, and clicking the paperclip all land in the same attachment chip row. While the agent streams, you can type a follow-up — it queues and sends the moment the turn finishes.
Three ways in, one row.
Click the paperclip, drag from the OS, or paste from the clipboard. All three land the file in the attachments row above the composer as a chip — image chips show a thumbnail, file chips show a type glyph. Chips are removable until the message is sent; after that they're citable from the turn.
The sidebar is your history.
Threads live in the left sidebar ordered by recency. The active thread is inverted. Hover or focus reveals the kebab — rename in place with double-click; delete asks for confirmation. An empty state teaches the first action rather than asking users to guess.
No threads yet.
Ideas live inside threads. Start one with a question or a document drop — the Librarian takes it from there.
Calls to action, in the flow.
Agent tools render rich cards inline in the assistant's turn. Clicking a card does the real thing — create a figment, connect an integration, save a memory — and the card updates in place to reflect the new state. Every card has a primary action, optional secondary, and surfaces any confirmations before destructive steps.
Situation → Capabilities → Tools.
This machinery is invisible to users. No situation banner, no capability picker, no "toolbox rebinding…" toast. The thread just keeps going; what the agent can do quietly expands or contracts with context. Users never see the table below — it's a reference for people building the product, not a surface in it.
A thread has exactly one active situation. The situation resolves to a
capability set, which flattens into concrete tools at turn start. Capabilities
are where access control lives — integration capabilities only resolve if the
user has actually connected the tool. The thread is the same thread across
transitions; what changes is what the agent can do, and which cards it can
render. Transitions are triggered by user actions on inline cards (creating a
figment moves the thread into studio_editing) or by route changes
(entering the workflow editor) — never by a chat message announcing them.
Wide for focus, compact for flow.
Two variants share the same grammar. Wide runs the full Studio column — larger type, user bubbles inverted for contrast, no role labels. Compact embeds inside other surfaces (workflow editor sidebar, agent-inspect panels) — smaller type, tighter rows, role strips restored for scannability.