Mind Map — notes, layers, AI, sharing and touch (part 2)
The second half of the Mind Map page: hidden notes attached to a node, drilling into a layer behind one, themes and layout, importing, exporting and sharing a map, the two AI features (which cost money), how a map behaves under your finger on a phone, and what is still rough.
On this page
What it is
This is part 2 of the Mind Map page. It covers everything around the map itself — the notes hidden on a node, layers, how the map looks, getting one in and out, the AI features, touch, and the parts still worth knowing about.
Where to find it
The same Mind Map panel as part 1 — all of this is reached from inside an open map.
How it behaves
Hidden notes on a node (annotations)
Any node can carry a note — a free-text comment that stays hidden on the canvas (it's not the node's label). It's for a side thought, a reminder, or a comment an AI agent leaves for you.
- A node with a note shows a small note icon in its top-left corner (only nodes that have a note show it, so the map stays clean). Hover the icon to peek at the note (read-only); click / tap it to open an editable box.
- Add or edit a note four ways — the icon, right-click → Add note / Edit note,
the
nshortcut, or (on a phone) the Note button in the action bar — for the selected node. Any node can have one, including the center "main" node. - The editor tells you when a note is near its length cap. A note is capped at 4,000 characters; once 200 or fewer characters are left, a line under the field says how many remain ("150 characters left", announced as it changes), and at the cap it says the note is full. Pasting something longer than the room left shows a notice that the paste was trimmed, so it is never silently cut. A shorter note shows no count at all.
- In the editor: type your note (it can be multiple lines — Enter makes a new line), then Save or just click away to keep it; Esc or Cancel discards. Clearing the text and saving removes the note (the icon disappears).
- A note reads as formatted text. The peek and the note box show headings, lists,
bold, italic,
codeand links — so a note written with markdown looks like the document it is, and a line break you typed stays a line break. Click Edit in the note box to get the raw text back; a node with no note opens straight in the editor. - Notes are undoable like node text (
Ctrl+Z), travel with a node when you copy/paste it, and are included in the JSON export and on the Share page (a note marker on the node opens the note). They're intentionally left out of the Markdown/Mermaid text exports. - An AI agent can annotate for you. A session (or any tool driving Omniscio's local API) can set or clear a single node's note without touching the rest of the map — and if you have that map open, the note appears live.
Links on a node
A node can point at something else — the repository, the pull request, the document, the ticket, or another node in the same map. It is what turns a map from a picture of your thinking into an index you can actually work from.
- Set it from the node menu — right-click a node → Add link (or Edit link when it
already has one). You get two ways to point: type a full web address
(
https://…), or pick another node in this map. The node list has a search box that narrows it as you type. Remove clears it. The same box opens withCtrl+Lwhile the map has the keyboard. - A linked node wears a small link badge in its bottom-right corner. Click the badge to follow it — a plain click still only selects, so you can keep editing without opening browser tabs by accident. Ctrl-click / ⌘-click no longer follows a link — that gesture now adds the node to a multi-selection (see Mind Map), and the badge is the one way to follow a link from a node.
- A web link opens in your browser. Only
httpandhttpsaddresses are ever opened; anything else is refused both when you save it and when you click it. - A link to another node jumps there — that node is selected and the view glides to it, opening any branches folded above it (for the view only; nothing about the map changes).
- If the target is gone — you deleted the node it pointed at — the badge shows a broken-link mark and clicking it reopens the link box so you can fix or remove it. Nothing crashes.
- Links travel with the map: they save and reload, undo and redo, copy and paste with the branch, ride the JSON export and appear on the Share page (a badge on the node). A web link is also written into the Markdown outline export as a standard Markdown link (the label in square brackets, then the address in round brackets) and read back on import; the Mermaid export cannot carry a link, so it keeps the label and drops it.
- Shortcut: you can also write a link straight into a node's label —
[the PR](https://…)— and the node's badge will follow it when the node has no link of its own.
Layers (a sub-map drilled in behind a node)
Any node can hold one layer — a full mind map of its own, anchored to that node. Think of it as flipping the node over to a fresh canvas: the rest of the map steps aside, you work on that node's layer, then flip back. It's how you tuck a detail-heavy sub-topic out of the main picture until you want it. One layer per node — pressing "layer" again on a node just takes you back into the layer it already has; it never piles a second blank one on top. To go deeper, nest: a node inside a layer gets its own layer.
- Open a node's layer — select a node and press
l. If it has no layer yet, a fresh blank one opens with its root in edit mode, ready to type; if it already has a layer, this drops you straight back into it. (No second blank layer is ever stacked.) - Flip in and out —
]/[toggle between the base map and the selected node's layer. - See which nodes have a layer — a small layer badge sits at a node's top-right whenever it has one (distinct from the collapse-count circle). Tap the badge to open that node's layer — even while you are already inside another layer — so it works on a phone with no keyboard.
- Know where you are / get back out — while you're inside a layer, a slim bar at the
canvas's top-left reads "In a layer" (with a Layers icon) and a
Maplink straight back to the main map, plus a back button and a crumb per drill step (e.g.In a layer · Map › Plans › Q3). So a blank sub-canvas never looks like your map vanished — it's clearly a separate layer, one click from home. On a plain (un-drilled) map the bar isn't shown at all. - Remove a layer — click the Remove this layer (trash) button at the end of the
layer bar to remove the layer you're in, or middle-click a crumb to remove that layer.
Middle-click asks you to confirm first when the layer has more than one idea, an idea with
typed text or a note, or ideas tied to tasks or board items. The trash button asks when the
layer has more than one idea, or any note, link, style, nested layer or idea tied to a task
or board item. Otherwise the layer goes instantly, and
Ctrl+Zbrings it back. ("Map" isn't a layer so it can't be removed; a normal left-click still just jumps to that depth.) - Nest up to 12 deep — a node inside a layer has its own single layer, and so on, but a sub-map chain stops at 12 levels. Asking for a 13th is refused with a short message and nothing is added. One map also holds at most 20,000 ideas across all of its layers; a save that would go past that is refused rather than quietly dropping the extra sub-map, so nothing you built disappears without a word. A whole map also has a size limit of about 24 million characters of saved text, ideas and notes together; a save past it is refused with a message asking you to remove some ideas or shorten long notes. Any map that saves can also be exported.
- Saving & undo — layers live inside the same saved map (nothing extra to
manage; deleting or copy/pasting a node carries its layer along). Anything you build
inside a layer saves right away — even on a brand-new map you haven't named yet.
Undo is per-view:
Ctrl+Zundoes what you're looking at, and moving in and out of layers never loses history. - No clutter — open a layer, change your mind without typing anything, and the empty layer removes itself (and its badge) when you leave, so blank layers never pile up. A map that never uses layers is byte-for-byte the same as before.
- Every export carries the whole map — JSON, Markdown, Mermaid and the Share page always cover the entire map, including every sub-map, even when you run them from inside a layer. A sub-map appears in a text/outline export as one extra branch under the node that holds it, and on the Share page as that same extra branch, so nothing built inside a layer is left out of a file you hand to someone. That extra branch keeps the sub-map's own colors and shapes: the color of the branch that holds it does not spill into it, just as the sub-map looks when you open it in the app. The one exception is PNG, which is a picture of the canvas as it looks on screen.
Layers are bounded by generous guardrails — one layer per node, 12 levels of nesting, and a 20,000-node budget across a map's layers. You won't hit the nesting or node limits by hand; they exist so a runaway or malicious import can't blow up the app.
Look & layout (themes, direction, background)
- Color mode button cycles Match app default → Light (this map) → Dark (this map) and back (default Match app default, which uses the app-wide Mind Map color mode described below).
- Visual theme picker restyles the whole mind-map view — sidebar, header,
canvas — with any of the app's 14 built-in themes, without changing the rest of
the app. Both are view preferences and both are set per map from the toolbar and
saved with the map. A map that carries no choice of its own follows the app-wide
fallback (
mindmapColorMode/mindmapVisualThemein Settings), which has no Appearance card — it is only reachable throughPATCH /settings. - Flow-direction button rotates the map through the four directions; the choice is saved for the level you are on: the main map and each sub-map keep their own direction, so turning a sub-map does not turn the main map.
- Condense button opens Map spacing — one slider that pulls every level of children closer to its parent (Compact, down to 35% of the usual gap) or pushes them further away (Spacious, up to 250%), live while you drag, with a percentage readout and Reset. It changes the gap between a node and its children only — the gap between sibling branches stays as it is. The gap is measured edge to edge on the real box sizes in every flow direction, so the slider always moves it by exactly its percentage and a tall or wide-text level never crowds the next one — and the amount is saved for the level you are on (the main map and each sub-map keep their own), so a big map can open condensed while a small one stays roomy. It costs no undo step, and the exported image and the shared page condense by the same amount. A map you never touch keeps exactly the spacing it always had.
- Text size button (beside Map spacing) makes this map's text Smaller or Larger, one step at a time through the app's text sizes, with Reset and a readout of the size shown. The keys are Alt+= (larger) and Alt+- (smaller) while the canvas has the keyboard. The size is saved for the level you are on (the main map and each sub-map keep their own), as a step up or down from your app-wide text size, so one big map can read larger without resizing the rest of the app. It costs no undo step, boxes and wrapping follow the new size exactly (the size used to lay a node out is the size it is drawn at), the picture export follows the canvas, and a map you never resize looks exactly as before. The published share page keeps the standard size.
- Tidy columns — nodes at the same level line up on the edge nearest the center (their left edges in the default left→right view; right / top / bottom in the other directions), so a column of different-width boxes reads as one clean line rather than a ragged stack. It's automatic — the widest box in a column anchors the line and the narrower ones slide in to meet it.
- Dotted-grid background toggle (off by default, remembered).
- The floating zoom controls in the canvas's bottom-right corner (the +/− and fit-to-view stack) wear the same glassy "bubble" look as the nodes — a translucent, softly-shadowed panel that recolors with the active theme (and frosts on the glass themes) — so they read as part of the map rather than a separate widget. They sit bottom-right so they stay clear of the bottom-left "Press ? for shortcuts" hint. Their behavior is unchanged.
- A scrollbar for a map too big to fit. Fitting stops once the labels would get too small to read, so a very large map stays bigger than the canvas. Whenever that happens the canvas grows a thin scrollbar along the overflowing edge, and dragging its thumb — or clicking the track — pans the map. The thumb tracks the view however it moved, so panning by dragging the canvas and scrolling with the bar can never disagree. A map that fits shows no bar at all.
- Ctrl+= / Ctrl+- / Ctrl+0 zoom the map while the canvas has the keyboard, instead of changing the app's text size; everywhere else those chords are still the app's text-size keys. Ctrl+0 returns the map to 100% (V still fits the whole map in view) and is the one chord the map borrows from the app's universal project shortcuts — it keeps its project-jump meaning the moment the canvas is not what you are working in.
- Smooth node motion — whenever the map rearranges (dropping a node on a new parent, adding/deleting, collapsing/expanding, flipping direction, undo/redo, or a drag that snaps back), the nodes glide to their new positions in a short (about 150 ms) ease instead of jumping. The node you're actively dragging still tracks your cursor exactly — the glide only plays as things settle. It switches off automatically on very large maps (to stay fast) and when your system reduce-motion / low-power setting is on.
Import, export & sharing
The toolbar's low-frequency actions are grouped into labeled dropdown menus so the bar stays uncluttered — map creation/import under a New menu, AI under an AI menu, and exporting and sharing under an Export menu — while the everyday view controls (fit, zoom, dotted background, flow direction, color mode, theme) stay visible on the bar. Between them, the New menu (for importing) and the Export menu handle several formats — all of them cover the whole map and its sub-maps, whichever layer you are standing in (PNG alone is a picture of the canvas on screen):
- JSON — the native format (
Import/ theJSONexport), fully re-importable. - One Import file row — the New menu's Import file… opens the file picker filtered to
every format it reads (JSON, Markdown, a
.txtoutline, Mermaid,.csv,.tsv,.xlsx, plus an All files row), and the format is taken from the file's extension, so nothing is pre-picked. Its tooltip names the formats and the two spreadsheet layouts before the picker opens. A file that is not a valid map is refused with a pointer to New > Import outline for pasting a text outline instead. - CSV and Excel — a
.csv,.tsvor.xlsxpicked through Import file… turns a spreadsheet into a map. Two layouts are understood: anid/parent_id/labeltable, or one column per level (Level 1,Level 2, …); either may addNoteandLinkcolumns. A level row may fill one cell (an indented outline) or several, read as a path from the first filled level to the last:Fruit, ApplethenFruit, Banananest both under oneFruit, so a filled-down sheet imports whole, and the row's note and link go on its deepest idea. Anidrow with a blank label becomes an untitled idea, so its children stay under it. Rows keep their file order, accents, emoji and quoted commas; blank rows are skipped; several top rows are gathered under one root named after the file. A row whose parent is missing (or sits in a parent loop) goes under the top idea, and a repeated id keeps its first row — both are named in a notice, never placed or dropped silently. The notice lists up to 10 rows of each kind and then says how many more. A row with noidis skipped and named by its text; a row with noidand no label, note or link at all is skipped without a mention. An Excel workbook is read from its first visible sheet, using formula results and dates asYYYY-MM-DD; old.xlsfiles are refused. A file in neither layout, or over 2,000 ideas, is refused in plain words. Mission Control's own spreadsheet readers do the reading. A CSV with no byte order mark that is not UTF-8 is refused with the same plain request to save it as UTF-8 that a map file gets, so no map is ever saved with broken characters. - File import decoding — a JSON, Markdown or Mermaid file is decoded the same way as a CSV: a UTF-8 byte order mark is dropped and UTF-16 files are read as text. A file that is not UTF-8 is refused with a plain request to save it as UTF-8, rather than imported with broken characters.
- Markdown outline — the
Markdownexport writes an indented-bullet list (.md); New → Import outline… turns a pasted indented list back into a map, and New → Import file… opens a saved.mdor.txtfile the same way (desktop app only), with several top-level items getting one synthesized root. Pasting a multi-line indented or bulleted outline straight into an idea of a new map that has not been saved yet (such as the landing map's first idea) does the same thing, so the paste becomes a tree rather than one long idea. An outline can be up to 500,000 characters, pasted or in a file; a longer one is refused with a message, so import it in parts. A normal Markdown document imports too: headings nest by level (#above##above###, a skipped level hangs off the nearest higher heading) and bullets sit under the heading above them. A quote (>) or a fenced code block becomes the note of the idea above it; front matter and divider lines are skipped; each table row becomes one idea with its cells joined; an image line becomes an idea named for its caption. A task-list box (- [ ],- [x]) is dropped from its item (an idea whose own text starts with[ ]or[x]is exported with a backslash before the box so it comes back intact), and an unclosed```or~~~fence line is skipped. A code block ends only at a bare fence line at least as long as its opener, never at one carrying a language name. Markup the import does not recognize, such as a===heading underline or an HTML tag, comes through as idea text. - Mermaid —
View as Mermaidopens a read-only panel with a rendered picture (when small enough), copy-able source, and a.mmddownload. Pasting a Mermaidmindmap(or opening a.mmd/.mermaidfile) is auto-detected and becomes an editable map — including a copy wrapped in a```mermaidfence, or one that opens with YAML front matter or a%%{init}%%directive. - PNG — a raster image of the canvas. A big map (over 300 ideas) normally draws only the ideas on screen; the export draws every idea while the picture is taken, so ideas scrolled off screen are never left out of the image.
- Share — publishes a self-contained, interactive, read-only web page (an
HTML+SVG view, mobile-friendly, themed to match the map). The viewer can zoom
(scroll-wheel / pinch / on-screen + / −; a sideways-only scroll never zooms), pan (drag), tap a node to fold
or unfold its branch, Fit to re-frame, Expand all (a button that appears once
they've folded something, then re-opens every branch and re-fits the view), and switch
light / dark with an on-page sun/moon button — all from one small inline script (no
external libraries), and the page renders full-screen. Every on-page button (zoom in,
zoom out, Fit, Expand all, sun/moon, the note panel's close button) and the note and link badges are drawn with the app's
own icon set, a broken link shows the app's broken-link icon, and keyboard focus is outlined
in the app's default indigo accent. It opens at a readable size:
a small map is never blown up past about 1.5 times its normal size, and on a phone a map too
big to read whole opens at normal text size on the central idea so the viewer pans instead of
squinting. Fit frames the whole map (with the same 1.5 times cap) and leaves room for the
on-screen buttons; the view can be pulled back to about half the fitted size before it
stops. Folding is by tapping the node (the shared page has no fold button on a node;
in the editor a folded branch still shows its clickable count circle, see
part 1); only ideas that can fold show the
hand cursor, and a folded idea shows a small count of its hidden ideas, like the app.
The note and link icons have a large invisible touch area so a fingertip opens them
instead of folding the idea. The usage hint stays visible on phones (under the title), the
buttons show a clear hover and pressed look, and the glide animation is switched off for
viewers who ask their device for reduced motion. The page is laid out in the map's own
direction (left to right, right to left, top down or bottom up) and its idea boxes use the
same text size and box measurements as the app, so labels wrap at the same words.
A note opens in a panel with a title row naming its idea and a full-size close button;
note text is 16px with larger headings, and on a phone the panel leaves the button column
uncovered. The page carries the map's own theme colors (the surface palette + accent, with
text at the default text step 800 like the app, never the brightest step),
read from the app's live theme at share time so the baked page can't drift from a hardcoded
list, and opens in the map's chosen color mode — falling back to the viewer's device
setting, then a neutral palette if a theme can't be read. The page runs only its own small
script; the map's text and title are escaped and its colors are checked before they reach
the page. An existing link is a snapshot of the map at share time — re-share to
update it. Re-sharing refreshes that same link; if the app cannot check for the earlier link,
Share stops with an error instead of publishing a second public link. The page now ships the whole map fully expanded: branches you collapsed in
the editor are included and open by default, so collapsing no longer hides anything
from a viewer (it only sets your own editor view). A viewer can fold branches themselves
and then Expand all to reopen everything. A long label wraps to at most four lines
on the share page, the same as on the canvas; anything longer ends in an ellipsis, so keep
long detail in the idea's note (notes open in full on the share page).
The page speaks the author's language: the document root carries the app's UI
language (
dir="rtl"for Arabic, Persian or Urdu) so a screen reader uses the right voice and the title bar and notes mirror, while the map drawing itself is not mirrored (it keeps the map's own direction). Its controls are translated, including the light/dark button's name in both states, which the page's own script now takes from the page instead of writing English over it. Box widths are estimated from the characters in a label, with a wide Chinese, Japanese or Korean character or an emoji counted as two, so those labels wrap inside their boxes. Capital letters are not counted any wider, so an all-caps label can run slightly past its box.
AI assist (billable)
Both live in the toolbar's AI dropdown menu.
- Expand with AI asks the AI to brainstorm a handful of child ideas for the selected node and inserts them (undoable).
- Generate map with AI turns a typed topic into a whole starter map. Its dialog names no AI vendor ("AI will draft a starter map you can edit"), and it opens with the topic box already filled with the open map's central idea when that idea has real text, so a topic you already typed is not asked for twice. While a map is being generated the dialog says that closing it cancels the generation. The topic can be up to 500 characters; the box stops taking text past that.
- What is sent, and to whom. By default both send text to OpenRouter, an outside AI
service, which routes it to a hosted OpenAI model (GPT-5.6 Luna), not to your Claude
account; a different Mind Map AI model, or a different global Utility AI model, changes
which service receives it. Expand sends the idea you selected and the labels of up to 20
ideas above it; Generate sends the topic you typed. Notes, links and the rest of the map
are not sent. API keys, tokens and labeled passwords (such as
password=...) are masked first. If the AI returns nothing usable, Omniscio asks once more, and that second try is charged too.
Both are paid the same way as Omniscio's other AI helpers — your own OpenRouter or
Anthropic key first, then your Omniscio credits, then a company allowance when your
organization provides one. A Claude login on its own is not used: with none of these, the
request stops before it is sent and tells you to add Omniscio credit or your own AI key.
They use the cheap GPT-5.6 Luna model (OpenRouter;
overridable with the mindmapModel setting), and are bounded by a daily spend cap
(mindmapAiCostCapUsd, default $1, settable from 0.5 to 50). While sign-in is required and the app cannot confirm a known plan tier, the cap is held at the free-plan $1 rather than the higher setting.
Canceling Generate map with AI, or a call that times out, stops the wait but may still be
charged by the AI service; that charge is not counted toward the daily limit or shown in the
spend breakdown.
- It only runs when you ask. Nothing on your map is sent to the AI unless you choose Expand, Generate, or start an AI session. There is no separate switch for the AI part; the lowest daily limit is $0.50, and switching Mind Map off in Settings → Features is the only way to remove the AI menu.
- Changing the daily limit. Settings → Sessions → Behavior → Advanced session settings → Limits → Mind Map AI daily limit, directly under the Mind Map AI model picker. Settings search finds it ("mind map limit"), and the assistant can point at it. When the limit is reached, a short message says so and that it resets tomorrow, and its Open Settings button goes straight to that setting. Only when an unrecognized plan held the limit at the free-plan $1 does the in-app message add "sign out and back in to refresh it" (the assistant's expand door keeps the plain message).
- Who pays shows in the spend breakdown. Every Mind Map AI charge carries a label: "Mind
Map", or "Mind Map: <map title>" when a map exists. A call an agent makes through the CLI
(
POST /mindmaps/generate,POST /mindmaps/:id/nodes/:nodeId/expand) is also charged to the agent's own session, read from itsX-AMC-Source-Session-Id. - Messages are translated. The no-API-key, daily-limit, "no ideas / no usable outline" and generic failure messages follow your language. A raw provider error never reaches you; an empty AI answer is retried once, then shows its own message.
- A temporary failure names its cause. A dropped connection says to check the internet
connection; a rate limit, or too many AI calls at once, says the AI service is busy and to wait
a minute; a request that took too long says so; any other provider hiccup keeps the generic
"could not be completed" line. Every Mind Map AI message stays within the 200-character limit
the app's error toasts show in full (
MAX_USER_MESSAGE_LENGTHinsrc/shared/ipc-error-copy.ts, the same value as the renderer's own cut inlib/ipc-error.ts; a guard test holds the Mind Map messages to it). - The app and the assistant doors give the same codes. One table in
mindmap-ai-errors.ts(mindmapAiFailureReply) gives each failure kind its code and CLI status: a missing key, the daily limit and a refused key or empty wallet are402 PAYMENT_REQUIRED; busy, timed-out and no-result are503 SERVICE_UNAVAILABLE. - A damaged map says it is damaged. A map whose stored data cannot be read answers open and
share with "This mind map is damaged and can't be opened", and duplicate with "couldn't be
copied", coded
UNPROCESSABLEso the message is shown as written and nobody is told to try again. A save the sub-map rules refuse shows that rule's own message, and a save whose tree is broken says the latest changes were not saved and to reopen the map; the raw reason goes to the log only. - Only the AI's list items become nodes. A lead-in sentence, a closing remark or a code fence around the list is dropped; Generate keeps headings (they still nest the bullets under them), while Expand also drops headings, nested sub-items and repeats within one reply. An answer cut off at the length limit or declined, a plain-text decline, or a generated map with a single node counts as "no ideas / no usable outline" (retried once) and is never saved. Each call asks with thinking off and no fixed temperature, and a picked Mind Map model is sent to the provider the model catalog names for it, exactly as picked (only Automatic follows the global Utility AI model). Each reply writes one log line (operation, model, finish reason, reply length, parse outcome), never the reply text.
AI sessions (a chat that reads & edits your map)
A "Maps / Sessions" tab at the top of the saved-maps list opens a list of AI chat sessions for mind maps — the same session experience as the rest of Omniscio (Needs You / Live / Paused / … sections, a "+ New session" button, and the right-click pause / rename / archive / snooze menu). It works the same way as the Sessions tabs in SMS and the Vault.
- "+ New session" starts a Claude session that
already knows the open map and can read and rewrite it for you — ask it to
brainstorm, reorganize, expand a branch, summarize, or tidy up. It edits through
Omniscio's validated internal
/mindmapsAPI (so it can never save a broken map). It is told to wait for your instruction before editing, but nothing in the app holds it back, and its changes save the moment it makes them — on a big map, export a JSON copy first. Unlike "Expand / Generate with AI", this uses your chosen session model, not the capped cheap model. - Starting from nothing: "+ New session" is there on the blank map Mind Map opens on, too. Clicking it first saves that blank map as a new "Untitled" map, then opens a session attached to it that knows the map is brand new, so you can tell it the topic and build the whole map in conversation. If the blank map cannot be saved, no session starts and you see the usual "couldn't save" message. A session you start and never use leaves that empty map in your list, where you can delete it like any other.
- The title follows the top idea. When the agent changes the map's top idea, the map's name follows it, the same as when you type it yourself, unless you named the map by hand.
- Opening a session opens a split view (desktop): the map on one side, the chat
on the other, resizable, so you watch the agent rebuild / expand / reorganize the
map live as you talk to it. While a chat is open, the two-column button beside the
Maps / Sessions tabs (tooltip "Hide the map (chat only)") collapses to chat-only, and
clicking it again brings the map back — auto-split is on by default
(
mindmapSessionSplit); your divider width is remembered. On a phone the chat replaces the map (too narrow to split); the map auto-saves and is one tab away. - The chat stays open while you are away. Leave the Mind Map for another part of the app and come back, and the chat you had open is still there on the same session. If you left from the map (the Maps tab), you come back to the map. You also come back to the map after closing the Mind Map with its close button, or when the session you were in has been archived.
- The Inbox shows the map too. Open a Mind Map session from the Inbox on desktop and its own map opens beside the chat, with the Inbox list still on the left: the full editor (toolbar, zoom, collapse and expand, editing, outline) and the same live updates. It uses the same two-column button; with the map hidden, or on a phone, the Inbox shows the chat only. The map's close (X) hides it for that one session, and its Open in Mind Map button (where the full-screen toggle usually sits) jumps to the Mind Map page with this map and session side by side; closing the map there returns to the Inbox. A session whose map was deleted shows the chat only.
- When the AI changes the map, the open editor refreshes live and the change stays undoable (Ctrl+Z reverts the AI) — this is what makes the split view show edits as they happen. If the AI changes the map while you are typing in an idea, its change waits until you finish that edit and then loads over it; a notice tells you, and Undo puts your version back.
- The sessions live in the internal
__mindmap__project. That project's sidebar row is the Mind Map hub row, shown while Mind Map is switched on; each session is bound to the map it was started from.
On a phone (touch)
Mobile always opens full-screen. With no keyboard, the editor shows an on-screen
action bar at the bottom — Find in map, Outline, Add child, Add sibling, Rename,
Note (add/edit the node's hidden note), Link (add/edit the node's link), Delete, Cut / Copy / Paste (Cut/Copy are grayed out unless a non-root
node is selected; Paste is grayed out until you've copied something), Collapse/expand,
Expand all (grayed out until a branch is collapsed), Undo,
Redo — every button always keeps its place, and one that cannot run right now is grayed
out rather than removed — wired to the same actions the keyboard and the desktop right-click menu use. A
touch-only tablet (a touchscreen with no mouse or trackpad) gets the same bar at any width;
a computer with a mouse, touchscreen laptops included, does not. The bar scrolls sideways so every button stays
reachable, and a soft fade at its end shows there is more to scroll to; Undo and Redo
stay pinned at the end, outside the scrolling strip, so they are always in reach. The bar's
bottom padding clears the phone's home indicator. On a touch device the first map and every
new blank map open with the central idea selected, not in edit mode, so the bar shows at once;
tap Rename to type. Add child and Add sibling carry distinct icons that picture where the
new node lands — a + nested down-and-right for a child, straight below for a
sibling — so you can tell them apart at a glance (a phone has no hover tooltip to lean
on). The top toolbar keeps the same buttons in the same order, except the one it drops on
a phone because it needs a desktop: Take a tour. The ? button stays on a phone too, so
the phone has one visible place to open the Mind Map cheat sheet of actions and their keys. Two more controls the phone does not
get live outside that row — Import file… is a row in the New menu and opening the
map in its own window is an editor-header button. Every button the toolbar does keep is at
least 44 × 44 px so a finger can hit it, and the bar scrolls sideways to reach the rest.
A computer, or a narrow desktop window, keeps the compact toolbar. The Mission Control,
Tasks and Vault bridges are desktop only — no chips, no Make a task / Make a board
item rows, no Send map to Tasks button and no workspace section in the link box —
because the handlers behind them do not run on the phone or in the web view. The one thing the New menu leaves out on a phone or in the web
client is file import — Import file needs the computer's own file picker, so use Import outline and paste the text
instead. The saved-maps list opens as a bottom-sheet drawer. Pan, pinch-zoom,
tap-to-select, and drag-to-re-parent work on the canvas — a long-press just grabs the
node to drag it; it does not pop a menu (the desktop right-click menu would collide
with the drag, so on a phone Cut/Copy/Paste live on the action bar instead). In the
saved-maps drawer a long-press behaves the opposite way — there's no drag to
collide with, so press-and-hold a map row opens its Rename / Duplicate / Delete menu (the row
has no trash button to tap). Editing a
node slides it above the on-screen keyboard so the box you're typing into is never
hidden behind it. You reach Mind Map from the account menu (the entry appears only
when the feature is on).
Limitations / known issues
- A published share link is a frozen content snapshot — the page itself is interactive (pan / zoom / fold / Expand all), but the map data is captured at share time, so re-share to push later edits. Deleting the map ends every link made from it.
- The usage hint has one wording for every device — it names taps and pinches on a desktop too, because a separate mouse wording would need a new translated string.
- Touch gestures can vary between devices. If a drag or pinch misbehaves on your phone or tablet, the action bar at the bottom of the editor offers the same actions as buttons.
- AI needs something to pay for it (your own OpenRouter or Anthropic key, Omniscio credits, or a company allowance; a Claude login on its own is not used), and is capped at $1/day by default.
- No pictures or files inside an idea. An idea holds text, a hidden note and one link (a web page, another idea or a Vault note).
- No print or PDF export. Export a PNG, or publish the Share page and print it from your browser.
- No XMind, FreeMind or OPML import. Export from the other tool as a Markdown outline or a CSV/Excel sheet, then paste it with Import outline, or use Import file for the saved outline or sheet.
- No editing together. A map belongs to the account that made it; Share gives other people a read-only copy, and two of your own windows on one map do not merge edits.
- An agent can do everything you can, except take the in-app PNG. As of
2026-09-08 the CLI covers the whole feature: list, read, create, import, save, rename,
delete, export (JSON / Markdown / Mermaid / PNG), open, annotate a node, write a
whole map with AI (
POST /mindmaps/generate), expand one node with AI (POST /mindmaps/:id/nodes/:nodeId/expand), and publish the share page (POST /mindmaps/:id/share, which hands back the public link). Themes, flow direction, folds and layers have no route of their own — they live inside the map's saved data, so an agent changes them by saving the map. That save follows the same rule as the app's own: it must name theupdatedAtthe agent last read, and a map that has moved on since refuses it (409, nothing written) rather than letting an agent's stale tree land on top of a newer one.POST /mindmaps/importtakesformat: 'outline'(Mermaid or Markdown),'csv','excel', or'json'— the native map JSON a?format=jsonexport returns, so an exported map comes back in with its structure, labels, notes, links, styles, layers and view settings; the one thing it does not carry is an idea's task / board-item link, so a re-imported map starts with those links cleared. The one thing that stays in-app is the PNG taken from the live canvas; the CLI'sformat=pngrenders the share-page drawing of the saved map instead. Unlike the published share page, it keeps the map's folded branches folded and follows the map's flow direction, so expand the map first if the picture must show every idea. One difference is worth knowing: an agent's share page and PNG open in the map's own light or dark choice, but they use the neutral palette, not the app's visual theme — a visual theme is a skin of the running app, and the CLI has no app window to read it from. That neutral palette is the default theme's own gray scale (surface steps 50, 100, 200 and 500, with text at the default text step 800), so an agent's share looks like the app's default theme rather than a separate look. Share from the app when the look matters. - 2,000 ideas per canvas — the main map and each sub-map can each hold up to 2,000 ideas, and a whole map at most 20,000 across all its sub-maps, with labels of up to 1,000 characters; the Mermaid picture is officially experimental and degrades to text when a given map can't render.
Build a map with the mind-map skill
A bundled Claude Code skill that generates a mind map from source material -- vault notes, local files, or Google Docs. Instead of dumping raw data into the import endpoint (which produces an unusable flat list), the skill interviews the user about scope, angle, and depth, synthesizes a properly structured Markdown outline, validates it against node/depth budgets, and creates the map via the CLI.
How to use it
In any Claude Code session, invoke it with:
/mind-map
(or say "make a mind map from my vault notes about X", "mind map from this file", "visualize as mind map", or similar). The skill walks through these steps:
- Feature gate -- checks whether Mind Map is enabled; if it is off, asks whether you want it turned on, and only then requests it (usually an approval in your inbox). If you say no, the skill stops.
- Source resolution -- reads your Vault notes, local files, or Google Docs.
- Interview -- asks up to 4 questions (source, angle, depth tier, preview preference), skipping any the user already answered. Never guesses.
- Synthesis -- builds a Markdown outline following structural rules: 5-7 top branches, 2-6 word labels, rolled-up counts instead of flat lists.
- Validation -- six-point checklist (node count, depth, label length, single-child branches, fat branches, root check). All must pass.
- Preview -- shows the outline if the user opted in; accepts approve, change, or reject.
- Creation -- imports the outline via
POST /mindmaps/import, renames the map, and populates hidden annotations for rolled-up detail.
Depth tiers and limits
| Tier | Typical nodes | Typical levels | When to use |
|---|---|---|---|
| Overview | 15-25 | 3 | Presentations, quick summaries |
| Standard | 25-40 | 4 | Most maps (default) |
| Detailed | 40-100 | 5-10 | User must request this tier |
Hard ceilings: 100 nodes, 10 levels. These are never exceeded without explicit user instruction.
What it does NOT do
- Pick layout direction (that is a canvas setting the user controls).
- Use the built-in AI expand/generate endpoints.
- Modify existing mind maps (always creates a new one).
- Spawn additional sessions.
Related
- Mind Map part 1 — opening a map, the library, and building one with the keyboard or the mouse.
- kms.md — the other panel where your notes live, and where a map can be imported from.
- artifact-sharing.md — publishing something you made so it can be opened elsewhere.
Last verified 2026-11-20