Quick start

  1. Open your vault and create it with a passkey or a wallet. Save the recovery phrase.
  2. Add a few memories, or import your ChatGPT or Claude export under Import.
  3. Go to Apps, choose Connect an app, pick the folders it may read and copy the app key. It is shown once.
  4. Add the connector to your AI app with the snippet the vault shows you (also below), and restart the app.
  5. Ask something like "What do my notes say about the launch plan?". Then open Read log in your vault to see what was read.

The connector

The Sigil connector is a small MCP server that runs on your own computer. It holds your app key, fetches the encrypted folders that app may read, and decrypts them locally. It needs Node.js 20 or newer.

Your AI app starts it for you with npx -y sigil-connector; there is nothing to install by hand.

It reads these settings from its environment:

VariableMeaning
SIGIL_APP_KEYThe app key from your vault. It starts with sigil_app. Keep it private: it can read the folders you granted.
SIGIL_URLThe address of the Sigil site your vault lives on, for example https://sigilvault.fun.
SIGIL_SEMANTICSearch by meaning on your computer. On unless set to off.
SIGIL_EMBED_MODELThe sentence model it uses, Xenova/all-MiniLM-L6-v2 by default (about 23 MB).
SIGIL_MODEL_DIRWhere the model files are kept: .data/models in the repository, or ~/.sigil/models elsewhere.
SIGIL_MODEL_FETCHFetch missing model files once from the public model hub. Set to off to use only files already on disk.

Claude Desktop

  • Open Claude Desktop, then Settings, Developer, Edit Config. Or open the file directly:
  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json

Add Sigil under mcpServers (merge it with any servers already there), save, and restart Claude Desktop.

claude_desktop_config.json
{
  "mcpServers": {
    "sigil": {
      "command": "npx",
      "args": [
        "-y",
        "sigil-connector"
      ],
      "env": {
        "SIGIL_APP_KEY": "sigil_app.<app id>.<secret>",
        "SIGIL_URL": "https://sigilvault.fun"
      }
    }
  }
}

Sigil then appears in the tools menu of a new chat. Claude asks before it uses a tool for the first time.

Cursor

  • Global, for every project: ~/.cursor/mcp.json
  • One project only: .cursor/mcp.json in the project folder

The file takes the same shape. After saving, check that Sigil shows as enabled under Cursor's MCP settings.

~/.cursor/mcp.json
{
  "mcpServers": {
    "sigil": {
      "command": "npx",
      "args": [
        "-y",
        "sigil-connector"
      ],
      "env": {
        "SIGIL_APP_KEY": "sigil_app.<app id>.<secret>",
        "SIGIL_URL": "https://sigilvault.fun"
      }
    }
  }
}

ChatGPT

ChatGPT connects to MCP servers over the internet rather than starting a program on your computer, so the connector runs in HTTP mode and ChatGPT reaches it through a secure tunnel that you control.

  1. Start the connector in HTTP mode with a long random token of your own:
Terminal
SIGIL_APP_KEY=sigil_app.<app id>.<secret> \
SIGIL_URL=https://sigilvault.fun \
SIGIL_HTTP_TOKEN=<a long random string> \
npx -y sigil-connector --http --port 8787
  1. It listens on http://127.0.0.1:8787/mcp/<token>. Expose that port with an HTTPS tunnel service of your choice.
  2. In ChatGPT, turn on developer mode for connectors and add a custom connector with the tunnel address, ending in /mcp/<token>, and no authentication. Which plans offer custom connectors is up to ChatGPT.

Keep the address private. The token in the path is what keeps others out: anyone who has the full address can read what that app key can read. Stop the connector or revoke the app key in your vault whenever you want access to end. Text that ChatGPT reads is processed on its servers under its own terms.

Other MCP clients

Any app that can start a local MCP server over stdio can use Sigil with the same command and environment. Apps that only take a URL can use HTTP mode as described for ChatGPT.

Terminal
SIGIL_APP_KEY=sigil_app.<app id>.<secret> \
SIGIL_URL=https://sigilvault.fun \
npx -y sigil-connector

Tools

The connector gives AI apps four tools that read, one that only suggests, and one that asks your AI self.

ToolWhat it doesWhat goes in your log
get_profileYour Self card: who you are, how you like answers, what you are working on. Only if the app may read the Self card folder.The app read the index, then the card.
list_foldersNames of the folders this app may read, with how many memories each holds.The app listed its folders.
search_memoriesSearches by meaning and by the words in titles, tags and first lines, on your computer. Takes query, and optionally folder and limit. An empty query lists the most recent.The app read the index (titles, tags, first lines) of N memories. The search words are not sent.
read_memoryThe full text of one memory, by id.The app read that memory.
propose_memorySuggests a memory to your inbox: title, body, and optionally tags and a folder name. Sealed on your computer for your vault. Works only if you let this app suggest.The app suggested a memory.
ask_selfAsks your AI self a question. It answers as you, from the folders your rules allow that this app may also read, with your own model key, on your computer. Works only if you let this app answer as your AI self.The app read the index and the memories it used, and your AI self answered a question (the question and answer, sealed for your vault).

No tool changes or deletes a memory. A suggestion becomes a memory only when you approve it.

Your AI self

