Sessions

Every chat tab in Crew is its own conversation. Conversations are independent: each one has its own context, its own history, and its own tool-approval state. You can have many open at once, each working on different things.

Sessions open as tabs above the transcript. The open set of tabs persists per surface: close and reopen the dashboard and your tabs are still there.

• Open a tab: click + in the tab bar, or middle-click / modifier-click a row in the sidebar to open a session without leaving your current tab
• Each tab shows live status (thinking, waiting, idle) at a glance
• Each tab has its own context window, tool-approval state, and project directory

Sessions started from Slack, Telegram, or Discord are also independent. A Slack thread is one session, a dashboard tab is another. They share memory (preferences, lessons, and history) but not in-session context.

Sessions idle past a threshold you choose collapse into a Dormant sessions (N) expander in the sidebar. This keeps the sidebar readable when you accumulate many sessions.

Pinned sessions, sessions with a running turn, and sessions with unread messages always stay visible regardless of the threshold.

Configure the threshold from Settings → Chat → Collapse dormant sessions. The default is 7 days; choose Never to keep every session visible.

The + New menu includes an Ephemeral submenu with two modes:

Incognito has access to your preferences, lessons, and history, but nothing you say enters long-term memory. Use it for sensitive queries or dry-run explorations.

Temporary starts completely fresh: no memory read, no memory write. Use it for fully isolated one-off sessions.

Both modes mark the tab visually so you can tell at a glance that the session is ephemeral.

You can send multiple messages while the agent is still responding. Messages are queued and processed in order once the current turn finishes.

• Messages arrive in the order you sent them
• Deleting a queued message before it runs removes it from the queue and restores its text and attached files to the composer
• The ⏹ Stop button interrupts the current turn and moves to the next queued message

You never lose a message by sending too fast.

Crew Mode lets one chat advance several pieces of work at once. Send your next message without waiting for the last one to finish: topics are dispatched to parallel sub-sessions, and their answers arrive independently rather than queuing behind each other.

• With Crew Mode enabled for a session, each dispatched topic runs in its own sub-session with its own context.
• Answers stream back as each sub-session finishes, so a slow task doesn't block a quick one.
• Use it when a single conversation naturally spans several independent threads — researching one thing while drafting another.

This differs from typing ahead, which runs your messages in order on one session; Crew Mode runs them in parallel across several.

Sessions survive gateway restarts. If you restart Crew (or it auto-restarts), your open dashboard tabs reconnect automatically. The next message you send continues the session.

Reopening an earlier chat loads it in the background while you read, so the first message you send goes out immediately instead of waiting on a cold start. Switching back to a tab restores your reading position, even when new messages or a growing reply change the transcript.

From Slack or Telegram, type sessions to see recent conversations with ▶ Resume buttons. You can also link a dashboard conversation to a Slack thread for bidirectional sync (💬 button in the tab header).

Session search spans every connected gateway and interleaves local and remote results, so one search covers the instances you run.

You can search by pull request, code review, or issue badge as well as by session title. A query like 4411, /pull/4411, or owner/repo#4411 all find the same related session.

Reaching the top of a long transcript loads older turns instead of stopping, so you can scroll back through a session's full history.

An opt-in dashboard MCP set lets one session message, stop, and read another, so you can hand work along with its context. It is deny-by-default and authorized with the gateway key. Turn it on before a session can drive another.

Toggle Autopilot per-session from the session menu. When on:

• Tool calls that pass security checks are auto-approved for this session
• No approval prompts interrupt the flow
• Deny rules and sensitive-path blocks still apply (autopilot doesn't bypass security)

Turn it off and you're back to interactive approval for each tool call.

Session close after a period of inactivity (default 30 minutes). When a session times out:

• Its resources are released
• It can be resumed — the next message reopens it
• Memory consolidation may fire during the idle period (writing preferences and history)

Configure the timeout in Settings or via kirocrew config set session.timeout_secs 3600.

Two levels of memory:

A new session starts with your memory injected (preferences, recent history, lessons) but no knowledge of what happened in other open tabs.

For the full model of how memory builds, decays, and gets retrieved, see Memory.

When you come back to a session you started earlier, a summary in the side panel tells you why you asked for the work, what happened, and what's still open, so you don't have to re-read the whole transcript. It's organized by intent (a goal that can span many turns), not as a per-turn log, with anything unresolved pulled to the top.

Session summaries are off by default: generating one spends tokens on a turn you didn't ask to pay for. Turn them on with session_summary.enabled (or from Settings); older sessions can be summarized on demand. The summary is stored beside the session and never rewrites the transcript.

If the gateway launched from a workspace with .kiro/steering/*.md files, every session in that workspace inherits those rules automatically. Steering is the recommended way to give project-specific context (coding standards, deployment rules, team conventions) without repeating yourself.

Want to explore a different direction without losing your current thread?

• Fork — clones the session into a new tab with full context
• Fork tail-only — carries over only the recent messages (lighter start)

The forked tab is fully independent from that point.

The composer shows how full the context window is as a percentage and a token count, and the turn-stats footer names the model that actually served each turn — useful when you're running on Auto.

Long sessions eventually fill the context window. Crew auto-compacts at ~90% usage — older turns are summarized to make room for new ones. You can also manually compact:

• Dashboard: session menu → Compact
• Slack: !compact

After compaction, the agent still has your intent and recent work — just with summarized older turns.

The kebab menu on each tab gives you quick access to session-level controls:

• Rename — change the tab title (auto-generated but overridable)
• Mark as unread — flag the session for later attention
• Pin: keep the session pinned at the top of the list, outside the dormant expander
• Tags: add or manage tags for organization; filter the session list by tag from the filter menu
• Session color: pick any custom hex color for visual identification
• Pop out to window — open the session in a separate browser window
• Copy link — copy a shareable link to this session
• Close session — end the session and remove it from the tab list