Your days come in on one side. Your palace files them. Your assistants read them on the other. Made-up notes.

For the curious

How it works, part by part.

One memory of you, in rooms, on a small computer of your own. Every assistant you connect reads it before it answers and saves to it as it goes. Routines run while nobody is talking to it. Here is how the parts fit, for the curious.

The idea: Muse remembers you for Meta, Claude for Anthropic, ChatGPT for OpenAI. Mind Palace remembers you for you. Your memory lives on your own small computer in the cloud; the brain is rented and swappable; assistants you connect read and save to the same memory, within what you let them do. (the plain-language version: /why)

Who can see my palace The layers Harness of harnesses Memory Your memory, everywhere Routines Permissions Building itself Seed and handoff Where it runs Pick a brain Updating Security Glossary

1The layers

A model on its own does nothing. It takes text in and gives text out. Everything that makes it useful is built around it, and that surrounding structure is the harness: what it can see, what it is allowed to do, what it remembers, what checks its work, what gets written down. Mind Palace puts these parts on your own private computer. Here is the stack, bottom to top.

Read it bottom-up. Everything above the model is yours. Your palace can add to everything above the spine (the connections it builds and how it looks; a page only when you clearly ask), with Undo; what other assistants send waits on a card for your yes. The spine it can never touch.

2Harness of harnesses

Here is the trick. Every connection holds its own sign-in and its own small set of tools, and nothing it could send leaves without the spine's yes. A routine is a harness for one task. Your palace is not a pile of plug-ins. It holds harnesses, and it can grow new ones.

Meta-harness just means a harness that holds, runs and grows other harnesses, under one set of rules and one memory.

Where the gate actually lives Not in the tool loop, and not in the prompt. Each connection holds its own credential server-side, applies it there, and hands the brain only the result. Sending as you, sharing outside your palace, granting assistant access and deleting for good ask first unless you change that. An action that asks is a card: your passkey signs that card's exact final words, the kernel checks the signature, and only then does it call the connection. That is why the brain can be swapped: Claude Haiku, Sonnet or Opus through Venice, your own key, or your own assistant, connected to your palace. None of them ever holds a token, and none of them can say yes for itself. In a turn that read outside content (an email, a message, a web page, a file, another assistant's proposal), anything that sends, shares, gives access or deletes is a card whatever your switches say, and a change to your palace is a card unless your own last message asked for it.

3The memory · the Karpathy-style wiki

Every part of your life, in its own room. A note for every person, place and topic in your life, and the threads between them. Your palace draws it, tidies it every night, and any assistant you connect can walk it. Shown with made-up notes.

The memory is not a database and not a vector store. It is a folder of markdown that a model maintains, after Andrej Karpathy's "LLM wiki" idea: raw sources come in, the model writes and re-writes a wiki of pages with an index, and it never asks you to tidy. Our version is Obsidian-shaped: a tiny router, maps of content, and one atomic note per person, company or topic.

That folder has a picture now. Memory opens on your palace: a floor plan with a room for each map that holds notes, the notes in each room, and the threads between them (the links the nightly tidy writes or you add, plus dotted ones where a key fact in one note names another person, place or company). Search lights up the rooms that hold a match. Open a note to see what links to it, fix a fact where it stands, or add and remove a link yourself; each of those is a line in your diary. A Palace / Decisions switch shows what needs you: questions, last night's tidy, and what is waiting to be filed. Nothing in the drawing calls the brain, so looking costs nothing. Only the screen says room and thread: the files, the tools and this page still say map and link.

The rules that keep it from rotting Capture cheap, file nightly, never reorganise by hand. One note per thing, never two. The router stays under 40 lines or it stops being a router. Cautions are few (six at most) and are cleared once they are over. Every inbox line carries its source, and facts that came from content your palace read never become instructions. A closed task is intent, not proof. When two facts conflict, keep the newer one and note the old one with its date. A mistake a machine can spot becomes a lint, and the prose rule is retired.

What goes into the inbox: what you say in Ask your palace, photos, PDFs and voice notes you send, what your connected assistants save, Import your memories (ChatGPT or Claude exports, an Obsidian vault zip, documents, or pasted text), and each night, just before the 3:00 tidy, what it learned from the accounts you connected (Gmail, Calendar, WhatsApp, Telegram, iMessage) and the day's chats.