Under AI self in the vault you set up an AI that answers as you. It is built from your memories at the moment of each question: nothing is trained, and nothing leaves your device except the request to your own model provider.

  1. Model. Choose Anthropic (the default) or OpenAI, a model, and paste your own API key. The key is encrypted with your vault key in your browser before it is saved. Calls go from your browser straight to the provider and are billed to your key.
  2. Rules. The folders it may use (nothing else is ever given to the model), topics it may and may not discuss, things it must never say, its tone, what it says when it does not know, and how many memories it may read per answer. A question about a topic it never discusses is refused before the model is asked. An answer that contains something it must never say is replaced by a refusal on your device. When nothing in its folders matches, it says it does not know without calling the model.
  3. Test chat. Ask what others would ask. Each answer shows the memories it used; click one to open it.
  4. Apps that answer as you. Let a connected app use ask_self and answer links. Your vault wraps the rules, your model key and your vault public key for that app's key only. The app reads memories through its own folders, so a folder must be both in the rules and given to the app.

The rules and the key are saved as encrypted settings. Changing them updates every app you allowed.

Memory inbox

Apps can suggest memories, when you allow it. Each app has its own switch, May suggest memories to your inbox, off until you turn it on under Apps (when you connect the app, or later under Permissions).

  1. Your vault has a public key (X25519) whose private half is wrapped by your vault key. When you turn suggestions on for an app, your browser tags that public key with a key derived from the app's own secret.
  2. The app fetches the public key and the tag, checks the tag, and only then seals the suggestion to the key, on your computer. The server stores a sealed box it cannot open.
  3. In the vault, Inbox opens each suggestion with your key. Edit it, then approve it into a folder, merge it into an existing memory (its text is added under a dated line), or reject it. The vault points out a suggestion that is already there.

Each suggestion is a line in your read log. One app may send 30 suggestions an hour, and an inbox holds up to 500 waiting ones. Revoking an app stops its suggestions at once; what already arrived stays for you to decide.

Search by meaning

Search finds a note about the garage when you ask about your car. A small sentence model (all-MiniLM-L6-v2, about 23 MB) runs on your device: in the vault, in a background worker in your browser, and in the connector on your computer. It turns each memory and each query into a vector, and results that match by meaning are ranked together with results that match by words.

  • Queries and vectors never go to the server. The server only hands out the model files, which are the same for everyone.
  • The vault keeps vectors in your browser's storage, encrypted with a key derived from your vault key and filed under names that do not show the text. The connector keeps them in memory only.
  • The same vectors find duplicates: the same text, nearly the same words, or the same thing said twice. Use Find duplicates under Memories to merge them.
  • Timeline shows every memory by the day it was written or last changed, filtered by where it came from.

The server fetches the model files once from the public model hub and keeps them in its data folder; set SIGIL_MODEL_FETCH=off and put the files in SIGIL_MODEL_DIR yourself to keep it offline, or SIGIL_SEMANTIC=off to search by words only.

Self card

The Self card is a short profile in three parts: who you are, how you like answers, and your current projects. Write it under Self card in your vault. It is a memory like any other, encrypted the same way, in a folder of its own, so an app reads it only if you give it that folder. Apps read it with get_profile, and the connector tells them to read it first.

Memory that thinks

The Review tab looks over your vault on your device.

  • Weekly brief. What is new, what changed and what you may have forgotten (untouched for 120 days), saved as a memory in a folder called Briefs. It is made when you open your vault and the last one is a week old (you can turn that off), or when you ask. With your model key and your permission, your model writes it; otherwise it is three plain lists.
  • Memories that disagree. Pairs that are about the same thing (close in meaning, or sharing many words) and show a sign of disagreement: one says no where the other says yes, opposite words, or different numbers and dates. Keep one, or mark both as true. With your permission your model can check a pair.
  • Merge every group. Under Find duplicates, all duplicate groups are merged after one approval: each into its newest memory, with what the others add and all their tags.
  • Expiry. Give a memory an expiry date in its editor. After that day it leaves the list, apps no longer see it, and it waits under Expired. When the grace period you set (30 days unless you change it) is over, the server deletes it for real, even while your vault is closed. For that the server keeps one time in the clear per expiring memory: when to delete it.

Browser extension

The Sigil extension for Chrome saves the selected text, the current page, or a whole ChatGPT or Claude conversation to your inbox. Everything is sealed in the browser for your vault, the same way as the connector's suggestions.

  1. Build it: npm run build -w sigil-extension. Then open chrome://extensions, turn on Developer mode, choose Load unpacked and pick extension/dist.
  2. In your vault, under Apps, connect a Browser extension with May suggest memories on. It needs no folders.
  3. Open the extension's options, enter the address of your Sigil site and paste the app key. It checks the key against your vault.
  4. Right-click a selection or a page and choose Save to Sigil, or use the toolbar button. On chatgpt.com and claude.ai a small Save conversation to Sigil button appears.

The extension reads only the two chat sites, and other pages only when you ask it to save them. It keeps the app key in its own storage in this browser profile.

Sign in with Sigil

A web app can ask for read access to folders of your choice with the @sigil/sdk package. A window from your vault opens; you unlock it, pick folders (and, if the app asks, whether it may suggest memories) and allow it. Your vault makes an app key for that app alone and hands it to the page that asked, and only to that page's origin. The app then decrypts what you allowed in your browser, on its page.

JavaScript
import { requestAccess, SigilClient } from "@sigil/sdk";

const access = await requestAccess({ vault: "https://sigilvault.fun", appName: "My app" });
const sigil = new SigilClient(access);

await sigil.folders();
await sigil.search("trip to Rome");
await sigil.read([id]);

