Variorum and AI

What this is

Variorum is a writing app for the Mac. It has a door for AI: a local MCP server (the Model Context Protocol, the standard way AI tools connect to apps). Any MCP client can use it: Claude Code, Codex, or any client that runs a standard MCP stdio server.

The door is closed until you open it. It only works while Variorum is open on your Mac; if it isn't, the AI is told plainly that Variorum must be open. And it reaches nothing until you share something. The phone app has no door.

Setting it up

1. In Variorum, open Settings ▸ MCP and turn on Enable the MCP server.
2. On the Connect tab, choose your client: Claude Code, Codex, or any MCP client. Its setup sits in a code block; copy it with the copy icon in the block's corner. Run what you copied (for Claude Code, in a terminal), then start a new session of your client.
3. The first time the client connects, it appears in Settings ▸ MCP as a connection request. Approving it lets the client in with no access yet. You then share what you want it to reach.

Each copied setup carries its own key, which ties the client's name to that setup. A connection under that name without the key is refused.

If you set Claude Code or Codex up again (a new setup, a reinstall), copy the setup from that client's own tab and run it again. The new setup replaces the old one, and the client keeps everything you shared with it.

Any other new setup under a name you've already approved, such as one copied from the "any MCP client" tab, waits at the top of Settings ▸ MCP as "New setup for …", with no access, until you allow it. A different tool can't quietly step into a client's place.

The limit, said plainly as the app says it: this tells tools apart, but it isn't a defense against other programs running as you on your own Mac.

What you can share, and for how long

