Hugging Face Introduces funes: A Durable Local Memory Layer for Coding Agents

Hugging Face Introduces funes: A Durable Local Memory Layer for Coding Agents Hugging Face has released funes, an open-source tool that provides coding agents like Claude Code, Codex, pi, and Hermes with persistent memory derived from past session traces. Operating as a single binary with local embedding and reranking, funes enables agents to index, search, and recall past decisions across different sessions, machines, and agent platforms. funes indexes local agent traces into a Lance dataset using local embeddings and cross-encoder reranking, without hosted ML runtime dependencies. Memories can sync across machines as Hugging Face datasets, which are private by default and feature automated credential redaction. Cross-agent compatibility allows different tools—such as Claude Code and Codex—to query and build upon the same historical execution records. On the handoff-vs-recall benchmark, retrieval via recall was 4x to 8x cheaper than written handoffs and avoided failure modes seen in context compaction. Architecture and Local Integration funes operates as a single binary that plugs directly into existing agents via an 'add' command. Its deterministic pipeline parses execution traces from Claude Code, Codex, pi, and Hermes into standardized turns and blocks, embedding them locally and storing them in an append-only Lance dataset. When an agent queries its history, funes executes a combined BM25 and vector search, fuses the candidate rankings, reranks them using a local cross-encoder, and adjusts for recency. Raw source traces are preserved rather than summarized into distilled facts, ensuring results link directly back to the exact turn and session where a decision was made. Cross-Host Synchronization and Security Local memories can be bound to Hugging Face datasets to synchronize across machines and team members. In this configuration, funes performs incremental indexing locally and pushes updates at session boundaries. Remote datasets are cached on local disk so subsequent queries maintain local latency. Security measures include stripping credentials during initial indexing, followed by a secondary scanning pass before any data is published to the Hugging Face Hub. Standalone Queries and Benchmark Efficiency For ad-hoc queries outside an active agent session, the read-only 'funes ask' command enables direct retrieval against local or public repository memories without modifying persistent agent setups. In empirical evaluations on the handoff-vs-recall benchmark, recall proved significantly more cost-effective than writing manual handoffs—reducing costs by 4x on one task and 8x on another. Additionally, recall avoided the failure observed in standard context compaction, where aggressive summarization dropped critical project details required to solve subsequent tasks.

开源工具 funes 为编码智能体构建跨平台私有持久记忆层 Hugging Face 推出开源工具 funes，旨在将编码智能体（如 Claude Code、Codex 等）的历史执行追踪转化为结构化记忆，实现多模型与跨设备的上下文检索与复用。 funes 支持单二进制本地运行，支持 Claude Code、Codex、pi 和 Hermes 等智能体，无独立 ML 运行时依赖。 记忆在本地存储为 Lance 数据集，混合使用向量、BM25 检索、交叉编码重排序及时间加权，保留原始文本与出处信息而非摘要。 用户可将记忆同步至私有的 Hugging Face 数据集，内置敏感凭证自动脱敏与缓存机制。 基准测试显示，在无法脱离先前知识的任务中，召回方案的成本比人工交接低 4 至 8 倍，且规避了上下文压缩丢失关键细节的缺陷。 从零散日志到可检索记忆 编码智能体在排错和开发中会产生详尽的会话记录，但长期以来散落各处难以跨机器调取。funes 通过一条命令即可为智能体接入 recall 和 get 工具，以增量方式将对话轮次切块、嵌入并存入本地 Lance 数据集。查询时结合向量与 BM25 检索并辅以重排序，直接返回原始对话片段与明确来源，而非压缩后的事实总结。 跨智能体与跨设备的共享记忆数据集 funes 将记忆定义为数据集而非中心化云服务。所有支持的智能体共用统一数据格式，使得一个智能体能调取另一智能体历史决策的原由。用户可将记忆绑定至 Hugging Face 数据集（默认私有），发布前经过凭证脱敏，跨机器拉取时自动本地缓存以维持查询速度。此外，还支持通过 ask 命令单次向共享记忆提问。 长会话成本与准确度对比 在 handoff-vs-recall 基准测试中，长会话上下文压缩往往因概括而抹杀关键线索，甚至在部分任务中无法给出正确答案。相比之下，funes 的精准召回机制不仅保留了完整证据链，其成本表现也优于人工编写的 handoff 方案，在两项测试中分别节省了 4 倍与 8 倍的成本。

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 new agent, on each new host, starts from zero. 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 . 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. 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. Add memory to the agent you already use funes is a single binary. Its default inference backend has no ML runtime dependency, and embedding and reranking happen on your machine . Install it: curl -fsSL https://huggingface.co/buckets/huggingface/funes/resolve/install.sh | sh Then add it to an agent: funes add claude # or: codex, pi, hermes 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 new 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 new 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 shows 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 important properties: One memory across agents: Claude Code, Codex, pi, and Hermes all write to the same shape. recall spans their histories, and every hit says which agent produced it. Raw evidence stays intact: Nothing is distilled into a fact at write time. A result can always lead back to the turn that produced it. recall is local by default: No account or Hub repository is required. A hosted model does not process your sessions for indexing; embedding and reranking run on your machine, and your coding agent does the reasoning. 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. A memory is a dataset, not a service To make a memory follow your work, bind one when you add funes to an agent: funes add codex acme/funes-memory 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. 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. 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. Ask first, wire later 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: funes ask claude "what did we decide about the streaming parser" 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: funes ask claude "why is funes append-only" --memory huggingface/funes-memory 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 says so. You can rephrase the question or add funes to the agent so it can search the memory iteratively during normal work. Switching agents without losing the thread 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: Across your machines: Bind each agent to one memory and recall the history from whichever host you are using. Across a team: A new teammate's agent can retrieve months of decisions on day one, including dead ends and rationale that never made it into a pull request. Alongside an open-source project: A maintainer can publish the sessions behind a release, naming them on the push. Think of it as a searchable CLAUDE.md that holds the history of why the project is the way it is, instead of a page someone must keep rewriting. Anyone can read a public memory with --memory . 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. The cheapest way out of a long session 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. 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. 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. Stop starting from zero “To think is to forget differences, generalize, make abstractions.” — Jorge Luis Borges, Funes the Memorious 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. Built on open source 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 issue for anything from an install snag to a recall that missed, or an agent you'd like supported.