Conversations

A session is a conversation in one workspace. Confirm the workspace name before sending a request: Kin’s work uses that folder and its instructions.

Start or resume

• Choose New session from a workspace’s Overview, a pinned workspace’s menu in the sidebar or its tile’s menu on Workspaces, or Search or ask Kin for a fresh conversation there.
• Choose Ask Kin on Home for a fresh conversation in Kin’s workspace.
• Choose Show Kin in the top bar or Ctrl+J / ⌘J for Kin’s panel. Chat in the sidebar gives that same conversation the whole page.
• Choose Continue · … on Home or a row under Live to return to work.
• Choose a workspace’s Session history… to find ended sessions. Search by title, then select one to continue it. The history control beside Live opens history across workspaces.

A conversation with nothing said in it yet is called New session everywhere. If you type or attach files, it stays under Live when you switch away. Choose that session to return to its draft. Each session keeps its own unsent words and files, even when several share a workspace; a new session starts separately. An entirely empty new session ends when you leave it.

Choose another workspace while you’re in a new session’s Chat and it goes with you, words and all (finding your way around). Drafts kept before this update are available through New session in their workspace.

Saved history comes from Kin. Opening a new browser window does not create another copy of your conversation history.

If a reply cannot be read, Space asks you to reload to recover it from Kin. Your unsent draft stays available, and later replies can still arrive.

A session is named after your first message until Kin gives it a better name. If your Kin has a small model set aside for housekeeping, it names a session in a quiet moment after it has something to say, and the new name appears in the sidebar, the palette, the top bar and the workspace Overview without reloading. Choosing a model before your first message still lets that message name the session. An older session left as New session can recover its name when resumed if its original message remains saved. A name you choose yourself stays yours.

Each live session carries a light along its edge, with its state in words. It follows the session through Live, the workspace Overview, Home’s Sessions card and the palette:

State	What you see and what to do
Working	A moving light; open the session to follow Kin’s activity. Small lights also show agents still working.
Needs approval, Has a question, or a plan to review	An amber light; open the session and answer its waiting choice.
Finished	Work finished while you were elsewhere, or while you were away from a session on screen: after a minute with no key, click or scroll, Space counts you as away. The light and word stay until you open the session, or until you are back with it in front of you, including after reloading this tab.
In use elsewhere, or a named client	A dotted edge; another client holds the keyboard. Open to watch or take the keyboard.
Reconnecting	A dashed light while this browser rejoins; wait before retrying a message.
Ready	The conversation is ready for another message. Live says Ready and how long the session has been open. Its edge keeps a still grey line, which the light fades into when a turn ends.

Background agents can keep working after Kin’s turn ends, and so can commands Kin started in the background. Their count stays in the caption, such as “1 command running”, and small lights keep moving on the edge until they finish.

While this session is open, a finished background agent or command, or a note from another conversation, can bring Kin back to work automatically. If you have left the conversation, a waiting command result can bring Kin back to work when you open it again. That continuation shows activity without adding an empty message from you. Enter queues your next words while Kin works, and Finished still marks work that ended while you were elsewhere. A retry caption names the wait and shows its remaining time; an error can include the action needed to continue alongside the failure message. Follow a named wait or sign-in action before repeating your request. The plain failure note can fold What Kin said beneath it for more detail. If her answer was cut off at the model’s output limit, or she reached the limit of model rounds for one turn, the note says so: ask her to continue.

Kin records how each turn ended, so these notes stay when you reopen the conversation. A turn that could not finish keeps its reason: an error, a limit, an interruption, or no recorded ending at all. An interrupted or unrecorded turn never reads as finished, and its note says some work may already have happened, so inspect files and saved messages before asking again. A turn that finished, or that you stopped, adds no note. With a Kin that does not record endings, these notes are temporary page guidance; after reloading, use saved messages, tool results and files to inspect the outcome. If Space says a session ended before its background work settled, inspect its saved history and changed files before starting more work.

On a Kinra connection configured for background model work, Reconnecting to her model means Kin is reaching the same answer again after its stream dropped; generation can continue while it reconnects. Wait before repeating your request. The conversation also says if an answer expired before Kin could receive it, if Kin could not confirm a stop, or if the model’s answer was cancelled elsewhere. A stop Kin could not confirm remains bounded by Kinra’s own time limit; it is not a confirmed cancellation.

A folded Live heading names the strongest state among its workspace’s sessions; a workspace’s own row in Pinned carries no light of its own. With the sidebar folded, a pinned workspace’s square carries the strongest state of its sessions, and the search control the strongest across all of them. State words remain available without relying on colour or motion; reduced motion holds the lights still. The top bar names where you are.

A scripted conversation fixture in the real browser interface. Messages and model labels are examples, not an inference or provider-availability claim.

Follow a link into a conversation

A link from another app can open a new conversation in a named project or portfolio, with a question waiting in its message box. Sign in if asked, then review the workspace and words before sending. Opening the link sends nothing to Kin and grants no workspace or server trust.

