Bundle Pluginsource-linked

Lethe

Lethe — Persistent Memory for AI Agents

lethe · runtime id lethe

Install

openclaw bundles install clawhub:lethe

Latest Release

Version 0.1.0

Download zip

Compatibility

{}

Capabilities

{
  "bundleFormat": "generic",
  "capabilityTags": [
    "bundle-only",
    "format:generic",
    "host:openclaw"
  ],
  "executesCode": false,
  "hostTargets": [
    "openclaw"
  ],
  "runtimeId": "lethe"
}

Security Scan

VirusTotal

Benign

View report →

OpenClaw

Benign

high confidence

✓

Purpose & Capability

The name/description (persistent memory for agents) matches the included Go server, SQLite schema, and OpenClaw plugin code that implement sessions, events, checkpoints, flags, and threads. No extraneous credentials, unrelated binaries, or unrelated platform access are requested.

✓

Instruction Scope

SKILL.md limits runtime actions to running a local HTTP service (Docker image or Go build) and using its documented API for creating sessions/events/checkpoints/flags. It does not instruct the agent to read arbitrary host files, access unrelated env vars, or send data to unexpected endpoints. The plugin is described as assembling context and calling the configured Lethe endpoint (expected behavior).

ℹ

Install Mechanism

This is instruction-only (no platform install spec). SKILL.md suggests pulling ghcr.io/openlethe/lethe:latest or building from source; source and a Dockerfile are included. Pulling a remote container image has the usual supply-chain risk — the repo contains build instructions and source which helps reviewability, but if you run the prebuilt image you are trusting GHCR content.

✓

Credentials

The skill declares no required environment variables or secrets. The server stores data locally in a SQLite DB under the configured mount (/data). Database and API fields are appropriate for the described functionality (session keys, token_budget tracking, etc.).

✓

Persistence & Privilege

The skill does not request always:true. It runs as a separate HTTP service and stores memory in its own SQLite DB; it does not attempt to modify other skills or require system-wide configuration changes. The included Dockerfile creates a non-root user for runtime.

Assessment

This skill appears to do what it says: it runs a local HTTP service that holds agent memory in a local SQLite DB and provides a plugin to assemble context for agents. Before installing consider: (1) whether you'll run the prebuilt GHCR image or build from source — building from the included source is more auditable; (2) the Lethe service will receive and store all session content you send to it, so do not point the plugin at a remote/untrusted endpoint if the data is sensitive; (3) ensure the host volume (/data) where lethe.db is stored is access-controlled and backed up per your policy; (4) review the included plugin code if you plan to let the agent auto-send full context (to understand precisely what fields are transmitted); and (5) running any network-exposed service implies you should firewall or bind it to localhost unless you intentionally want remote access.

Verification

{
  "hasProvenance": false,
  "scanStatus": "clean",
  "scope": "artifact-only",
  "sourceCommit": "2411d03",
  "sourceRepo": "openlethe/lethe",
  "sourceTag": "v0.1.0",
  "summary": "Validated package structure and linked the release to source metadata.",
  "tier": "source-linked"
}

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)