Why markdown: you can read it, grep it, back it up, move it, and tell your palace to forget a line. No vendor, no schema, no migration.

Documents and photos live there too. Keep a document or photo next to the note it belongs to: up to 25 MB each, inside your palace's 2 GB. Your palace reads the words out of PDFs, Word, Excel and PowerPoint files, emails and text files on the machine itself, with no brain and no network, so search finds them. A scanned PDF or a photo has no words to read and is found by its name and date; letting your brain describe one is a switch in Settings → Memory, off by default; each one uses a little of your thinking budget. A file you send in Ask your palace is kept only when you tap Keep in my palace. Once your palace is locked, files sit on the same locked disk as the notes. Download my palace includes them, and removing one takes your passkey.

Fixing a fact. Say it in plain words in Ask your palace ("the blue lamp arrived and was sent back"), or edit the fact where it stands in the palace. The fact changes in place and the old wording stays in that note's timeline. If more than one fact could be the one, nothing changes and it asks which. A correction made in a turn that has just read an email, a message or a file waits on a card instead, so nothing it read can rewrite your memory. Connected assistants do the same with memory_update and memory_correct.

3½Your memory, everywhere

The memory isn't trapped in your palace. Every palace has its own link for assistants at https://<your palace>/mcp, and one address stands in front of them all: https://www.usemagicbox.com/mcp. Add that address to Claude (claude.ai or the desktop app: Customize → Connectors), ChatGPT (chatgpt.com/plugins, as a custom MCP server), Grok (grok.com: Connectors → Custom) or Muse (paste the message your palace copies for it), and they all read and write the same notes your palace uses, so what you tell one, the others know. Claude Code, Codex, Cursor and other tools on your own computer use a key and your palace's own address instead. In your palace, Connections → Your assistants has a card for each one: one Connect button, every step, and a live check that says "Claude is connected and just read your memory." when it works. Step by step: /connect.

Through usemagicbox.com. The assistant sends you to usemagicbox.com, which asks one thing: which palace is yours. Sign in there and pick it, or type its address. It then sends your browser to your own palace's consent page, where you say yes with your passkey exactly as if the assistant had connected directly; the site can't say yes for you. After that it passes each request on to your palace with a short-lived Ed25519 signature that names the connection, the assistant and that exact request, and your palace checks it against a key pinned in its signed release. The site keeps no copy of what passes through, a token stolen from it is useless without that signature, and it can never give an assistant more than you ticked. In Connections → Your assistants the connection reads "ChatGPT (via usemagicbox.com)"; Disconnect there ends it at its next call. It works with any palace on release 45 or later.

Claude, ChatGPT, Grok and Muse connect with OAuth 2.1: dynamic client registration or a client ID metadata document, PKCE S256 only, and a consent page served by your own palace that needs your passkey every time a new assistant connects. Reading memory is always in. The consent page has Read and save my memory ticked. Under More choices, off until you tick them, are My messages, mail and documents (read your WhatsApp, Telegram, iMessages, email and calendar and the documents and photos you keep; read only, every read in your diary, never ticked for you) and Can build for my palace (section 6; never ticked for you). The last two are offered only to Claude, ChatGPT, Grok, Muse or an app on your own computer, and your palace decides which assistant it is from where the sign-in really goes back to, never from the name it gives itself. Through usemagicbox.com, the messages checkbox appears only after you switch that on in Connections → Your assistants. Another app (Claude Code, Codex, Cursor, a tool on your own computer) uses a key you make in Connections → Your assistants → Another app (Authorization: Bearer mbx_…), with the same three checkboxes. Tokens are stored as hashes; access tokens last 30 days and refresh tokens rotate (90 days); keys last 6 months (30 days for a key that can build; an OAuth grant like that ends 30 days after your yes); Disconnect stops one at its next call.