The workspace must already exist at the top of your home. A link cannot create it, open a portfolio member or choose a model. If you left a draft there, the link’s words follow yours. If your draft is a command, Space keeps it and explains why the link’s words were left out. An invalid workspace or message produces a notice instead of starting work. If a long link cannot survive sign-in, sign in first and follow it again.

Name a session

Choose Rename… from a Live row’s … menu, or its separate pencil control on the workspace Overview. The Overview also lets you name a recently ended conversation without opening it.

1. Edit Session name, starting from the current saved name.
2. Use a nonempty, printable single line of at most 256 characters.
3. Choose Save, or press Enter. Cancel or Escape leaves the name alone.

The saved name follows the conversation through Live, Home, Session history, the palette, headers and its next alerts. Kin keeps it through compaction and restarting and does not replace your chosen name automatically. Renaming sends no message, starts no model work, resumes no ended conversation and does not take its keyboard.

If saving fails, the previous name and your edit remain. If someone else named the session meanwhile, the dialog shows its current saved name; review it and choose Save again only if you want to replace it. If the response was lost, Space reads the saved name before allowing a retry—it may already have been saved. Refresh name appears if that read could not finish. A cancelled save already in flight may still finish, but its reply never takes over another rename’s draft or focus. An older Kin offers no Rename saving path; update your Space first. A removed copy’s row keeps its recovery path rather than offering a name edit.

Work side by side

A new session starts exactly in the workspace you name, even while another conversation or terminal agent is working there. The workspace menu, palette and empty conversation no longer offer a copy as a starting choice, and Space does not choose one from how busy the folder looks. Your existing sessions, copies, branches, drafts and kept views stay where they are.

Two edits in one project can still trip over each other. Kin may give independent editing agents their own copies when the work needs isolation; your parent conversation stays in its named place. She starts a copy from the last checkpoint, not unsaved work. A copy isolates repository files, not ports, databases or the rest of the machine. It grants no extra permission to keep, share, bring back or discard work.

A retained copy’s sessions still read Copy of Garden; in its workspace’s Live group they say Own copy and its name. Choosing one opens its actual copy, not the main folder. New session on that copy’s Overview stays there. A copy is trusted as its project is; the project’s settings and files named by .worktreeinclude come along. An agent’s facts name its copy, such as in its own copy, ab12cd-agent1. Inspect it and bring work back from the project’s Overview or the copy’s Source.

Session history retains a removed copy’s conversation and asks before making that named copy again from the project as it is now. A failed recovery does not silently continue the conversation in the main folder. Copies need a Kin that supports them; ordinary starts use the named workspace with older companions too.

Notes from your other conversations

Kin’s conversations on your machine can send each other short notes: to say that one finished something another is waiting on, or that two are changing the same files. Ask Kin in one conversation to tell another, for example:

Tell the session working on the garden plan that the sunlight measurements are in Garden/STATUS.md.

Kin asks before she sends a note. A note Kin has read appears in the receiving conversation where she read it, captioned with the conversation that sent it, such as From Garden thought · garden, and its time. Its words are shown exactly as they were written, never as your message, and Kin’s reply follows it. A note from a conversation that keeps customer records under custody in another workspace arrives under that conversation’s name alone, without its title, since the title may echo those records.

A note that has not reached Kin yet waits above the message box, listed under the conversation that sent it:

• A note from other sessions waits for Kin’s next step. Kin reads it when she next can, and an idle conversation open in Space can wake to read it. Hold keeps this note, and any that follow, for you to look at first.
• A note from other sessions is held for you. Kin hasn’t read it. Let Kin read gives it, and any that follow, to Kin. Refuse turns it away, and any that follow.

These buttons answer for this conversation only, as Kin’s /messages command does, and its reply appears in the conversation. After Refuse, nothing waits above the message box; send /messages accept or /messages hold to take notes again. When another window holds the keyboard, take it to answer. See Kin’s sessions guide for how notes travel between conversations.

Talk with Kin from any page

Kin has a panel that opens over any page, so you can talk without leaving what you are doing. It uses Kin’s workspace, ~/Workspace/Kin, where she keeps your home and personal memory. A project’s own conversation stays with that project. Chat and the panel show one conversation in two sizes.

Open the panel with any of these:

• Show Kin, the speech bubble at the end of the top bar on every page. While the panel is open, the same button reads Hide Kin.
• Ctrl+J, or ⌘J on a Mac. It puts the cursor in Kin’s message box; pressed again from inside the panel, it hides her. When Kin is waiting for a choice, the first press takes you to that prompt.
• Show Kin in the command palette.
• Ask Kin on Home for a fresh conversation, or a card’s K to ask about that card. For a custom card, the draft includes up to six of its text files, beginning with its page and settings when present. Your existing words are kept.

In a wider window the panel floats over the page from the side, and the page beneath stays in use at its full width. Dock beside the page gives it a column of its own and the page fits into the space left, including the Terminal, whose grid resizes. Float over the page returns that room. Narrow desktop windows share the available width rather than letting the dock cover the page. Drag its inner edge to change its width, or Tab to that edge and use the arrow keys; where there is too little room to resize, the edge returns when you widen the window. Space remembers where you put it, its width, and whether you left it open. From inside the panel, Escape hides it while it floats; a docked column stays until you choose Hide Kin. The keyboard returns to where you were.

