# Message Scient

Use the composer to tell your selected AI what you want to understand, create,
change, or run in the current project. Describe the outcome, important
constraints, and any files or evidence it should use. What the AI can do is
also controlled by the selected provider, available tools, and
[permission mode](permission-modes.md).

## Send a message

Messages can contain up to 120,000 characters. If a draft is longer, Scient
keeps it in the composer and shows how many characters need to be removed.
Shorten the draft or split it into multiple messages, then send again in the
same thread.

On web and desktop, attachments upload as soon as you add them. The send button becomes available
after every upload finishes. Failed uploads can be retried or removed.

In the retained mobile client, an empty composer shows an interrupt button while the agent is
working. Adding text or an attachment replaces it with the send button in both compact and expanded
composers.

On web and desktop, if you reload before a file finishes uploading, the draft keeps the file's name
and shows **Attach again** next to it. Attach the file again or remove it, then send.

On web and desktop, HEIC and HEIF photos are automatically converted to JPEG when you drag them into
the composer or paste them into a message. On iOS, selecting them from **Photo Library** does the
same. The 10 MB image limit applies to the converted photo.

Pasting 32 KiB or more of text adds that fragment as a text-file attachment so
the agent can inspect it without filling the model context. A smaller paste also
becomes an attachment when inserting it would exceed the message limit. On a
hardware keyboard, use `Cmd+Shift+V` on Apple devices or `Ctrl+Shift+V` elsewhere
to keep a large paste editable in the composer instead.

## Formatting

The composer writes Markdown and shows it styled as you type. When your cursor
is on styled text, its Markdown shows instead, such as `**bold**`, and the
markers edit like any other text: delete them to remove the style, or change
`**` to `*` for italic. The style updates when your cursor leaves. To write
plain Markdown with no styling, turn off **Settings → Chat → Rich text
composer**. Lines starting with `- `, `1. `, `- [ ] `, `> `, `# ` or `---`
become lists, task lists, quotes, headings and rules; ` ``` ` followed by Enter
opens a code block. What you typed is what the agent receives, markers and
numbering included, and `#1234` without a space still looks up a pull request.

Some styled text containing or touching literal Markdown characters, such as a
bold `path\` or `2*3`, keeps its styling without showing markers. Use formatting
shortcuts or turn off rich text to edit the formatting of those ranges.

Enter sends. In a list or quote, **Shift+Enter** continues it, and Shift+Enter
on an empty line moves out one level, then leaves it; **Tab** nests a list item
under the one above and **Shift+Tab** moves it back out. In a code block, Enter
starts a new line at the current indentation, **Tab** and **Shift+Tab** indent
the selected lines, and a closing ` ``` ` followed by Enter, or two blank lines
at the end, leave the block. **Backspace** at the start of a code block turns it
back into plain lines. Choose the language in a code block's corner to change
it. Very large code blocks are shown without syntax highlighting.

## Spelling

Right-click an underlined word to replace it with a suggestion. On Windows and
Linux, Scient checks spelling in your system languages. It also checks in the
language of any alphabet you write that none of them uses: Latin letters add
English, and Hebrew, Greek, Armenian, Korean or Tamil letters add that
language. To add or remove a language, right-click in the composer and use
**Spelling Languages**; your choice stays until you change it. Windows
suggestions use dictionaries Scient downloads the first time a language is on.
On macOS, the system spellchecker detects each paragraph's language itself.

## Attach files