Tell it once. A connected assistant still has to choose to use the tool, so your palace tells it to, twice. First when it connects: the instructions it returns on initialize say whose memory this is and what your palace is called, and tell the assistant to look once at the start (memory_overview), to search for each question about you (memory_search with two or three words) before it answers, to save before it replies (memory_remember, one plain fact in the third person, without asking first), to save anything new at the end of every conversation, and to set up anything on a schedule with routine_add; memory_update is for a correction and memory_forget for when you ask. They also say which checkboxes this connection has and what can never happen through that connection. Second, in your own voice: right after your yes, the consent page shows one more step, a short paragraph to paste into that assistant's standing instructions, with a Copy button and where it goes (for Claude, Settings → Your Claude → Instructions). The same text is always at https://<your palace>/connect/instructions.txt, and on /connect.

Ask your palace is one more reader of the same memory. Every writer lands in the same inbox and the memory log shows who wrote what. A page your palace built keeps its own notes in the same memory, in a map of its own that the nightly tidy never moves them out of.

Tool	What it does
Every connection (reading memory is always in)
`memory_overview`	the router, the maps of content and the note index: where an assistant starts
`memory_search`, `memory_read_note`, `memory_recent`	find words anywhere (notes, core facts, the unfiled inbox); open a map or a note, with its links both ways; who saved or forgot what
`memory_stats`, `memory_review`	the numbers (by map, by where facts came from, last night); a look back over a day, a week, a month or everything
`todos_list`, `routine_list`, `jobs_list`, `jobs_pending`, `job_get`	your open tasks; your routines; the run log, what waits on you, and one run's numbered events
`attention`, `page_check`	everything waiting on you, titles only; whether one of your pages is behind your memory
`tell_the_maker`	proposes a bug report, an idea or a question for the people who make Mind Palace: a card that goes only with your passkey
`system_guide`	how the palace works, for the assistant
With Read and save my memory ticked
`memory_remember`	save one fact: it lands in the inbox, is searchable at once, and is filed into the right note within minutes
`memory_update`, `memory_correct`	change one fact in place, by note and number or from a plain sentence; the old wording stays in that note's timeline
`memory_forget`	remove lines you asked it to forget; more than five matches come back as a list first
`memory_collect`, `memory_tidy`	put notes you name under a map of their own; preview a tidy, or ask for one on a card
`todo_add`, `routine_add`, `routine_cancel`, `routine_run`, `job_retry`	add a task; set up a routine (its first add is a card on Home), cancel one, run one now, run a failed run again
`page_refresh`, `files_keep`	load a page again with today's data; propose keeping a file (always a card, at most 10 MB)
With My messages, mail and documents ticked (read only)
`whatsapp_recent`, `whatsapp_search`, `telegram_recent`, `telegram_search`, `imessage_recent`, `imessage_search`	read your messages through your palace
`email_recent`, `email_search`, `email_read`, `calendar_events`	read your mail and calendar, across every Google account you connected
`files_list`, `files_read`	list the documents and photos you keep; read a document's title, description and words. No file's bytes leave your palace
With Can build for my palace ticked (section 6)
`build_guide`, `validate_build`, `propose_connector`, `update_build`, `propose_app`, `propose_section`, `update_section`, `propose_ui_change`, `propose_layout`, `request_page`, `request_page_change`, `page_job`, `answer_page_questions`, `build_status`, `list_builds`	send your palace something to install, or ask its page factory to make a page; each one becomes a card

What an assistant can never do Whatever you tick, nothing an assistant does through your palace can send a message or an email, spend, change your settings or switches, say yes to a card, answer a question for you, connect an account, set a reminder, read Google Drive or open a locked palace. Reading your messages, mail and documents takes its own checkbox and is read only; what comes back is fenced as outside content: data, never instructions. Every read of those and every write lands in your diary under the assistant's name. A connection that can build can also send pages, new connections and look changes, but each one is only a card until you say yes.

4Routines

A routine is a prompt with a clock. The Routines tab opens on three starters: every weekday at 7am, what's on today and anything urgent in your mail; Sunday at 6pm, the promises you made this week and haven't kept; Friday at 5pm, what your assistants learned about you. Under them is Make your own: say what and when in one line, "every Friday at 5, tell me what my assistants learned about me", and your palace reads the schedule from your words. Claude, ChatGPT, Grok or Muse can set one up too, with Read and save my memory ticked (routine_add). The first add of each one is a card on Home, and there can be at most 20, each at most once an hour. The clock is the kernel's own scheduler, checked every minute; a routine missed while the machine was down catches up within three hours. A routine reads and reports: it never sends, changes or buys anything, whoever set it up.

