Lethe — Persistent Memory for AI Agents

"AI that remembers what you decided."

Every AI agent starts from scratch. Same question, same reasoning, same dead ends — every single session. Lethe breaks that loop.

Lethe is a persistent memory layer for AI agents. It records reasoning chains, decisions, observations, flagged uncertainty, and task history across sessions — so your agent carries context forward instead of rebuilding it from nothing.

What It Records

Type	Use Case
`record`	A decision made, a direction chosen, a conclusion reached
`log`	An observation, a discovery, something worth noting
`flag`	Uncertainty that needs human review before proceeding
`task`	A work unit with a status chain: todo → in_progress → done

Records carry confidence scores (0.0–1.0). Flags persist across sessions until explicitly reviewed. Task events chain together so you can trace the history of any piece of work.

How It Works

┌─────────────────────────────────────────────────────────────┐
│  Your AI Agent                                              │
│                                                             │
│  ┌─────────────┐    context assembly      ┌──────────────┐  │
│  │  Lethe      │◄────────────────────────   LLM prompt │ │
│  │  Plugin     │                          │   (prepend)  │  │
│  └──────┬──────┘                          └──────────────┘  │
│         │                                                   │
│         │ HTTP                                              │
│         ▼                                                   │
│  ┌──────────────┐   ┌─────────────────────────────────────┐ │
│  │  Lethe       │   │  Lethe Server (Go + SQLite)         │ │
│  │  Plugin      │   │                                     │ │
│  │  (Node.js)   │   │  Sessions · Events · Checkpoints    │ │
│  └──────────────┘   │  Flags · Threads · Task chains      │ │
│                     └────────────────────────────────────┘
└─────────────────────────────────────────────────────────────┘

Sessions — Each agent session gets a stable key. State: active, interrupted, or completed.
Events — Every meaningful agent action is logged: decisions, observations, flags, tasks.
Checkpoints — Periodic snapshots so the agent can resume exactly where it left off.
Compaction — When a session grows long, events are synthesized into a narrative summary, preserving the full history in compressed form.
Threads — Flags and uncertainty can be grouped into named threads for tracking open questions across sessions.

On session resume, the plugin assembles context: session summary + recent events, prepended to the LLM prompt. The agent picks up exactly where it left off.

What Makes It Different

Most agent memory is just conversation storage. Lethe is different:

Structured, not soup — Records, logs, flags, and tasks have meaning. It's a memory schema, not a chatlog.
Confidence scoring — Every record carries a confidence score so the agent can calibrate how much to trust prior conclusions.
Flag system — Uncertainty gets surfaced and tracked, not buried in context.
Crash recovery — Interrupted sessions resume from the last checkpoint, not from zero.
No external dependencies — SQLite only. No API keys, no embedding models, no vector search to tune.
Lightweight — A single Docker container. Drop it into any agent stack.

Quick Start

Docker

docker run -d \
  --name lethe \
  -v lethe-data:/data \
  -p 18483:18483 \
  ghcr.io/openlethe/lethe:latest

From Source

go build ./cmd/lethe
./lethe --db ./lethe.db --http :18483

The server starts on port 18483 with a built-in UI at http://localhost:18483/ui/.

API Overview

Method	Path	Purpose
`POST`	`/api/sessions`	Create a session
`GET`	`/api/sessions/{key}`	Get session
`GET`	`/api/sessions/{key}/summary`	Session summary + recent events
`POST`	`/api/sessions/{key}/heartbeat`	Heartbeat ping
`POST`	`/api/sessions/{key}/interrupt`	Interrupt session
`POST`	`/api/sessions/{key}/complete`	Complete session
`POST`	`/api/sessions/{key}/compact`	Trigger compaction
`GET`	`/api/sessions/{key}/events`	List events
`POST`	`/api/sessions/{key}/events`	Create event
`GET`	`/api/sessions/{key}/checkpoints`	List checkpoints
`POST`	`/api/sessions/{key}/checkpoints`	Create checkpoint
`GET`	`/api/flags`	List unreviewed flags
`PUT`	`/api/flags/{id}/review`	Review a flag
`GET`	`/api/stats`	Dashboard stats

Full API reference at docs.openlethe.ai.

Integrations

OpenClaw Plugin

The Lethe plugin for OpenClaw handles bootstrap and context assembly automatically. Install the plugin and configure your endpoint:

{
  "id": "lethe",
  "endpoint": "http://localhost:18483",
  "agentId": "archimedes",
  "projectId": "default"
}

Roll Your Own

Any agent that can make HTTP calls can use Lethe. The plugin protocol is just a session lifecycle + context assembly API. See the API reference for details.

Architecture

cmd/lethe/main.go        — entry point, wires server + store + session manager
internal/api/            — HTTP handlers, Chi router, request/response types
internal/db/             — SQLite store, embedded migrations, all CRUD
internal/models/         — domain types (Session, Event, Checkpoint, Flag, Thread)
internal/session/        — session lifecycle state machine and manager
internal/ui/             — embedded UI (Go templates, HTMX)

Lethe