Private by design · Self-host or Cloud

Your AI forgets.
Lodestone remembers.

Lodestone keeps a private memory of your work with AI: the decisions, the background and the way you like things done. Every AI app you use can draw on it, so you never have to explain things again. Share it with the people you choose, or publish what you know for anyone to follow.

Your AI apps
Claude Code
claude.ai: web, desktop, mobile
Codex
VS Code and others
Lodestone
  • Saves your sessions
  • Sums them up as short notes
  • Brings them back when needed
Yours to keep
Your notes
Your full history
A private copy you own
Security first

You're trusting us with your memories. Here's how we keep them safe.

That trust is a responsibility, not a feature, and it shapes every decision we make: what we store, who can see it, and how easily you can take it all back.

How Lodestone protects you →

Secrets stripped on your machine

Known secret formats (API keys, tokens, passwords in links) are removed on your device before anything is stored.

Encrypted in transit, secrets at rest

HTTPS only in transit. Lodestone Cloud encrypts your tokens, keys and backups; a key per account for your memory comes in Phase 1.

You decide who sees what

Each device gets its own key, limited to what you choose. Nothing is shared unless you share it, and you can switch any of it off in one click.

No one at Lodestone reads it

Self-hosted, it never touches our servers. In Cloud, nobody at Lodestone reads it, and if we ever need to look, we ask you first.

The problem

Your context is scattered, and none of it is yours.

Every chat starts from zero

You explain the project, the decisions and your preferences again, in every new chat and every new session.

Memory is stuck in one app

What Claude learns in the browser is invisible to your other apps, your other account and your work laptop.

Lose the account, lose the history

When an app, an account or a laptop goes away, months of context go with it. There's no copy you control.

How it works

It saves, it sums up, it remembers.

You don't have to tell your AI to remember things. Lodestone keeps up as you work, so nothing depends on anyone's good habits.

1

Saves your sessions

Claude Code sessions are saved automatically as you work. Your claude.ai chats come in from claude.ai's data export. Passwords and keys are removed before anything is stored.

2

Sums them up

Each session becomes a few short notes: facts, decisions, your preferences, and where each project stands. When something changes, the old note is kept and marked out of date, and every note shows where it came from.

3

Brings it back

Ask any of your AI apps about a project and it catches up from your notes in seconds. When nothing relevant is there, it says so instead of guessing.

Share and publish

Your memory doesn't have to stay with you.

Share part of it with the people you choose, or publish it for anyone to follow. You decide what goes out, and you can stop it at any time.

Publish

Publish what you know. Their AI keeps up.

Like a newsletter, but instead of posts people read, it's knowledge their AI can use. Pick a folder of notes and publish it. Anyone can follow it from their own AI app and ask it questions. When you have something new, you publish an update, and everyone following gets it.

  • Nothing goes out until you publish. Later edits stay private until your next update.
  • Followers see what you published, nothing else.
  • Unpublish, and it stops working for everyone at once.
For example

A tax adviser publishes her guidance for small businesses. Her clients' AI answers their questions from her latest advice. When the rules change, she publishes an update, and their answers change with it.

See it live

Our own release notes are published this way. Add this address to your AI app and ask it what's new in Lodestone:

https://nick.getlodestone.net/pub/lodestone-releases/mcp
Share

Hear from people in their own words

A customer or partner shares a folder of notes with you, such as their feedback on your product. Your AI reads it alongside your own notes. You can read them but not change them, and they can set an end date or switch sharing off at any time.

Keep apart

Work stays at work

Give your work laptop a key that opens your work folders and nothing personal. Lose the laptop? Switch its key off in one click.

Share

Bring your team up to speed

Share a project's folder with your team, so everyone's AI knows the decisions and the background, and nobody has to explain them again.

Two ways to run it

The same Lodestone. You choose who runs it.

On request

Self-hosted

Free

Run it on your own computer or server. For people comfortable with a terminal: bring your own git repo and your own AI model for the summaries.

  • Everything: the server, automatic saving and the web app
  • Runs on a laptop, a VPS or Railway
  • Summaries with your Claude subscription, the API or a local model
  • Shares with every other Lodestone, hosted or not
Request access
Under the hood

Plain files, an open protocol, nothing hidden.

