pond

Lossless, searchable, SQL-queryable storage for every AI agent session, restorable into any supported client.

Source repo
tenequm/pond
Stars
★ 89
Last updated
1d ago
License
Apache-2.0
Primary language
Rust

At a glance

Works with
Universal · cross-platformCodex · Claude CodeClaude.ai (Partial support)
You'll need
Rust toolchain (only for cargo/source install)protoc (source build on Windows)NASM (source build on Windows)S3/GCS/Azure credentials (optional, remote storage)Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
A developer who has used Claude Code and Codex for months wants the three-month-old fix for a bug, and lets the agent query pond over MCP instead of grepping transcripts.
Main limitation
Pre-v1: the README states schemas, wire shapes and config keys may change in breaking ways before v1.

What does this agent do, and when should you use it?

pond is a Rust storage and retrieval layer that automatically ingests the session files agentic clients already write to disk — Claude Code, the Claude desktop app, Codex CLI, opencode, pi-coding-agent, oh-my-pi, OpenClaw, NanoClaw, Hermes Agent, letta-code, grok-build, Antigravity CLI and Devin CLI — plus a manual claude.ai export import. Each adapter is a bidirectional codec between a client format and one canonical Session / Message / Part model, so records land in three Lance datasets (sessions, messages, parts) with no synthesis of missing values, and any session can be restored into any supported client rather than only its origin. Storage belongs to you: a local directory by default, or S3, GCS, Azure or any S3-compatible bucket through Lance's object_store integration. Retrieval runs a single arm per query — BM25 full-text by default with a language-neutral tokenizer, or optional vector search over intfloat/multilingual-e5-small embeddings — and groups results into one summary per session keyed on session_root. The same handler set is exposed as a CLI, an HTTP+JSON server, and a stdio MCP server with pond_search, pond_get_session, pond_get_message, pond_ingest and read-only pond_sql. It is pre-v1: schemas, wire shapes and config keys may break before v1.

pond init runs guided setup — storage destination, adapter discovery and enabling, MCP registration (including the bundled pond skill), and an optional sync schedule. pond sync reads raw session records from every enabled adapter, parses them through extractor helpers that make inventing a value a compile error, commits them to the Lance sessions, messages and parts datasets, and folds the search indexes by default; when embeddings are enabled, vectors are computed inline at ingest into the nullable vector and embedding_model columns on messages. pond search answers a query with exactly one retriever — fts (BM25) or vector (cosine with a recency tiebreaker, only available when embeddings are enabled) — with --sort-by recency for newest-first and --explain for Lance's analyze_plan. pond sql plans read-only SQL over the same datasets with DataFusion, matching the pond_sql MCP tool. pond serve starts HTTP on 127.0.0.1:9797, while pond serve --transport stdio or pond mcp expose MCP over stdio; both transports dispatch into the same handlers, and MCP additionally exposes the schema://pond, schema://pond-sql and stats://pond resources. pond get-session and pond get-message fetch single records; pond copy moves a whole corpus between local and remote storage, then rebuilds destination indexes and verifies every row landed (exit code 6 on mismatch); pond creds add and pond storage use/check manage remote destinations; pond schedule start/status/logs drive launchd, systemd user timers, cron or Task Scheduler; pond optimize --only embed|index runs maintenance on demand.

  1. A developer who has used Claude Code and Codex for months wants the three-month-old fix for a bug, and lets the agent query pond over MCP instead of grepping transcripts.
  2. An engineer running different coding agents on a laptop and a work machine points both at one S3 bucket and inspects per-host ingestion with pond status --hosts.
  3. Someone migrating from opencode to another client restores existing sessions into the new client and continues there instead of re-explaining context.
  4. A team that needs structured answers about its corpus, such as message counts per project or tool-call activity over a period, runs read-only SQL through pond sql.
  5. A platform builder who wants a ready-made storage and retrieval layer for agent sessions integrates over HTTP+JSON or MCP and uses object-store IAM as the tenant boundary.
  6. A user who wants coding agents to recall past debugging automatically installs the pond skill and lets the agent call pond_search mid-conversation.