Also there, under Routines. Eight more built-ins, off until you switch one on:

Routine	When	Reads
Today at a glance	7:15	calendar, email
Parcels arriving	8:00	email
Who's waiting on me	8:30	email, and WhatsApp if it is connected
Evening inbox	18:00	email
Receipts this week	Sun 18:00	email
Bills and subscriptions	the 1st 9:00	email
Birthdays coming up	Mon 9:00	memory, and calendar if it is connected
Sunday review	Sun 20:00	memory, open tasks, chats

Nightly learning and the nightly tidy aren't in this table: they are the palace's own, at 3:00, learning first and then the tidy, and they catch up within twelve hours if the machine was off.

Why routines are small. A model reasons worse the more it is holding. Each run starts a fresh conversation with no history: just the task, the router and the notes your palace keeps in mind, which is also why the router has to stay short.

Every run keeps a log. A run keeps a numbered log of each step: what it read, what it was refused, what it answered. If the machine restarts or the brain is slow mid-run, it carries on from its last step by itself, up to three times. Its result lands on Home, in Routines, in Ask your palace, and on WhatsApp or Telegram when you linked one, and in a note of its own in the Routines room, one dated line per run. A run that can't go on without something only you know asks one question on Home and carries on with your answer. A run that fails is a card; Retry runs it again. A routine can also name a check that has to pass before a run counts, and the check runs with no way onto the internet.

5Permissions · the spine

Five switches, and nothing hidden under them. Each one is Just do it (it runs at once, with a diary line and Undo), Ask me (a card on Home you say yes to with your passkey) or Never (refused, in a plain sentence). Changes to your palace just happen, with Undo. Sending as you, sharing outside your palace, giving another assistant access and deleting for good ask first, unless you change that. Anything another assistant asks your palace to build or install is always a card, whatever the switches say.

Switch	Covers	Starts at	Can be
Change my palace	pages, how it looks, routines, settings, what it remembers	Just do it	Just do it · Ask me · Never
Send as me	WhatsApp, Telegram, iMessage, email drafts, posting, Tell the maker	Ask me	Just do it · Ask me · Never
Share outside my palace	a connection that reaches new websites, anything that sends your palace's data somewhere new	Ask me	Just do it · Ask me · Never
Give other assistants access	new keys and connections	Ask me	Ask me · Never
Delete for good	forgetting a page's notes, removing a connection with its keys	Ask me	Ask me · Never

Anatomy of a card What it wants to do, in your words. The exact content, editable. Door: one-way (cannot be undone: sends, payments, deletes) or two-way (undoable). Blast radius: who or what it touches. Three buttons: Yes, just this once · Change it · No. A yes needs your passkey. Every answer is written to the diary with the card that allowed it.

The gate lives in the spine, not in the prompt. Prompts can be talked out of things. A gate cannot.

6Building itself · and letting others build for it

When you ask for something none of its tools reach, your palace says so and offers to build it on its own: a connection (code that reaches one service), a change to how it looks (CSS), or a change to how the screen is arranged (which tabs show, their order and names, what opens first). It builds a page only when you clearly ask for one: it writes a brief with checks, asks a few questions if it needs to, builds it, loads it with your data, judges every check and fixes what fails; each change after that is the next version, with the last ten kept. Pages live under Settings → Things I built. The kernel ships no code for any site; your palace writes it, with Undo. What your other assistants build arrives as a card for your yes.

The envelope A connection's card shows its envelope: every host it may reach, every key it will hold and the one host each key goes to, whether it only reads, media help (transcribe, see), and its limits (at most 256 MB, 120 s a call, 100 MB a day). When an action asks, your passkey signs its exact action and envelope hash. Inside that envelope your palace may write new versions (each one in the diary, undoable, 5 kept); anything that reaches further, holds another key or does more than read is a new card.