Over a workspace’s Overview, Files, Source or Terminal, the project’s session may already be open, floating over the page as the panel does (the session beside the page). Rather than cover one another, Kin’s panel and the session then stand as a stack of cards: where they float, or in the column of whichever you docked. The card in front fills the stack; the one behind shows only its heading, a shade darker. Point at that heading and the whole card lifts, then click it to bring it forward, or Tab to its title and press Enter; the cursor goes to its message box. Choosing the session in Live brings it forward too. Escape puts away the card in front: Kin hides, or the session goes until Show the session brings it back. Where both are docked and the window has room for two columns beside the page, they stand side by side instead. The two headings match: each starts with its glyph, the workspace’s for the session and the speech bubble for Kin, and ends with Open in Chat, dock or float, and hide.

On a phone, including one held sideways, or in a window as narrow as one, the panel is a sheet that rises from the bottom of the screen and keeps its message box above the keyboard. On a touch screen it opens on the conversation; tap the message box when you want to write. Put it away with Hide Kin, Escape, or by pulling it down by its grip or the bar at its top. A reload does not reopen it.

A conversation begins when you first send a message; opening the panel alone adds nothing to Live. The first time you send there, Kin asks you to trust her workspace. Read the choices before deciding: Trust this workspace means she will not ask again there, and Not now keeps your words in the panel without sending them.

Open the panel again and it takes up the conversation already in Chat, or the latest live conversation in Kin’s workspace. It also opens that conversation for watching when another device holds the keyboard. Its place reads Chat in Live and Home’s Sessions card. Choosing its row opens the panel while the panel holds it. Kin ends a conversation a day after the last device lets go of it; Session history keeps it for continuing later in Chat.

• New conversation starts afresh and leaves the last one under Live, as New session does.
• Open in Chat moves the same conversation to the whole page. Opening the panel over Chat takes it back into the panel and returns the page to Home. If Kin does not confirm the handoff, the conversation and your draft stay in the panel so you can retry.
• End session, from its row’s … menu, ends it as it would any session.

The panel keeps a draft for its workspace. Hide it and Kin keeps working; Live marks when she finishes, and an alert can tell you when she needs an answer. About thirty seconds after you hide it, it releases the keyboard for another device, once any message on its way has been accepted. Opening it again can take a free keyboard automatically.

Questions and approvals from the panel appear where its message box usually sits. The page’s conversation can show its own question at the same time. A question asked while the panel is hidden waits until you show it again, and its row in the sidebar says what it is waiting for. When Kin has a view or a page for you, Open view or Open page waits above the conversation beside a close icon, Dismiss view or Dismiss page; a view opens in Chat. A page waits the same way above Chat’s message box. Files you attach in the panel belong to the workspace its conversation is in, normally Kin’s workspace, and the panel stays there until you send or remove them. Ask Kin cannot begin afresh while a message is awaiting acceptance or files are attached in another workspace; the notice explains what to settle first. For work that belongs in a project Kin can offer to start a session in that project.

Ask about a project without leaving Chat

In Chat, Kin’s panel, or a conversation begun with Home’s Ask Kin, you can ask about projects you have already trusted:

What does Garden still need before its next release? Compare its checklist with Orchard’s.

Kin can find the available projects, read the files relevant to your question, and answer here. Asking does not start another session. If a name could mean more than one project, she asks which you mean.

Availability uses your saved trust for each exact project folder, not a second reading list. A portfolio and its members qualify separately: trusting the portfolio does not include repositories inside it. A missing or replaced folder, or one whose trust you removed, is no longer available through this workflow. Kin can explain what she could not read and offer the project’s normal session and trust review; she does not trust it for you.

This is for conversations in ~/Workspace/Kin, not ordinary project sessions, apps, copies, the night or child agents. Reading does not activate the project’s settings or give this conversation permission to change its files or run its commands. It is not an operating-system sandbox, and removing trust does not erase what has already been read into the conversation. See Kin’s permission boundaries.

When you ask for a concrete project change, Kin can offer a session brief with the goal, files she read, constraints and checks. You review and can edit it before starting work under that project’s own guidance and trust. You stay here; the new session does not inherit this chat, and its result returns only if you bring it back. A question alone need not become a session, and declining an offer leaves the discussion here.

Kin’s workspace and memory

Your home arrangement, workspace icons and custom cards live in ~/Workspace/Kin, alongside the instructions you keep for Kin. Changes there are kept in local Git history with the conversation or night that prompted them. The workspace is reached through Home and Chat rather than another row among your projects.

Ask Kin there to remember a preference or a useful fact about you. Her memory is plain Markdown in Kin/memory/: an index, MEMORY.md, and a file for each memory. You can inspect and correct those files. They are loaded as personal context in Kin’s own workspace, where the night also tends them.

Ask her to forget an item to remove its file and index entry. It then stops loading as memory. Earlier copies remain in Git history until you deliberately remove that history; forgetting is not an erasure of every retained copy.