How do you install or deploy this agent?

Install with Homebrew on macOS/Linux, or Scoop on Windows:

brew install tenequm/tap/pond
scoop bucket add tenequm https://github.com/tenequm/scoop-bucket
scoop install tenequm/pond

Other supported paths are Nix, prebuilt release archives, cargo, and a source build (on Windows enable long paths and pass an explicit --target x86_64-pc-windows-msvc; protoc and NASM must be on PATH):

nix profile add github:tenequm/pond#pond
cargo binstall pond-db
cargo install pond-db
git clone https://github.com/tenequm/pond.git
cd pond
cargo install --path packages/pond

Optional CUDA acceleration:

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

How do you use this agent?

Run guided setup once, then sync and search:

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

Register pond as an MCP server (pond init does this for Claude Code; Codex prints the command):

claude mcp add -s user pond -- pond mcp
codex mcp add pond -- pond mcp

Serve, run stdio MCP, or query with read-only SQL:

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

Adapters must be enabled explicitly (config lives at ~/.config/pond/config.toml, or %APPDATA%\pond\config.toml on Windows):

[adapters.claude-code]
enabled = true
path = "~/.claude/projects"

[adapters.codex-cli]
enabled = false
path = "~/.codex/sessions"

Opt into semantic search, then backfill embeddings once:

[embeddings]
enabled = true
pond optimize --only embed

Switch to an S3-compatible bucket:

pond creds add
pond storage use s3+https://nbg1.your-objectstorage.com/my-pond
pond storage check

Keep it current on a schedule:

pond schedule start --every 15m
pond schedule status

What are this agent's strengths and limitations?

Pros
  • Keeps the whole session — every message, tool call and result — not extracted facts, and the record outlives the harness deleting its source file.
  • You own the storage: a local directory or your own S3/GCS/Azure bucket, with object-store IAM as the boundary instead of a vendor database.
  • Bidirectional adapters restore a session into any supported client, so history survives switching tools; a dozen-plus clients are covered today.
  • BM25 full-text is the default arm with a language-neutral tokenizer, and embeddings are strictly opt-in; the README's benchmark reports 1.5–3k recall tokens versus 90–255k for grep plus a transcript read.
  • Ships CLI, HTTP+JSON, stdio MCP and read-only SQL over the same handlers, so both humans and MCP clients reach the same corpus.
Limitations
  • Pre-v1: the README states schemas, wire shapes and config keys may change in breaking ways before v1.
  • Enabling an adapter is an explicit step — pond sync never picks one up implicitly — and cross-machine sharing requires configuring and copying into object storage first.
  • Remote reads are not yet as fast as local reads; that remains an open roadmap item.
  • Deletion (pond erase), namespaces/tenant scoping and redaction on copy/export are not finished, per the roadmap.
  • Building from source on Windows involves long-path config, an explicit target flag, protoc and NASM — heavy for non-Rust users.

How does this agent compare with similar options?

The README positions pond against two groups. Session-search tools (ctx, deja-vu, cass) also cover history from before install, but keep a search index rather than the sessions; ctx is single-machine, deja-vu copies records between machines over ssh, cass pulls remote session files in over ssh/rsync and ships no MCP server. Memory layers (Mem0, Letta) keep only extracted facts, cannot backfill pre-install history, and keep nothing once the harness deletes the file. pond sits underneath both: whole sessions, in storage you own, shared across machines. Per-cell receipts are at pond.locker/compare.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
pond This agent 53 · Major gaps — ★ 89 1d ago Rust Codex · Claude Code
Emulo 78 · Good Agent plugin / skillFree + model costs ★ 302 1mo ago HTML Codex · Claude Code
funes Agent Memory 68 · Some gaps CLIFree ★ 587 1d ago Rust Codex · Claude Code
Cognee Memory Platform 47 · Major gaps Library / SDKFree + model costs ★ 33k today Python Claude Code · OpenAI API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
53/ 100 5-point scale 2.7 / 5
Trust 13/29
Reliability 8/14
Adaptability 10/18
Convention 11/18
Effectiveness 7/13
Verifiability 4/8
Why each dimension lost points
Trust13 / 29 · 2.2/5

