It knows what you have open and acts on it. The Assistant does not answer only about your notes: it knows which tab is active, what is selected in it and what else is open in the window, and it can read and change what you are looking at — the note, the code, the task board, the table, the SQL script, the HTTP test —, with a local or a cloud model. You always decide: every change is proposed and only takes effect after your approval, almost everything can be undone, and nothing leaves the machine without you seeing where it goes. Changing things requires the Change with approval Mode; in the Read Mode it looks things up without changing anything.
Asking about what is on screen. AI → Ask the Assistant about this (Ctrl+Shift+Q) opens the Assistant with the active tab already in the question — and, with the focus in a terminal, its last command block. "This file", "this table" and "the recording" resolve on their own, with no attachment. Requests that work this way: "analyze this recording and create the tasks", "create the structure for me to write a thesis", "read this page and put it as a checklist in this note".
What it sees
The current view. With each question, the Assistant receives a short summary of the active tab: the type (note, code, SQL script, HTTP test, SSH connection, task board, Custom Table, Base, canvas, PDF, spreadsheet, terminal), the path, whether there are unsaved changes, and the selection — the rows ticked in a table, the selected tasks, the PDF page, the SQL statement under the cursor, the test chosen in the .lnh. In the Context selector, the Current view item shows its name. The summary has a size cap and says when it was cut.
The Explorer selection and the open tabs. Along with it go the items selected in the Explorer (up to 20) and the list of open tabs (up to 30), with any excess mentioned. Secrets do not leak this way: the HTTP test request goes masked, the SQL error and query go through the same mask as the plan, the rows of the last result only go when the connection allows AI queries, and the SSH connection carries the server and the folder, never a password or a key.
Tools in packs. To avoid offering dozens of tools with every question — above about 30, the model starts choosing badly —, the Assistant gets a fixed base (notes, tasks, this Help, asking you, settings), the pack for the active view (database in an SQL tab, tests in an .lnh, SSH in an .lns, table in a Custom Table, editing in the editor, files and folders in the Explorer) and the pack the question names: "in the sales database…" turns on the database tools even with no SQL tab open.
Propose, never act alone
In the editor, the proposal is the diff. When it proposes changing the open text, the conversation shows the change hunk by hunk, each with its own checkbox: Apply the ticked ones replaces only the lines that changed, all at once, and one Ctrl+Z in the editor undoes everything. It refuses without opening anything when the file is read-only or when the text has changed since the question.
On task boards, tables, Bases and canvases, it uses the same operations as each screen's Edit with AI: with the tab open, they apply on the screen and are undone with its Ctrl+Z; with the tab closed, they go to the file. With more than one board in the folder, it asks which one before creating tasks.
One batch, one approval. Creating twelve tasks, a structure of folders and notes or several changes to a table becomes one approval request, with the plan in view — the tree of folders and notes, the list of tasks, the operations in readable sentences. What would fail never even reaches the approval: a folder that already exists, a protected name, an executable file or a tab with unsaved changes go back to the model as an error, with nothing written. Batches, reads that leave the machine and settings never fall under Allow in this conversation: each one is approved on its own.
Files and folders. It creates what does not exist — a note, a folder, the whole structure of a work, including as a Binder, with the chapters in order and the templates from the Templates folder —, copies, moves and renames (the open tab follows along) and edits with a diff. It never overwrites or deletes a file.
Undo
Undo the last AI action. Every approved change goes into a stack in the conversation, one item per approval. The Applied notice carries the Undo link, and the ⋯ menu has Undo the last AI action; undoing goes from the most recent to the oldest. Each screen undoes the way it already knew how: created tasks are archived, never deleted; the table and the canvas go back through their own undo; created files go to the Recycle Bin, and created folders left empty are removed.
It only undoes what is still as the AI left it. If you changed it afterwards, undo will not overwrite it and says why. What cannot be undone — changing a setting, deleting a task, sending an HTTP test — is stated before, in the approval request itself. The stack lives with the conversation: a new conversation starts without it.
Database
It queries through the open connection. In an SQL tab — or when the question names the database —, the Assistant reads through the window's own session (with Oracle, password asked on the spot, and SSH tunnel), with read-only queries only and up to 1,000 rows. The connection must have Allow AI queries (MCP) ticked on its screen; without it, the Assistant says where to tick it, and it never turns that permission on by itself.
The SQL goes to the script, not to the database. To write SQL — a query, the fix for an error, an UPDATE —, it proposes the text in the open script: under the cursor, in place of the statement under the cursor, or in a new script next to the connection. The approval request says Contains writes when there is an INSERT, UPDATE, DELETE or DDL. Nothing runs until you execute it.
Reading a web page
A narrow door. The Assistant reads a page by its address (http or https), with GET only, with no header, body or cookie chosen by the model, and refuses addresses on your network (localhost, private network, disguised address); each redirect is checked by the same rule. The page becomes text, with a size and time cap, and every read leaves Page read: with the address in the conversation.
Who wrote the address decides whether it asks. An address that you wrote — in the question or in the open note — is read without asking. One the model came up with asks for approval, showing the whole address: the query string of such an address is where a hostile text would try to carry your data out, and that is what you need to see before allowing it.
Web search
Off by default. Turn it on in Settings → AI Providers → Web search, with a search service and your own key (Brave Search, Tavily, Exa, Jina, Google Programmable Search or your own SearXNG instance) — or, with Anthropic, through the provider's own search, which needs no key and is billed to that account. The key is kept encrypted on this machine only, and the blocked domains apply to both paths.
One permission per conversation. The first search in a conversation asks for approval and says who will search. From then on, each search shows up as Searching: before it goes out, the pages the results bring back are read without asking again, and the answer ends with the Sources. There is a cap per question (5 searches and 10 reads), and the permission dies with the conversation. /research followed by a topic starts a search.
HTTP tests and SSH
HTTP test. In an .lnh, the Assistant reads the selected test with the secrets masked, creates or adjusts tests, checks and variables in the same format the app writes (a secret only as a {variable}) and only sends a request with your approval, which shows the method, the address, the environment and the checks. In the production environment, a request that changes the server is refused before asking.
SSH, read-only. It lists the saved connections, without secrets, and, through the open and connected .lns connection, lists a remote folder and reads a remote text file — always with approval and through a separate channel, without touching the panel's screen. With the connection closed, it returns the link to open and connect it. Running or typing commands on the server is left out.
AI permissions. An HTTP test that carries a secret is only sent with Allow AI to use this file's secrets checked in the .lnh, and SSH reading only happens with Allow AI to read files from this server checked in the connection, inside the authorized folder. Both also apply to AI CLIs, and the password and the secret stay in the window: see Test HTTP APIs and SSH connection.
Long conversations, reasoning and cost
The conversation remembers what it did. The reads and changes of each step are recorded: reopened the next day, the conversation knows what it has already read. When it goes past the model's context window, the beginning is compacted into a summary (goal, decisions, what was done and what is left), and the model receives the summary in place of the old messages, which are still kept. /compact, with or without a focus, does this right away.
Reasoning and footer. In models that reason before answering, the reasoning appears in a collapsible block, Reasoning, closed and kept out of the answer and of what gets copied. The footer shows how much of the context window the last question used (context: used / window), the conversation's accumulated cost when the catalog knows the model's price — never estimated without it — and, for a local model, the tokens per second.
What never happens
Left out, on purpose. The Assistant does not run commands on the computer or over SSH, does not run SQL that writes, does not overwrite or delete files, does not make free-form HTTP requests, does not change keys, provider addresses or program paths in the settings, and does not scrape search engines. The text of your notes — including that of a note that arrived through sync — goes into the conversation, and that is why the way out stays closed: what it reads may try to steer it, but it has no way to carry your data off without you seeing.
The other AI screens continue in the Assistant. The result of Ctrl+K/Ctrl+I, the Ask AI of error messages (SQL, execution, lint, HTTP test, terminal, formatter, Git), the Edit with AI of tables, tasks, Bases and canvases and the transcription notice of an audio recording carry Continue in the Assistant (or Analyze in the Assistant), which takes along what has already been put together — the snippet, the diagnosis, the selection. Nothing is sent on its own: the request stays in the field for you to review.
Index
Editing
- Overview
- Getting started
- Workspace and windows
- Activities panel: tasks and messages
- Code editor
- Markdown and wikilinks
- Diagrams (Mermaid)
- Mathematics and chemistry (LaTeX)
- Calendar in a note
- Numbering and cross-references
- Citations and references
- Academic paper standard
- Connections graph
- Canvases (.canvas)
- Tables (Parquet, CSV, JSON, Excel)
- Analysis area: pivot table and several charts
- PDF and images
- Images: marking up a screenshot
- HTML pages (.html)
- Printing
- Zip as a folder (.zip)
- Blocks (.lnb)
- Tasks (Kanban / Gantt)
- Custom table (.lnd)
- Bases (saved queries over your notes)
Tools
- Search in files and Pending items
- Versioning (easy Git)
- Snapshots and backup
- Review changes (checkpoints)
- Compare files (diff)
- Run code (F5)
- Terminal and AI CLIs
- AI in the editor (Ctrl+K / Ctrl+I)
- AI on your computer
- AI sessions
- Assistant
- The Assistant and what you have open
- Test HTTP APIs (.lnh)
- Databases (.lnc)
- SSH connection (.lns)
- Security: Passphrase, PIN and Secure Markdown
- Daily notes, quick capture and tray
- Resurface old notes
- Your notes on your phone
- Record audio (voice, meeting) with AI transcription
- Sticky notes
- Calendar
- Command palette
Automation (AI / scripts)
Reference