When the night is enabled for your Space, it uses the Kinra Gateway by default. To use another model, choose a model for Unattended in Kin’s terminal /models hub. This choice is separate from the model you use in a conversation. Without either a Kinra connection or an Unattended choice, the night stays quiet. A sealed letter waiting for a model explains those two ways to enable reading.

Continue in another workspace

Name the project or existing folder when you want Kin to continue elsewhere. Space shows the destination and an editable Message to bring. Review the message, then choose Open conversation. Kin asks for destination trust as the next step in that same conversation area, on the new conversation’s connection.

The new conversation has its own workspace and history. Your reviewed message waits in its composer for you to send. The original conversation and unsent draft stay where they were. Local file selections stay with the original conversation; the review names them. Hide keeps your edited message for later, Show returns to it, and Stay here declines the move. Stop Kin stops the blocked turn.

A request allows up to five minutes for review. If the destination cannot open or the request expires, your original drafts remain. After reloading, the message to bring may start with only the destination’s existing draft; you can edit it before continuing.

Start a session in another project

When part of what you ask belongs in another project in your Space, and can go ahead on its own, Kin may end its reply with a brief for that project. Space shows it as a card: the project’s name, its exact folder, the brief, and Start session. Nothing happens until you choose it.

Start session opens a review. Edit the Brief if you like, then choose Start session again, or Cancel to leave everything as it was. If the project needs trust, the same review shows that choice for the new conversation. The brief becomes the first message of a new conversation there, which runs under that project’s own instructions and trust.

You stay in the conversation you were in. The new session appears under its project’s heading in Live, and the card reads Started · Open session, even after a reload. If the card is out of view, a short notice also offers Open session. Start again starts another one. Nothing from the new session comes back to this conversation; if you want its result here, paste it.

A brief for a folder that does not exist, is outside your Space, or is the project you are already in stays an ordinary code block, with a line saying why. In Kin’s terminal or another client, the brief is a code block you can copy.

Write and send

The message box ends in one corner key. Its arrow, Send message, is visible on desktop and touch. Your message joins the conversation the moment you send it, and the message box is free for your next words. Until Kin confirms the message, the key reads Sending… and your next one waits. On a desktop keyboard, Enter also sends and Shift+Enter adds a line. On a touch keyboard, Enter adds a line; tap the arrow to send. At the beginning of the composer, Up recalls earlier prompts; Down returns to the draft you parked. On a touch screen there is no Up to press, so Recall last message appears beside + while the draft is empty. The composer grows to a share of the space above the keyboard rather than of the whole screen, so the conversation keeps its room while you type. The field grows with its frame, and while you are following the latest content the conversation’s end moves with it.

Drop or paste files, or choose +, to attach up to eight files. They go to Kin rather than into your project: each waits with Kin beside the workspace’s conversations, so nothing new appears in Files or in the project’s changes. The copy’s name uses ordinary single spaces and omits invisible characters, including the unusual space in some screenshot names. Removing a file chip before you send removes Kin’s copy too. Once a copy goes with a message, removing a stale chip in another window keeps that copy, even after Space restarts. If a send loses its connection before confirmation, Space keeps the copy so Kin can still read it if the message arrived. A long list of attachments scrolls inside the composer so the message and send control stay in reach. If the installed Kin cannot keep handed files, uploads still go into the workspace; removing a chip then leaves the file in Files.

To share an existing workspace file by its path, it must be inside the conversation’s workspace. Ask Kin about from Files, a Home card or a view says so and adds nothing when the file is elsewhere; open a session in that file’s own workspace to ask about it. A view of a running application is not a file: Ask Kin about this view puts its address in your draft instead.

After you send, an Attached group stays with your message in the timeline. Choose a file to open it again. A file you gave Kin opens as the copy Kin keeps; a file from the workspace opens its current contents, which may have changed since you sent it. Attachments also appear when you reopen the conversation; seeing one records what you shared, not whether Kin has read it.

When the work calls for it, Kin can check Space’s current project, its Git status and its document locations. This happens on request from Kin. Unsaved editor paths are visible, but their text is not: save an edit before asking Kin to read it.

Unsent words and attached files keep their place through a tab’s recovery and moves between Chat and Kin’s panel, and two windows on the same conversation add and remove files without overwriting each other’s choices. A late confirmation of an earlier message clears only what that message carried, never newer words that happen to match it or a file you chose again.

If a message may not have arrived

Space keeps an exact copy of every message, with its files, until Kin confirms that she recorded it. On a healthy send you never see that copy. When confirmation is lost, for example because the connection dropped as you sent, a card above the message box says so and takes the message back: it leaves the conversation, and if you have not typed since, its words and files return to the message box beside the card. Open Original message and files to read exactly what was sent.

Card	What it means
Message waiting for confirmation	Space cannot yet tell whether Kin received it.
Kin didn’t receive this message	Kin confirms that exact message never arrived.
Kin received this message	Kin has it but has not yet confirmed recording it.
Message not sent	The message never left this page, for example because its model could not be set up.