For engineers: your memory is a git repo of Markdown files, served to any MCP client. Here's what that means in practice.

A note is just a Markdown file
---
namespace: proj/lodestone
kind: decision
title: Railway hosts the MCP server
status: active
created: 2026-10-05T12:01:42+00:00
sources:
  - archive/claude-code/macbook/2026/10/0c1f….jsonl#msg-41
  - archive/claude-code/macbook/2026/10/0c1f….jsonl#msg-44
---
Deployed from main with the Dockerfile. A volume mounted at
/data holds the data clone, the index and the model cache.
Why: one always-on endpoint every client can reach.
Your memory is a git repo you can read
lodestone-memory/
├── archive/     # every transcript and artifact, append-only
├── memory/      # distilled notes, one subject per file
│   ├── me/preferences/
│   └── proj/lodestone/{facts,decisions,threads}/
├── digests/     # one line per session, per day
└── config/      # namespaces, relations, shares

Works with every MCP client

Local over stdio, or remote over HTTPS with OAuth, so claude.ai, Codex and others connect from web, desktop and phone. Agents call context to catch up on a project in about 2k tokens, or recall to search everything.

Files are the source of truth

The archive is append-only, notes are versioned by git, and the search index is a cache you can rebuild at any time. No proprietary database to lose.

Search that knows when to stop

SQLite full-text search plus local embeddings, merged and filtered by relevance thresholds you can tune live. Distilled notes rank above raw transcripts.

A token per device, scoped

Give your work laptop access to proj/acme and nothing personal. Read-only or read-write, revocable in one click. Tokens are stored hashed.

Federation over an open protocol

Servers share with each other over the Carrick Protocol, an open standard. A peer's shared notes show up in your recall, labelled with their name; publications are pinned releases any MCP client can read.

Nothing fails silently

Health checks for storage, push access and sync run at startup and after every sync. While data is at risk, writes are refused with the reason, not silently lost.

Questions

Frequently asked

Do I need to be technical?
Not to use it: once it's set up, you just talk to your AI as usual. Setting it up yourself takes some comfort with a terminal today. Lodestone Cloud is for everyone else: you connect claude.ai without opening a terminal. Following someone else's publication is the simplest of all: you add one address to your AI app.
Which AI apps does Lodestone work with?
Any app that supports MCP, the standard way AI apps connect to tools: Claude Code, claude.ai on web, desktop and mobile, Codex, VS Code with Copilot, and others. Sessions are saved automatically from Claude Code, and from claude.ai through its data export. In other apps, your AI saves what matters as you go.
Where does my data live?
In a private repo of plain files that you own. Self-hosted, that's a repo you choose, and your server keeps a copy on its own disk. Everything else, like the search index, is rebuilt from those files, so nothing important lives anywhere else.
Can anyone else read my memories?
Self-hosted, your memory never touches our servers. In Lodestone Cloud, nobody at Lodestone reads your memory, and if we ever need to look, we ask you first. Your tokens, keys and backups are encrypted; a key per account for the memory itself comes in Phase 1. Inside your own Lodestone, every device and person gets a key limited to what you choose. Read the details.
What happens when I share or publish?
When you share with a person, they can read what you shared and nothing else, and they can't change it. It's read straight from your Lodestone, not copied, so when you stop sharing, they lose access straight away. When you publish, what you published becomes available to anyone with the address, and later edits stay private until you publish again.
What model writes the notes?
Self-hosted, you choose: your existing Claude subscription, the Claude API, or any OpenAI-compatible endpoint, including a model running on your own computer. You can also turn summaries off and keep just the history and search.
Will self-hosting stay free?
Yes. Self-hosting is free, and during early access we provide the software on request. Cloud is a convenience for people who'd rather not run a server, not a separate product with the good parts held back.
Can I move between Cloud and self-hosting?
That's the plan. Both run the same software over the same files, so moving is a matter of pointing a server at your repo. We'll document the exact steps before Cloud launches.
What about passwords and keys in my chats?
Before anything is stored, known secret formats (private keys, cloud and API tokens, passwords in links) are replaced with a marker such as [REDACTED:<type>]. You can add your own patterns.

Give your AI a memory you own.

We'll look after it as if it were our own.