pond

pond

"I know we discussed that before. Why can't I find that damn conversation?"

Pond makes every AI agent session you've ever run - Claude Code, Codex, any tool, any machine - searchable in one place.

Your agent history is already on your disk: thousands of sessions full of decisions, fixes, and dead ends - scattered across tools that can't search them. Pond ingests them all automatically and losslessly into storage you own (a local dir or your own S3 bucket), makes the whole corpus searchable and SQL-queryable, and hands that recall back to your agents over MCP - so "how did we fix this before?" is a query, not an archaeology dig. Sessions stop being locked to the tool that created them: any session can be restored into any supported client and continued there.

brew install tenequm/tap/pond   # macOS / Linux

scoop bucket add tenequm https://github.com/tenequm/scoop-bucket # Windows scoop install tenequm/pond

Or prompt your agent: *"Please install and set up pond (see github.com/tenequm/pond)"* - the full, failure-proofed version of that prompt is in Connect your agents.

A live 12k-session corpus, then a three-month-old fix found and verified against the current code ( crisper MP4 )

Five real recall questions, one corpus, one machine - method, raw numbers, and a rerunnable script in docs/benchmarks

Status: pre-v1. Schemas, wire shapes, and config keys are subject to breaking change until v1. Full documentation lives at pond.locker; the contract is docs/spec.md.

Quickstart

Install, run guided setup, and ingest your local sessions:

brew install tenequm/tap/pond   # macOS / Linux; Windows: Scoop or a release zip - see Install below

pond init # guided setup: storage, adapters, MCP + agent skill, optional schedule pond sync # ingest and index - every enabled adapter

pond init registers pond as an MCP server for Claude Code and installs the bundled pond skill; for Codex it prints the command to run instead - restart the client afterwards so the tools load. By hand: claude mcp add -s user pond -- pond mcp, codex mcp add pond -- pond mcp; skill: mkdir -p ~/.claude/skills/pond && pond skill > ~/.claude/skills/pond/SKILL.md (that whole line is POSIX-only - mkdir -p, &&, and > all break or corrupt in Windows PowerShell 5.1; use the PowerShell block in Connect your agents). Then ask your agent - real prompts from daily use:

check in pond how we solved this before, then apply the same fix here

where we left off yesterday - check pond, then continue

are you sure that won't break X? check in pond how we struggled with exactly this

Sessions are picked up automatically from Claude Code, the Claude desktop app (local agent mode), Codex CLI, opencode, pi-coding-agent, oh-my-pi, OpenClaw, NanoClaw, Hermes Agent, letta-code, grok-build, Antigravity CLI (agy, including its ACP server), and Devin CLI (devin). A Claude.ai data export imports with pond sync claude-ai-export --path (manual download, so not auto-discovered).

Isn't this another memory tool?

No - it's the layer underneath one. Memory tools store what they decided you'd need - facts, summaries, filed chunks; the sessions themselves are gone. Pond keeps the sessions: every message, tool call, and result, value-complete, cross-client, in storage you own, never pruned - searchable over MCP and restorable into any client. Memory is a derived view you can always rebuild from an archive; an archive can never be rebuilt from memories.

Three kinds of tool get called "memory". Side by side:

¹ cass also mirrors the raw files, so they outlive the source. ² deja-vu copies records between machines over ssh; cass pulls other hosts' session files over ssh/rsync into its local index; ctx is single-machine. ³ cass has no MCP server.

Pick session search for fast local recall. Pick a memory layer when the agent should carry distilled facts, not the record. Pick pond when you want the sessions themselves, in storage you own, from every machine you run.

Full comparison, with receipts per tool: pond.locker/compare. Every cell is a claim about a specific version of someone else's project. If one has gone stale, open an issue and it gets fixed the same day.

Background

Every agentic CLI ships its own session format and its own search surface. Switching tools means losing history. Replaying a Claude Code session in another provider's tooling means re-translating the wire shape by hand. Hosted multi-tenant deployments rebuild the same storage layer from scratch.

Pond is the storage and retrieval layer that sits underneath. Every adapter is a bidirectional codec between a client format and one canonical schema, so any session can be restored by any adapter - it need not return to the client that produced it. Storage, search (BM25 full-text by default, with optional semantic search, one arm per query), and provider-agnostic replay all sit on a single Lance-on-object-storage foundation.