• Check again asks Kin what she received. It sends nothing.
• Retry original message appears only after Kin confirms the message never arrived, and sends the same words and files. Send original message sends a message that never left this page.
• Forget recovery copy… asks before letting the copy go. Forgetting does not cancel anything Kin may already have done with it, and your newer words and files stay.

Reconnecting or reloading never sends a kept message again by itself. While the card waits, the message box says Resolve the outgoing message above before sending another. Once the card says The recovery copy is kept by Space, you can leave the conversation and come back; until then, keep the page open.

The model control changes the model, working mode, and supported reasoning settings. An existing session keeps its own model, and each model remembers its own reasoning effort. See Accounts and models.

For workspace email, Ask Kin about this email prepares an unsent copy. It carries the readable document, original email, a manifest and up to five extracted attachments under the existing eight-file limit. Conversion warnings and links to inline images travel with it. These copies preserve the received material; attaching them does not establish that Kin has read every workbook or image.

Your workspace operator can also connect Space’s native mail tools to Kin. After server trust, Kin can list and read saved correspondence in that workspace. Retrieving an original, attachment or complete bundle asks before making private temporary copies for her file readers. This tool path has no eight-file limit and keeps the workspace’s custody restrictions. A reconnection needs fresh file retrieval; arrival still starts no conversation.

Keep a long conversation going

Kin compacts a long conversation so there is room to continue: older context becomes a summary while recent messages and tool results remain. Every earlier turn is condensed into that summary; none is dropped whole. Your saved conversation keeps its name. Compaction can happen between tool steps in one long turn; you need not send another message to make it durable.

Space marks where this happened with Kin summarized the earlier conversation to make room. Open What Kin’s summary keeps beneath it to read the summary. It is Kin’s summary, not a message from you, and stays that way when you reopen the session. Kin keeps promises and unfinished work between her conversations in the summary. A note from another conversation remains that conversation’s claim, including anything it says you approved; it cannot supply your approval.

On a ChatGPT subscription, Kin uses the account’s model guidance and newly returned tool results to decide when to compact. A known account maximum bounds the active context budget; your own window setting is kept when you change models or resume. Explicit compaction settings still take precedence. If a summary cannot be saved, Kin reports the failure and avoids repeating it on unchanged context. See Kin’s session guide for the policy and recovery details.

When Kin asks you something

A question, approval, plan review, or workspace trust request takes the place of that conversation’s message box while Kin waits. The transcript stays in view and you can continue reading it. If several requests arrive, the oldest shows first with a count; answering it brings the next. Your unsent words and attachments return when the requests are done.

Choose Hide, or press Escape, to fold the request into a short bar. This does not answer Kin. Show opens it again, with any choice you made still selected. Stop Kin cancels the turn, except when you are deciding whether to trust a workspace. A question’s Skip question tells Kin you are passing on it. On a phone, a view Kin showed you stays above the question instead of being covered by it. Kin’s panel has its own request area, so it can wait while a page’s conversation also waits.

An approval shows the complete operation and its review evidence. A command keeps its arguments visible, and a file change shows the added and removed lines. Read that evidence before deciding. Allow this action uses the shown action; Decline refuses it. You can include a direction when you decline, and Kin receives that note with the refusal. If you leave the conversation, a waiting request remains Kin’s and appears again when you return as its writer. A background agent’s question can remain after Kin’s own turn ends. Answering in another window clears it here too, including in a window that only watches. If someone answered just before you, Space removes the request and tells you it was already settled. An alert for a session you are not looking at offers Open to take you to it.

For folder access, read the exact folder, Kin’s reason and the scope beneath each choice. This conversation starts selected. When Kin offers Until revoked, that choice also applies in later trusted conversations, including unattended work. Choose the lifetime, then Allow folder access. Protected files still require their own approval. If a folder cannot receive remembered access, the request explains why and offers the current conversation alone.

Send /grants in the composer to review access. To revoke one, copy its key from the result and send /grants revoke <key>. Revocation removes the write access that grant supplied. Older requests may show the general approval without a lifetime choice.

Servers and customer records

A workspace can connect Kin to an MCP server, which supplies tools and data. Trust MCP server shows its connection, credentials and any custody terms before connecting. Read that evidence and choose Decline, For this conversation or Always trust. Persistent trust lasts until the server’s configuration changes; trusting a workspace does not replace this decision.

Once you trust a server, Kin uses its read-only tools without asking, and asks before every other tool. That request names the server and the tool, such as Allow relay · apply changes. It shows every value Kin will send as labelled fields: Kin’s summary and reasons first, then the values, then identifiers. Quoted passages show who said them and where. A list of changes is numbered, and fields left empty are named together. As Kin sent it shows the exact arguments. In the conversation, a server’s row names the server and the tool, such as relay · query. Opened, it shows the same fields and the answer in a readable form, such as a table or formatted text. As Kin reads it shows the exact answer.

When one change in a list is wrong, choose Leave out on it. You can add a Note for Kin saying what’s wrong. Marking a change hides nothing: it stays in the request as Kin sent it. Space writes the Reason for declining from your marks. It names each change you left out by its number and title, with your note, and asks Kin to send the rest again as a new call. Read it, and edit it if you like. If you change the marks after editing it, choose Write it again to start over from the marks. Kin approved the request as a whole, so part of it can’t be allowed. While anything is marked, Ask Kin for the rest declines the request with that reason, and Kin sends the remaining changes for you to allow. If every change is marked, the button reads Decline. Clear marks removes the marks and brings back Allow this action. A reason for declining can be up to 500 characters.

