The announcement starts from a familiar problem: each coding agent, on each machine, starts from zero. funes, which Hugging Face announced on September 3, indexes the sessions already on a developer’s machine from Claude Code, Codex, pi and Hermes, and gives each agent a way to search them. It is open-source software under the Apache 2.0 license, with tagged releases since early July; version 1.3.0 came out on September 1.
What it does on one machine
One command, such as funes add claude, builds an index of past sessions, gives the agent two tools, recall and get, and installs a hook that indexes each finished turn. recall returns the original text rather than a summary, with the agent, time, session and turn it came from; get opens the full turn.
Everything runs locally by default. Embedding and reranking use a pinned local model, the index is a Lance dataset on disk, and no account is needed. funes has no generative model of its own: the agent reading the results does the reasoning. Because every agent’s history lands in the same format, a task started in Claude Code can continue in Codex, which can recall the first agent’s reasoning.
Where the memory goes when it travels
To follow a developer across machines or reach a team, funes publishes the memory as a Hugging Face dataset owned by the user, private by default. The project’s design notes call the Hub “plain object storage, not a service”: search still runs locally over a cached copy, and nothing on the Hub processes the data.
This is where the switching cost moves. The memory no longer belongs to Claude Code or Codex, but its shared form lives on the Hugging Face Hub, behind a Hugging Face token. Only the local version needs no account at all.
The same notes say what funes is worse at. Memory services that use a language model to distill sessions are, in the project’s words, “genuinely better” at cross-session synthesis and at reasoning about entities and relationships. funes presents itself as a layer such a system could sit on.
The risks it names
Session transcripts are, according to the project’s security policy, “among the most sensitive data on your machine.” funes redacts credentials when it indexes, and at publish time runs every chunk through TruffleHog, withholding any row that still contains a secret. The gate fails closed: if the scanner is missing or crashes, nothing is published. The policy also states the limit. If a credential reaches a remote memory anyway, it has to be rotated immediately, because the repository history keeps it.
Reading someone else’s memory carries its own risk. Recalled passages go into the agent’s context, so a memory published by a third party is “untrusted input” that could carry instructions aimed at the agent. The policy recommends querying such memories one call at a time instead of binding them.
What the benchmark measures
The announcement says recall was the cheapest way to carry a past investigation into a new session: eight times cheaper than a written handoff on one task and four times on the other. The figures come from a benchmark published by funes’s own author, David Corvoysier, with two tasks and thirty Claude Code runs. The unit is weighted tokens per successful task. Recall took 101,000 and 169,000 on the two tasks, against 851,000 and 637,000 for a written handoff. A fresh session carrying nothing never reached the right answer, and compacting the context failed on one of the two tasks.
The method is unusually open: every run’s transcript and grade are published. The headline leaves out some limits the results page itself records:
- Dollars are left off the page on purpose, because billing depends on each session’s configured context window.
- One handoff figure is reconstructed from a printed summary, because its receipt was lost.
- The handoff’s cost includes writing the handoff, while building recall’s index is not counted.
- The page does not name the model the runs used.
No independent replication appears in the sources reviewed.
Related reading
- funes repository — Hugging Face
- Handoff-vs-recall benchmark — Hugging Face dataset
- Memory that doesn’t forget: how Xiaomi’s MiMo-Code is changing coding agents — IA al Día