Trust: the README and design docs state plainly that pond does not authenticate, authorize, or model identity; tenant isolation relies on object-store IAM; encryption is an operational concern (bucket SSE / filesystem encryption); and pond holds no keys. That is a transparent boundary statement, but least_privilege scores only 1: the MCP server is registered at user scope by default (claude mcp add -s user) and exposes the read-only pond_sql query tool and the pond_ingest write tool, with no per-tool permission narrowing or confirmation gate. user_confirmation scores 1: pond init writes MCP config, installs skills, and optionally registers scheduled tasks, all side-effecting operations, yet the docs describe no interactive confirmation or dry-run preview (pond sync --dry-run exists, but init itself has no documented confirmation). data_flow_transparency scores 2: the README clearly states that data lands in a local directory or the user's own S3/GCS/Azure, that credentials are supplied via env/file/command, that embedding credentials in URLs and passing secrets on the CLI are explicitly forbidden, and that config show redacts. sensitive_data_handling scores 2: the design docs give concrete credential rules (no userinfo, no argv leakage, _command caching, name-based redaction of key/secret/token/password), but session content itself contains sensitive conversations and redaction is listed as a roadmap follow-up (#167) with no redaction today, hence the deduction. dependency_security scores 1: Cargo.toml shows only a workspace profile, with no dependency list or audit configuration; CI pins third-party actions to commit hashes (a plus), but there is no evidence of dependency vulnerability scanning or supply-chain auditing. external_effects scores 1: pond sync reads local session files, pond copy/migrate write to target storage, and schedule registers system scheduled tasks, all side-effecting; the docs note that copy does not delete the source and migrate is idempotent, but there is no unified confirmation/preview mechanism. rollback scores 1: the docs mention Lance versioning and time-travel, idempotent copy that does not delete the source, and re-runnable migrate, but pond erase is not yet implemented (roadmap item 10), so deletion and recovery paths are incomplete. source_attribution scores 2: the adapter table lists read paths and last verified dates item by item, and the design requires adapter-provenance-required and no-synthesis, giving structural traceability.

Reliability8 / 14 · 2.9/5

Reliability: the README's installation, configuration, adapter table, and design docs are mutually consistent (e.g., embeddings off by default, BM25 default, single-arm retrieval), with no obvious contradictions; however, the README roadmap says "Eleven harnesses" while the adapter table lists 14, a minor count inconsistency, hence 2 rather than 3. dependency_availability scores 1: install channels (Homebrew tap, Scoop bucket, Nix, crates.io, release zip) are described in detail but are all externally hosted resources whose availability static review cannot confirm; building from source requires protoc/NASM and other prerequisites, widening the dependency surface. failure_messages scores 2: the docs repeatedly stress that errors name the file, name the creds set, give migration rewrite recipes, and that config check has distinct exit codes, a well-grounded error design; but no actual error output samples corroborate it.

Adaptability10 / 18 · 2.8/5

Adaptability: audience_and_scenarios scores 2, as the README clearly targets multi-client agent users with real usage prompts and a comparison table, making the scenario clear. capability_boundaries scores 2, clearly distinguishing pond from memory tools, noting ingest-only adapters, single-arm retrieval without fusion, and no hosted service, an honest boundary. trigger_precision scores 1: MCP tool triggering depends on the agent deciding when to call pond_search, and the README gives only example prompts, with no trigger conditions or precise tool-description spec. environment_fit scores 2: covers macOS/Linux/Windows and explains PowerShell vs POSIX differences, long paths, and CUDA/Metal/CPU fallback, an adequate environment fit.

Convention11 / 18 · 3.1/5