The app appears under Apps as a web app with its origin in its name; change its folders or revoke it there, and its reads are in your read log. A complete example is in examples/hello-sigil in the repository.

Sharing a folder

Share a folder with another Sigil vault, read only.

  1. The other person copies their vault code from Folders in their vault and gives it to you. It holds only their vault's public key. Read each other the fingerprint shown next to it to be sure it is theirs.
  2. Choose Share on a folder and paste the code. Your browser seals the folder key to their public key; the server only passes the sealed key on.
  3. They accept it under Shared with you, and the folder shows in their Memories, read only. Each time their vault opens it, a line goes into your read log.
  4. Stop sharing gives the folder a new key on your device: every memory in it is encrypted again, and the new key is wrapped for you, for each app that may read the folder and for everyone else you share it with. The vault you removed keeps only the old key, which opens nothing that is stored now.

Legacy

Under Legacy you name the people who receive your vault if you stop using it: which folders each one gets, whether they may talk to your AI self, how long without a sign of you counts (3, 6 or 12 months), and how many of them must act together.

  1. Naming someone. Paste their vault code and compare its fingerprint with them, or send them an invite link. The link carries a one-time secret after the #; their vault answers with its public key and a tag made with that secret, and your vault checks the tag and shows their fingerprint before it seals anything to them.
  2. Sealing. Your browser makes a legacy key, splits it with Shamir's secret sharing (the audited shamir-secret-sharing library), and seals each share to one person's vault public key. Each person's bundle (the keys of their folders and, if allowed, your AI self's rules and model key) is encrypted under a key from the legacy key and then sealed to that person's vault, so opening it takes the shares and that person's own vault. Every change makes a new legacy key, so shares from before stop fitting.
  3. The heartbeat. Any sign-in or vault action counts as alive, and Check in does it by hand. The tab shows when the next check-in is due. A first warning comes a month before the end (a third of the period for short ones) and a last one a week before; each is written to your read log and shown in the vault when you come back. Sigil has no email or other channel to reach you.
  4. Release. Once the whole period has passed, the server hands each person their share. One asks for a release; the others pass their share to them, sealed to the key you named for that person (taken from their own copy of the plan, not from the server). The shares are combined in their browser, their bundle opens, and they keep a copy under their own vault key. They read exactly the folders you left them and, if you allowed it, talk to your AI self in legacy mode: your rules, only those folders, and every question and answer sealed into your log.
  5. Coming back. Your next sign-in closes the plan again, and the vault tells you what was reached while you were away. If it was released, seal the plan again for a new legacy key.

Limits. The server decides when the period is over. It cannot open a share or a bundle, but a server that worked together with enough of your trusted people could hand out shares early. What a person opened while the plan was released stays with them. The full picture is on the legacy page and in the threat model.

Phone and devices

Sigil installs as an app on a phone or a computer: in Safari use Share, Add to Home Screen; in Chrome use Install. The app shell works offline. Installed on Android, Sigil also appears in the share sheet; Safari on iPhone does not offer that to web apps, so there the capture screen is the way in.

Add a device by QR code

  1. On the new device, open the vault and choose Add this device. It makes a one-time key pair and shows a QR code and a ten-character code made from the public key.
  2. On a device where your vault is open, go to Devices and scan the code, scan it with the phone's camera app, or type it. The vault checks that the key the server returns is the one the code was made from, and both screens show the same fingerprint.
  3. It matches: send my vault makes a key slot for the new device (a device secret from which its sign-in token and the key that wraps your vault key are derived) and seals the vault key and that secret to the one-time key. The relay keeps the sealed box for at most ten minutes and hands it out once.
  4. The new device opens the box, signs in with its own key slot and keeps its device key in the browser as a key the page can use but never read out.

Revoke deletes the device's key slot and ends every session it opened at once; the next time it reaches Sigil it forgets its device key and its offline copy. What it already showed cannot be taken back.

Quick capture

Share text, a link or a photo to Sigil from any app, or open /capture. It is sealed on the phone to your vault's public key (checked against the key the device saw when the vault was last open) and waits in your inbox. The vault does not have to be unlocked. Photos are made smaller on the device and kept inside the memory's encrypted body. Offline, the capture is sealed and waits on the device until there is a connection.

Offline copy

Under Devices you can keep an encrypted copy of the vault on a device: the server's answer as it came (ciphertext) and the locked vault key for the way you signed in there. Without a network the vault offers to open that copy, read only, with the same passkey, wallet, phrase or device key.

Agent vaults

Under Agents you give an AI agent a memory of its own: its own folder, which only it and you write, other folders it may read or also write, and a switch for each tool. Its key is an ordinary app key, so it runs through the same connector; the connector sees that the key belongs to an agent and adds these tools:

ToolWhat it doesIn your log
rememberWrites a memory to its own folder, or a folder or team space it may write, encrypted on your machineRemembered, with the memory
recallSearches what it may read, by meaning and words on your machine, and returns the best matches in fullThe index and each memory read
forgetDeletes memories for good, only where it may write. Off until you turn it onForgot, with the memory id
leave_handoffLeaves an encrypted note for its next session, or for the agents in a team spaceLeft a handoff note
pick_up_handoffsReturns the notes waiting for it and marks them picked upPicked up a handoff note

The server enforces each switch and each folder's read or write mode on every call. Notes for the next session are encrypted with a key derived from the agent's secret; you hold that secret under your vault key, so you can read them under Agents.