When a server’s customer records must stay on Kinra-operated inference, the browser composer shows Custody and whose records it covers. Kin keeps the conversation on an eligible model. If that connection is unavailable, follow the request to reconnect Kinra. An action that could send records out asks separately, offering Decline or Allow this action for that one call.

A conversation under custody cannot move to another workspace, start a session elsewhere, offer a letter or be enclosed in one. It can receive notes from your other conversations. Conversations in the same custody workspace write to each other without asking; a note to a conversation elsewhere asks you first and names where it goes. Its workspace is excluded from Chat’s trusted-project reading, its words stay out of the night’s reading, and push alerts use a generic conversation title. See Letters for ordinary sharing from other conversations.

Follow work and answer decisions

Kin’s responses appear in the timeline. Open a folded activity group or tool to inspect its inputs and output. A session opens at its latest messages every time: when you open it, come back to it, or move it between Chat and a page. Scroll up to read without following new text. While there is more below, Back to latest waits at the end; choose it, or scroll back down, to follow again. Only moving the conversation stops following: a click beside it, or a scroll with nowhere to go, leaves it following Kin’s reply. Opening a folded detail at the very end pauses following too, and Back to latest appears once something arrives below it.

With a Kin that records times, a conversation says when it was had. A turn you begin an hour or more after the last one, or on another day, opens with a quiet line such as Today at 14:02. A message’s time shows beside its copy and menu buttons when you point at it, or beneath it on a phone. A reopened conversation keeps how long each of Kin’s tools took. Conversations from before Kin kept times show none.

Kin’s shell commands have their own cards. While one runs, its output appears in a small scrolling window. When it finishes, it settles to one line with the command and result. Open that line to inspect the full output; a card you opened or folded keeps your choice. Short Git reads settle quietly too, so they do not hide Kin’s response among expanded tool output.

When Kin edits or writes a file, the change appears in the timeline itself: the file’s path, how many lines were added and removed, and the changed lines with their line numbers. Long changes start folded; choose Show more lines for the rest. Very large changes are shortened here, and Source has the whole change. Code in a response has a copy control at its top right corner, on a band of its own above the code on a phone or tablet, and long lines scroll sideways rather than wrapping. Tab to a code block or wide table, then use the arrow keys to scroll it. Each code block briefly confirms when you copy it.

Replies and reasoning use Space’s Markdown formatting; styling supplied in their text is not applied to the surrounding page.

A file link in Kin’s reply opens the file beside the conversation, reading its current contents from your machine. A linked folder inside the conversation’s workspace opens in Files. A line number in the link does not select that line; the file opens whole. Web links open in a new tab. If a local link cannot open, read its failure notice and check the path. A blank preview keeps Preview not displaying? and Try again outside the document; see preview recovery for opening its source or details without losing an unsaved edit.

When Kin hands part of a task to an agent, a strip above the message box gives her agents a part of their own, Agents: how many are working and what the newest is doing. Choose it to see each agent’s state, how long it ran, and its recent steps. Agents’ own tool calls stay out of the timeline. Ask Kin if you want an agent’s full output, or want one stopped.

With a Kin that supports it, the same place lets you Pause a working background agent, Resume a paused one, or Stop… an agent while you hold the keyboard and are connected. Kin’s to-dos for the task sit just above the message box; open it to see its first twelve items and the count of any more.

When Kin runs a command in the background, such as a long build or a test run, the same strip gives it a part of its own, Commands, beside Agents: how many are running and how long the newest has run, then how each ended: finished, failed, or stopped. Each part has its own light, so a failed command never makes working agents look failed. On a phone the two parts stack as rows. The command’s card in the conversation says the same, rather than looking finished the moment it starts. Choose Commands, or the card’s Work button, to see each command under Background commands in Work.

Open one to read the whole command, where it runs, and its retained output through the final lines. The output opens at its end and follows new lines unless you scroll up. Choose Copy command or Copy output to copy what you need.

While you hold the keyboard, Stop… asks before stopping a running command. Kin is told how each command ended, including when you stopped it. If a stop fails, the notice names the command; keep watching its output before trying again. A row you are reading stays open when its command ends. Ended commands otherwise sit under Ended. Hiding an ended command from the strip doesn’t stop it or remove it from Work.

This needs a Kin that reports its background commands; with an older one, the card says only that the command started in the background. An overnight update waits for these commands to finish, as it waits for agents.

Images Kin makes

Kin can make images only once an image service key is connected to her, and none can be issued yet, so your Space may not offer it. Where it does, each request makes two images, A and B, from one description and keeps both in a new folder of the project.

While they are being made, a card beneath Kin’s request shows two empty frames. Stop cancels only that request. When they are ready, the card shows A and B side by side, or one above the other on a phone, under the name of their folder. A pair made to change an earlier one names it, such as Revises garden-sketch · B. Under each image:

