Skip to main content

​
What Notes Are

Notes in Linkly AI are a stream of small cards ordered by time: type a line into the box at the bottom whenever something occurs to you, hit save, and it becomes a card on the timeline. The biggest difference from other note apps is this — each card is a plain .md file on disk. No proprietary database, no export feature (because none is needed): you can open them in Obsidian or VS Code any time, or just grep them. At the same time Linkly AI indexes them, so they turn up in search and your AI assistant can read and write them.

Fast Enough Not to Think About

The input box is always there at the bottom. Write, press ⌘/Ctrl+Enter — no new file, no title

Just Local Files

Standard Markdown with a YAML header; any editor can read and edit them, and they survive the app

​
What They’re Good For

Notes are built to be short, fast, and findable later — not for long-form writing:
  • Things that just occurred to you: a one-line to-do, a product idea out of nowhere
  • Annotations while reading: have the AI dig through material and write down the conclusions as you go
  • Conclusions for the AI to record: have the Chatbot read a batch of material and turn the key points straight into a note
  • A landing spot for stray facts: a number you heard in a meeting, a book someone recommended
If what you’re writing is a proper document, creating a Markdown file directly in ~/LinklyAI is a better fit — it gets indexed just the same.

​
Opening Notes

Notes are not a separate window; they’re a view inside the main window, alongside views like Ask and Find:
  • Click Note in the main window’s sidebar
  • Or press ⌘⇧N (Windows / Linux: Ctrl+Shift+N)
⌘⇧N is not a global shortcut — the main window has to be in the foreground for it to do anything. There are two global shortcuts: ⌘K / Ctrl+K opens the main window, and ⌘L / Ctrl+L summons the search launcher; users upgrading from an older version keep their previous settings. Both can be changed under Settings → Shortcuts.

​
Writing Your First Note

1

Type into the box at the bottom

The notes view has a permanent input box at the bottom, with the placeholder Write a note… Type # to pick a tag.When the text runs long, click the expand button in the top-right corner and the box grows upward in place (up to 90% of the window height). No new window opens, and neither your draft nor your cursor position is disturbed.
2

Save

Press ⌘/Ctrl+Enter, or click the send button in the bottom-right. The card appears at the bottom of the timeline immediately.
Plain Enter inserts a line break and does not save — deliberately, since notes often run to several lines.
3

Edit

Click Edit on a card and it becomes editable in place, with no dialog. Only one card can be edited at a time.When you’re done you have to click Save or press ⌘/Ctrl+Enter.
4

Delete

The ⋯ menu in the card’s top-right corner → Delete → confirm.
Deleting permanently removes that file from disk. It doesn’t go to the trash, and there’s no undo in the app. The confirmation dialog is explicit about it: This permanently deletes the note file from disk. This cannot be undone.

​
What the Editor Can Do

The note editor is a plain Markdown text box, not a rich text editor — what you see is the source. The toolbar has just 5 buttons: There is no button for italics, headings, links, or code blocks — a deliberate narrowing, because notes are meant to stay short. Pressing Enter inside a list continues it with the next item. Once saved, the card switches to reading mode and renders the Markdown normally.
Drafts are cached to disk automatically. Anything in the input box or the editor that you haven’t published or saved yet is written to the app data folder about 1 second after each change. Whether the app crashes, is force-quit, or is closed normally, your draft is still there when you reopen it. But a draft isn’t a note: until you press ⌘/Ctrl+Enter to publish or save it, it won’t appear on the timeline and can’t be searched.
In reading mode, images are never loaded from the network — you get a placeholder block with the alt text instead. This is a privacy decision: rendering a remote image tells that server you read this particular note at this particular moment.There’s no character limit in the interface; the backend caps a single note at 10 MiB, which day-to-day writing won’t come close to.

​
Tags