The v1 surface includes: full CLI, HTTP+JSON and MCP transports, search over three Lance datasets, opt-in intfloat/multilingual-e5-small embeddings at FP16 weights (Metal on macOS, CUDA opt-in, CPU fallback), and local-FS / S3 / GCS / Azure backends through Lance's object_store integration.

Install

Linux, macOS, and Windows are supported.

macOS and Linux:

brew install tenequm/tap/pond              # Homebrew

nix profile add github:tenequm/pond#pond # Nix

Windows (Scoop, the primary channel - it also ships pondw.exe, the windowless launcher that scheduled sync runs through):

scoop bucket add tenequm https://github.com/tenequm/scoop-bucket

scoop install tenequm/pond

Buckets are git clones, so the first line needs git on PATH - if it fails with "Git is required for buckets", run scoop install git and retry.

No Scoop yet? Bootstrap it first, from a normal (non-admin) PowerShell (its installer refuses an elevated shell):

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser -Force

irm get.scoop.sh | iex

Then open a new terminal - PATH changes reach only processes started after the install. See the Windows notes for Defender, long paths, scheduling, and WSL.

No package manager (any platform): every release attaches prebuilt binaries (pond-x86_64-pc-windows-msvc.zip on Windows, ~223 MB unpacked) - unpack one and add its directory to PATH (on Windows: Settings > System > About > Advanced system settings > Environment Variables, under your user variables), nothing else to install.

Via cargo (any platform, needs the Rust toolchain):

cargo binstall pond-db   # downloads the prebuilt binary (needs cargo-binstall)

cargo install pond-db # builds from crates.io (installs the pond command)

Both install pond.exe only, so scheduled sync on Windows - which runs through pondw.exe - wants the Scoop or zip install instead (or --features windows-launcher on a source build). cargo install also needs the protoc and NASM prerequisites below.

Build from source:

git clone https://github.com/tenequm/pond.git

cd pond cargo install --path packages/pond

On Windows that clone needs git config --global core.longpaths true first (test-fixture paths exceed 260 characters), and the build needs an explicit --target x86_64-pc-windows-msvc - without it cargo applies the repo's +crt-static flag to build scripts and proc-macros too, which then fail to load.

For CUDA acceleration on Linux:

cargo install --path packages/pond --features cuda

On macOS the Metal backend is selected automatically; on other systems the CPU fallback runs without extra features. Building from source on Windows additionally needs protoc (winget install Google.Protobuf) and NASM (winget install NASM.NASM, then add C:\Program Files\NASM to PATH yourself - its installer doesn't) on PATH.

If any install path fails, the Troubleshooting guide covers the common stalls.

Usage

Sync and search

Set up storage, adapters, MCP registration, and an optional sync schedule in one pass (idempotent - re-run it any time to repair or update):

pond init

Then import sessions from local adapters, update indexes, and search:

pond sync

pond search "how did we wire up the OCC retry loop"

Run a server

pond serve                         # HTTP on 127.0.0.1:9797

pond serve --transport stdio # MCP over stdio pond mcp # alias for stdio MCP

Fetch and copy

Fetch a single session or message, or move a whole corpus:

pond get-session <id>

pond get-message pond copy --from local --to snapshot.pond pond copy --from snapshot.pond --to local

Read-only SQL

Ask structured questions with read-only SQL (the same surface as the pond_sql MCP tool):

pond sql "SELECT project, count(*) FROM messages GROUP BY project ORDER BY 2 DESC"

Maintenance

Run maintenance on demand (sync folds indexes on every run):

pond optimize --only embed   # only when [embeddings].enabled = true

pond optimize --only index

Scheduled sync

Keep pond current automatically (launchd on macOS, systemd user timers or cron on Linux, Task Scheduler on Windows - there, run it from a normal shell, not an elevated one, or the task ends up owned by Administrators):

pond schedule start                # every 5m by default (--every 15m|1h|6h|1d)

pond schedule status pond schedule logs

Status and introspection

pond status prints a per-table storage