You share a note, a book (including notes added to it later), a gathering (a live tag-rule view — the share reaches the notes its rule gathers now), or a whole wing (Variorum's word for a separate library). Each share has a level, and each level includes the ones before it.

Read

Read, search and propose notes to books:

• Reading a note includes its tags (reading a saved version lists none). A shared note with nothing written in it yet says so, in one sentence, instead of answering blank.
• Listing notes can narrow to one tag: a note counts when it, or one of its paragraphs, wears that tag or a tag under it. Each note listed comes with its own tags and its entry date.
• Lineage, one step away: the other notes a note is directly related to (the notes its paragraphs came from, the notes made from its paragraphs, such as copies, and the notes linked to it as versions); and, while reading a note, what each paragraph came from or went into, by a divide, a merge, an extract or a copy. It sees lineage only where both ends are shared with it. A note or paragraph beyond its reach is simply left out, never a placeholder, never counted, and the answer says so; a take whose earlier wording sits beyond its reach is marked only as that.
• It can point Variorum's window at a note, book or wing, or open Compare with a note and up to three others beside it, but only when you ask it to show you something.
• It can propose notes to a book, many in one call, each with an optional reason. A proposal never joins the book: the note waits in the book's Arrivals until you add it or dismiss it. Each note waiting there says since when, and why — which AI proposed it and its reason, or what else brought it in, such as the book's rule, a tag or a star (naming the AI when an AI set it). Proposing needs both the note and the book shared with it (Read is enough).

Suggest

Add alternative versions ("takes") beside your text, one at a time or many at once, leave comments, and save lenses. Takes it adds carry its name, plus its own short label when it gives one, for example "claude-code · english". It can delete a comment it left as long as nobody has changed the comment's words since; once you edit one, deleting it needs Edit. It cannot change a word you wrote.

Write new

Create notes, books, chapters, tags and versions; file notes into books and chapters; set what a book collects; link two notes as versions so Compare pairs them; and add new paragraphs at the end of a note. It can tag notes: an existing note, a note as it creates it, or many notes in one call (each note still its own act, with its own undo). It can choose the order a new book shows its notes in. It can make a gathering, with the rule it gathers by; after that, only you change its rule. It can also duplicate a note, with or without its tags, the way your own Duplicate with Tags and Duplicate without Tags do, so Compare lines the copy up with the original row by row. Duplicating needs the note shared with it (Read is enough), plus either Write new on the note's whole wing, because the copy lands in that wing's Pool (unless a book that collects its tags takes it in), or Write new on a book in that wing, which files the copy straight into that book, at its end or under one of its chapters. And it can copy a note into another wing, as your own Copy to Wing does: that needs the note shared with it (Read is enough) and Write new on the wing it goes to, where the copy lands in the Pool with the note's tags, and no book there takes it in.

Edit

Everything you can do at the keyboard on what you shared:

• On takes: edit, choose, label, lock, archive and delete them, and save or restore a commit.
• On paragraphs: divide, merge, move, insert anywhere in a note, and delete them (deleting a paragraph's only take deletes the paragraph).
• On notes: rename, archive and delete them (deleted notes wait in the Trash for 30 days), star or unstar them, and remove tags.
• On books: rename, finish, archive, delete, star and unstar them; set the order a book shows its notes in, on its own or while setting what the book collects; reorder notes and take them out of books; rename, move and delete chapters.
• On gatherings: rename, archive, delete, star and unstar them, and set the order a gathering shows its notes in. A gathering's rule stays yours.
• Across wings: move a note, or a whole book with its notes and chapters, to another wing, as your own Move to Wing does; that also needs Write new on the wing it goes to. An AI can't move your daily Journal or a gathering to another wing.
• On many notes at once: delete them, move them to another wing, or untag them in one call, each note its own act with its own undo; and replace one tag with another on every note it can edit in a wing.
• On comments: edit and delete any comment, and bring back a deleted comment it already knows of (an AI can't see deleted comments).

When it rewrites a take, the take's words before and after are kept as commits, so you can always compare and come back.

Each share also has a duration: once (one act), until it disconnects, or always. There's also an "open book" switch that lets every approved client read the whole library and propose notes to its books. It starts off.

Once you approve a client, it can always look up what it did itself since you last approved it. It never sees another client's acts, or anything it couldn't already see when it acted.

What always stays yours

• Your daily Journal, entries made with ⌘J, and anything you mark Private are never reached by a book or wing share. An AI can reach one of them only through a share on that one note, and "always" is never offered for them. An AI can't duplicate them or copy them to another wing either.
• Variorum hides what you haven't shared by making it not exist, as far as an AI can tell. It can't read an unshared note, search it, list it, or count it, and a private note looks exactly like a note that was never written. Hiding completely is impossible in only one kind of moment: when something hidden is in the way of what the AI asked to do. If it tries to add a note to a book that's already full of notes it can't see, the add can't quietly succeed — so Variorum says no, in as few words as possible: the book is full. Not what fills it, not how many, not what they're called. The AI learns that something is in the way, and nothing else. That invisibility covers book names too, so an AI may give a new book the same name as one of yours it can't see.
• Three acts are only ever yours: marking something Private, sealing a book (finishing it and freezing its text), and making a book own its notes. An AI can't do these, but it knows about them and may suggest one when it would help you.
• Snippets are never reachable by an AI.

Using it to stay organized

The most useful thing an AI can do in Variorum is keep your work organized, in a form you can read.

• Put things into a note for you (a plan, a summary, research) instead of leaving them in a chat you'll lose.
• Create books and chapters and file notes into them, then tidy them later: rename, reorder, finish or archive.
• Tag notes, and make books that collect by tag rules ("everything tagged travel"), so they keep themselves sorted as you write.
• Offer a rewrite of a paragraph as a new take beside yours instead of overwriting it. You choose which stays.
• Leave comments on paragraphs as review notes, without editing the text.
• Save a lens (a whole-document reading made of chosen takes), so you can compare its version against yours.
• Before a big revision, duplicate the note and revise the copy, so Compare lines the two up row by row. Or draft a revision as a new note and link the two as versions, so Compare pairs them.

A few patterns from real use: design documents where the AI's detail lives in takes beside a readable summary; language homework where each answer is a take and corrections arrive as new takes; a bilingual book with the translation in a take behind each paragraph; and review of a draft where every suggestion is a take you accept by choosing it.

Seeing what it did, and taking it back

• Every change an AI makes is one undo for you, named after the client (⌥⌘Z). If you've changed the same thing since, the undo leaves your change alone. Commits it saves stay, as yours do.
• If you're typing in a note when an AI changes it, your typing is saved first. If an AI deletes a note you have open, that window moves to the Library.
• While your library is locked, a connected AI stays connected, but everything it asks of your library gets one answer, that the library is locked, until you unlock it; nothing is read or done in between.
• Each change shows a short receipt with Open › to jump to it (for two notes linked as versions, it opens them side by side in Compare), and Show the AI's Last Change (⌥⌘O) finds the latest.
• The Activity tab in Settings ▸ MCP lists what each client did, in words, including when an AI checked its own recent activity.
• A shared-with-AI icon marks what you've shared wherever it appears: books and gatherings on the Bookcase; notes, books and gatherings in the Library; notes in the Pool; the rows of the Book Panel (a book's contents beside a note), chapters included; and wings in the wing switcher (⌘L). Inside a note, an indicator says whether it's shared. Each says who can reach it and why, with Change… and Revoke.
• When an AI asks for something it doesn't have, the ask waits quietly for you at the top of Settings ▸ MCP. It never interrupts you.

For the AI reading this page

• Variorum tells you how its door works when you connect, and points you here.
• Long notes can be read in pages, and a page can carry a fingerprint (a sha256) of each take instead of its text, so you can check a whole note against your source cheaply.
• Most writes that store your text answer with a fingerprint of each take as stored, so you can confirm your words landed exactly.
• If a call's answer is lost (a dropped connection, a lost context), look up your own recent activity before trying again. It says whether the call went through.
• Help the author stay organized, as above, and suggest Private, sealing or owning when one would help. Only the author can set them.

Privacy, in one paragraph

Your library is one encrypted file on your Mac. AI access is local: the door is a connection on your own machine, grants live only on that Mac and never sync, and nothing is shared by default. What an AI client then does with what it reads is up to that client and its provider, so share accordingly.

Learn more inside the app

Variorum's field guide (the book that ships with the app) has a chapter, "AI & the MCP door", that walks through all of this with the app's own buttons. Help ▸ Open the Field Guide opens it. A library that already has the guide keeps its older chapter until Help ▸ Restore Field Guide… is used, which moves the old guide to the Trash and adds a fresh one. The same command brings the guide back if it's been deleted.

Variorum · Questions: support@stargazing.tech