# First session > Build the muscle memory for a normal Kin session: send work, read the timeline, recover a queued draft, review an edit or plan, and return to the conversation later. Build the muscle memory for a normal Kin session: send work, read the timeline, recover a queued draft, review an edit or plan, and return to the conversation later. ## Outcome After this short tour you can distinguish replies, reasoning, tools, and edits; interrupt or queue work without losing text; understand the human-visible plan review; and reopen a saved or live session. If Kin is not connected yet, use [Connect a model and first run](/docs/kin/getting-started/first-run/) first. ## The screen at a glance The normal session has four stable regions: | Region | What stays there | |---|---| | **Top bar** | Workspace/Git/model identity, clock, and context usage | | **Transcript** | User turns, Kin replies, collapsed reasoning, tools, agents, and workflows | | **Status bar** | One active phase or idle key hint on the left; current mode on the right | | **Composer** | Multi-line input, one queued follow-up, and completion menus | A fifth strip appears only when background agents outlive the foreground turn. It remains quiet at rest and keeps truthful activity visible without forcing the full agent panel open. ## Fast path ### 1. Confirm the session Before typing, read the welcome panel: - **model** is the backend that will receive the message; - **workspace** is the project Kin can change; - **session** is the durable conversation id; - the posture line names `auto` or `strict` and the active shell containment. The top bar keeps workspace, git, model, clock, and context usage visible after the welcome panel disappears. The composer stays intentionally quiet: `Message Kin…`. ### 2. Send a concrete outcome Try: ```text Explain this project's entry points and suggest one small improvement. ``` Press ++enter++ to send; ++shift+enter++ inserts a newline. The status line becomes the single active heartbeat. Kin's answer streams in cyan, reasoning is collapsed in periwinkle, and tool calls appear as compact rows with a readable summary. Only `edit_file` and `write_file` auto-expand their diffs. Only those tools receive a `(+N -M)` badge. Their expanded view uses truthful line numbers and one unchanged context line above and below each change cluster; read-only patches and commit-review output stay collapsed, then retain their fuller review context when you open them. [![Kin timeline with completed reasoning, expanded shell details, an intentional edit diff with one context line and a change-count badge, and an interrupted foreground agent whose child tool is settled.](/docs-assets/kin/assets/screenshots/timeline_states.svg)](/docs-assets/kin/assets/screenshots/timeline_states.svg) *The timeline is a work log, not raw event output: edit intent controls automatic disclosure, and `(+N -M)` belongs only to file-writing tools.* ### 3. Queue, take back, and interrupt Start a longer request, then type a follow-up while it is running and press ++enter++. Kin holds one latest-wins queued message. The composer title reads: ```text queued · up edits · ``` Press ++up++ to withdraw that queued message into the composer. It will no longer send automatically; edit it, delete it, or submit it again. If you had already started a different draft, ++down++ restores that draft. There is no queue counter because only one message exists. Press ++esc++ when you want to stop the running turn instead. Partial assistant text stays visible with an interrupted marker, unfinished foreground reasoning/tools/agents settle, and independently running background agents continue truthfully. ### 4. Review an action Kin starts in `auto`: edits and shell commands can run without per-call prompts, with shell contained by the OS sandbox when available. Press ++shift+tab++ to switch to `strict`, where writes and non-allowlisted commands ask first. An approval offers human-readable choices: allow this action once, allow the same call signature for the session, or deny it. The modal shows the actual command or edit body, not a generic warning. See [Modes & approvals](/docs/kin/guide/modes-and-permissions/) for the exact matrix. ### 5. Review a plan For broad work, Kin may enter a read-only planning freeze. The visible review lets you: - **Approve & execute**, which lifts the freeze with the current planning context; - **Approve, clear & re-inject**, which starts execution from the self-contained plan without the exploratory planning chatter; - **Review plan first (adversarial)**, which asks a critic for concrete findings. The critic path does not quietly leave planning mode. Kin can apply a bounded targeted correction to the saved plan while the freeze remains active, then present it again. General file writes and shell remain denied until you accept execution. Dismissing the modal keeps planning. This preserves the distinction between revising the plan and starting implementation. ### 6. Browse and resume Press ++ctrl+b++ for cursor mode. Use ++up++/++down++ to move through timeline items, ++tab++ to expand the focused reasoning or tool row, and `y` to copy it. ++esc++ exits. Cursor mode waits until the composer is empty so an unsent draft cannot be hidden by navigation. Press ++ctrl+l++ or run `/sessions` to open the session switcher. It groups individually identified live processes (including siblings in this workspace), saved conversations, Outpost work, and an always-available **New session here** action. `/resume` is the narrower saved-history picker for this project. If an exact saved conversation is already live, either route switches to its owning process rather than opening a second writer. Sessions are append-only JSONL journals under `~/.kin/projects//.jsonl`. On a normal quit with ++ctrl+c++, Kin seals the journal and closes background resources; the saved conversation can be continued later. The journal records provider-native history rather than a flattened rendering, so a same-provider resume preserves typed tool and thinking blocks. The transcript you see is a presentation of that durable event history, not the storage format itself. ## Alternative controls #### Keyboard ++enter++ sends, ++esc++ interrupts, ++shift+tab++ changes mode, ++ctrl+b++ browses the transcript, ++ctrl+l++ switches sessions, and ++ctrl+o++ opens the agent panel. Press ++f1++ for the full map. #### Slash commands Type `/` to filter commands. `/mode`, `/sessions`, `/resume`, `/providers`, `/model`, `/tokens`, and `/help` cover the most common session controls. Use ++tab++ to complete the highlighted command. #### Mouse Click a reasoning/tool title to expand it, choose modal actions directly, and select rows in the session or agent panels. Keyboard and pointer paths mutate the same underlying state. ## Troubleshooting - **A follow-up disappeared:** check whether it was queued and auto-sent. While still queued, ++up++ takes it back; ++down++ restores the newer draft. - **A diff did not open automatically:** only `edit_file` and `write_file` carry edit intent. Expand review and read output manually. - **Mode will not change:** a planning freeze cannot be escaped with ++shift+tab++ or `/mode`; choose a plan-review action. - **Cursor mode refuses to start:** send or clear the composer first. - **A session is missing:** `--no-save` sessions are ephemeral, and subagent journals are intentionally excluded from the ordinary resume picker. ## Reference - [Modes & approvals](/docs/kin/guide/modes-and-permissions/) - [Sessions](/docs/kin/guide/sessions/) - [Commands](/docs/kin/guide/slash-commands/) - [Keybindings](/docs/kin/guide/keybindings/) - [Subagents](/docs/kin/guide/subagents/) - [Architecture](/docs/kin/concepts/architecture/)