With Lore, we help teams organize AI work, instead of it living on one person's computer and disappearing. We gather every prompt, skill, and AI session and turn it into searchable, shareable infrastructure. Lore preserves the context behind useful threads and enables several use cases built on top of this data.

We initially built Lore to share our Claude threads with each other: as contextual links on PRs, snapshotting some research or investigating for someone else to pick up, or just "check out this cool thing I did." Since then, we've run into many other use cases, and built a whole product around this primitive.

You can sign up on web or in the macOS app. Your teammates can join just by signing up; we'll automatically add users with the same email domain to your workspace (users with gmail.com and other individual email domains will get their own individual workspaces).

Install Lore#

The easiest way to use Lore is the macOS desktop app: it browses Lore in its own window, captures your sessions in the background, and installs the Lore plugin into your coding agents automatically. There's nothing else to install. The plugin and the CLI can also be set up on their own (if you're not on macOS, or you want a scriptable interface); the options below cover those too.

The desktop app is the easiest way to get started, and it needs no terminal. It's a native macOS app that lets you browse Lore in its own window and captures your coding-agent sessions in the background.

Download the macOS app

Download it from lore.link/desktop and drag Lore into Applications.
Sign in through your system browser.
Approve the Claude Code connection; the app shows you the exact settings it will add before writing anything.

That's it. The app keeps itself up to date, starts capturing sessions in the background, and installs the Lore plugin into your coding agents (Claude Code, Cowork, Claude Desktop, and Amp) automatically, so you never have to set up the plugin or the CLI yourself. The usual upload filters and visibility rules apply (see Data Privacy).

First run#

Setup is two steps:

Sign in. The app opens your system browser for sign-in (the same account flow as the web app) and returns you to the app automatically.
Configure session upload. Lore works best when it can automatically capture your agent sessions. You'll have the option to enable it for the agent harnesses installed on your computer. You'll also be able to configure an allowlist of directories or git origins for automatic uploads, and choose whether you want to upload existing sessions from the past few days to populate content.

Lore desktop app session upload settings with automatic upload, filters, and history options

If you've used the app before, you won't see these steps again; the app opens straight into Lore.

You can disable automatic session upload at any time by going back to the “Configure Session Upload…” menu item.

Background capture#

After setup, the app uploads your Claude Code, Cowork, Codex, and Amp sessions as you work. A status pill in the title bar shows what it's doing: Importing sessions while uploads run, Waiting for activity when it's idle, and states like Consent needed or Signed out when it needs your attention.

A few things worth knowing:

What gets captured. By default the app captures Claude Code sessions from any project. The app and CLI share ~/.lore/upload-filters.json, so changes made through Configure Session Upload…, lore configure, or direct edits apply to both.
Visibility. Uploads follow the same visibility rules as every other way of sharing: your default visibility setting applies, and you can change any thread afterwards. See Data Privacy.
Mechanism. Background captures use harness-native telemetry (i.e. OTEL) when available, and falls back to a filesystem watcher otherwise. For Amp specifically, we symlink an Amp plugin that converts Amp-emitted events into OTEL spans.

When the app is capturing in the background, the Lore web app shows an Active indicator in the header, so teammates browsing on the web can see the desktop app is doing the uploading for you.

Using the desktop app? Skip this option; the app installs the plugin for you. The manual steps below are for anyone setting up the plugin without the desktop app.

The Lore plugin works with Claude Code, Cowork (in Claude Desktop), and Codex. Pick the instructions for your agent below.

Open Customize from the side bar.
Click +, then choose Create (not Browse).
Click Add marketplace, enter loredotlink/lore-plugin, and click Sync.
Under the Personal tab (next to “Anthropic & partners”), open the Lore marketplace and install the Lore plugin.

This gives you the plugin slash commands: /lore:share to export sessions, /lore:read to read and search threads, and /lore:fork to continue from an existing thread. Background session capture is managed by the desktop app or the CLI (lore configure), not by a plugin command.

Inside a live Claude Code session, run /plugins to open the interactive plugins TUI.
Switch to the Marketplaces tab and choose Add Marketplace.
Enter the marketplace source: loredotlink/lore-plugin.
Open the new loredotlink marketplace and install the Lore plugin.

Claude Code: /plugins → Marketplaces → loredotlink → install Lore:

Claude Code marketplaces list with the loredotlink marketplace highlighted

Claude Code loredotlink marketplace showing the Lore plugin installed

Or install from a plain terminal outside a session:

claude plugin marketplace add loredotlink/lore-plugin
claude plugin install plugin@loredotlink

Install Lore from a plain terminal:

codex plugin marketplace add loredotlink/lore-plugin
codex plugin add lore@loredotlink