The sandbox A built connection runs in bubblewrap as its own user with no network of its own: its only way out is a proxy in the kernel that lets it reach the hosts on its card and nothing else (no private addresses, no metadata server, never the machine itself or the website), checks the TLS name, and meters it. Keys stay with your palace: the code only ever sees a placeholder, which the proxy swaps for the real key on that key's own host, and scrubs from the answers. Tests and a health check run before it turns on; 3 crashes in 10 minutes turn it off. Pages are single pages in a sandboxed frame with no cookies and no outside addresses, the known browser channels out blocked, talking to the palace only through a narrow bridge that sees their own notes.

The walled core Nothing your palace builds, and nobody who asks, can change the walled core: sign-in and passkeys, the cards and your yes, the diary, the memory engine, the built-in connections (Google, WhatsApp, Telegram, iMessage), the sandbox and its proxy, the vault of keys, the locked door, and updates (only signed releases). A build can't read another build's data. Look changes are CSS only for now (no url(), no imports, the whole CSS on the card). Safe mode (Settings → Things I built) pauses every connection, page and look change it built and stops new ones; turning it off takes your passkey. Open your palace with ?plain=1 (old ?safe=1 links still work), or hold the keeper for three seconds, to load one tab without its look changes. Settings → Things I built lists every one, who wrote it, its hosts and keys, with Undo and Remove.

Other assistants as builders