• Save copies the exact original into the project beside its folder, such as garden-sketch-a.png, after checking it against Kin’s record. It asks nothing of Kin. Saved again, it says where the copy already is; if the name is taken, a field offers the next free one.
• Download original gives you the same file.
• Change this one chooses that image to change. Pressing the image does the same. Write what should be different in the box beneath and send it: Kin writes a full new description and asks before she makes another pair. The box waits until you have chosen A or B.

The small control on an image opens it larger. Beneath the pair, its size and What Kin asked for sit folded. The newest pair in a conversation keeps its box open; an earlier one offers Change one of these.

A pair that is still being made, was stopped, could not be finished, has expired, or is no longer in the project says so on its own card, with what to ask Kin next.

Put finished work away

Choose the × at the end of finished to-dos (Hide finished to-dos), or at the end of the strip once agents or commands have ended (Hide finished agents, Hide ended commands, or Hide finished background work for both), to reclaim the space above your message. Hiding only puts the summary away: it does not delete tasks, stop an agent or a command, or change saved history. Failed and stopped runs still say what happened, even when you choose to hide them.

Work in the conversation’s header opens its current To-dos, Task list, Agents and Background commands, including hidden summaries and every available list item. On a phone, look for the checklist icon in that header. It remains available while a question or the Space app’s own message box replaces Space’s composer. Opening Work only inspects; choose Show above the message box to bring a hidden list back, or Show finished agents above the message box for agents. An unfinished list keeps the message area for now, but the finished list remains readable in Work. Undo last hide is available briefly there. Escape or the close control returns to the conversation, not to its message box.

Successful work you have not opened also leaves the message area when your next turn actually begins. An open list or Work inspector stays, as do unfinished or paused agents and failures or stopped runs. Queuing a message, an agent waking Kin and reloading do not put work away. New or resumed work appears again.

Hide choices follow the same conversation through reloads and movement between Chat and Kin’s panel. If Space cannot keep a choice, Work says so and offers Try again; the local change may return after a reload. Work shows Kin’s current lists and the agent runs she still keeps, not an archive of every past list.

Alerts when a session needs you

Space tells you when work elsewhere needs an answer: an approval, a question, or a plan to review. A compact note names what is waiting and which session it belongs to; Open session takes you there. A rising pair of notes can sound with it. Finished work stays marked in Live, without a toast or chime while you are using Space. This covers Kin’s live sessions and agents running in the machine’s Terminal.

• The session you are looking at, in a window you are using, is never announced. The conversation in Kin’s panel counts as looked at only while the panel is open.
• A new request can ask once, never just because you opened Space on an already waiting session. A session you just started from Kin’s reply is the exception: a request can ask on first sight; completion still quietly marks Live.
• While you are using Space, Kin’s live sessions are checked about every three seconds, plus the time to read the result. Terminal agents and background checks remain about fifteen seconds apart. A browser slows a hidden tab, so a background alert can arrive later.
• A browser plays sound only after you have clicked or typed in the page once.

Settings → Alerts turns the Sound on or off; choosing On plays it. System notifications asks this browser for permission, then shows alerts through your device while Space is not the window in front; choosing one opens that session. Away alerts still include finished work and its falling sound. Permission belongs to each browser, so allow it on every device where you want them. On an iPhone or iPad, install Space first.

One note stands in front. N more opens the other current notes on either a phone or a desktop; Show less folds the list. Requests take priority over other information. A request note lasts about six seconds, pausing while you point at it or use its controls, but Live and the unanswered choice remain. Routine confirmations stay beside their controls instead of filling this list; failures stay available until dismissed or recovered.

A notice asking for you goes away as soon as its conversation is in view in the window you are using, whether you open it from Live, Home, the palette, an Overview, Kin’s panel or the notice itself. This only puts the pointer away: the amber light and unanswered choice remain until you answer or cancel. A hidden, folded or back-of-stack conversation, a background window, or an opening that failed does not count as seeing it.

Answering from another client, cancelling the request or ending the session also retires its notice when Space next learns that state. A failed read does not mean the work resolved. Requests held while you read or write a letter retire too. Leaving the letter rechecks them and never replays old sounds or routine information. Other notices stay, and a genuinely new request can alert you even while the same conversation is already waiting. A workspace’s Terminal puts away only its own agents’ request notices, once the shell is ready. Browser notices cannot recall an operating-system notification. A compatible native app can retire its own request notifications; see Alerts in a native app.

While Kin is working

Keep typing. When Kin supports queued messages, press Enter on desktop or choose Queue message: Kin takes it at its next safe point in the task, and it still runs if you close the page. Queued text wraps above the composer; scroll the list to read longer messages. Choose Take back to return queued text to the message box. With files attached, your draft waits for the next turn, and the action remains Stop Kin until the current turn ends.

Commands and your own shell line

On a touch screen, tapping a command in the / list fills it into the composer rather than running it, so you can add its arguments and choose when to send.