Setting it up

Make the agent in your vault, copy its key once, and add the connector to the client with it.

Claude Code, for every project of your user:

Terminal
claude mcp add sigil --scope user \
  --env SIGIL_APP_KEY=sigil_app.<app id>.<secret> \
  --env SIGIL_URL=https://sigilvault.fun \
  -- npx -y sigil-connector

Cursor, in ~/.cursor/mcp.json or .cursor/mcp.json in one project:

mcp.json
{
  "mcpServers": {
    "sigil": {
      "command": "npx",
      "args": [
        "-y",
        "sigil-connector"
      ],
      "env": {
        "SIGIL_APP_KEY": "sigil_app.<app id>.<secret>",
        "SIGIL_URL": "https://sigilvault.fun"
      }
    }
  }
}

VS Code, in .vscode/mcp.json:

.vscode/mcp.json
{
  "servers": {
    "sigil": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "sigil-connector"
      ],
      "env": {
        "SIGIL_APP_KEY": "sigil_app.<app id>.<secret>",
        "SIGIL_URL": "https://sigilvault.fun"
      }
    }
  }
}

Claude Desktop takes the same JSON as Cursor, in the file named above. Any other MCP client that starts a server over stdio uses the command and environment shown under other clients.

Agents are told to call pick_up_handoffs at the start of a session and leave_handoff before they stop. The connector routes they use: GET /api/connector/v1/agent, POST /api/connector/v1/remember, POST /api/connector/v1/forget, GET and POST /api/connector/v1/handoffs, POST /api/connector/v1/handoffs/picked, GET /api/connector/v1/spaces and POST /api/connector/v1/spaces/<id>/memories and /forget. Each is in the API reference.

Team spaces

A team space is one shared memory that several vaults and agents read and write. Make one under Agents, then add people by vault code and your agents by name, each with a role: reads, reads and writes, or admin (who also adds and removes members). A member who may write can add their own agents.

  • The space has its own key. Every member, you included, receives it sealed to their own public key: a vault's box key, or the key an agent derives from its secret.
  • Each member entry carries a tag made with the space key over its id, kind, key and role. The server cannot make one, so a member it slipped in shows as not added by a key holder, and nothing is sealed until an admin removes it.
  • Removing a member gives the space a new key on an admin's device: every memory encrypted again, the key and names sealed again for each member who stays. The agents of a removed vault go with it.
  • Agents in a space recall what is in it, remember into it, and leave handoff notes for the other agents there.

Proof of a real life

A life certificate shows that a vault has a long, continuous sealed history without showing anything in it. While your vault is open, your browser signs one presence statement per seal period with an Ed25519 key derived from your vault key; the server checks the signature and writes a presence entry, which is sealed with the hour like every other entry.

Under Proof, Make a certificate gathers every sealed presence hour with its proof, counts first and last seal, hours and days with activity, the longest gap and how long the history has run with no gap over 30 days, and signs the whole with the same key. Download it as a file, or publish it by link; the link opens the verify page, which checks the signature, every statement, every proof and the summary in the browser, compares the roots with the seals the site publishes and, when the seals are anchored and a public read address is set, with SigilSeal on chain.

What it proves, and what it does not. It proves that whoever could open this vault signed in each listed hour and that the site sealed it then. It does not prove who that is, that it is one person, that a person rather than a program kept the vault open, or anything about the vault's contents. While seals are local, the site holds the list of roots.

Live sync

Under Sync your vault keeps Gmail, Google Calendar, Google Drive and Slack in folders you choose, read only. Your browser signs in to the service in a small window (OAuth with PKCE, as a public client: no client secret anywhere), trades the code for tokens itself, and encrypts the sign-in with your vault key before it is saved. Then it asks only for what changed (Gmail history ids, Calendar sync tokens, Drive change tokens, the newest Slack message per channel), and encrypts every mail thread, event, document and channel-day on the device. The server stores envelopes.

  • Gmail: the last 90 days, then every change, one memory per thread; spam and trash left out. Calendar: your main calendar, one memory per event, cancelled events removed. Drive: Google Docs and text files as text, trashed files removed. Slack: your channels and direct messages from the last 30 days, then every new message, one memory per channel and day.
  • No duplicates. A thread or event that a Google Takeout import already brought lands on that memory. A new one gets an id derived from the folder key, so two devices syncing at once write one memory.
  • Pause and disconnect. Pause stops a source. Disconnect deletes its stored sign-in at once; the memories it made stay.
  • While the vault is closed. Pick a connector app for a source and run sigil-connector --watch on your machine. The vault wraps the source and its folder key for that app's key only; the connector refreshes the sign-in, encrypts on your machine and writes only into that folder. Each write is in your read log.

Setting up the sign-in (for whoever runs the site). Live sync needs a public OAuth client id per provider, set in the server's environment. Without one, the source says so and does not pretend to connect.

.env
# Public OAuth client ids for live sync. No client secret on the server.
SIGIL_GOOGLE_CLIENT_ID=<id>.apps.googleusercontent.com
SIGIL_SLACK_CLIENT_ID=<id>
  1. Google: create an OAuth client that may trade a code with PKCE and no client secret (a public client), add https://your-site/vault/connect as a redirect address, and allow the read-only Gmail, Calendar and Drive scopes on the consent screen.
  2. Slack: create a Slack app that allows PKCE for public clients, add the same redirect address and the user scopes channels:history channels:read groups:history groups:read im:history im:read mpim:history mpim:read users:read.
  3. A client type that still asks for a secret at the token step does not work from a browser. For background sync the connector reads SIGIL_GOOGLE_CLIENT_SECRET or SIGIL_SLACK_CLIENT_SECRET from your own machine's environment; it is never sent to Sigil.