Typing # in the body pops up a list of your existing tags (most used first, up to 8); keep typing to filter, move with ↑↓, and confirm with Enter or a click. Only a tag picked from the list is a tag, and it gets a blue background in the input box. When no existing tag matches, the list ends with Create #xxx. A #xxx you type on without picking (an issue number like #114, say) stays plain text and never becomes a tag; so does pasted text. When the query is empty or a number, nothing in the list is preselected, so Enter is just a line break. A picked tag behaves as one unit: Backspace right after it deletes the whole tag, and editing inside it turns it back into plain text. In the file, an unpicked #xxx is stored as \#xxx (the standard Markdown escape, shown without the backslash). Notes written before this change are untouched: an existing #xxx in the body is still a tag, and when you edit a note with number-only tags, you are offered a one-click conversion to plain text. After saving, tags are lifted out of the body and shown on the tag strip at the bottom of the card — click any of them to filter down to every note carrying that tag. Tags can be nested with /, for example projects/client-a or reading/tech. A single note can carry up to 50 tags, and each tag is 1–64 characters.
There is no separate tag input in the interface; tags can only be written in the body. Which also means: to remove a tag, delete that #tag from the body — the body is the single source of truth.

​
Finding a Note

​
The Timeline

The notes view is a flat stream of cards with no date grouping. The order is always oldest at the top, newest at the bottom, the same way a chat log reads — so the most recent note is always right in front of you. It loads 20 at a time; scrolling near the top loads earlier notes automatically, and when sorted by Oldest created, scrolling near the bottom loads newer notes automatically. To the left of the timeline runs a month-by-month time axis: each month gets a short bar — the longer the bar, the more notes that month — and clicking one jumps to that month.

​
Sorting

The sort menu at the top has three options:
Sorting is session-scoped — it isn’t persisted when you quit, and the next launch starts back at Newest created.

​
Filtering by Author

The Author menu at the top lets you see only the notes written by one party. The options are All, Me, and each agent that has written notes. Click the magnifying glass at the top, or press ⌘/Ctrl+F. Search isn’t a simple substring match; it runs through Linkly AI’s full-text retrieval (a keyword + semantic hybrid once the semantic index is built, keyword-only otherwise). So searching for “launch plan” can also surface a note that says “release schedule”.
Search returns at most 20 results and has no pagination. To narrow things down, click a tag to filter first and then search. Input is debounced by about 0.3 seconds, so the query only fires once you stop typing.

​
Why a Note You Just Wrote Isn’t Searchable Yet

This is the most confusing part. The three things you see in the notes view come down three different data paths, with different latencies: So “the note I just wrote shows up on the timeline, but search can’t find it and # autocomplete doesn’t know it” is normal — it sorts itself out once indexing catches up. Conversely, the timeline is always current: it never consults the index at all.

​
Where Notes Are Stored

Every note lives under Notes/ inside your library root (~/LinklyAI by default), filed by month:
Month folders are computed in UTC, so a note written at the very start or end of a month may land in a folder a day off from your local time zone.

​
Filename Rules