Type / for Kin’s commands, such as /compact, /tokens, /rewind, or one of your skills. Keep typing to narrow the list, use the arrow keys, press Tab to fill a command that takes arguments, and Enter to run it. A new skill session starts with the command you typed as its default title; Kin may give it a shorter title later. /reload refreshes the list with any skills it adds.

/model and /effort without an argument open the model picker; change those settings between turns. /resume opens Session history, /help opens this guide, and /close ends the session. /mode and /settings report Kin’s current working settings above the message box. /nudges and /cost are not offered in Space.

A command that rewrites the conversation asks first and describes what will change. In particular, /rewind files and /rewind both put files back and lose uncommitted changes. Read that warning before confirming. A message over 32,000 characters stays in your draft with a warning instead of being sent; shorten it or send it in parts.

Start a line with ! to run a command in the workspace yourself, without opening Terminal. Its output appears in the conversation and is given to Kin with your next message. Start with !! to keep the command and its output to yourself. The line under the message box says which will happen before you press Enter.

Your shell line uses the same command card, with its output open for inspection. It is yours, not one of Kin’s background commands, so it never joins the strip above the message box. Its Stop ends that command independently of Stop Kin, which stops Kin’s turn. Stop is a separate button beside the command and remains available while its output is folded. Tab to it and press Enter or Space from the keyboard; tap it on a phone. Stopping either leaves your next message draft available.

Plan mode

Plan mode is yours to turn on. Kin may ask Plan this first? for a task that needs agreement on the approach; choose Plan first or Just do the work. You can also switch it in the model picker between turns. While it is on, the model control shows Plan mode, and Kin reads and writes a plan but changes nothing until you approve it.

When Kin presents a completed plan, its approval options are one choice list. Arrow keys move between them, Enter confirms the selected choice, and Keep planning asks Kin to revise. Escape folds the request without answering it.

Each live session in the sidebar says what it is doing when it is doing something: Working, Needs approval or Has a question. A ready session says Ready and how long it has been open.

Questions and approvals stay in the session that asked them. Read the operation, affected files, and available choices. A Git credential request has a separate Git access review. Decline an action you do not want and include a direction in the refusal when it helps Kin continue.

Reasoning, when forwarded by Kin, appears with Markdown formatting. It is optional transient display. Saved sessions do not replay that text. Use saved answers, tool results, and files when you need to return to an outcome.

Stop, leave, or end

Action	What happens
Stop Kin, the corner key while Kin works	Stops the current turn; your next draft remains.
Open Home or another workspace	Leaves the browser attachment; Kin can keep working. The workspace’s own Overview, Files, Source and Terminal keep the session over them.
Leave a new session before sending anything	Ends it; what you typed waits for your next new session in that workspace.
Hide Kin	Hides Kin’s panel; Kin keeps working, and the conversation stays under Live.
Close the tab	Disconnects this browser; work and saved history remain on the machine.
End session from a session row’s … menu	Ends the live session and moves it to Session history; active work asks for confirmation.
Sign out	Closes Kin and terminal connections in tabs using that sign-in; retained work stays on the machine.

Stopping does not undo completed changes. Inspect Files or Source before asking Kin to retry an interrupted action.

If the keyboard is in use elsewhere

A session another window or device holds opens here for watching. The message box says Watching this session., and each message the other side sends appears as Kin starts on it, followed by Kin’s answer.

A watching page takes a free keyboard when you return to use it. If another client still holds it, Take the keyboard takes it at once. The other window keeps any words it had not sent and watches in turn; it can take the keyboard back the same way. If Kin is working, it carries on, and Stop, queued messages and waiting questions move with the keyboard. A message sent just as the keyboard moved is either shown once or returned to that window’s draft with a note that nothing was sent. Only the window with the keyboard can direct the session or end it, so take the keyboard before ending a session another window holds.

An untouched draft picks up words and ready files saved from another device when you return. Words you typed here are kept. If those exact words were sent elsewhere, the stale draft clears after the message appears. See moving between devices.

Search or ask Kin

1. Open Ctrl+K / ⌘K and type a filename, session name, command, or question. Before you type, it lists sessions by workspace, your pinned workspaces first.
2. Use arrows and Enter to select a result, or tap a row on a phone. A row under Files opens that file in its workspace; it does not start a conversation.
3. Once file discovery finishes completely, the Ask Kin: “…” row appears after the matching results. Choose it to start a new session in the current workspace, or on a page the workspace the page is for, and send the question. Ctrl+Enter / ⌘Enter does the same without selecting the row, including while search is still reading.
4. Choose Session history… to open ended sessions. It appears once: as a command when your search matches it, otherwise as a button at the foot.

Each search word must occur in a file’s path, session or command; it does not match scattered letters. If files cannot be read, choose Try again, or explicitly Ask Kin instead if you meant a question. If only part of your home was searched, use Go to file… within a workspace for a narrower search, or explicitly Ask Kin instead. Enter on a failed or incomplete search does not send the filename to Kin.

Asking from the palette sends immediately. Wait for acknowledgement before asking again: a second question during that wait is refused and is not kept. If the question cannot be sent, because model setup fails, you decline to trust the workspace, or the connection ends before Kin accepts it, the question returns to your draft.