I work across several machines, and I switch coding agents depending on the task. Every one of them meets my projects as a stranger. The reasoning from βlast Tuesdayβ disappears when the session ends. Each latest agent, on each new host, starts from zero.
Recent findings suggest that earlier this year, Software Forgets: Agent Traces Are the Memory made the case that coding agents already produce the record we keep losing. As they search a codebase, try approaches, hit errors, read documentation, and change direction, they leave behind a dense account of not just what changed, but why.
In a recent development, while the diagnosis is correct, traces are only potential memory. The session logs of an agent are still just an archive. You cannot grep your way to βwhy did we move off the streaming parser?β across ten thousand turns. For an agent to use those traces while it works, they need indexing, retrieval, ranking, and exact provenance.
Industry observers note that that is what funes provides. It is a durable memory layer for your agents (Claude Code, Codex, pi, and Hermes). It is built from the sessions already on your machine. It works locally and becomes part of your agent's normal workflow with one command. When you want it to, it can also travel to a Hugging Face dataset you own, private by default.
funes is a single binary. Its default inference backend has no ML runtime dependency, and embedding and reranking happen on your machine. Install it:.
That one add command builds the first index, gives the agent recall and get tools, and installs the automation that indexes each completed turn. Indexing is incremental, with latest runs adding new turns rather than embedding the whole history again. The older and deeper content can backfill in bounded steps.
From there, you just work. When a task touches a past decision, rationale, or finding, the agent can reach for recall itself. You do not need to remember the old session or paste its context into the newly introduced one.
With funes added, recall happens inside the conversation. The agent reaches for its memory on its own and names the session behind its answer.
recall returns the original text, not a summary, and demonstrates exactly where it came from (the agent, timestamp, session, and turn). Each result includes a get command that opens the full turn and its surrounding context.
Underneath, one deterministic pipeline parses every supported trace into the same turn-and-block shape, chunks it, embeds it with a pinned local model, and writes it to a local Lance dataset. A query combines vector and BM25 search, fuses their rankings, reranks the candidates with a cross-encoder, reweights them by recency, and attaches neighboring chunks.
That design gives funes three notable properties:.
It has been revealed that the agent as a stranger problem is already solved on one machine. But memory gets more useful when the next agent is running somewhere else.
To make a memory follow your work, bind one when you add funes to an agent:.
Industry observers note that the bind publishes your current memory there. funes then keeps it current, indexing each turn locally and publishing at session boundaries. The agent recalls from it throughout. Run the same command on another machine and the memory follows you there.
Underneath, the local memory is a Lance dataset, and the shared memory is a Hugging Face dataset (private by default) you own.
According to recent reports, before anything reaches the Hub, credentials have already been redacted during indexing. Publishing then scans every chunk again and withholds anything that still looks like a secret. The scanner behind this is documented in SECURITY.md, including what it does and doesn't cover.
It has been revealed that when an agent reads a remote memory, funes caches the dataset files locally, so warm queries return to local speed. The Hub supplies the ownership, access control, versioning, and distribution it already supplies for other datasets. Your memory does not become an account in a separate memory service, and you do not rent it back through an API.
recall is shaped for agents. When you want to put a question to a memory yourself, use ask. It reads your local memory by default:.
According to recent reports, or point it at a shared memory. We published a memory of funes development, so you can ask why funes works the way it does without creating a memory of your own:.
Sources indicate that funes ask is the read-only, one-question sibling of funes add. It recalls the passages, hands them to a coding agent, and returns a grounded answer that names its sources. It does not install an integration or change the agent's persistent setup.
A retrieval miss is not papered over. If the passages do not support an answer, the agent notes so. You can rephrase the question or add funes to the agent so it can search the memory iteratively during normal work.
Industry observers note that A shared memory is not tied to the agent or model that created it. Start a task in Claude Code, continue it in Codex next week, and the second agent can recall the first agent's reasoning. Use pi with a local model or one served through the Hugging Face router, then return to Claude.
Claude makes a decision; a hook indexes it; Codex recalls it in another session. The older hits in the demo are earlier recordings of the same experiment: an append-only memory remembered the rehearsals too.
This matters in a few different scopes:.
In a recent development, published memories carry a dataset card and the funes tag, making them recognizable and discoverable on the Hub. The Hub already hosts open weights and datasets. funes adds open working memory. It holds the decisions, failed approaches, and rationale behind a project, queryable by another agent and traceable to the sessions that produced them.
A long investigation bloats a session until each turn costs more to carry the context than to do the work. The usual answers are to let the agent compact and carry on, or to write a handoff and start fresh. Recall is a third, so we measured them against each other on the handoff-vs-recall benchmark: two tasks whose answer cannot be reconstructed without the session prior knowledge.
In a recent development, compaction is what most agents do by default, and it was the only one of the three whose result divided: it arrived on one task and never arrived on the other. Where it failed, its summary had flattened the findings that mattered. Recall returns the passages themselves, so a finding does not have to survive summarization.
Recall was the cheapest of the three on both tasks, 8x cheaper than a written handoff on one and 4x on the other.
In a recent development, the lighter segment of each bar is the one-time charge for preparing the channel, the handoff or the compaction, paid before the first question is asked and counted once. A cross marks a channel that never arrives, and so has no cost per success.
βTo think is to forget differences, generalize, make abstractions.β β Jorge Luis Borges, Funes the Memorious.
Industry observers note that your agents already wrote the record. funes lives at github.com/huggingface/funes, one command away from turning that record into a memory the next agent can read, on whichever machine you happen to be on.
funes invents little of this. It leans on open-source embedding models good enough to run locally, on Lance's append-only datasets with cheap incremental writes, and on the Hub's caching and content-dedup for datasets. The work is in fitting them into a memory an agent can actually use.
funes is open source too. Open an concern for anything from an install snag to a recall that missed, or an agent you'd like supported.
Ran funes 1.3.0 on a machine with 19,195 coding-agent sessions already on disk (LongMemEval laid down in the real ~/.claude and ~/.codex layouts), 100 questions whose answer sits in exactly one session, scored by whether that session comes back. Disclosure: I maintain deja-vu, one of the tools in the same table.
Sources indicate that full index: 2h03m on an M4 pro laptop (308k chunks), 6.3s per query. With defaults: hit@1 9/100, hit@5 39, found@50 71. With --half-life 0: 19/46/71 β the 30-day recency half-life halves rank-1 on history older than a month, which is most of what's on a real disk; worth a mention in the docs. Once recency is off, the vector+rerank stack is clearly the best ranker in the table at rank five. The documented one-minute first pass leaves 218 of the 19k sessions indexed (0/100 answered), so the "about a minute" framing is really "about a minute until the embedding job starts".
For comparison on the same corpus, deja-vu (plain BM25 over 24 agents' files) indexes in 29s and answers in 24ms at hit@1 18/100, hit@5 35. Corpus, drivers and every row: vshulcz.github.io/deja-vu/guide/day-zero.html - happy to be corrected if a setting I missed changes the numbers.
Industry observers note that longmemeval does not really need semantic search: BM25 already gives the same ratio you mentioned IIRC, so for this use case this is pretty much expected that it is not worth paying the cost of evaluating the embeddings (this extra cost you see at indexing and recall time). funes shines when the information is actually difficult to find.