funes: Local Memory for Coding Agents, Built on Lance

Your coding agent solved this once.

It found the failing test, tried the obvious fix, rejected it, learned the weird constraint, and made a decision. Then the session ended. Next week, a new agent meets the same project as if none of that happened.

funes turns those past agent sessions into memory your agents can actually use. It indexes Claude Code, Codex, pi, and Hermes traces into one local Lance dataset, then gives the agent recall and get tools.

The next time a task depends on old reasoning, the agent can pull the original passage back. No LLM summarizing your traces at ingest. Just your working record, local by default, shareable when you choose.

Try it now

Install the binary:

curl -fsSL https://huggingface.co/buckets/huggingface/funes/resolve/install.sh | sh

Add it to the agent you use:

funes add codex    # or: claude, pi, hermes

That command builds the first index, registers the tools, and installs hooks so new turns are indexed automatically. From there, keep working. The agent can call recall on its own when old context matters.

You can also query the memory directly:

funes recall "why did we switch off the streaming parser"

recall returns ranked passages from real sessions. Each hit includes where it came from and a get command to open the surrounding turns:

funes get <session_id> --from 40 --to 60

If you want an answer instead of raw evidence:

funes ask claude "what did we decide about the storage layout"

ask retrieves locally, then asks the selected agent to answer from those passages. Use recall instead when you want to inspect evidence.

Privacy first and Local by default

Agent traces can contain sensitive work like local paths, stack traces, unreleased plans, customer-specific debugging, and sometimes pasted credentials. funes treats that seriously.

Indexing is deterministic:

1. parse the transcripts
2. chunk the blocks
3. embed locally
4. store it as a lance dataset

There is no LLM in that path. No hosted model reads your sessions to summarize them into memories. The embedding model is pinned and recorded in the dataset, so funes refuses to query a memory built with an incompatible model.

Publishing (only when you need it) has a second guard. When TruffleHog is available, indexing redacts detected credentials before storage. On funes push, an always-on fail-closed scan checks the rows that would leave the machine. If a block still contains a secret, funes holds it back.

Why Lance

funes stores memory as one growing table. Every completed turn adds a few chunks. Every passage retains its original text, exact provenance, and vector embedding. Recall needs to search that table across both semantic context and exact terms. When sharing becomes necessary, exporting a single dataset artifact should suffice.

Lance fits because one dataset directory holds all of it:

chunks.lance/
  data/        text, provenance, vectors
  _indices/    BM25 and vector indexes
  _versions/   committed dataset versions

There is only one artifact to manage, rather than a document store, vector store, and separate search system that all need to stay in sync. New chunks can be appended without rewriting the dataset, every commit creates a version that can be rolled back, and BM25 and vector indexes stay with the data. Lance also supports fast random access for reranking and runs in-process against local disk or object storage, so Funes can remain a library instead of another service that has to be deployed and kept alive.

On recall, funes performs vector search to capture semantic meaning and BM25 to catch exact names, flags, errors, and identifiers. It then reranks the best candidates and applies recency weighting so newer decisions can carry more weight.

Because completed turns produce deterministic chunk IDs, re-indexing is cheap. Funes does not re-embed chunks it has already written. The memory is a rebuildable artifact, while the source transcripts remain the source of truth.

The takeaway

funes is not a knowledge base that rewrites your history. It is a local recall layer for the work your agents already did.

Install it, add it to your agent, and ask:

funes recall "what did we already learn here?"

The answer should come from the record itself, local, auditable, and ready for the next agent.