This gives you the plugin commands: $lore:share to export sessions, $lore:read to read and search threads, and $lore:fork to continue from an existing thread. Background session capture is managed by the desktop app or the CLI (lore configure), not by a plugin command.

The plugin bundles Lore's MCP server, so the agent commands and the Lore MCP tools are both available the moment it's installed. You don't need to add the MCP server separately; that's only for clients that aren't using the plugin.

The first time you use the plugin, it will walk you through authenticating with your Lore account.

The CLI is optional; if you use the desktop app, background capture is already built in. Install the CLI for a scriptable interface to Lore's APIs or background uploads on a machine without the desktop app.

npm install -g @loredotlink/cli
lore login

The login flow prints a verification URL and a short user code. Open the URL in your browser, enter the code, and you're authenticated. The CLI gives you the lore command set (lore export, lore threads ..., and more); the slash commands come from the plugin.

Privacy#

Lore threads can be in one of three privacy settings:

private is visible only to you.
workspace is visible to your team (anyone logged in with your same email domain).
public is visible to anyone with the URL.

New threads default to workspace if you belong to a team workspace and haven't turned off the Share new threads with my workspace setting (on by default). If you're not in a workspace, or you turn that setting off, new threads default to private.

If you use the CLI's background daemon, you can control which directories it watches with lore listen commands and fine-tune uploads with filter rules. See Data Privacy for details.

A quick tour of the nouns you'll see throughout these docs.

Sessions and threads#

A session is the local transcript your coding agent produces as you work: the running record of messages, tool calls, and file edits inside Claude Code, Cowork, Claude Desktop, or Amp.

A thread is that session persisted to Lore. When you share or upload a session, Lore stores the transcript, parses it, gives it a title, and makes it searchable and shareable. Thread IDs start with th_, and every thread has a URL like https://lore.link/thread/th_....

In short: a session is the thing on your machine; a thread is the thing in Lore.

What a thread contains#

Beyond the raw transcript, each thread carries:

The messages and tool calls from the session, broken into blocks.
The file paths touched during the session, so threads are searchable by code area.
The harness it came from and the originating session ID.
A title (auto-generated, or one you set when sharing), the author, and timestamps.
The skills and slash commands invoked during the session.
A visibility setting (private, workspace, or public). See Data Privacy.

Decisions#

Lore extracts decisions from your threads: the moments where something was asked, requested, decided, corrected, shared, or set as a requirement. Decisions get their own summaries, they're what Ask your threads most often cites when answering a question, and the threads feed can filter by decision kind. They're how "why did we do it this way?" stays answerable months later.

Projects#

A project is a hand-curated collection of threads and docs around one piece of work. Add the relevant threads to a project to give teammates a single place to start; Lore generates a short summary of what the project covers and keeps it fresh as threads are added. Projects are workspace-scoped, can be archived when the work ships, and are listable from the CLI with lore projects list.

Skills and the skills library#

A skill is a reusable set of instructions your coding agent can invoke, like a slash command or a saved workflow. Skills are where a team's working knowledge lives: the prompts, conventions, and procedures you want every agent session to follow.

The skills library is your workspace's shared catalog of skills. From the Skills page (on the web or in the desktop app) you can publish a skill from your machine to the library or install a team skill locally; the CLI mirrors this with lore skills list, lore skills sync, and lore skills status. Threads also record which skills a session invoked, so you can see how a skill performs in real work.

Components#

Lore is made up of a few components:

A macOS desktop app that browses Lore in its own window, captures your coding-agent sessions in the background, and installs the plugin into your agents automatically.
A plugin for Claude Code and Cowork that lets you share and read threads without leaving your session.
A CLI for advanced workflows like forking and a scriptable interface to Lore's APIs.
A web service for browsing your threads, managing sharing permissions, and hosting your team's skills library.

You don't need to install the plugin or the CLI yourself; the desktop app sets everything up.

Harnesses#

A harness is the coding agent a session came from. Lore recognizes Claude Code, Cowork, and Amp, plus threads created directly in the Lore web UI. (Cowork sessions come from Cowork running inside Claude Desktop.) The harness is attributed at upload time so threads can be filtered and analyzed per agent.

Workspaces#

A workspace is your team in Lore, keyed by a verified email domain. Workspace IDs start with org_. Anyone who signs up with the same company email domain is automatically added to the same workspace, with no manual invitations, and workspace-visibility threads are shared across everyone on the domain.

You can belong to more than one workspace and switch between them in the web UI. Public email domains (gmail.com, outlook.com, and the like) are excluded from auto-grouping, so personal-email signups don't get pooled into a shared workspace. See Data Privacy for how workspace membership drives default visibility.