Claude, ChatGPT, Grok, Muse, Codex, Claude Code, Cursor or a tool on your own computer can build for your palace over the same connection, thinking on their own subscription (cheaper than your palace's own brain). The connection needs the build scope: in Connections → Your assistants → Another app, make a key that Can build for my palace (30 days), or tick that checkbox on your palace's consent page, under More choices, never ticked for you. Your palace checks what they send and shows it as a card that says Sent by that assistant. A connection bundle or a look change is installed exactly as sent: the card is bound to the exact bytes (the files' sha256 and the envelope hash), no brain runs in between, and if anything changed, nothing installs. A page is different: the HTML an assistant sends is only a first draft, never installed as sent. Your palace writes the brief and the checks, tests the draft with your data, fixes what fails and installs the result as a version; an assistant can also skip the HTML and ask your palace to make the page itself (request_page). They can propose how the screen is arranged too (propose_layout). An update from outside is always a card. Each connection may have 5 waiting and 20 a day. A build connection always reads memory; saving to it needs Read and save my memory ticked as well. Its build tools (build_status, list_builds) never return your memory, messages or keys. The manual they read is /for-bots.

What can't work (it says so) Building connections needs the signed system helper. Updates install it without erasing anything. Restart only restarts the machine; a locked palace waits for its owner to open it. Updates never need Rebuild. Big video and social sites often block cloud computers (YouTube and Instagram often do). It won't log in to a private account with your password, so a private Instagram never works. Services that need "Sign in with…" (OAuth) don't work; it takes keys you paste in Settings → Things I built (for one connection) or keep under a name in Settings → Keys. You can choose your own key, or your ChatGPT plan, instead of Claude through Venice; a Claude Pro or Max plan can't be used.

7Seed and handoff

We maintain the computer; the palace is yours. One customer, one dedicated machine, one palace. Your memory, mail and messages live on it, locked with your passkey. We can't open a locked palace or read it. The front door keeps your sign-in, your palace's name and address, whether it is awake and locked, which release it is on, daily usage counts (numbers only) and your help note for the maker. It temporarily holds setup answers and a per-palace key for the brain until the first claim, then deletes them. Google client credentials travel with the claim too; connection tokens, messages and memory never live here. Updates are signed and wait for your yes, unless you tell Settings to install them on their own.

The handoff, step by step

#	What you do	What happens underneath	Who holds what after
1	Palaces are invite-only: each one starts with a code. Give your first name, email, one thing you want help with, and a name for your palace.	Only the setup answers become a config blob: your palace's name and your first name. The private help note stays on the front door's record. It never goes to the palace or any AI. No passwords, no tokens, no messages. The front door mints a pairing code: single use, expires in 30 minutes (minted when the machine is built, so it can't expire while we make room).	Front door: config blob + code.
2	Tap your email link. Your invite is the yes, and the site starts building it. If ten palaces are already live, yours waits until a person makes room.	We create a dedicated Google Cloud VM with its own static address and pass the code in its cloud-init. The machine starts with no identity.	Your palace: the code, nothing else.
3	Nothing. You watch "Your palace is being built".	Your palace calls the front door with the code, downloads the config blob from its own address only, and the code is burned. A second claim is refused.	Your palace: config. Front door deletes the blob and staged inference key in the claim, then clears user-data from the machine metadata.
4	Open your palace's own address. Make a passkey (Face ID or your fingerprint).	Your palace enrols your passkey; from then on every API on it needs your passkey session.	Your palace + your device. Not us.
5	Nothing to sign into: your palace gets its own private Venice key when it's built.	The key is made per palace with a monthly spend limit, staged privately until the first claim, then lives only on your palace.	Your palace only.
6	The first run walks you through it: connect your first assistant and see it work, bring in what your other AIs know, connect your email, calendar and chats (Connections → Your data), and pick a routine. Steps you did are ticked; any step can be skipped.	Google sign-in goes through the site's one redirect address, which relays the sign-in only to palaces it knows. The tokens land encrypted on your palace. Read-only first (Gmail + Calendar); drafting is a second consent and only ever makes drafts.	Your palace only.
7	Your palace says "I'm alive" and offers to go on your home screen.	A ping to the front door, then one every 10 minutes: alive, which release, whether it has a passkey and is locked, its time zone, and daily counts of how much it is used (the full list is in the Privacy Policy). Numbers only: never your memory, messages, what you asked, page names, card titles or what an assistant asked for. The front door shows your palace's address and steps out.	Front door: account, private request note, the ping's status and counts.

The name isn't fixed. Change it in Settings (Rename it), or ask in Ask your palace ("call yourself Juniper") and say yes on the card. Up to 24 characters, emoji welcome. The new name shows everywhere in your palace at once, your diary notes the change, and each connected assistant hears it the next time it connects. Only you can rename it: a page, a routine or another assistant is refused.

When a step goes wrong

Problem	What happens
The code expired or was already used	If a new palace's pairing code expires before the machine claims it, a person rebuilds that machine (nothing of yours is on it yet), which makes a fresh code. Old codes stay dead.
Your palace hasn't said "I'm alive" after 20 minutes	The page flags the delay after 20 minutes. A person checks the computer and can restart it without erasing anything. Rebuild erases the palace and is only for a fresh start.
You lost the link to your palace	Sign in on usemagicbox.com and it shows your palace's address. That's the one thing it remembers about where your palace is.
You're moving to a new machine	Download my palace (Settings → Safety), start a fresh palace, then Import your memories on it. Your memory comes back; your accounts ask you to connect again, because their tokens never leave the old palace.
You cancel	Download my palace first, then Delete my palace on your account page. That turns its computer off for good.

Your accounts are yours too. Their tokens land encrypted on your palace and never live on the front door (step 6).

7¼Where it runs, and bringing your own brain

Every palace runs in the cloud: a dedicated Google Cloud VM per person, kept running by us and updated with your yes (or on its own, if you switch that on). There's no home install. Instead, your own assistant can be the brain.

	Your palace (always)	Your own assistant (optional)
What it is	the cloud VM	Claude (app or claude.ai), ChatGPT, Grok, Muse, Claude Code, Codex, Cursor, any app with a key
What it does	keep the memory organized; run routines, nightly learning and nightly tidy while you sleep; hold your Google, WhatsApp, Telegram and iMessage sign-ins; the website and Ask your palace	think with you while you're using it, reading and writing the same memory through your palace's link
Who pays for the thinking	Venice, included and capped by a monthly budget; or your own key or ChatGPT plan, on your own bill	your own subscription to that assistant
What it can reach	your accounts, memory, routines	memory and routines; with "My messages, mail and documents", your messages, mail, calendar and kept documents, read only; with "Can build for my palace", it can also send pages, new connections and look changes, each one a card

So "the palace on my own computer" is simply: connect Claude Code on your computer to your palace's /mcp address.

iMessage is the one thing that touches your Mac (macOS 13.5 or later). Connections → Your data → iMessage → Connect, on your Mac, gives you one line to paste into Terminal; it installs a small helper that reads Messages read-only and passes new ones to your palace, and sends the iMessages you said yes to on a card, at most once. It needs Full Disk Access and, for sending, permission to control Messages. Your Mac has to be on for anything to sync or send.

7½The brain · you pick it

Your palace does not care which model is inside it. Memory, rules, routines and the gate are identical under every brain. Brains are picked in Settings → Brain: the included picks below run through Venice, or use your own key (Anthropic, OpenAI, Grok from xAI, Muse from Meta, OpenRouter or Venice) or your ChatGPT subscription, on your own bill. Each request carries your question and the bits of memory it needs; it runs on Venice's account, not under your name, and isn't used for training (Claude models are served by Anthropic behind Venice). Switching is instant; your palace always says which model it is on.

Pick	What it uses
Auto	Claude Haiku 5.5 for everyday questions; it hands anything tricky to Claude Sonnet 5.5 by itself; plans, decisions, letters and photos start on Sonnet
Fast	Claude Haiku 5.5
Smart	Claude Sonnet 5.5
Smartest	Claude Opus 5.5
Your own key or plan	Anthropic (Claude), OpenAI, Grok, Muse, OpenRouter or Venice on your own key; or your ChatGPT Plus/Pro plan through Codex. Claude subscriptions can't be used (Anthropic doesn't allow them in other apps): use an Anthropic key.
Your own assistant	Claude, ChatGPT, Grok, Muse, Codex, Claude Code or Cursor connected to your palace thinks on its own subscription and shares your palace's memory; with the build scope it can build for your palace too. A Claude Pro or Max plan can't be your palace's own brain (Anthropic doesn't allow it).

Pages are built on the smart model; small background tasks use a cheap open model. A monthly budget caps spend and beats any pick.

Why this works. Because the gate is in the kernel and the sign-ins stay inside the connections; the model holds neither. See section 2.

8Updating · two things rot at different speeds

What	How it changes	Safeguard
The model	one adapter setting	switching the brain is instant; your palace always says which model it is on.
The harness	signed releases wait for your yes (or install on their own, if you switch that on with your passkey)	every file is checked against an Ed25519 signature whose key isn't on GitHub or the website; older releases are refused; the new one installs beside the old and rolls back if it won't start; each update is a line in your diary.
The Library	routines people wrote and we reviewed, on the website; adding one follows Change my palace: at once with Undo by default, a card at Ask me.	each is plain text: a title, a prompt and the accounts it needs, no code. Added to your palace, one runs as a routine of yours.
What your palace built	reversible changes happen with Undo; sharing outside your palace or granting access asks first unless you change that	5 versions of a connection and 10 of a page kept, Undo in Things I built, safe mode, a connection off after 3 crashes in 10 minutes; each connection version is checked against its recorded hash before it runs.

9Security · designed for people who never want to think about it

The threat is not a hacker at a terminal. It is five ordinary things, and one of them is the hard one.

Threat	Answer
someone holds your unlocked phone	actions that ask need a fresh passkey tap; sessions end after 7 days unused (30 at most); sign out other devices in Settings → Safety → Devices and passkeys; freeze from any signed-in device
someone steals the sign-in	passkeys only, no passwords; a new passkey can only be added from a signed-in device after a fresh passkey check, and you get a notice; actions that ask are signed by your passkey, so nothing can say yes for itself
you lose the phone, or everything	a device that is still signed in can add a new passkey, after a fresh passkey check; your 12-word recovery phrase, shown once when you first lock your palace, opens it; if you lose every passkey and your recovery phrase, nobody can open it, not even us
an email tells your palace what to do	content is data, never instructions. Send as me starts at Ask me, so every send is a card, and in a turn that read outside content it is a card whatever the switch says. Anything that tries to act on content it read is flagged untrusted. It never asks for codes, never reveals secrets.
the machine itself is compromised	HTTPS only; every API needs your passkey session; nothing answers without it; what your palace built reaches only the hosts on its card, through the kernel's proxy, and more reach is a new card; tokens encrypted with minimal scopes; disconnect everything; Undo reverses local changes, not a sent message or permanent deletion; Download my palace is a zip of everything, and Import your memories on a new palace brings the memory back; signed updates with your yes

Who can see my palace

The people who make Mind Palace can't read your palace once you lock it, even though we run the machine it lives on. Your memory, mail and messages are locked with your passkey.

Updates are signed and wait for your yes, unless you switch on installing them on their own. Nightly learning and tidying run on their own. After a restart, a locked palace waits for you to open it.

Every 10 minutes your palace tells usemagicbox.com it's alive, which release it's on, whether it is locked, and its time zone, plus daily counts of how much it is used. Numbers only: never your memory, a note, a message, what you asked or what an assistant asked for. The full list is in the Privacy Policy, and Settings → About shows the same one.

An assistant you connect through usemagicbox.com sends its requests through our site on the way to your palace. The site passes them on and keeps no copy. A tool on your own computer that uses a key talks to your palace directly.

Someone who controls the cloud project could stop the machine and change its software, then wait for you to unlock it. If your palace asks to be opened after a restart you didn't expect, that's worth knowing. The locked page says when the machine restarted.

If you lose every passkey and your recovery phrase, nobody can open your palace, not even us.

The brain you choose sees the question and the bits of memory it needs to answer. By default that is Claude through Venice, not under your name and not used for training. You can use your own key, or your ChatGPT plan, instead.

10Glossary

Harness: Everything around a model that makes it useful: tools, permissions, memory, checks, logs. The model is the engine; the harness is the vehicle.
Brain: The model doing the thinking (never the memory).
Memory: The notes, owned by you.
Meta-harness: A harness that holds, runs and grows other harnesses under one set of rules and one memory. Your palace.
Spine: The walled core: what nothing built can change. Sign-in and passkeys, cards and your yes, the diary, the spend meter, the memory engine, the built-in connections, the sandbox and the proxy that keeps each build to its own hosts, and signed updates.
Seed: What we ship: kernel, spine, memory engine, built-in routines, intake, pairing. It grows on your palace.
Library routine: A routine from the website's reviewed library (the code calls it a skill): a title, a prompt and the accounts it needs, no code. Added to your palace, it runs as a routine of yours.
Connection: One account or service your palace can reach (Google, WhatsApp, Telegram, iMessage, or one it built itself), holding its own sign-in or key.
Page: A page your palace built when you clearly asked, under Settings → Things I built. It keeps its own notes in your memory and reads the maps you allow; "app" and "section" were the old names.
Envelope: What a built connection may reach: hosts, keys, media, read or do, limits. The card binds its hash.
Things I built: Settings → every connection, page and look change on your palace, and who wrote it.
Can build for my palace: The build scope for another assistant: it may send pages, new connections and look changes, each one a card. Lasts 30 days.
Inbox, sleep cycle, router, MOC, atomic note: The memory engine's five parts: capture, filing (minutes after, and nightly), the 40-line index, the maps per domain, one note per thing.
Routine: A prompt plus a schedule plus the accounts it needs.
Switch: One of the five things you let your palace do: Change my palace, Send as me, Share outside my palace, Give other assistants access, Delete for good. Each is Just do it, Ask me or Never; Give other assistants access and Delete for good can only be Ask me or Never.
Run: One run of a routine, with its own numbered log and a dated line in the Routines room.
Ask your palace: The one conversation with your palace itself, at the bottom of Connections. One more reader of the same memory.
Card: Your palace asking. Content, door, blast radius, three buttons: Yes, just this once / Change it / No. Logged with the answer. A card from another assistant says Sent by.
Door, blast radius: One-way or two-way; who or what the action touches. Both on every card.
Switching the brain: Instant, in Settings → Brain or by asking in Ask your palace. Your palace always says which model it is on.
Credential injection: A connection holds the token and applies it; the brain only sees the result. Why the brain can be anything.
Recovery phrase: Twelve words shown once, when you first lock your palace, and stored nowhere. If you lose your passkey, they open your palace.
Room, thread: What the Memory screen calls a map of content and a link between two notes. Same files, drawn as a floor plan.
Tell it once: The paragraph you paste into an assistant's standing instructions so it looks in your palace before it answers and saves as it goes. Your palace shows it right after you connect an assistant, and serves it at https://<your palace>/connect/instructions.txt.
The one address: https://www.usemagicbox.com/mcp: what you give Claude, ChatGPT, Grok or Muse. It asks which palace is yours, sends you there to say yes with your passkey, then passes requests on. Tools on your own computer use a key and your palace's own address.
For builders: The manual an assistant reads: /for-bots

← back to the friendly version For builders →