Convention: information_architecture scores 2, with a clear README structure (install/usage/design/roadmap) and docs/spec.md as a contract. install_notes scores 3, with extremely detailed install instructions covering multiple platforms, multiple package managers, source-build prerequisites, and troubleshooting. naming_stability scores 1: the README states pre-v1, with schema, wire shape, and config keys all subject to breaking change, and the design docs record renames such as --data-dir→--storage-path, so stability is insufficient. examples_and_faq scores 2, with example commands and prompts but no formal FAQ. known_limitations scores 2: the token statistics doc lists limitations such as 11% underestimation and missing account attribution, and the roadmap flags unimplemented items, but the README body does not collect limitations in one place. license scores 3, with the full Apache-2.0 text present and consistent with the badge. versioning_changelog scores 1: there is a roadmap and release links, but no CHANGELOG file, and the versioning policy is only "pre-v1 may break". maintenance_responsibility scores 1: publisher identity is unverified, there are no SECURITY.md/CONTRIBUTING details, and maintenance ownership is unclear.

Effectiveness7 / 13 · 2.7/5

Effectiveness: output_usability scores 2: outputs are CLI text, JSON, SQL results, and MCP tool returns, and the docs give concrete queries and formats (--format ndjson), so usability is decent but there are no output samples. marginal_value scores 2: it addresses the real pain point of cross-client session retrieval and is distinguished from memory tools and session search tools, with a concrete value proposition; but similar tools (cass, ctx, deja-vu) already exist, so incremental value needs real-world verification. cost_benefit scores 1: the README cites token cost benchmarks (1.5-3k vs 90-255k), but those are self-reported by the project and were not reproduced in this review; the install footprint is large (about 223MB unzipped on Windows) and requires a Rust toolchain or package manager, so the cost is not low.

Verifiability4 / 8 · 2.5/5

Verifiability: claim_traceability scores 1: the README's comparison table and token benchmarks point to docs/benchmarks and pond.locker, but only some docs are present in the repo, so most claims cannot be traced in the supplied files. cross_source_corroboration scores 1: the token statistics doc says it cross-validates against ccusage and Claude Code cost-state, which is self-reported, with no independent third-party evidence; CI config exists but test results are not shown. fact_inference_separation scores 2: the docs fairly clearly separate measured numbers, methods, and limitations (e.g., "transcript underestimates by about 11%", "account attribution only from 2026-08-10"), so facts and inferences are well separated.

Risks and how to mitigate them
  • Publisher identity is unverified; maintenance responsibility and update path are unclear, so verify provenance before enterprise adoption.
  • Project is pre-v1: schemas, config keys, and wire shapes may change breakingly; expect migration cost on upgrade.
  • MCP is registered at user scope by default and exposes pond_sql and pond_ingest, with no per-tool permission narrowing or confirmation gate.
  • Session content is not redacted by default; redaction remains on the roadmap, so sensitive conversations may be persisted in full locally or to object storage.
  • No evidence of dependency security or supply-chain auditing; the Cargo dependency list is not present in the supplied files.
  • Deletion and recovery paths are incomplete (pond erase not yet implemented), limiting rollback.
  • Minor inconsistency between the adapter count in the roadmap and the adapter table; benchmark figures are self-reported and not independently reproduced.
Evidence confidence: Low Reviewed Nov 06, 2026 Reviewed revision 3f10be0230d4
See the full review method →

FAQ

Will pond delete or rewrite my existing session files?
No. Adapters read source records and write the canonical model into Lance; ingested records survive even if the client deletes the original. pond copy likewise never deletes the source.
Do I need a paid API or cloud account?
The software is Apache-2.0 and runs fully locally. Semantic search is optional and loads intfloat/multilingual-e5-small when enabled; S3/GCS/Azure costs, if you use them, come from your own object storage.
Can I count on config and data formats staying stable?
Not yet. The project is pre-v1 and says schemas, wire shapes and config keys may break before v1; plan migration windows and treat docs/spec.md as the contract.
My agent client isn't on the supported list — can I add it?
Yes. The repo ships a pond-add-adapter skill as the playbook, with a conformance harness and real captured fixtures; the roadmap lists Qwen Code, Crush, Cline and others as wanted community adapters.
How is data separated across machines or tenants?
Today via one shared bucket plus pond status --hosts for per-ingest-host views; per-tenant namespaces are still in progress, and pond itself performs no authentication — the object store's IAM is the boundary.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents