---
title: Chats and projects
description: Projects hold your folders and their chats, and the message box sends, queues, steers and stops the agent's work.
canonical_url: https://lookout.itoowasinarcadia.com/docs/chats
type: guide
section: Use Lookout
last_updated: 2026-10-23
related:
  - https://lookout.itoowasinarcadia.com/docs/modes
  - https://lookout.itoowasinarcadia.com/docs/context
  - https://lookout.itoowasinarcadia.com/docs/subagents
  - https://lookout.itoowasinarcadia.com/docs/checkpoints
  - https://lookout.itoowasinarcadia.com/docs/worktrees
  - https://lookout.itoowasinarcadia.com/docs/memory
  - https://lookout.itoowasinarcadia.com/docs/shortcuts
---

> Every page of these docs: https://lookout.itoowasinarcadia.com/llms.txt

# Chats and projects

Projects hold your folders and their chats, and the message box sends, queues, steers and stops the agent's work.

A project is a repository (or a folder) the agent works in, with any extra folders you add in its **Project settings**. Every chat belongs to one project, and the sidebar lists your projects with their chats under them. **Scratch**, one shared project for chats that need no folder of yours, is always its first row.

## Start a chat

1. Press `⌘N`, or click **New chat** at the top of the sidebar. The new chat starts on Scratch.
2. To work somewhere else, pick it from the picker above the message box: a recent project, **Open folder** (`⇧⌘O`), **Open as its own project**, or **Start from scratch**. You can also type a path into the picker's search.
3. Type your message and press `⏎`.

To start a chat in a project you already have, click **+** on its row in the sidebar.

A new chat is named by the opening words of your first message, whole, until Lookout names it from that message and the first reply, a moment after the reply starts. A name you give it with **Rename** is never replaced.

## Open a folder

A project is identified by its repository, not by a folder's path. When you open a folder (**Open folder**, `lookout exec`, or a delegate over MCP):

- A worktree or a clone of a project's repository (the same git repository, or a clone with the same `origin`) opens in that project. The new chat works in that checkout, and its row in the sidebar shows the checkout's name beside its title after a branch glyph, without the project's name in front (`acme-web-rounding` in `acme-web` shows `rounding`). When the title needs the room, the checkout's name gives way whole.
- A folder under a temp folder (`/private/tmp`, `$TMPDIR`) or a lane root (a folder named `<name>-wt` or `<name>-wt.noindex` that holds checkouts), which no project claims, opens as a Scratch chat that works there.
- Any other folder, such as one that holds several repositories or a fork with its own `origin`, becomes a project of its own.

**Open folder** shows the macOS folder panel. It starts in the folder you last picked from, or at the path you typed into the picker's search, and its **New Folder** button makes one to open. In a [window on another machine](https://lookout.itoowasinarcadia.com/docs/machines#open), Lookout lists that machine's folders itself, and the picker has **New folder** too.

To make a checkout a project anyway, choose **Open as its own project** in the picker, or **Move to its own project** in the menu of a chat that works in one: the chat moves with it. `LOOKOUT_SCRATCH_ROOTS` (folders separated by commas) replaces the temp and lane roots; set it empty and no folder opens in Scratch.

## Write a message

| To | Do this |
|---|---|
| Send | `⏎` |
| Start a new line | `⇧⏎` |
| Bring back a prompt you sent | `↑` on the first line, once per prompt: this chat's newest first, then the project's other chats'. `↓` goes forward, and past the newest (or `Esc`) brings back what you had typed. Only the text comes back, not attachments |
| Mention a file, folder, chat, project or skill | Type `@` ([Context](https://lookout.itoowasinarcadia.com/docs/context#mentions)) |
| Point at exact lines of a file | Select them in a diff or a preview and press `⌘L` ([Add lines](https://lookout.itoowasinarcadia.com/docs/chats#lines)) |
| Attach an image or a file | Paste it, drop it anywhere on the chat, or click **+** › **Image** or **File**. It can be the whole message |
| Save a note to memory | Start the message with `#`, or `#!` for a note every project sees |
| Change the mode | `⇧Tab` ([Modes](https://lookout.itoowasinarcadia.com/docs/modes#switch)) |
| Dictate, on a Mac | Click **Dictate** (the microphone) and speak, or hold `⌃M` and release to insert. `⏎` inserts the text, `Esc` discards it. The text goes to the chat you recorded in, even after you switch chats. A take that ends with the word in **Settings › Chat** sends, and the word is left out. Right-click the microphone for **Recent dictations** ([Mac app](https://lookout.itoowasinarcadia.com/docs/mac-app#dictation)) |
| See every command and mode | Click **+**, or press `⌘/` |

The **+** menu lists the modes, then **Image**, **File**, **Remember something** and, in a chat, **Connectors** and **Compact context**. Type `/` for commands:

- `/compact` (or `/summarize`), in a chat, summarizes it to free up context. Words after it say what the summary
  must keep: `/compact keep the migration plan` ([Context](https://lookout.itoowasinarcadia.com/docs/context#compact)).
- On a model with effort levels, `/effort` opens the model menu on its effort slider and `/effort high` sets a level
  directly.
- A model with a variant you can turn on or off adds a command named after it: `/<variant> on` or `/<variant> off`.

The model and its effort are one control in the message box beside Send, such as **Opus 5.5 Max**; its menu lists the
models with the effort slider under them, and `⌘E` opens it on the slider. In an agent's chat it is the **Model** row
of the **+** menu instead ([Talk to an agent](https://lookout.itoowasinarcadia.com/docs/agents#chat)).

## Send while the agent works

While the agent works, a message you send waits for it, one of two ways:

- **Queue**: it runs as the next turn when the agent finishes.
- **Steer**: the agent reads it at its next step, without stopping. A wait it is in (on a command, a pause, a [subagent](https://lookout.itoowasinarcadia.com/docs/subagents#kinds)) ends early for it; what it waited on keeps running.

In a coding chat, **Settings › Chat › When you send** decides which (**Queue** by default). In an [agent's chat](https://lookout.itoowasinarcadia.com/docs/agents#chat) a message steers by default: an agent's turn can run for half an hour, and it reads your message at its next step instead of after the turn. The line under the message box says which way a message goes before you send it (**Steer, read at the agent's next step** or **Queue, runs when the agent finishes**), and the send button's tooltip names it, **Steer** or **Queue**. Press `⌘⏎` instead of `⏎` to send one message the other way, in either kind of chat.

Waiting messages sit above the message box: one is a single line, **Queued** and its words; more sit under **N queued**. Once a message has waited a minute, its line ends with how long: **Queued 12 min** for a lone one, **12 min** (or **Steer, 12 min**) under **N queued**. Each line shows as many whole sentences as fit, else the first one up to a comma, else whole words; never a cut word. Click one (or press `⏎` on it) to read it whole, with **Copy**, **Edit**, **Remove**, and **Steer at the next step** while the agent works; `Esc` closes it. Drag a message to reorder it. From an empty message box, press `↑` to reach the last one; then `E` edits it, `S` steers it, `⌫` removes it, and `⌥↑` or `⌥↓` moves it.

**Edit** puts the message in the message box, and its line says **Editing** and ends in **Discard**. The check where send was (`⏎`) saves it in its place; **Discard** or `Esc` leaves it as it was.

Queued messages run one per turn. A queue holds up to 100 messages.

Messages you send while Lookout pauses for an update or a restart wait in the queue and run together, in the order you sent them, as soon as it is back. A message you send after that never runs ahead of them.

## Stop the agent

Press `Esc` with the message box empty, or click the stop button: while a turn runs it takes Send's place when the message box is empty, and sits beside Send once you type. With no turn running, Send stays Send.

- `Esc` and the stop button end the running turn only. Subagents running in the background go on. An `Esc` right after another one (the one that closed an edit, a menu or a list) stops nothing.
- While subagents or a workflow the chat started go on, the stop button opens a menu instead: **Stop this turn**, then **Stop this turn and 2 subagents** (**and the workflow**, or **and all its work** when it started both).
- In an agent's chat whose turn answers other agents, the stop button opens a menu too, with **Stop the whole conversation** after the turn's own items, whether or not other work goes on.
- Nothing under the message box lists that work: each subagent stops from its own row in the chat, and the sidebar lists the ones at work.
- If the agent hadn't replied yet, your message comes back to the message box.
- Messages it hadn't read go back to the queue, first in line, and the queue waits under **Paused after Stop**. Click **Resume**, or send a message, to go on.

A failed turn pauses the queue the same way (**Paused, the last turn failed**), and so does Lookout restarting unexpectedly while messages wait (**Paused after a restart**).

## Stop everything in a project

When a plan is burning or a change went wrong, the project's menu (its row in the sidebar) has **Stop all in this project**. Every chat of that project with something running stops whole: its turn, its background subagents, a question it was waiting on. A toast says how many chats it stopped, and other projects keep running.

**Stop all and hold** does the same and also holds the project's new work until you choose **Resume project** from the same menu: delegated turns from an outside orchestrator are refused with the code `project_paused`, and agent chats in the project stay idle. Your own messages still run.

## Try again after an error

When a turn fails, the chat says why and offers what can be done:

- After a provider failure or a spent plan, **Continue on** picks the turn up where it stopped. Its main part names the best move: **Retry** on the chat's model when that can go on, else another account of the provider with room, else **Continue on MODEL** (only from the chat's fallback models when it has a fallback policy or is an agent's chat). Its chevron lists every model the chat can run now, each with what is left of its plan and the effort it runs at: the chat's effort, carried to the same place on the new model's levels (the highest stays the highest); **›** on a row picks another. No model of the spent plan is listed, and one billed per token reads **Per token**. The chat keeps the model it continues on. On a spent plan with nothing else open, **Wait for the reset** waits for it.
- A chat that waits for its plan on its own (delegated to wait, or woken by a message) says **Waiting for MODEL's plan** and when it resets, with **Continue on** and **Stop waiting**.
- When the network drops, a turn doesn't fail: it shows **Waiting for the network** with the time it went down, the sidebar shows **Network down since TIME**, and the same request goes again on the same model as soon as the provider answers. **Stop** still ends it.
- When the chat no longer fits the new model's context window, the retry starts at once and summarizes first: its turn shows **Summarizing context to fit MODEL**, then goes on.
- A retry that fails the same way (the same message from the same model) keeps one notice, the latest: its **Details** say how often it failed, such as **Failed 2 times, last at 12:57 PM**.
- After other failures, **Try again** runs your last message again, and its chevron runs it on another model.
- With the message box empty, `⏎` does what the main part does, and so does `⌘⏎`. The send button draws that action: a circling arrow for **Retry** or **Try now**, a clock for **Wait for the reset**, the send arrow for **Continue on**. **Details** shows the provider's own message, and `⇧⌘⏎` copies it.

If Lookout stopped while a turn was running, the turn reads **Interrupted**. Click **Continue** to pick it up where it stopped.

## Edit and resend a message

1. Point at one of your messages and click **Edit** beside **Copy**, or press `⇧⌘I` to edit the last one. A click on the message itself only selects its text.
2. Change it and click **Resend** (`⏎`). **Cancel** (`Esc`) leaves the chat as it was.

Resending removes every later message in the chat. If files changed since that message, Lookout asks **Revert files to this message?**: **Revert files** puts your files back as they were then, and **Keep files** (`⇧⏎`) leaves them as they are.

## Answer the agent's questions

The agent can stop to ask you something. Its question appears above the message box with numbered options.

- `1` to `9` picks an option. **Other** lets you type your own answer.
- `⏎` goes to the next question, and submits on the last. `⌘⏎` submits all answers.
- **Skip** sends no answer, and the agent carries on without one.
- `⇧Tab` in the message box moves to the question.

## Have a chat message another

Ask a chat to talk to another of your chats or agents, in words ("ask the rootway chat whether the mesh is up") or by
mentioning it with `@`. It finds the chat by its title or lane, sends the message, and carries on; the answer arrives in
the chat that asked when the other one replies. Both chats show the message: the sender's as the command it ran, the
receiver's as a message **From** the sending chat.

- A message from another chat is never you: the agent weighs it as a colleague's request, under its own mode.
- A chat that started another (with the `lookout` command) sends it follow-ups as you would.
- A subagent's message comes from its chat, named as that chat's subagent, and is never a follow-up in your name. A reply to it goes to that subagent while it runs, read at its next step, so the agent's wait on the subagent goes on; once the subagent has ended, the reply goes to its chat.
- A running chat reads a message at its next step; an idle one starts a quiet turn on it. Chats that keep messaging
  each other without other work are held for you.
- To keep a chat to yourself, turn off **Messages from other chats** in its menu (**Chat actions** in the top bar, or right
  click its row). Other chats and agents are then told it takes no messages; an answer to something it asked still arrives.

## Keep watching something

A chat you started yourself can keep an eye on something for you between your messages: ask in words ("watch PR 1919's
checks and tell me when they change", "remind me at 9 tomorrow"). The agent sets up a routine: a prompt that starts a
turn in that chat on a schedule, at most every 15 minutes, often after a check, a command that runs first and costs
nothing, so the turn runs only when its output changed. A routine keeps going across your messages and across a
restart of Lookout, unlike a command the agent watches, which your next message ends.

- A chat holds up to 5 routines. Ask the agent to list, change, pause, run now or delete them.
- A fire waits while you and the agent are working in the chat, and starts its turn once that turn ends.
- Archiving the chat pauses its routines; deleting it deletes them.
- Chats another chat or app started (with `lookout`, Delegate or Claude Code) have no routines of their own: the chat or
  agent that started them does the watching.

## Charts, diagrams and briefs

The agent can answer with a chart, a diagram or a layout (a brief or a status card: an agenda, progress, a few
numbers, a checklist), drawn in the chat. It knows the skill, so asking in plain words can be
enough; `/visualize` anywhere in your message (at the start, or "maybe using /visualize?") sends the skill with it, so
the agent answers with one. A follow-up in the same chat draws a new one, and the earlier chart stays as it was. A
Mermaid or Vega-Lite block the agent writes in any reply draws as a chart too.

The agent writes each one as a Vega-Lite, Mermaid or layout file under `.lookout/visuals/` in the project and checks it
draws before it shows it, in every mode. A chart's menu copies or saves the image, copies the source or the data, and
shows the data as a table; a layout draws in the app's own look in both themes, and its menu copies it as text or
copies its spec.

## Find in a chat

Press `⌘F` and type. `⏎` and `⇧⏎` step through the matches; `⌘G`, `⇧⌘G` and `F3` do too. Folded steps that hold a match open, and so does a row such as **lk-withholding-m2 finished** whose reply holds one. `Esc` closes the bar.

## Search every chat

Press `⌘K`, or click **Search** in the sidebar, and type. Search finds chats by title, what was said in any chat, projects, commands and settings. The filters **All**, **Chats**, **Work**, **Messages**, **Projects** and **Actions** narrow it; `⌘[` and `⌘]` step through them. A result under **Messages** opens its chat at that message. **Work** lists what the open chat started, newest first by day, then the subagents working in other chats; a result opens its page. Before you type, the chats that need you come first, under **Needs you**: the ones the sidebar's **Needs you** lists.

## Browse the project's files

Press `⇧⌘R` to open the side pane and choose **Files**. It lists the chat's folder as a tree, without files and folders whose names start with a dot, and without the paths your ignore files leave out ([Keep the agent out of files](https://lookout.itoowasinarcadia.com/docs/rules#ignore)). Click a file to preview it: images, video and audio show in place, Markdown shows rendered (**Source** shows its text), and code shows with line numbers. The preview follows the file as the agent changes it. A folder shows its first 2,000 items and says so when it holds more; a linked file opens from where it points, and a linked folder outside the chat's folder says so instead of listing it. In a chat with an [agent](https://lookout.itoowasinarcadia.com/docs/agents#folder), **Files** lists the agent's own folder instead.

- An image opens fitted to the pane. Pinch, `⌘+` and `⌘−` zoom at the pointer, `⌘0` fits it again and `⌘1` shows it at 100%, one image pixel per screen pixel; a double-click switches between the two where you click. The zoom in the header opens **Fit**, **50%**, **100%** and **200%**. Scroll or drag to move around a zoomed image. Each image keeps its zoom while the pane stays open, and the chat's image viewer zooms the same way.
- A file the **Changes** tab's current view counts as changed is marked **A** (added), **M** (modified) or **D** (deleted), and a folder that holds one shows a dot.
- The pane shows files and never edits them. In the Mac app, the button beside the `⋯` menu opens the file in the Mac's default app for it (its tooltip names the app, such as **Open in Preview**), and the `⋯` menu has **Copy contents**, **Copy path** and **Reveal in Finder**.
- A file path in the agent's reply is a link. **Settings › General › File links open in** decides where it opens: in the side pane (**Lookout**) or in the Mac's default app (**Default app**, the default). The default app opens documents it only shows, such as text, images, PDFs, office files and media. A program, an installer, a disk image or any other type is shown in Finder instead.

## Add lines to a message

Select lines in the side pane's **Changes** diff, in a file's preview in **Files**, or in the code of a file the agent read, and click **Add to chat** under them (over them when there's no room below), or press `⌘L`. Or point at a line and click the **+** over its number; on a change's header, **+** adds the whole change. The message box gets a pill at its caret, such as `src/cart/total.ts:12-18`.

- When you send, the agent gets those lines with the file's path, numbered as its own reads number them, so it can change them without looking for them first. They are read from the file as it is when you send.
- Lines from a diff's left side, the lines it removed, read `src/cart/total.ts:12-18 (before)`. The agent gets them as they were where the diff starts: before the turn, before the chat's changes, or at the last commit.
- Lines from a past turn's right side are sent as that turn left them, and the pill reads like any other. If the file has changed since, the agent is told so. If that turn's copy can't be read anymore (after a rewind, say), the agent gets the file's lines as they are now, and is told that too.
- Click a pill in a sent message to open its lines: the file's preview at the first line, or the diff it came from on that file.
- While a subagent's view hides the chat's message box, the pill waits in the chat's draft. In a narrow window, where the side pane covers the chat, a notice says the lines were added. While you edit a queued message, finish the edit first.
- Lines count toward a message's 60,000 characters of attachments ([Context](https://lookout.itoowasinarcadia.com/docs/context#mentions)). Past that, the agent is told how to read the rest.
- `⌘L` adds lines only while some are selected. Otherwise it moves to the message box.

## Organize the sidebar

Right-click a chat, or press `⇧F10` on it, for its actions: **Rename** (`F2`, or double-click the chat), **Pin**, **Highlight**, **Mark unread**, **Move to its own project** (a chat working in a checkout of another project's repository), **Move to** another project, **Copy path**, **Copy ID**, **Export**, **Archive**, **Archive all below** and **Delete chat** (`⌘⌫`).

Right-click a project for **New chat**, **Mark all as read**, **Edit icon**, **Copy path**, **Connectors and skills**, **Move up**, **Move down**, **Project settings** and **Remove project**. **Mark all as read** clears the unread dot on every chat in the project, including ones past **More** and a folded project's dot. It is unavailable when no chat in the project is unread. Removing a project deletes its chats from Lookout and keeps its folder on disk.

**Filter projects and chats**, the button beside **Projects**, holds:

- **Ordering**: **Manual**, **Recent activity** or **Name**.
- **Status**: one at a time. **All** shows every project. **Needs you** lists every chat that waits on you or whose
  last turn failed, and **Running** every chat that works now or that (or whose subagent) waits out a spent plan. Each lists
  them in place of the projects, from every project (folded ones, the ones past **More** and inactive ones too),
  newest first, each with its project's name. **Started by me** appears once another app (an orchestrator over MCP)
  or one of your [agents](https://lookout.itoowasinarcadia.com/docs/agents#chats) has started a chat: it leaves those chats out.
- **Open archive**, **Collapse all** and **Mark all as read**.

A folded project shows the most urgent dot of its chats and the time of its latest chat. Both count only the chats
the project lists when you unfold it: an archived chat, or one **Started by me** leaves out, never marks it, and
reopening its folder or changing its settings doesn't move its time. A chat past **More** that runs, waits on you,
failed or finished unread stays listed above **More**.

A chat waits on you, and its dot says **Needs you**, only while a question card it asked waits for your answer in the
composer (a launch of more subagents than your allowance asks this way too). A reply that just ends on a question is
not waiting: like any finished turn it shows the unread dot until you read it.

A chat whose subagent waits for a spent plan to reset shows a hollow ring in place of its dot, the subagent waits
under it on the same ring, and the subagent's row in the chat says until when. It needs nothing from you: the subagent
goes on by itself. So does a chat another app started with a wait for its plan ([MCP tools](https://lookout.itoowasinarcadia.com/docs/mcp#quota)): the ring
stays until the reset, then the turn goes on. A chat whose turn stopped because the plan ran out, or because the
provider kept limiting requests past Lookout's retries, shows the same ring, as its stop row reads as a wait; the red
alert is for a turn that failed. Unlike a waiting subagent, that turn doesn't go on by itself, so the chat stays under
**Needs you** until you retry it.

A chat whose own turn has ended while its [subagents](https://lookout.itoowasinarcadia.com/docs/subagents) still work keeps its working mark, and they show
under its row, three at most, then how many more are working. A chat that started other chats says **Waiting on 3
chats** while they work. **Stop all work** in a chat's actions stops its turn, its subagents and the chats it started
that still work.

A chat another app started whose turn only waits on its own work (a long command, a pause, a subagent) for more than
20 seconds keeps its working mark, and says what it waits on under its last step: it doesn't count
against the [machine's limits](https://lookout.itoowasinarcadia.com/docs/machines#capacity) while it waits. When the wait ends it goes on by itself,
once there is room again (**Waiting to go on** names the limit until then). It lists under **Running**.

Hover a chat another app or an agent started to see who, and its lane key. An open one started by another app names
it in its top bar, after the project; one another chat or an agent started leads its top bar with that chat, a click
away.

A title too long for its row takes the room of the chat's time, which the chat's hover card shows instead.

## Archive a chat

Press `⇧⌘E`, or choose **Archive** from the chat's actions. The chat leaves the sidebar.

If the chat has its own worktree, Lookout asks whether to remove it too. **Remove if safe** removes its folder when nothing in it is uncommitted, and its branch too when its commits are merged or pushed; a branch that isn't stays with every commit, and the folder comes back on it when you use the chat again. With uncommitted work the chat archives anyway and Lookout says why the worktree stayed, then checks it again every hour and removes it once that is safe. **Keep it** leaves the worktree as it is, and the hourly check leaves it too. An archive you didn't make (an agent's, another app's, or **Archive idle chats**) removes a worktree by the same rule without asking ([Remove a worktree](https://lookout.itoowasinarcadia.com/docs/worktrees#remove)).

Archived chats are in **Settings › Archive**: search them, select some, then **Restore** or **Delete forever**. **Keep archived chats** is **Forever** by default; with **90 days** or **30 days**, a chat archived longer than that is deleted for good, unless its project folder is gone. A restored chat keeps its messages and its subagents' transcripts, but its subagents can no longer be continued ([Continue a subagent](https://lookout.itoowasinarcadia.com/docs/subagents#continue)).

Archiving puts the chat's work away: a turn it is running stops, and so do its subagents and the commands it left running or watches. While it is archived nothing starts it again: a command that ends, a line it watched for or another chat's news waits. A message or a retry sent to it brings it back to the sidebar and runs.

To archive idle chats on a schedule, open the project's **Project settings** and set **Archive idle chats**. Pinned chats stay put, and so does a chat with anything still running, until it ends.

## Export a chat

Choose **Export** from the chat's actions. Lookout saves a .zip of the whole chat: every message and tool result, the changes it made to files, its usage, its images, plans and subagent runs, and a README that says what is where. The export holds file contents and command output from your project.

## Delete a chat

Press `⌘⌫` on the chat in the sidebar, or choose **Delete chat** from its actions, then confirm. The chat and its history are deleted, and files in the project stay as they are. If the chat has its own worktree, Lookout asks whether to remove it too: **Remove if safe** follows the archive's rule and keeps the chat when the worktree isn't safe to remove, saying why; **Keep it** deletes the chat and leaves the worktree.

## Related

- [Modes](https://lookout.itoowasinarcadia.com/docs/modes.md): Agent and Ask tell the agent what a chat is for, Multitask splits Agent's work across subagents, and you can switch at any time.
- [Context and compaction](https://lookout.itoowasinarcadia.com/docs/context.md): What the agent sees in a chat, how to add files and images to it, and how Lookout keeps long chats within the model's context.
- [Subagents](https://lookout.itoowasinarcadia.com/docs/subagents.md): The agent can hand parts of a task to subagents that report back, waiting for them or working on while they run.
- [Checkpoints and changes](https://lookout.itoowasinarcadia.com/docs/checkpoints.md): Lookout records the chat's folder before every turn, so you can review what the agent changed and put files back.
- [Worktrees](https://lookout.itoowasinarcadia.com/docs/worktrees.md): Give a chat its own branch and folder, then merge its work back into your project.
- [Memory](https://lookout.itoowasinarcadia.com/docs/memory.md): What Lookout remembers across chats, for you and for each project, and how to see and change it.
- [Keyboard shortcuts](https://lookout.itoowasinarcadia.com/docs/shortcuts.md): Every keyboard shortcut in the Mac app, grouped by where it works.