On web and desktop, attach files with the file picker, drag and drop, or paste.
There is no document-type allowlist: PDFs, spreadsheets, archives, audio, video,
code, and files with unfamiliar extensions can all be attached. Images without
a native image-input path, such as SVG and TIFF, are attached as ordinary files.
Files must be readable and non-empty, fit the server's displayed size limit,
and finish uploading before you send. Each message can contain up to 100 files.
Each image can be up to 10 MiB, with at most 80 MiB of images in one message.
Other files, including videos, can be up to 50 MiB each, subject to the
environment's upload support and limit. Provider and model limits still
apply, including images already in the conversation. A video attachment gives
the agent a file path; only [Antigravity](./providers-antigravity.md#skills-and-attachments)
sends supported videos to Gemini models as video.

Attaching a file makes it available to the agent; it does not guarantee that
every provider can understand every format. Depending on the provider, it
receives the attachment directly or a server-local path it can read using its
available tools. Uploaded files are not automatically executed.

Click a video attachment to play it. If its format cannot play in the app, use
**Download video**. Select another attachment to preview it when its format is
supported, or save the original file to open it elsewhere.

## Send while the agent is working

On web and desktop, choose **Settings → Chat → Follow-up behavior** to queue
new messages for a later turn or steer the running turn immediately. The setting
applies to this client; already queued messages keep their place. Queued messages
are saved on the server and can be edited or removed before they send.

On web and desktop, a message sent during a running turn joins the queue at the
end of the thread. The server keeps its order across navigation and restarts,
then sends it after the current turn finishes successfully. Use **Send now** on
a queued message to send it into the running turn, or edit or delete it from
the queue. **Stop**, interruptions, and failed starts hold the remaining queue
until you choose **Resume**. A later successful answer does not release that
hold. When the thread is idle, **Send now** on any held message starts it, and
the rest of the queue continues after it in order. Once resumed, the queue
sends each message after the preceding answer finishes successfully.
When Enter sends, `Cmd+Enter` on macOS or `Ctrl+Enter` on Windows and Linux uses
the opposite action: it steers when your default is Queue and queues when your
default is Steer.
If your **Send shortcut** requires `Cmd+Enter` or `Ctrl+Enter`, that shortcut uses
your default follow-up behavior; add **Shift** to use the opposite action. This
applies only to multiline messages when you choose the multiline send option.

Use `Cmd+Shift+Enter` on macOS or `Ctrl+Shift+Enter` on Windows and Linux to send
the oldest queued message as a steer. This leaves the current draft intact and
requires an active turn that supports steering. If that shortcut sends the opposite
action for your draft, move focus outside the composer to steer the queued message. Change
`thread.steerQueuedMessage` in **Settings → Shortcuts** to use another shortcut.

Press `Option+Up` on macOS or `Alt+Up` on Windows and Linux with the cursor at the
start of the composer to edit the most recently queued message. Change
`thread.editQueuedMessage` in **Settings → Shortcuts** to use another shortcut.

Mobile has the same choice under **Settings → Chat**. While a turn is
running the send button shows which action it will take. Long-press it to use the
other action for a single message. From a hardware keyboard, `Cmd+Return`
(`Ctrl+Return` on Android) uses the other action, or `Cmd+Shift+Return`
(`Ctrl+Shift+Return`) when Return inserts a new line. The button only offers
Steer when the running agent supports it.

On mobile, open the queue sheet and choose **Edit** on a waiting message to load it into the
composer without removing it from the server queue. Keep or remove its existing attachments and
add new ones as needed. Sending from this edit mode saves the replacement in place; it does not
send a new message. **Cancel** leaves the queued message unchanged and returns to your ordinary
draft. If saving fails, the edit stays in the composer so you can resolve the error or retry.

## Queue messages offline on mobile

In the retained mobile client (not yet a public Scient release), tap **+** for **Photo Library**
or, when the connected server supports file uploads, **Choose Files**. Photos, videos, and files can
also arrive through the system share sheet. Mobile keeps a local draft copy, allows previewing and
queueing while offline, resumes uploads after reconnecting, and preserves drafts and queued messages
across app restarts. Signing out keeps them on the device until the same account signs in again.

Tap an image or PDF before or after sending to open it. On iOS, the native viewer supports image
zoom, sharing, and PDF page navigation and search. On Android, images use the image viewer and PDFs
open through the system chooser. Videos open in a full-screen player with native controls on mobile;
supported iOS videos stream from their environment as they play. Unsupported formats can still be
saved or shared to another app.

On desktop and web, supported file attachments stay with the message when it is queued.
Editing a fork from a sent message with file attachments is not supported yet;
fork from a completed response to retain the conversation and its files.

On web and desktop, **Settings → Chat → Collapse composer** defaults to **Never**,
so the composer stays expanded. Saved preferences are preserved. You can enable **On unfocus**,
**On scroll**, or both. With **On unfocus** enabled, an existing thread settles its composer into
a single-line resting state when it loses focus. At wider sizes, **On scroll** also rests a focused composer,
except when scrolling toward the end while already there. When the thread-context strip has room,
the model and mode controls stay available beside the thread context; otherwise they return when the
composer is focused. Focus the composer or start typing to expand it again. The conversation keeps
the expanded composer's space clear above its last message while the composer rests, so expanding it
again never covers what you scrolled to. New-thread layouts keep the full composer.

At phone-sized web or desktop window widths, existing threads animate between their compact and
expanded layouts. Up to three image attachments remain visible in either resting layout, followed
by a count when more are attached. At wider sizes, videos, files, and other draft context remain
visible at their natural height; the phone-sized compact row reveals those details when expanded.

On mobile, the model picker shows each OpenCode model's upstream provider, such as Anthropic,
GitHub Copilot, or OpenCode Zen, beneath its name. Search by that provider name to narrow the list
when starting a thread or changing an existing thread's model.

To rename a built-in model on every client, edit the server's `settings.json` in its `userdata`
directory. Add a custom model entry with the built-in model ID and a new name under that provider
instance:

```json
{
  "providerInstances": {
    "codex": {
      "driver": "codex",
      "config": { "customModels": [{ "slug": "gpt-5.5", "name": "Team GPT" }] }
    }
  }
}
```

## Model defaults

Fresh Scient Agent, Pi, and Oh My Pi model preferences include GPT-6.1 Terra among the visible
OpenAI account models when the agent discovers it. Saved visibility choices take precedence.
The reasoning column shows the model’s supported levels directly; other agent options appear
below them when available.

On desktop and web, model choices show the company below the model name. Long names wrap
so their distinguishing suffix stays readable. The picker has one bottom footer: **Fork to
continue in a new chat** on the left when available, and speed and permission controls on the right.

For providers that support custom models, **Settings → Providers → Models** lets you give an
unlisted model a display name and define its options. Only options supported by the integration
affect turns; declaring an option does not add a new provider capability. Antigravity uses the
account's catalog rather than custom model entries.

Scient remembers the last provider, model, and model options you selected and reuses that
selection for new threads. A model configured in a project's settings overrides the remembered
selection for that project; resetting the project setting returns it to the remembered selection.

Model options shown as provider defaults remain display values until you choose them in Scient.
Scient only sends options you selected explicitly, so an unset reasoning level or service tier can
still come from the provider's own configuration.

## Quote a Markdown file

In a workspace Markdown file's rendered view, select text and choose **Ask in chat**.
Scient adds a file-quote chip to the current chat and opens the same optional
comment bubble used for assistant quotes. **Ask in side chat**, offered beside it
wherever a quote can be taken, adds the chip to the open side chat instead, or
starts one. Text in paragraphs, lists, tables,
and ordinary code blocks is supported; selecting an entire image, formula, or
interactive chart is not part of this action. When an editable diagram's source
is visible, selecting that source is supported like any other code block; selecting
the rendered diagram is not.

The chip retains the exact selected text, the original environment and workspace,
file path, and the containing Markdown source lines. The line range describes
where the text appears, not an exact character-by-character mapping through
Markdown formatting. An unsaved draft is identified as such; citing never saves
or changes the file. The quote and comment stay together through draft reload,
copy/paste, and sending.

Click the chip to reopen the original file and highlight the passage. If the
file has changed, Scient highlights only a uniquely verified match. If the text
has disappeared or its location is ambiguous, the saved quote remains intact
and Scient explains that it could not verify the location. The agent receives
the captured quote and its source information, not an automatic read of a newer
file version. If the conversation has moved to another worktree, the original
file opens in the existing read-only host-file preview instead of resolving the
same filename against the new workspace.

## Quote code or source

Select code in a workspace file's source editor and choose **Ask in chat**.
This also works in Markdown and LaTeX Source/Split, compute source editors,
and read-only code previews. The quote keeps the exact selected code, its
file and UTF-16 offsets, and the captured saved or draft revision. Citing does
not save or change the file.

Click the quote chip to reopen Source. Scient selects the original range when
the revision still matches, or a uniquely verified match after the source moves.
If it cannot verify a location, the quote remains intact and the recorded line
opens with a notice. Existing rendered Markdown quotes keep their rendered-view
reopening behavior.

## Quote a PDF

Select text in a PDF and choose **Ask in chat**. The quote keeps the PDF, the
page and the exact text, and its chip reopens the PDF at the passage. See
[PDF reader](pdf-reader.md#ask-in-chat-about-a-passage) for what can be quoted
and what happens when the PDF has changed.

## Quote a Word page or slide

Select text on a Word page or a PowerPoint slide in the file viewer and choose **Ask in
chat**. The quote keeps the file, the page or slide number and the text; its chip reopens the
file at that page with the quote marked. The page number is the one Scient's viewer shows,
which can differ from Word's own pagination. Text in a slide's pictures cannot be selected.

## Quote an assistant response

On web and desktop, select text in an assistant response, then choose **Ask in chat** from the
menu that appears when you release the selection. This inserts an inline quote chip at your cursor
and opens an optional comment bubble beside the selected text; press `Enter` or choose **Save** to
attach the comment, or leave it blank to keep just the quote. You can type before and after the
chip, such as a quote followed by "what do you mean?". A selection must stay within one response
and fit in 8,000 characters.

The chip shows your comment when it has one, or a short quote preview otherwise. Use the pencil
button to add or change the comment, and the remove button to delete the quote and its comment from
the draft. Copying, reloading, and restoring a [stashed prompt](#prompt-stash) keep each comment
with its quote, and sending tells the agent which words were quoted and which comment you wrote.
The quoted text and comment count toward the message limit.

Select a chip in the composer or a sent message to open the source thread, scroll to the response,
and highlight the quoted passage — including in older history. The
highlight pulses, holds for a moment, then fades on its own; press `Escape` to stop the navigation
or clear it early. If the source is unavailable or its text has changed, the saved quote stays
readable and Scient shows a warning.

Mobile shows the full saved quote and its comment in sent messages. It does not offer
**Ask in chat** or navigation to a quote's source.

## Recall a sent prompt

Press `ArrowUp` in an empty composer to bring back the last prompt you sent in this thread. Press
`ArrowUp` again to go further back, and `ArrowDown` to come forward. Moving forward past the newest
prompt clears the composer. Recall walks the prompts loaded in the thread. Attachments, terminal
context, and other extras from the original message are not restored, only the text you typed. A
composer that holds an attachment or a picked element does not count as empty.

When the composer has text, the arrow keys move the caret as usual. Recall takes over only while
the text is an unedited recalled prompt, with the caret on the first visual line for `ArrowUp` or
the last visual line for `ArrowDown`, counting wrapped lines. Editing a recalled prompt turns it
into a normal draft.

## Suggested next prompt

Turn on **Suggest next prompt** in Settings > Labs. After a Claude or Codex turn completes, the
empty composer shows a predicted next message. Press `Tab` to fill it in, then edit or send it, or
press `Escape` to dismiss it. Each suggestion is one extra request that reuses the turn's prompt
cache, so it uses a little of your plan's usage. Claude skips suggestions on the first turn of a
thread and near usage limits. Codex needs version 0.165 or later; if Scient manages
Codex, update it in Settings > Providers. Codex follows a change to the setting at once; open Claude
threads follow it after they restart. Suggestions show on web and desktop.

## Edit an earlier prompt

On web and desktop, choose **Edit from here** beneath a sent message to rewind
the conversation to before that message. Choose **Revert and keep changes** to
leave workspace files as they are, or **Revert files too** to put the workspace back
to its checkpoint from before that message. That also undoes edits you made yourself.
File restore is only offered for threads running in a worktree, and it is
refused when another thread or agent session also uses that directory, a folder
inside it, or a folder that contains it, since
restoring would erase their changes. A thread that works in the project directory
rewinds the conversation only. When Scient could not save a snapshot of the files
before that message, such as in a folder that is not a Git repository or whose
changed files are too large, the dialog offers only **Rewind chat**, which leaves
the files as they are. The selected prompt and its attachments return to the composer for editing and
resending. Any unsent draft stays above the restored prompt.

This removes the selected message and later conversation from the active thread
and provider history. It does not undo external actions or separate provider
memory. The action is available only when the provider supports rewind.

## Prompt stash

On web and desktop, press `Cmd+S` on macOS or `Ctrl+S` on Windows and Linux to save
the current prompt and its attachments for later. Wait for uploads to finish first.
With an empty composer, the same shortcut restores a single stash or opens the
stash menu when there are several.

Stashes containing uploaded files must be restored in their original environment.
Those files are retained for 24 hours. After an upload expires, restore the prompt
and use **Attach again** or remove the missing file before sending.

## Voice input on web and desktop

Use the composer's microphone or `mod+shift+d` to dictate into your draft. Audio
is transcribed on an environment you choose in **Settings → Voice**; nothing is
sent until you choose one. See [Voice input](./voice-input.md).

## Voice input on mobile

Use the composer's microphone to record, then confirm to transcribe. Text is
inserted where your selection was when recording started, ready for you to review
and edit before sending.

By default, audio stays on the phone. Local transcription needs a supported iPhone
with iOS 26 or later, or Android 12 or later with compatible Google speech services.
To use a paired environment instead, open **Settings → Voice → Transcribe on**,
choose the environment, and confirm. Finished recordings go only to that environment,
even when a draft belongs to another one. This also works on phones without local
speech recognition. If the chosen environment disconnects, dictation stops; it never
switches hosts. Choose **This device** to revoke access and discard pending audio.
For [cloud dictation](./voice-input.md#choose-where-audio-goes), open **Cloud providers**
under the environment in **Settings → Voice** and confirm which provider may receive recordings.
On Android, keep Scient open while recording and transcribing.

The first use may download a speech model and needs a network connection.
Later transcription works offline for that language. On Android, transcription
processes the full recording at roughly its original duration. Recordings can be up to five
minutes long. Canceling or an audio interruption discards the recording and
preserves your existing draft. Navigating to another screen keeps dictation active;
use the floating controls to finish or cancel. While recording, the screen stays
awake; it can sleep normally once recording stops.

Choose a preferred order in **Settings → Voice**. Voice input requests the first
connected microphone in the list. The list mixes kinds (built-in, other wired, other
Bluetooth, and CarPlay on iOS) with wired and Bluetooth devices you have dictated
with, listed by name. Drag to rank them together:
for example, put **Other Bluetooth** above your AirPods so a new headset is preferred
while the AirPods microphone stays low. By default, CarPlay comes after the built-in
microphone on iOS. Swipe a device left to forget it. Android may use another input
when the preferred microphone cannot be routed. Devices with the same name may share
a saved preference, but simultaneous same-name inputs remain separately selectable.

Transcription runs on your device. Scient deletes the temporary audio after
transcription or cancellation; only the message text is sent when you submit.

## Queued messages

On web and desktop, the composer shows **Interrupt** while the agent is working and the draft is
empty. Adding text or attachments replaces it with a send button that shows your
[Follow-up behavior](#send-while-the-agent-is-working): a queue icon for Queue or a steer arrow for
Steer. Click it or press your send shortcut to use that action. Hold `Cmd` on macOS or `Ctrl` on
Windows and Linux to switch the button to the opposite action, then click, or use the opposite-action
shortcut described above.

On web and desktop, queued messages appear at the end of the thread as dashed messages that have
not been sent yet. On mobile they appear above the composer. Each shows its text and any attached
images. **Send now** sends a message right away, into the running turn if there is one. While a
compaction runs, **Send now** skips the compaction and sends the message instead. You can also
edit or remove it.

After Stop, a failed turn, or a server restart, queued messages keep their order and are held.
While the agent is idle, every held message shows **Send now**, on mobile too. Send now starts
that message, and the rest of the queue continues after it in order. Sending a new message
directly also continues the held queue after that message. On web or desktop, **Resume** in an
empty composer continues the queue too, as does **Resume queue** on mobile. You can edit or remove held messages without starting
them. If the thread stopped at a usage limit, Send now is not offered: use **Resume thread** in an
empty composer on web or desktop to continue the thread, and the queue follows.

The pencil on a queued message opens it in the composer for editing. The original message
stays in the queue until you save, and it is highlighted while you edit. The message's
attachments appear above the text with a remove control, and new images can be added the usual way.
The checkmark saves the queued message in place; **Cancel** next to it leaves it unchanged. Whatever
you had typed in the composer before starting the edit is restored afterwards. If the queued
message starts or is removed while you are editing, the edit ends: changed content moves into the
composer when it is empty, and is discarded otherwise.

## Commands and skills

Type `/` for commands or `$` to add a skill from the selected environment and
provider. On mobile, both are also available before starting a thread on
**New task**.

The slash menu also includes skills unless you turn off **Settings → Chat →
Show skills in slash menu**, under Advanced. Only skills enabled for the provider are listed.

After you add or change skills, plugins, or MCP servers, use **Restart agent
session** in the command palette on web and desktop. The conversation continues,
and your next message starts the agent again with the new setup.

Provider commands must start the message to run. Scient commands such as
`/model` and skill mentions work on any line.

Send `/compact` in an existing conversation to reduce context usage when the
provider supports it.

Send `/clear` on its own, or pick it from the slash menu, to start a fresh session
in the same thread. Your next message goes to a new provider session that doesn't see the
earlier messages, and the thread marks where it began with **New session**.
Earlier messages and diffs stay in the thread. Dismiss the notice above the
composer to keep the current session instead.

On web and desktop, turn on **Context window** in **Settings → Appearance →
Thread details** to see context usage in the thread details card. It appears
once the provider reports usage.

Claude instances can also compact idle threads for you. See
[compact long conversations](./providers-claude.md#compact-long-conversations).

## Goals

With Codex and Claude, send `/goal` followed by what "done" means, for example
`/goal all tests in packages/api pass`. The agent keeps working across turns
until it judges the goal met. The thread shows **Goal** while it works, and a
line at the end of the thread (above the composer on mobile) shows the goal and
its progress.

- `/goal` alone shows the current goal. `/goal clear` removes it.
- Codex also supports `/goal pause` and `/goal resume`. Stopping a Codex goal
  pauses it, and so does Codex ending its work without meeting the goal.
- Stopping Claude ends the current turn, but the goal stays set. Claude checks it
  again at the end of your next message.
- Sending a new goal, or `/goal resume`, while the agent works stops the current
  turn and starts the goal, unless you queue it. `/goal clear` and `/goal pause`
  stop the turn only when it is working on the goal. Other goal commands wait for
  the turn to end.

## Context in your message

Context you attach lands where your cursor is, as a chip inside your text: a terminal excerpt,
a review comment from a diff or file, a preview annotation, or a file. You can type before and
after a chip, move it by cutting and pasting, and delete it like a character. Hover a chip for
its brief details. Select a terminal excerpt to open its captured output, or select a review
comment, picked element, or preview annotation to open its full details. Chips read as "Terminal
excerpt, Terminal 1 lines 3-4" and similar to screen readers.

A pull request appears as its icon and number. Its color reflects whether it was open, draft,
merged, or closed when it was attached. Select it to inspect the captured title and branches,
then choose **Open pull request** to visit the pull request. On web and desktop, type `#` to browse the newest
pull requests in the current project's repository. Pull requests linked to the thread are included
from any repository and listed first, after any exact number match. Continue typing digits to filter the recent list
by any part of its pull request numbers. A complete number is also resolved directly, even when that
pull request is older than the recent list. Type a single word after `#` to search pull requests in
the repository by text. Choose a result to insert it as a chip.

Another thread can be context too. Type `@` followed by part of its title to pick one from
the same server, or from a machine it links to while the Linked environments beta is on; those
show the machine's name. On web and desktop you can also drag a thread out of the sidebar and
drop it on the composer; a multi-selection drops together. On any client, **Copy thread** copies a
link to the thread that pastes into a composer as its chip. The chip shows the thread's
current title and opens it when selected. Your prompt only carries a reference: the agent reads the thread's
history on demand, so attaching a long thread costs nothing until the agent looks. Attaching a
thread does not change it, and the agent cannot send messages to it unless you ask.

A thread from a linked machine, picked, pasted or dropped, stays a reference that the agent reads
on that machine. A pasted link to a thread on any other machine stays a link. Dropping a thread
from any other environment attaches a saved transcript file. The source
environment must be connected and up to date. The transcript includes the visible history and
saved text context at the time of the drop; later messages and the contents of attached files
are not copied. The agent can read the saved transcript after the source disconnects. Normal
file attachment limits apply.

Type `@` and part of a model or provider name, such as `@opus`, to name that model for the
agent, for example when delegating. It does not change the thread's model. Join words with
`:`, `/` or `-`, as in `@opus:opencode`.

Images keep their thumbnail shelf above the text and also get a chip at your cursor, so you can
say exactly which image you mean. Deleting an image chip leaves the image on the shelf; removing
the thumbnail asks first when the image is still mentioned in your text, then removes both. Files
exist only as chips: deleting a file's last chip removes the file from the message.

Copy text that holds chips and paste it into another draft, in the same thread or another one,
and the chips come along with what they point to. Images and files are fetched again from the
environment they came from; while that happens the chip shows a dashed outline, and if it cannot
complete Scient tells you and leaves the chip for you to remove or replace. A chip whose
context is no longer available shows the same dashed outline; hover it for what to do.

Copying a message with the copy button, or copying text out of it, gives other apps readable
Markdown with a link in place of each chip. Older messages that were sent before chips still
show their context. Stashing a prompt keeps its chips and what they point to; restoring brings
them back.

On mobile, tap a chip to inspect its content. File references open the current file; attached
files show the copy that was attached to the message.

## Attached files

Select a file chip in your draft or a sent message to preview it. Code and JSON use syntax
highlighting; Markdown, HTML, Mermaid, CSV, and TSV offer rendered and raw views. Audio files have
playback controls. Supported Office documents, notebooks, archives, fonts and SQLite files
have read-only previews. A notebook shows its saved cells and outputs; opening it does not
execute its code or load external chart data. Large text files load indexed pages as you
scroll; save the original file when you need it outside Scient.

On web and desktop, files open beside the conversation with the same controls as a workspace
file: a header row with the view toggle, **Copy contents** and **Save file**. On mobile, documents
open in the same file screen as workspace files; its menu holds **Copy contents**, **Save or
share** and **Open in file viewer**. Pictures, videos and PDFs keep their native viewers, and
other document formats such as Word or Pages open in the device's own viewer when it has one.
If nothing on the device can show a format, save or share it to open it elsewhere. A ZIP up to
50 MB opens as a folder list on every surface; on mobile, select a file inside it to preview,
save, or add it to chat.

## Images and videos in messages

On web, desktop, and mobile, select a link to an image or video to open it inside Scient.
Workspace image and video links open the file viewer. Links to media outside the workspace
open a media preview.
Videos opened from the file explorer or a file-viewer tab also play inside Scient. They
stream from the environment as needed, rather than downloading the entire video before playback.
Paths in inline code, such as `/tmp/recording.mp4`, work the same way. Image embeds stay inline;
video embeds show a player with the browser's controls, full screen included. Visible video previews load
an initial frame when supported, but stay paused until you press Play. Video file references use
a filmstrip icon.

On web and desktop, hover over a preview to see its full file path or original URL. Right-click
to copy that reference, save the image or video, or copy an image to the clipboard. The video
player's built-in controls can download a video too. If the player cannot decode a video, its error message
offers a link to open the source in the browser. Workspace media also offers **Copy relative
path** and **Open in file viewer**. These actions are available in expanded previews too.

On mobile, touch and hold an inline image or a video thumbnail to see its source,
copy the path or URL, or choose **Save or share**. Workspace files can open in the file viewer
from the same menu. Saving downloads a copy only when you request it; it does not change how
the video buffers during playback. On iOS, touch and hold a file reference in a message to
copy its full or relative path or open it in the file viewer.

Use Markdown image syntax to embed either kind of media:

```markdown
![Screenshot](/tmp/screenshot.png)
![Recording](/tmp/recording.mp4)
[Open recording](/tmp/recording.mp4)
```

Relative paths resolve from the thread's workspace. Absolute paths and `file://` links refer to
the environment's machine, even when you connect remotely or use your phone. Supported media
can live outside the workspace, including in Downloads or `/tmp`.

Scient serves the original file without adding it to attachment storage. If that file is moved
or deleted, its preview can no longer load from the environment. A browser or device may still
have a cached copy. Supported video formats and codecs depend on the browser or device.

Bare paths in ordinary prose and paths inside code blocks stay text. Raw HTML `<video>` tags
are not supported; use the Markdown embed syntax above.

## Files outside the workspace

When an agent links to a file it wrote outside the workspace, such as a Markdown report in
`/tmp`, select the link to open it in the file viewer. The viewer shows the file read-only, with
rendered Markdown available as usual; it cannot edit files outside the workspace. The workspace
file tree stays hidden because it does not describe the open file. HTML and PDF files outside the
workspace open the same way as ones inside it. Because such a file is served on its own, an HTML
page outside the workspace cannot load scripts, styles, or images from files beside it.

## HTML and PDF files in the file viewer

On web and desktop, the file viewer shows HTML and PDF files as a rendered page. Use the
source toggle in the viewer's header to switch an HTML file between the page and its markup; the
choice persists like the rendered-Markdown toggle. A link to a line always opens the source. HTML
runs in an isolated frame with no access to your Scient session. On desktop, the integrated
browser remains available from the same header for a full browser view.

The file viewer recognizes images, HTML, and PDF files by their filename extension,
including filenames or folders containing `#` or `?`.

On mobile, select a PDF attachment or link to open it. iOS uses the native viewer;
Android opens a compatible installed file viewer.

## Changing projects

On web and desktop, changing the project from a new thread keeps the current environment when that
project exists there. If it does not, Scient selects another environment that has the project.

## Notices above the composer

On web and desktop, loading and syncing statuses use the available banner width. Task progress
appears above the composer, while the timeline's working indicator shows only elapsed time.

When several notices are active, the additional notices peek above the attached banner. Hover over
the peek, or focus **Show other notices** and press `Enter` or `Space`, to reveal them. Press
`Escape` to close the stack. On a touchscreen, tap the peek.

## Prompt stash

To recall text you already sent, press `ArrowUp` in an empty composer. Further presses go backward
through loaded prompts in this thread; `ArrowDown` goes forward and clears the composer after the
newest prompt. Recall restores text, not attachments or other context. A composer holding an
attachment or picked element is not empty.

Use the default shortcut, `Cmd+S` on macOS or `Ctrl+S` on Windows and Linux, to stash the current
prompt and its attachments after uploads finish. Restore the entry later from the stash menu. A
stash containing files belongs to the environment where those files were uploaded. The server keeps
stashed files for 24 hours; after that, restore the prompt and use **Attach again** or remove the
expired file before sending.

With exactly one stash and an empty composer, the stash shortcut restores that entry directly.

## Voice input on iPhone

In the retained mobile client, supported iPhones with iOS 26 or later can record a message from the
composer. Tap the microphone, speak, then tap the checkmark to transcribe on the device. The draft
stays visible in an expanded composer; a collapsed composer becomes a compact recording strip. The
result is inserted where recording began so it can be reviewed and edited before sending.

The first use may download Apple's speech model and require a network connection. Later
transcription works offline for that language. Recordings are limited to five minutes. Canceling,
leaving the screen, or an audio interruption preserves the existing draft and attachments while
discarding the new recording. Scient deletes the local audio after transcription or cancellation
and sends only the normal message text.

## Commands and skills

When an agent provides an artifact-template card, **Use template** adds its
skill prompt to your existing draft. Review or edit it before sending; the
button does not send a message automatically or grant new permissions.

Type `/` to open the command menu. Type `$` to find and add a skill. Skill rows show their source,
such as System, Personal, Project, or App.

On mobile, these menus are available on the **New task** screen before you start a thread. They
use the skills and commands from the selected environment and provider.

In a thread with prior conversation context, send `/compact` to reduce context usage. Web and desktop also offer this action from the context meter, and the work log records token counts when the provider reports them.

On web and desktop, new profiles leave **Show skills in slash menu** off. Type `$` to select a skill,
or turn on this option in **Settings → Chat** (under Advanced) to include skill aliases in `/` as well. Saved
preferences are preserved. Provider-native slash commands are still shown when skill aliases are off.

When enabled, skill results use the `/skill:Skill Name` label and add the
same `$name` skill token to your message. The original skill name remains searchable. If the provider
also reports that skill as a native slash command, Scient hides the duplicate native entry and keeps
the `/skill:Skill Name` label.

Scient-managed skills are available from **Settings → Skills** on supported providers. **Agent may
use** lets the agent select a skill when the request clearly matches it. **Only with $name** keeps the
skill available only when you add its exact `$name` token. Skills provide instructions; they do not
add tools or permissions. Changes apply to the next message.

Project skills live at `.scient/skills/<name>/SKILL.md` inside an initialized Scient project. A
new valid project skill is available automatically on the next message and only in that project.
Use **Settings → Skills → Project skills** or the project's **Skills** settings to choose **Agent
access**, **$name only**, or **Deactivated**. Agents can create these ordinary project files when
asked; your access choice remains controlled in Settings.

A skill token runs the skill wherever it sits in your message. Scient sends it to each provider in
the form that provider runs, so the text before and after the token is kept. Skills that only you may
start, and never the agent on its own, work the same way. A skill you switched off in the provider's
settings does not appear in either menu.

Use **Settings → Skills → External skills** to inspect provider-owned skills.
Where a switch is available, it changes the provider's own setting and can also
affect that provider outside Scient. Codex, Grok, and ordinary personal Claude
and Droid skills support switching; other entries remain read-only when Scient
cannot change their native setting. Claude and Droid project skills are
read-only here: change them in the project. A provider may require a new
conversation to load changed settings.

Provider commands such as `/compact` only run when they open the message, so the `/` menu offers
them only there. Scient's own commands, such as `/model` and `/plan`, and skills stay available on
any line.

On desktop, press `Cmd+Enter` on macOS or `Ctrl+Enter` on Windows and Linux from a new thread to
start it in the background. Scient opens another new thread and shows an **Open** action for the
thread that started. The new thread keeps the selected workspace mode and base branch. If **New
worktree** is selected, each background thread creates its own worktree.

## Continue with another provider

Forking lets you continue a conversation with a different provider or model
without changing the original. Use **Fork** beside a sent message or completed
response, use **Fork to continue in a new chat** in the model picker, or run `/fork`
to start from the latest completed response. In the new conversation, choose
the provider and model you want before sending.

**New worktree** is off by default, so the fork uses the current workspace without rewinding its
files. Turn it on to create an isolated worktree at the selected checkpoint. The switch is
unavailable when the project is not a Git repository or the fork point has no saved checkpoint.

Forking from a completed response keeps the conversation through that response.
This includes submitted question answers and their attached files, with independent copies owned
by the fork. Unsubmitted question answers stay with the original conversation.
Forking from a sent user message places that message and its images in the new
composer as an unsent draft. A temporary setup failure is safe to retry; Scient
does not open a partially created conversation.

Scient checks the selected response, retained attachments, and available
workspace before creating the fork. A stopped or failed answer is not a
completed fork point; choose an earlier completed response or a sent user
message instead. `/fork` and the provider picker's Fork action resolve the
latest completed response on the server.

A fork of a running response with **New worktree** off shares the current files;
it does not capture another workspace snapshot. Its first send records its own
starting file history, including changes made between forking and sending.
Rewind uses that saved starting point, never the repository's latest commit.
Restoring files into a folder shared with another live conversation remains guarded.
With **New worktree** on, Scient captures the current files before admitting the fork.
If that capture exceeds the snapshot limits, fork locally or reduce the files included
in Git's workspace snapshot. Scient does not change your ignore rules automatically.

Errors appear inside the fork dialog. **Retry** resumes the same attempt,
including its original title and workspace choice. Losing the connection does
not discard the staged draft or create another conversation. This recovery
survives reloading the app in the same browser profile. If you switch
conversations during setup, Scient finishes the fork in the background without
moving you away from your current conversation. Open the ready fork from the
sidebar, or return to the same Fork action to resume it.

If the original worktree was removed, **New worktree** can still restore its
saved checkpoint when the project repository retains it. Scient never silently
substitutes a different workspace. Missing retained files must be restored, or
you can choose a fork point before they were attached.

You can rename the fork afterward without affecting its history or source link.
The **Conversation forked here** marker opens the original conversation, even
after either conversation is renamed. Archived originals can still be opened;
deleted originals remain unavailable.

Choose any configured, available provider and model before the fork's first
send. The provider-switch Fork action moves an unchanged ordinary composer
draft after setup succeeds. A draft changed during setup stays in the original
conversation. Queued messages and queue edits always stay with the original;
forking never sends them.

If the first request's provider acknowledgement is lost, Scient does not
automatically send it again. A response to that request lets you continue in
the same fork. If no response arrives, create a fresh fork from the last
completed response to start an independent session. Retained history is sent
as bounded context, so very long histories and older images may be omitted
from the provider's input while remaining visible in Scient.

Server-checked eligibility and in-place setup retries require an updated
server. Older servers retain their previous fork behavior and recovery limits.

## Queue or steer while an agent is working

On desktop and web, press **Enter** while an answer is running to queue your
message, images, and selected context in that thread. Terminal excerpts, review
selections, and browser annotations stay with the queued message, including
when you edit it. Messages start one at a time after the
previous answer has fully finished. They continue in their original thread when
you visit another thread or close its view. Sending while other messages are
waiting normally adds your message behind them. After **Stop**, an ordinary new
message starts work while that queue waits, as described below.

Use **Cmd+Enter** on macOS, **Ctrl+Enter** elsewhere, or a queued row's **Steer**
action to request an immediate steer. The provider must support adopting the
message into its current turn; a rejection remains visible.

Drag queued rows to change their order, or delete them. **Edit** removes a row
from the waiting list and puts its text, attachments, and context into the same
composer as an ordinary draft. Any draft you were already writing is saved in
the usual stash menu. The edited message has no reserved queue position.

Other waiting messages can continue while you edit. Your draft stays in the
composer until you press **Send**: it starts when the thread is idle and eligible,
or joins the end of the queue when work is still running or other messages are
waiting. Finishing a turn or starting another queued message does not submit
your draft automatically. **Stash** saves it for later through the usual menu.

**Stop**, interruptions, and failed starts leave the remaining queue held.
Sending another ordinary message releases the queue to follow it automatically,
one message at a time after each successful answer. Restarting work or the server
does not release a held queue. You can also click **Send** on any waiting message:
that message starts first and the remaining queue is released in its retained
order, with automatic completions first. Reorder while idle to choose the order.

**Retry** is for a queued message whose provider failed to start; the message stays
queued. It cannot bypass a running answer or silently release the held tail.
Ordinary **Send** is accepted as a new turn
or a queued message, including while the previous answer's checkpoint is settling.
This completion race does not require sending again.

Queues survive app restarts and hold up to 20 messages and 64 MiB per thread,
including their attachments. Local threads that have not reached the
server yet have no persistent queue. Edited drafts recover from this browser's
local storage; keep the owning window or reopen it to finish an edit. Older
clients must update before sending to a server using the new queue protocol.

## Reading while an answer arrives

While the agent works and you are at the bottom, the view follows it: thinking,
tool steps and short progress notes scroll by at a calm pace, so you always see
what it is doing now. It stops for things you read: when an answer, a plan or a
card arrives, the view follows it only until its start reaches the top of the
reading area, then stays there while the rest grows below. Work you opened
yourself, such as an expanded tool group, counts as something you read too.
After that stop, a newer message pushed below the screen shows just its first
lines. "The bottom" means the end of the latest content, and you still count as
at the bottom with up to its last three lines hidden behind the composer.

This works the same however the agent's turn started: from this window, another
window or device, a schedule, another agent, or a queued message that starts
while you are at the bottom. Opening a working thread at its end follows it too.
Your own message is part of the work going by; it may scroll away above.

Scrolling up stops following, and the agent's activity then never pulls the
view down. Scroll back to the bottom, or click **Scroll to end**, and you follow
it again; what you scrolled past is treated as read, except an answer still
arriving, which is never followed down. Selecting text holds the view still
until you clear the selection. Clicking does not stop following. If you send a
message while reading earlier content, your position stays where it is.

Your queued messages stay reachable. While you follow the agent they are part
of the end it keeps in view; queuing a message at the bottom brings it and its
**Send now** into view; and a queue that is fully in view stays in view when it
grows or the composer grows while you edit. When your queue is below where you
are reading, **Scroll to end** appears and says how many messages are queued.

While nothing is running and you are at the end, the end stays in view when the
window resizes or a diagram or image finishes rendering.

**Scroll to end** jumps to the bottom. It appears when more content remains
below you, not just blank space reserved for message placement, or when your
queued messages are out of view.
Its small count shows
new answers below your view that you have not reached yet: once per response,
not once per progress note or streaming update. It excludes your messages and
tool activity.
The count tracks reading within the current app window session; opening older
history does not mark it newly unread.

Returning to a thread, or reloading the same window, restores the message you
were reading and its position in the view. If you left while the view was still
following your message's response, you come back to where it would be now, and
it keeps following while the agent works. If a temporary working indicator has
become an answer, restoration uses that turn's content. Older history loads when
needed to find the saved message; if a few pages do not contain it, the nearest
message or the end is used instead. A thread with no saved reading position
opens at the end once, and stays there while its rows finish rendering. These positions are local to the window, not synced read receipts.