Meeting transcripts

Under Import, choose Meeting transcripts and drop a transcript saved from Zoom, Google Meet or Microsoft Teams as .vtt, .srt, .txt or .docx. It becomes one meeting memory: who was there (the people who spoke), what was decided, what was promised and by whom, and the transcript. With your model key set, your own model writes the extract from this browser; without it, or with that switch off, plain rules make it: a decision is a sentence that says something was decided or agreed, a promise a sentence where someone says they will do something.

Protected folders

Under Folders, Protect marks a folder as health, money, legal or other. Then no app, agent, AI self or link reads it without your fresh yes for that read:

  1. An app asks (a search that names the folder, or a read of a memory in it). The server holds the ciphertext back and puts a request in your inbox.
  2. You say yes or no in the Inbox. A yes lasts ten minutes and covers that one read.
  3. The app asks again and gets it; the yes is used up. The read is logged as protected, and your answer as an approval, both sealed with the hour.

Your own AI self passes the same gate: answering a link or another self it leaves the folder out and asks you; in the test chat you allow it on the screen for one answer. The kind of folder stays in its encrypted name; the server knows only that it is protected. A protected folder cannot be made public.

Redaction. Per folder, mask card numbers, IBANs, account numbers, national ID and passport numbers, phone numbers and email addresses before anything leaves the vault: in the connector before an app gets the text, in your browser before your model or a public page does. It matches common shapes (with the Luhn and mod 97 checks for cards and IBANs), so an unusual way of writing a number can slip through. Your vault keeps the text as written.

Public AI self

Under AI self, Public AI self gives you a page at /@yourname where anyone can ask your AI self. It answers only from folders you make public: those are published as a separate public copy, masked with each folder's rules, and the page's sources point to it. Every answer is marked as AI.

  • Answered by you. A visitor's question is sealed in their browser for your public self's key; your open vault, or your connector with --self when you pick it, answers with your model key. When neither is running, the page says it is offline and takes no question.
  • You stay in charge. Set the greeting, tone, topics it never touches and a limit of questions per visitor an hour. Every question and answer is in your read log, sealed. Show answered questions on the page if you like, and hide any of them. Turn it off, or delete it with its public copy.
  • The limit. The page is public, so its key comes from the server rather than a link: a server that swapped it could read a visitor's question. Nothing private is at stake, since the public self can only answer from what you published.

Selves meet

Under Meet, invite another vault's AI self by its vault code, for one purpose: find a time to meet, check whether a collab fits, or swap intros. Nothing is said until its owner says yes and picks what their self may use. Then the two selves take turns, each with its owner's model key, rules and chosen folders (and, to find a time, the calendar if you allow it), up to the number of turns you set.

The invite and the answer are sealed boxes to the other vault. Every turn is encrypted under a key only the two vaults can derive from their own keys, so the server, which relays the boxes, can neither read nor write one. Both of you read the whole transcript; either can stop it. Every step is in both read logs, sealed. Your self takes its turns while your vault is open.

Your AI self at work

Under Work, ask your AI self for a reply to a message you paste or to a mail thread you synced or imported, or for a plan of the next seven days from the calendar memories in your vault. With your model key set, it writes them with your own model on your device, from the folders its rules allow. Without one, a reply is a plain start in your own greeting and sign-off and a plan is a plain list of each day with its free time.

Every draft waits in an approval queue. Nothing is sent anywhere on its own: approving a reply or a plan copies it for you. You can also hold the answers your open vault gives through ask links, your public page and meetings of selves: they then wait in the same queue, and approving one sends it back through the channel it came from, and nowhere else. A link answered by the connector is not held.

When you change a draft before approving it, the change becomes a note in a folder called How I write: written by your model when you allow it (told to describe style only, not what the text says), or as a plain summary of the change (the greeting, the sign-off, the length, words you replaced). Later drafts follow these notes. You can read, change and delete each one. Drafts, approvals, discards and lessons are all in your read log, and sealed.

Identity and wallet

Under Identity, make your AI self's key. It is a secp256k1 key derived from your vault key on your device, never stored and never sent; its address is the self's identity on any EVM chain. Sign an identity statement (its name, what it is for, optionally your own address and its wallet) with both your vault key and the self key: anyone can read it at /api/identity/at/<address> and check both signatures, here or on the verify page.

Draft the rules of its wallet: a cap per payment and per day, the recipients and contracts it may pay or call and which functions, tokens with their own caps, and an end date. The draft is encrypted in your vault, and you can try any payment against it. The contracts that make this real on chain are in the repository: SigilSelfRegistry records which owner stands behind a self key (both must agree), and SigilSelfWallet lets the self key act only within the owner's rules while the owner can freeze it, change its rules and withdraw at any time. They are tested and not deployed. Until a site sets SIGIL_IDENTITY_CHAIN_ID and SIGIL_IDENTITY_REGISTRY, the tab says so and everything above works off chain; with them set, your own browser wallet sends the calls.

Proving a fact

