firmware you can read
& any AI can run
Plain text your AI reads before it answers. Local-first, no account, no cloud. Drop the blueprint in. Your AI boots up knowing your rooms and your terms. A plain-text spec any file-aware model executes. MCP-native, keypair-signed, zero cloud.
A regular user who wants their AI to stick. Start in plain markdown, no build: copy the kit, point your AI at it. Local, private, no account, no cloud, no re-explaining yourself every session.
A technically curious builder, gamer, or power user. Run a single curl one-liner to wire loci into Claude Desktop (or your favourite MCP-aware client). Optional Tauri palace app for the full RPG view. Works with local or remote LLMs.
A developer or researcher who wants full control over the context layer. git clone + inspect the MCP server, config, and primitives. Ollama local inference (nomic-embed-text, zero API keys) and MCP plugin for Goose, Continue.dev, and Claude Code are both shipped. Nostr keypair identity in progress, see the roadmap.
The apps you use don't store your knowledge.
They store it for you.
Notion holds your notes. ChatGPT holds your context. Apple holds your memory. Your thinking lives in their architecture, retrievable at their pleasure, gone when you leave. The knowledge you build with AI is yours. It just doesn't live where you live. Yet.
loci inverts this. It is plain text on your machine, firmware any AI can run. The substrate belongs to the person who runs it.
The palace gives a file-aware AI somewhere to come back to. Reads your rooms. Knows your crystals. Sessions start with the context the last one left, less re-explaining, less rebuilding. Your AI doesn't grow wiser; it stops starting over.
A room is a named context space, Dev, Design, Research. Each has a soul file your AI reads before it speaks. The room holds what happened here before: the decisions, the patterns, the things that should never need explaining again.
Every room has a CLAUDE.md, the briefing file your AI reads at the start of every session. Two sentences or twenty. It answers: what is this room for, and what must never be forgotten here? Write it once. Let it grow.
A crystal is a fact established once, never re-derived. The decision you keep explaining from scratch every session. Write it in the room's soul file, it becomes part of the palace. Your AI never asks again.
The garden holds open questions growing across sessions. Not tasks, not features, genuine inquiries you're moving toward slowly, across many sessions. A garden plant is something you tend. The garden remembers.
New projects are fragile. The hatchery is the palace's incubator, a room without pressure, for ideas that aren't ready to be named. Prototype. Explore. Fail fast in the dark. When something matures, graduate it to the palace proper.
Local LLMs, MCP-native rooms, remote agents. The palace exposes your rooms as tools your IDE can call. Every room becomes a live context source for any agent in your stack. The palace serves every conjuration.
Shared rooms. Shared crystals. When a teammate opens the Design room they inherit the same accumulated context, not just your notes, but the living memory of every session held there. Co-intelligence that travels between minds.
Every session logged. Every decision preserved. The chronicle is the palace's long memory, not just what you know now, but how you came to know it. Navigate back through your thinking. The palace remembers what you forget.
Search across the rooms and crystals you've written down. The notes you keep are the notes you find. Every room a persistent location; every locus a file you laid down. Walk the palace from the CLI or your editor. Persistent context across sessions for the files in the palace. Search via loci-cli. Semantic indexing optional.
Automatically group conversations by topic, project, or date. Your ideas stay connected, even across different AI tools. Each room is a fully configured MCP workspace. Dev room, Design room, Research room, each with its own tools, memory, and agent context. First-class MCP server support. Compose rooms as namespaced tool collections. Expose or isolate contexts as needed.
Any AI that can read a folder of plain text can read the palace. File-aware ones (Claude Code, Cursor, Goose, Continue, Zed) read it directly; MCP-aware ones wire in through the server. Switch tools without losing what you wrote down. Plain text the file-aware models read directly; MCP for the rest. Local LLM via Ollama, remote agents via your own key. Plain-text substrate; any file-aware client reads it. MCP server exposes rooms as resources. Local-first, cloud-optional.
loci remembers what you already figured out. Link back to past insights instead of rebuilding context from scratch every session. A living room for growing ideas. Seeds become concepts, concepts become loci. The garden grows quietly between sessions, return to find it richer than you left it. Rooms are namespaced scopes. Dev context stays in Dev. Research stays in Research. Explicit boundary control per session.
Everything runs on your machine. Plain text in a folder you own. No account, no telemetry, no cloud sync from the palace itself. The third-party AI you point at it keeps its own policies; that part is yours to choose. Where new projects incubate. Prototype, experiment, fail fast in an isolated room. When an idea matures, promote it to the palace proper. Plain-text on disk; git-friendly. Diff-able across time. Export is the filesystem.
The palace distils your best thinking into crystals, reusable, quotable, linkable knowledge nodes. Extract once, reference everywhere.
One substrate, many shapes. Pick a use-case to trace which features it leans on. No two patterns are the same. One genome, many classes. Click a path to light its skill tree. The substrate is the same; the build is yours. // one substrate, N expressions. select a use_case to highlight its primary and supporting sets.
| use-casepathuse_case | Memory | Context | Identity | Garden | Continuity | Trust | Interop |
|---|---|---|---|---|---|---|---|
primary supporting · click a use-case to trace its pattern
Keep it close. loci desktop · Tauri v2
loci for Desktop is your palace on your machine. The Tauri app boots into your ~/.loci/ directory, rooms configured, crystals loaded, agents connected. It lives in your system tray. When you open your IDE, loci is already there. Not a browser tab. Not a cloud sync. A local memory hub that runs while you work. Native Tauri v2 shell wrapping the loci WebView frontend. Gives the renderer OS-level file system access. Manages ~/.loci/ bootstrap on first run. Exposes MCP server via local HTTP. System tray entry point for ⌘K search overlay.
The onboarding runs like a dungeon. Each step is a room. Enter the Palace, configure your rooms, summon your first LLM, expose the MCP server. Complete the setup and your palace is live. The quest doesn't end, it continues with every session. Every room you add is a new wing. Every crystal you extract is loot.
Runs local. No account. No cloud. Runs local. No account. No cloud. Runs local. No account. No cloud.
We built loci because the best AI work kept vanishing. A breakthrough insight at 2am, searched for a week later, gone. Re-explaining the same context to the same AI, session after session. Your thinking was happening, just nowhere permanent. loci is the fix: a plain-text substrate your AI reads before it answers, so the work you do together stays yours, local, searchable, never leaving your device.
The memory palace is one of the oldest techniques for thought: a place for everything, everything in its place. loci applies this to co-intelligence. A room is a persistent workspace, Dev, Design, Research, not a single conversation. Conversations happen inside rooms, accumulating context over time. What crystallises from that work becomes a locus: a fixed point in the palace, a node your memory navigates back to. The palace grows as you build inside it. Your thinking becomes architecture.
loci is a mindspace primitive: an intelligence substrate any file-aware model runs. It solves the stateless session problem for LLM-native workflows, not by adding a cloud layer, but by treating your local machine as the canonical context store. No accounts. No sync. Architecture documented at docs.loci.garden.
{
"version": "0.6.0",
"tier": "wizard", // "eli5" | "wizard" | "llmage"
"index": {
"auto_sync": true,
"sync_interval": "5m",
"full_text": true,
"semantic": false
},
"llm": {
"provider": "local", // "local" | "claude" | "openai"
"endpoint": "http://localhost:11434",
"model": "llama3"
},
"mcp": {
"expose_rooms": ["dev", "research", "design"],
"port": 3721
}
}
{
"loci": {
"url": "http://localhost:3721",
"transport": "http"
}
}
- Any AI tool you already use (Claude, ChatGPT, etc.) A working LLM endpoint, local or remote node >= 18 or python >= 3.10
- About 20 minutes to set things up 20 minutes + the step-by-step guide MCP-compatible client (Claude Code, Zed, Cursor)
- A browser (that's it!) A local LLM or Claude API key (for full palace mode) git + config.json (provided)
-
1
Start in plain markdown, or grab the app Claim Your First Room clone + configure
Fastest start is plain text: copy the kit, point any AI at it, no build. Prefer a GUI? Grab the desktop demo. Local, no account, no cloud. Open Claude Desktop (or your MCP client). The one-liner below writes a backup-protected config entry that loci satisfies as soon as the desktop app is running.
git clone https://github.com/huximaxi/loci && cd loci/desktop && cat .mcp.json -
2
Connect your AI chats Configure Your MCP Endpoint wire MCP server
Point your AI at the palace folder. Claude Code and Cursor read the files directly; MCP-aware clients wire in through the server. Nothing leaves your device that you don't send. Point loci at your local LLM or API key. Your palace connects to the conjuration engine of your choice. Add loci to your
mcp_serversconfig. Restart your IDE client. -
3
Search anything you've said Walk the Palace invoke + verify
Open the desktop app (or your AI), search the palace, find the room and the crystal. The work compounds because you wrote it down. Navigate your rooms, recall your loci, summon your agents. The palace grows the way you tend it.
loci-cli read <room>from the CLI, or query rooms over MCP. Verify the context is populated before the first agent run.
curl -fsSL https://loci.garden/install/wizard.sh | bash
Prefer the GUI? Grab the Tauri palace app below (open beta) or build from source: github.com/huximaxi/loci.
{
"loci_dir": "~/.loci",
"llm": { "provider": "local", "endpoint": "http://localhost:11434" },
"mcp": { "expose_rooms": ["dev", "research"] },
"index": { "semantic": false, "sync_interval": "5m" }
}