A knowledge base for you
and your AI agents.

How it works

lattice runs on your own server and serves its own web client, so there is nothing to host elsewhere and nobody to sign up with. One command installs it. Everything below lives on that server: your documents, your agents' memory, and whatever you decide to publish.

Memory and knowledge for your agents

Plugins for Claude Code and Hermes turn lattice into long-term memory for your agents. At the start of a session the agent loads your standing rules and an index of what it knows. With each task it recalls what bears on the work. It saves facts as it learns them, signed with its name, and supersedes them when they change. Anything an agent saves shows up in your knowledge browser, and anything you write is there for the agent to find.

Beyond its own memory, an agent can read a wider body of reference: your personal wiki, pages that other people's servers publish, and web pages you have clipped and saved. It draws on all of that without leaving your control or going through a vendor's API. And if you run orrery, the world-model app on the same ship, lattice opens each session with orrery's read on your day and keeps your daily briefs as private journal pages.

Each agent gets its own key, made in lattice's settings and scoped to just the memory and pages you allow. Publishing, sharing, and settings stay yours, and you can revoke any key on its own. Your agents' memory lives on your server, not in a vendor's cloud. Details in the docs.

What it does

• Documents in any format Write in markdown, HTML, or plain text. Or write a page in Hoon, the server's own language, and it computes its content: live pages with commands, state, and references to other pages.
• Private notes A private, tagged note store with full history and a trash you can restore from. Browse by folder or tag, with live updates. Drive it from the web app, an HTTP API, the agent plugins, or the filesystem mount.
• Search A full-text index over your documents and notes, from the reader's search bar. Every hit is badged with its scope, so a published page never reads like a private note.
• Your pages as files lattice-fs mounts every page as a local file. A cold mount warms in one round-trip, so grep and cat run from memory, and your editor's backup files never touch the server.
• Publish on your terms Every page you save gets an address other servers can fetch directly, peer-to-peer, with no host in the middle. Pages and whole folders can also go public on the open web. Share a folder and you have published a site.
• Editor Syntax highlighting for every format, live preview, inline errors for programmable pages, templates, folder-level share, move, and delete, and drag-and-drop upload of files or whole directories. Name a page "My Page" and it keeps that name in the tree.
• Works offline Lose the connection mid-session and your saves queue locally, then replay when it returns. Deletes, moves, and renames queue too, in order. A concurrent edit is never lost: the overwritten version is kept as a real page under conflicts/.
• Export and restore One button downloads every page and every memory as a single archive of plain files you can read, grep, or commit to git without lattice. Restore takes an archive back with paths, tags, and dates intact, and says what it will overwrite before it acts. The desktop app schedules these backups to a folder on your machine.
• Sharing that scales Named groups with per-path read and edit grants, per-file grants from the editor, and a banlist that revokes access on ban. Readers can leave comments on the pages you publish; a moderation inbox lists and removes them.
• Follow & subscribe Follow other servers to track what they publish, or subscribe to a single file and get each edit the moment it lands, over a live subscription rather than a polling timer.
• Browse the network Read anything any server publishes, peer-to-peer, right in the web reader. Bookmark pages as stars, pull up a stranger's full index, or copy a remote file onto your own server at a path you choose.
• Light and dark The reader, the editor, and the PWA follow your system theme.

What it isn't

• Not a hosted service. You run it on your own server, an Urbit ship: yours, a friend's, or a hosted one.
• Not just a website. Pages are addressed and move server-to-server, peer-to-peer. Putting one on the open web is something you opt into, and your own server serves it.
• Not an app to install, mostly. The web client is served by your server. The desktop app and the filesystem mount are optional extras.
• Desktop builds are unsigned for now, so macOS Gatekeeper warns on first launch.

Privacy

Under the hood

lattice is built on Urbit, a personal server that is also a peer-to-peer network. The server side is written in Hoon and stores your pages and memories as content-addressed values, published into Urbit's shared namespace and served to other servers directly. The web client is served by that same server, with live updates over an event stream and a service worker that keeps the shell and your last-known tree at hand offline. The filesystem client is Rust, the desktop app is Tauri, and the agent plugins are small Node and Python clients of the server's HTTP API.

Install

1. On your server

lattice installs through grubbery, the small app platform it runs on, alongside the other apps ~ricsul-bilwyt publishes. Approve lattice's permissions at /apps/grubbery/permits and it binds /apps/lattice. It stays unavailable until you do. New versions arrive on their own, and one that needs a new permission asks first. If you already run grubbery from another publisher, read the notes on switching first.

2. Open it

Log into your server's web login with its access code (+code), then open /apps/lattice to read and /apps/lattice/app to write. On a phone, use your browser's Add to Home Screen: lattice is a full PWA with its own icon and standalone window.

3. Optional: the desktop app

The same server-served client in its own window, plus managed filesystem mounts, scheduled backups, and auto-detection of servers running on the same machine. Direct links resolve to the latest release; the releases page has older versions and notes.

Windows and Android use the PWA. The filesystem client on its own is lattice-fs in the repo, built with cargo build --release.

Don't have a server yet? urbit.org/overview/running-urbit walks you through booting one.