Under Proof, Prove a fact makes one claim, signed by your vault and sealed with the hour, that shows nothing else: one field of a memory (a line such as Nationality: ...), that a date in a memory is more than a number of years ago (an age, with the date kept back), how many months of sealed history the vault has, or that it joined a team space and when. Share it by link or file; the verify page checks it in any browser.

Who stands behind each: sealed history and team spaces rest on the site's seals and are checked in full. A field or an age is your vault's own statement, committed and signed; nobody else checked it. Zero-knowledge proofs, where a checker computes an age from a date nobody sees, are on the roadmap.

Emergency card

Under Emergency, pick health memories and fill a card from them: blood type, allergies, medication, conditions, languages and who to call. Change what you like, then publish. The card is encrypted on your device with a key that is only in its link, after the #, which browsers never send to a server; Sigil stores ciphertext it cannot read. Save the lock screen image with the code (made on your device) and set it as your wallpaper. Whoever scans it sees the card, in large type, on any phone. You see each opening with its time, a device class and a language; nothing that tells who it was is kept. Take it down, or issue a new code, at any time.

Agreements

Under Agreements, write an agreement and send it to another vault by its vault code. You sign it as you send it; its owner reads it in their vault, where it is checked against both vaults' keys, and signs the same fingerprint, or declines. Once both signed, the fingerprint is in both read logs and both hourly seals. Nothing is changed after signing: an amendment is a new version that names the old one. Either side can download a verifiable copy and check it on the verify page. The text travels sealed to the other vault; the server checks signatures, never reads the text.

Knowledge packs

Under Packs, publish a folder as a pack with a title, a description and a version, signed by your vault. Its memories are masked with the folder's rules first; a protected folder can never be published. Anyone with the link sees it at /p/<id> and can follow it: their vault copies it into a folder of its own and takes in each new version when it opens, checked against the publisher it first followed. Give that folder to your AI self or your agents like any other. Packs are free.

Voice

In the AI self's test chat, and on ask links and the public page when you offer it, choose Turn on voice. A speech model (Whisper, about 41 MB, English) is then fetched once from this site into the browser and runs in a worker on the device: press Speak, say the question, press again, and what it heard is written into the question field for you to check. The audio never leaves the device; the browser's own speech recognition, which sends audio to a cloud service in most browsers, is not used. With Read answers aloud, answers are spoken by the browser's speech synthesis, only with a voice that runs on the device; when a device has none, nothing is read aloud. A node turns voice off with SIGIL_VOICE=off and picks the model with SIGIL_SPEECH_MODEL.

Capture from anywhere

Under Devices, make a capture key for each phone, watch or shortcut. A key can only add to your inbox: it reads nothing, sends at most 20 captures a minute and 300 a day, each one in your read log, and you revoke it on its own. What it sends is sealed to your vault's key on the device that sends it, after that device checks the key against a tag your vault made for it.

  • iPhone, Siri and headphones: a shortcut with Dictate Text, URL Encode and Open URLs, opening https://sigilvault.fun/c#k=<capture key>&t=<what you said>. The page seals the text on the phone and puts it in the inbox.
  • A watch: it cannot open the page, so give its key permission for plain text. The shortcut then sends POST /api/capture/v1/text with the key's token, and Sigil seals the text to your vault's key the moment it arrives, keeping only the sealed box. That one path has Sigil handle the text in the clear for that moment; it is off unless you allow it for that key.
  • Android: install Sigil to the home screen and use the share sheet, or open the same link from an app; HTTP shortcut apps can send the plain text request for a key that allows it.

Sessions

Under AI self, once your public AI self is set up, open sessions: topics, how many questions a session holds, its length, the days and hours in your time zone, up to six intake questions, house rules (for example: not medical advice, see a doctor), how many sessions a day, and the text a visitor agrees to. Visitors book a free time on your page; their intake is sealed in their browser to your public self's key, and the session link they get holds the only key to the session. Answers come only from what you made public, under your rules and the house rules, each marked as AI. You read every booking, what the visitor agreed to and the transcript, opened on your device, and can end a session or block its visitor. Answers in a session are sent at once even when you hold other answers for approval. Payments are not part of Sigil.

Shared memory

Under Shared memory, start a family's or a team's history: a shared space with a timeline of stories (with a year, a month or a day), the people in them (members and others, by name) and photos, each marked with who added it. Add members by vault code with read, write or admin roles. A writer changes and deletes only what they wrote; leaving, being removed or deleting an account never deletes what others wrote, and the history is deleted only by its last member. Name heirs by vault code, for one member or for all: their key is sealed now, and they become members when that member's legacy plan releases. Download the whole history as one document, made on your device, to keep or print; it is also in each member's bundle.

Backups and restoring

Under Storage, download your vault as one bundle: every memory, key slot, setting, app, shared space and the sealed log with its proofs, all still encrypted, signed with your vault key on your device. Or add your own storage and let it run every day or week while the vault is open: an S3-compatible bucket (with CORS allowing this site), an IPFS pinning service or your own IPFS node with your own token, or Arweave through a bundler with your own key file. Tokens are kept only in your vault, encrypted with your vault key, and used only from your device, or from a connector you allow to back up while it runs with --watch. Where each copy went is in a record only your vault opens.

How long a copy lasts depends on where you keep it: a file as long as you keep it, a bucket while your account and the object exist, IPFS while the pin is kept, Arweave while its network keeps what was paid for. Sigil does not pay for, renew or check any of these.

