Key details

  1. Funes supports Claude Code, Codex, pi and Hermes at launch.
  2. It indexes existing coding-agent session traces rather than requiring a separate manual memory format.
  3. Local memory is stored as a Lance dataset.
  4. Embedding and reranking run locally by default.
  5. Recall returns provenance so a user or agent can inspect the underlying source material.
  6. Memories can optionally be synchronized to a user-owned Hugging Face dataset that is private by default.
  7. Remote memory files are cached locally for subsequent queries.
  8. Funes performs credential/secret scanning before publishing but documents that the protection has limits.
  9. The project is open source.

What builders should take away

  1. Treat agent traces as durable project data if you adopt Funes: decide how long they should live, who may read them and which repositories or clients may contribute.
  2. Start with local-only memory before enabling Hub synchronization so you understand what your agent sessions actually contain.
  3. Keep provenance in the loop when a recalled decision matters; a retrieved passage is evidence of prior context, not necessarily a still-correct architectural choice.
  4. Do not rely solely on automatic redaction for sensitive repositories. Add your own secret scanning and access controls before synchronizing session-derived memory.
  5. Cross-agent memory is most useful when integrations share the same project identity and conventions; test recall quality before assuming one memory will transfer cleanly across every workflow.

What changed

Hugging Face released Funes on September 3 as an open-source durable-memory layer for coding agents including Claude Code, Codex, pi and Hermes. Funes ingests the session traces those agents already create, incrementally indexes them into a local Lance dataset and exposes retrieval designed to return both relevant passages and their provenance. Embedding and reranking run locally by default. A user can optionally bind the memory to a Hugging Face dataset they own, private by default, so the same memory can be reused on another machine or by another supported agent. Funes scans indexed content for credentials and performs another secret scan before publishing, but its own documentation does not claim those checks are infallible.

Why it matters

Coding agents are increasingly capable within a session but still routinely lose project decisions, failed approaches and architectural context when the session or tool changes. Funes makes that accumulated trace a portable artifact controlled by the developer rather than another vendor-specific conversation store. That can reduce repeated repository exploration and make switching agents less expensive, while keeping the default retrieval path local. The trade-off is governance: agent traces can contain credentials, internal code fragments and sensitive reasoning context, so turning them into a long-lived searchable dataset creates a new asset that needs access, retention and secret-handling rules.

The memory starts from traces the agents already produce

Funes does not require developers to maintain a separate project notebook. It indexes existing agent sessions, preserving original text and provenance so a later retrieval can point back to the source turn rather than returning only an opaque synthesized memory.

Retrieval stays local by default

The local memory is stored as a Lance dataset, while embedding and reranking use models that can run on the developer’s machine. That means a single-machine workflow does not require a separate hosted memory API or send every recall query to a remote service.

One memory can be shared across supported agents

Funes integrations let the same indexed history be recalled from Claude Code, Codex, pi or Hermes. When a memory is bound to a Hugging Face dataset, another machine can download and cache it locally, allowing context to move with the user rather than staying trapped in one agent’s session database.

Publishing memory introduces a secret-management boundary

Funes redacts detected credentials while indexing and scans chunks again before publishing. The project documents the scanner and its limits rather than treating detection as a guarantee. Teams should therefore assume session traces may contain sensitive material and apply private dataset permissions, retention rules and independent secret scanning where the stakes justify it.

What to watch next

  • Support for additional coding agents and editors.
  • Measured recall quality and latency on large, long-lived repositories rather than launch examples.
  • How the memory schema evolves as agent trace formats change.
  • Independent audits of secret-redaction behavior and private dataset workflows.
  • Whether agent vendors expose portable session formats that make cross-agent memory less adapter-specific.

Still unclear

  • Funes is a new project and broad production adoption or long-duration recall quality has not yet been demonstrated.
  • Automatic secret detection can miss sensitive data; the project’s scanning should not be treated as a security guarantee.
  • Recall quality depends on the content and consistency of the underlying agent traces.
  • A shared Hugging Face dataset adds a remote storage and access-control dependency even though retrieval is cached locally.

Sources

Direct reading behind this dossier.

2 sources
Give Your Coding Agents a Memory You Own
Hugging Face primary

Primary launch describing supported agents, local Lance memory, retrieval/provenance, optional private Hub synchronization and secret scanning.

huggingface/funes
Hugging Face / GitHub primary_repository

Source repository and implementation documentation for the open-source memory tool.

Discussion

Discussion is reader-contributed. Comments are not part of the BTN dossier or its editorial evidence.

0 visible comments

Join the discussion

Keep comments useful and relevant. Reader contributions may be moderated and are not BTN editorial evidence.

Sign in to comment