The filename is <first 10 characters of the body>-<first 8 characters of the note id>.md:
  • The 10 characters are counted as Unicode characters — one CJK character counts as one
  • Runs of whitespace collapse to a single space, and that space counts toward the 10
  • Characters illegal in filenames (/ \ : * ? " < > |) are stripped and do not count
A real example: a note whose first line is **Launch checklist**. The * characters are stripped without counting, leaving Launch che as the first 10 characters, so the file is named Launch che-91805137.md. If the body is all punctuation or whitespace (no usable stem), or the stem happens to collide with a reserved Windows device name (CON, NUL, and friends), the name falls back to a timestamp: YYYY-MM-DD-HHMMSS-<8-char id>.md.
The filename is fixed at creation and editing the body never renames the file. That keeps a file’s identity stable, so the index and any external references don’t all break because you fixed a typo.

​
File Format

Each file is standard Markdown with a block of YAML front matter at the top:
What the fields mean: The field order is fixed. Unknown fields you add by hand are preserved verbatim — the app won’t strip them, so tucking your own metadata in there is safe. A note written by AI looks like this, and carries an Agent badge in the interface:

​
Opening Notes in Another Editor

There’s an Open notes folder button at the top, which opens the Notes/ directory directly in your system file manager. Because it’s all standard Markdown, Obsidian, VS Code, and Typora can read and write it as-is. The tags: field happens to be one Obsidian recognizes natively, so opening Notes/ as a vault gets you its tag panel for free. External changes are picked up on the app’s next scan. If you happen to be editing the same note in the app at that moment, a conflict prompt appears asking you to choose Reload latest or Copy my text — neither side is ever silently overwritten. You’re also free to rename files; the app won’t rename them back.
Two things will make a note seem to disappear. Watch out for them:
  1. The timeline only scans .md files in the two-level Notes/YYYY-MM/ structure. Files sitting in the Notes/ root, or in some other subfolder like Notes/archive/, won’t appear on the timeline (though they’re still full-text indexed and still searchable).
  2. Delete the YAML header and the note drops off the timeline — the file is still on disk and still searchable, the app just no longer treats it as a note.

​
Letting AI Write Notes for You

Notes can be read and written by an AI assistant. Two tools cover it, exposed both by the local MCP server and, remotely, by the cloud gateway: Full parameters are in Using the CLI. For MCP setup, see Connecting AI Tools. Plain language is enough to drive it:

Write One

“Save that conclusion as a note and tag it product and todo”

Read First, Then Write

“Read the material on attention in my ml-papers library and write the key points up as a note”

Dig Through the Past

“List my notes tagged ops”
A few differences worth knowing:
  • Edits carry a version for concurrency checking. When the AI edits a note it must send back the version it read; if the note changed in the meantime, the write is rejected (NOTE_VERSION_CONFLICT) rather than blindly overwriting.
  • Note bodies written by AI are format-restricted: only paragraphs, bold, strikethrough, ordered and unordered lists, and plain text are allowed — matching what the interface toolbar can produce. Headings, italics, code blocks, links, images, and tables are rejected. What you type by hand in the interface is not subject to this restriction.
  • MCP has no delete tool. Deleting a note can only be done in the app.
  • Remote access still lands on your own computer. Both tools also work over the cloud gateway (linkly --remote, or the cloud connector in your AI client), but the gateway only forwards to your Desktop — notes are never stored in the cloud. So working with notes remotely needs that computer online and a Pro plan, and when it isn’t reachable there’s no cloud copy to fall back on.
  • Tags are read from the body (Desktop 0.11.0+): an unescaped #tag the AI writes into the body is one of the note’s tags. That is the form the interface saves for a tag you pick from the list, while a #xxx you type without picking is saved as \#xxx. So to write a plain # in the body (an issue number, for example), the AI writes \#114; otherwise it becomes a tag. The tags parameter only adds tags (the server appends the missing #tag markers to the body); the AI removes a tag by deleting its #tag marker from the body.
After an AI writes a note over MCP, the notes view refreshes automatically and the new note appears right on the timeline.

​
FAQ

Notes currently have no dedicated cloud sync; they’re kept as local files in your library folder.One thing to watch: if you add the Notes/ folder to a library, and that library is bound and pushed to a cloud library, your notes get uploaded like any other Markdown document. To keep them strictly local, don’t put Notes/ in a library you push.
This shortcut only works while the main window is focused — it isn’t a global shortcut. Click the main window first, then press it, or press the global shortcut ⌘K / Ctrl+K to open the main window first. The other global shortcut, ⌘L / Ctrl+L, summons the search launcher.
It isn’t. The timeline scans the file system directly, so it’s visible immediately; full-text search goes through the index, which lags. It’ll be searchable once indexing catches up. New tags likewise take a moment to appear in the # autocomplete.
None of those exist today. Pinning, favoriting, and archiving aren’t features yet; exporting isn’t needed — a note is already a .md file on disk, so just copy it. If you need something like archiving, move the file elsewhere in an external editor, but be aware that it will disappear from the timeline (see Opening Notes in Another Editor).
This was a limitation of versions before 0.11.0: the AI’s tags were stored only in the file’s YAML, with no matching #tag in the body — and the interface edits tags by editing the body.Since 0.11.0 the body is the single source of truth for tags on every path, and old notes heal themselves: the next AI edit automatically appends the missing #tag markers to the body. You can also fix one immediately by adding the matching #tag markers yourself and saving once from the interface.
No. Deleting removes the file from disk directly; it doesn’t go to the system trash, and there’s no undo in the app. Be sure before you delete, or back the file up in an external editor first.
Yes. Notes are ordinary Markdown files under ~/LinklyAI, scanned, indexed, and retrieved exactly like any other document — which is also why you can find them in the search launcher, and why an AI assistant’s search will hit them.

​
Further reading