To restore, open /vault/restore on any Sigil node, give the file, a link, an IPFS content id, an Arweave id or your bucket (its address is signed on your device and fetched by the node), and sign in with your recovery phrase or wallet. The bundle is opened and checked in full on your device first; the node takes it in only with a statement your vault key signed for that node.

Your own node, and moving

Every Sigil server is a node with the same site and API. With Docker, from the repository:

Terminal
SIGIL_ORIGIN=https://sigil.example.org SIGIL_PORT=8080 docker compose up -d --build

The node listens on SIGIL_PORT, keeps its data in a volume, and answers GET /api/health. Put a TLS proxy in front of it for a public address. Settings are in the README; the addresses that go into the content security policy (SIGIL_ORIGIN, SIGIL_BACKUP_ORIGINS and the chain read addresses) are fixed when the image is built.

To move, under Storage, give the new node's address and how long the old node should send your links on (7, 30 or 90 days), and sign. Open the link you get on the new node and sign in there with your recovery phrase or wallet: it fetches your vault from the old node with the code in the link, your device opens and checks it, and signs an arrival the old node checks. The old node then sends your ask links, public page, packs and emergency card on to the new address, turns sign-ins and app keys away with the new address, and deletes the vault when the period ends. App keys keep working: change SIGIL_URL to the new node. Every step is in the log of the node it happened on.

Privacy score

Under Apps and Agents, each app and agent has a privacy score, computed in your browser from your own read log of the last 30 days. It starts at 100 and loses points for five things, each shown with its reason:

PartPoints taken
How much it readUp to 30: the share of the memories it may read that it read in full
FoldersUp to 20: 5 for each folder it read from
Protected readsUp to 25: 10 for each read of a protected folder
How oftenUp to 15: the share of the 30 days it was active
WritesUp to 10: 1 for every 5 suggestions, memories written or removed

80 and above reads as light, 50 to 79 as regular, below 50 as heavy. The score says what an app read and how often, nothing more: it cannot see what an app did with what it read. It looks at an app's latest 1,000 log entries.

Open standard

The Sigil open standard, version 1.2, describes the memory format, folder keys and sealed boxes, the connector's tools and permissions, the access log entry, hourly seals and presence, certificates, the AI self's identity and wallet rules, proofs of a fact, the emergency card, agreements and knowledge packs, the vault bundle, storage, nodes and moving, capture keys, sessions and shared memory, so anyone can build a vault, a connector, a node or a checker. Its test vectors are generated from the code in this repository, and a test checks on every run that the code still produces them.

Importing

From ChatGPT

In ChatGPT, open Settings, Data controls, Export data. You receive an email with a link to a zip file. Drop that zip (or the conversations.json inside it) into Import in your vault. Each conversation becomes one memory in a folder called ChatGPT, following the branch you last saw when a conversation was edited.

From Claude

In Claude, open Settings, Privacy, Export data. Drop the zip you receive into Import. Conversations, projects with their instructions and documents, and Claude's saved memory (when present) become memories in a folder called Claude.

From Obsidian

Choose the folder of your Obsidian vault. Each Markdown note becomes a memory with its front matter and inline tags; the settings folder and attachments are left out. To keep it in sync, run the connector with --watch:

Terminal
SIGIL_APP_KEY=sigil_app.<app id>.<secret> \
SIGIL_URL=https://sigilvault.fun \
node connector/dist/index.js --watch "/path/to/your/Obsidian vault"

Use an app key that may suggest memories and read the folder you imported into. New and changed notes are sealed on your computer and wait in your inbox, where a change offers to update the memory imported from the same note. Up to 8 notes go in one pass; the rest follow a minute later.

From Apple Notes

Ask Apple for a copy of your iCloud data, choose iCloud Notes, and pick the zip or the unpacked Notes folder. Notes exported as text, Markdown or HTML files work too. The first line of a note is its title.

From Gmail and Google Calendar

In Google Takeout, choose Mail and Calendar. Pick the zip, or the .mbox and .ics files inside it. Each mail thread becomes one memory with the sender, recipient, date and text of each message (quoted replies left out), up to 4,000 characters a message and 20,000 a thread, and the newest 5,000 threads at most. Spam and trash are left out. Each calendar event becomes one memory with its time, place and description.

From Notion

In Notion, export all workspace content as Markdown and CSV, and pick the zip (a zip inside the zip is opened too). Each page becomes a memory titled without Notion's page id, with its parent pages named at the top. Databases are left out.

From GitHub

Write a repository (owner/name) for its commit history, up to the newest 1,000 commits, or your user name for your recent activity (GitHub keeps about 90 days). Your browser asks GitHub directly. A token is needed only for private repositories or more requests; it is used for that import only and never saved or sent to Sigil. Commits and activity are grouped into one memory per day.

Files are read and encrypted in your browser, up to 1 GB at once. Every import shows a preview first, lets you choose the folder, and leaves out what is already in your vault: the same source (a note path, a mail thread, an event) or the same title and text. Very long items are shortened to 500,000 characters, and the memory says so.

API

The connector API is what the connector, the extension and the SDK use, and what you can use to build your own reader. It reads, and takes suggestions when the owner allows them. Send the app token in Authorization: Bearer <token>, where the token is derived from the app key's secret (see the encryption model below). Everything returned is encrypted; decrypt it with the app key. These routes answer any origin (they take no cookie), so web apps can call them.

