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.

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 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:

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.

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:

queued · up edits · <preview>

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 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/<project>/<session>.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
• Sessions
• Commands
• Keybindings
• Subagents
• Architecture