RequestReturns
GET /api/connector/v1/folders{ appId, folders: [{ id, meta, wrappedKey, count }] }
GET /api/connector/v1/index{ appId, folders, memories: [{ id, folderId, head }] }
POST /api/connector/v1/read with { ids: [...] } (1 to 20){ appId, folders, memories: [{ id, folderId, head, body }], missing }
GET /api/connector/v1/inbox{ appId, publicKey, tag }, or 403 when the app may not suggest
POST /api/connector/v1/proposals with { id, sealed }{ appId, id, createdAt }
GET /api/connector/v1/self{ appId, config, links: [{ id, publicKey, box }] }, or 403 when the app may not answer as the AI self
GET /api/connector/v1/self/pending{ appId, questions: [{ id, linkId, sessionId, askerKey, sealed, createdAt }] }; marks the app online for its links
POST /api/connector/v1/self/questions/<id>/answer with { sealed, note, cited }{ ok }
POST /api/connector/v1/self/asked with { id, note, cited }{ ok }; the log line for an ask_self answer

A revoked or unknown key gets 401 with code app_revoked. Too many requests get 429. Every endpoint, with its full response and limits, is in the API reference.

Public endpoints need no key. The two used most:

RequestReturns
GET /api/seals?limit=24{ mode, periodSeconds, seals: [{ hour, root, leaves, sealedAt, anchorTx }] }
GET /api/statusWhether sealing is on, and whether seals are local or anchored.
GET /api/ask/<link id>{ id, publicKey, intro, state, online, expiresAt, remaining } for an ask link; the greeting is encrypted

The vault page itself uses a session API (/api/vault, /api/memories, /api/folders, /api/apps, /api/proposals, /api/shares, /api/settings, /api/self, /api/log and the sign-in routes under /api/auth). It accepts only encrypted payloads and only requests from the site itself. It is described in the source in web/src/server/api.ts.

Encryption model

Envelopes

Every encrypted value is a string v1.<nonce>.<ciphertext> (both base64url): AES-256-GCM with a random 96-bit nonce and a 128-bit tag. The additional authenticated data names the record, so an envelope only opens in its own place:

ValueKeyBound to
Vault key copy (one per sign-in method)Key from passkey, wallet or phrasesigil:keyslot:<kind>
Folder keyVault keysigil:folder-key:<folder>
Folder nameFolder keysigil:folder-meta:<folder>
Memory head (title, tags, source, first lines, dates)Folder keysigil:memory-head:<memory>
Memory bodyFolder keysigil:memory-body:<memory>
App name and app secretVault keysigil:app-meta:<app>, sigil:app-secret:<app>
Folder key, for one appApp wrap keysigil:app-folder-key:<app>:<folder>
The vault's private box keyVault keysigil:box-secret
Your note on a share (who it is for, their public key)Vault keysigil:share-note:<share>
A search vector kept in the browserKey derived from the vault keysigil:embedding:<model>:<name>

Sealed boxes

Data for a vault that is not open (a suggestion, a shared folder key) is sealed to the vault's X25519 public key: s1.<ephemeral key>.<nonce>.<ciphertext>. A fresh ephemeral key pair is made per message; the shared secret goes through HKDF-SHA256 with the ephemeral and recipient public keys as salt and sigil:box:v1:<context> as info, and the result keys XChaCha20-Poly1305 with a random 192-bit nonce and the context as associated data. Contexts are proposal:<id>:<app> and share:<id>:<folder>, so a box moved to another record does not open. The primitives come from the audited @noble libraries.

Key derivation

All derivations use HKDF-SHA256 with the salt sigil/hkdf/v1 and a label per purpose:

  • Passkey: PRF evaluated on SHA-256("sigil/passkey-prf/v1"), then sigil:kek:passkey.
  • Wallet: a personal_sign signature of a fixed message naming the wallet, then sigil:kek:wallet:<address> for the key and sigil:auth:wallet:<address> for the sign-in token.
  • Recovery phrase: the 256-bit entropy of the 24 words, then sigil:kek:phrase, sigil:auth:phrase and sigil:lookup:phrase (which lets the server find the vault).
  • App key sigil_app.<app id>.<secret>: the 32-byte secret, then sigil:auth:app (the bearer token, base64url), sigil:wrap:app (the key that opens the app's folder keys) and sigil:tag:app-box (the key of the HMAC-SHA256 tag that vouches for the vault public key to this app).
  • Vectors kept in the browser: the vault key, then sigil:embed-cache:names (HMAC names) and sigil:embed-cache:values (AES-256-GCM).

The server stores the SHA-256 of each sign-in token and app token, never the tokens.

Seals

A read-log leaf is SHA-256(0x00 || data), where data is the lines sigil-read-v1, entry id, app id, kind, memory id, count, time and salt, joined with newlines. The kind is folders, index, read, propose (a suggestion, with its id) or shared (another vault opened a shared folder; the app id is the share). Inner nodes are SHA-256(0x01 || min(a, b) || max(a, b)), and an unpaired node moves up unchanged. The root of each hour is its seal. The on-chain contract, contracts/src/SigilSeal.sol, implements the same rules, so the same proof checks in the browser and on chain.

Run Sigil yourself

Sigil is open source. To run the whole site and server on your own machine:

Terminal
git clone https://github.com/SeierkDeveloper/Sigil.git
cd Sigil
npm install
npm run build
npm start

It serves on http://localhost:3000 and keeps its data in web/.data/sigil.db, with the model files in web/.data/models. To run a node for others, see Your own node, and moving. See the repository README for settings and tests.