Key Takeaways
- Funes indexes session logs from four coding agents into one shared local memory.
- Recall returns raw evidence with provenance, so key decisions aren’t lost in summaries.
- Memory is a portable dataset you own, not a cloud service, and it syncs across devices.
Table of Contents
Funes Turns Local Session Logs Into Portable Agent Memory
Today, Hugging Face’s engineering blog reports that funes is now available as a single local binary for memory across four coding assistants.
Claude Code, Codex, pi, and Hermes all write into the same indexed memory layer instead of leaving session logs to rot in local archives.
The problem is familiar to anyone who splits development across machines or alternates between agents.
Every new session arrives as a stranger to the project, with no access to the reasoning from last Tuesday unless a developer manually pastes it back into context.
Funes converts the dense traces that agents already produce into searchable recall, so the next agent can retrieve decisions, dead ends, and rationale without a handoff document.
Inside The Indexing Pipeline That Makes Agent Recall Work
As detailed on Hugging Face’s engineering blog, installation is a curl command that downloads one binary, and the default inference backend carries no ML runtime dependency.
Adding the tool to an assistant is a single command: ‘funes add claude’ — with the same pattern working for Codex, pi, and Hermes.
That command builds the first local index, gives the agent two new tools called ‘recall’ and ‘get’, and installs automation that indexes each completed turn.
Indexing is incremental, so fresh runs append new turns rather than embedding the entire history from scratch.
Older and deeper content can backfill later in bounded steps.
How Recall Preserves Raw Evidence
‘Recall’ returns original text instead of a summary, and every hit identifies the producing agent, timestamp, session, and turn.
The companion ‘get’ command opens the full turn along with its surrounding context, preserving the exact reasoning path that produced a decision.
Behind the scenes, a deterministic pipeline parses each supported trace into a common turn-and-block shape.
The content is chunked, embedded with a pinned local model, and written to a local Lance dataset.
A query combines vector search and BM25, fuses the rankings, reranks candidates with a cross-encoder, reweights by recency, and attaches neighboring chunks.
That design creates three specific properties.
- One memory across agents: Claude Code, Codex, pi, and Hermes write to the same shape, and recall spans their histories while naming the source agent.
- Raw evidence stays intact: Nothing is distilled into a fact at write time, and a result can always lead back to the turn that produced it.
- Local recall by default: No account or Hub repository is required, and embedding plus reranking run on the machine rather than through a hosted model.
Memory Becomes A Dataset, Not A Service
For memory that follows a developer across hosts, the ‘add’ command can bind a remote dataset.
‘funes add codex acme/funes-memory’ publishes the current memory there and keeps it current at session boundaries.
The local record remains a Lance dataset, while the shared copy is a private dataset on the Hub that the user owns.
Credentials are redacted during indexing, and publishing scans every chunk again to withhold anything that still looks like a secret.
Remote memory caches dataset files locally, so warm queries return to local speed.
The Hub supplies ownership, access control, versioning, and distribution without turning memory into a separate API service or rented account.
Ask First, Wire Later
For a one-off question, the ‘ask’ command reads local memory or points to a shared dataset without installing an integration.
It recalls relevant passages, hands them to a coding agent, and returns a grounded answer that names its sources.
If the passages do not support an answer, the agent says so instead of concealing the gap.
The funes development team has also published a shared memory of its own build process, so users can query why the tool works the way it does without creating a personal memory first.
The underlying design leans on open-source embedding models, Lance append-only datasets with cheap incremental writes, and Hub caching and content deduplication for datasets.
The real work is in fitting those pieces into a memory layer an agent can actually use.
Why Agent-Agnostic Memory Changes The Economics Of Coding Workflows
Long investigations inflate context until each turn costs more to carry than the work itself is worth.
Most agents answer that with compaction or a written handoff, but both approaches carry hidden tradeoffs.
In a head-to-head benchmark on two tasks that could not be answered without prior session knowledge, recall was the cheapest option on both.
It came in roughly eight times cheaper than a written handoff on one task and four times cheaper on the other.
Compaction produced a split result: it arrived on one task and never arrived on the other, because its summary flattened the findings that mattered.
Recall avoids that failure mode by returning the original passages, so a key finding does not need to survive summarization.
The agent-agnostic design matters beyond personal convenience.
When memory is a dataset rather than a service, the switching cost between Claude Code, Codex, pi, and Hermes collapses.
A decision made in Claude Code can be recalled in Codex on a different machine without copying conversation transcripts.
New team members can query months of rationale on day one, including failed approaches that never reached a pull request.
Open-source maintainers can publish queryable memory alongside a release, creating a searchable record of why a project evolved the way it did.
That dynamic shifts memory from an individual productivity hack to durable infrastructure for teams and public projects.
Ending The Zero-Context Restart
The release of funes changes the default: an agent no longer has to greet a project as a stranger because the reasoning record is already queryable. For teams building AI-native development tooling that needs to scale, programmatic SEO and AI automation is how Andres SEO Expert approaches agent workflow strategy — talk to us about making your technical content findable.
Frequently Asked Questions
What is Funes and which coding agents does it support?
Funes is a local binary from Hugging Face that creates a shared, indexed memory layer for coding agents. It works with Claude Code, Codex, pi, and Hermes, allowing them to recall previous sessions with a single command like ‘funes add claude’.
How does Funes index agent session logs?
Funes uses a deterministic pipeline that parses supported traces into a common turn-and-block shape, chunks content, embeds it with a pinned local model, and writes to a local Lance dataset. Queries combine vector search and BM25, rerank with a cross-encoder, and reweight by recency.
Does Funes preserve raw evidence or summarize it?
Funes returns original text rather than summaries. Each hit identifies the source agent, timestamp, session, and turn. The ‘get’ tool opens the full turn with surrounding context, preserving the exact reasoning path behind a decision.
How can memory follow a developer across machines?
The ‘funes add’ command can bind a remote private dataset on the Hub, such as ‘funes add codex acme/funes-memory’. The local Lance dataset stays primary, while the Hub copy is synced at session boundaries and cached locally for fast queries.
How does Funes compare to written handoffs or compaction in cost?
In a head-to-head benchmark, recall was roughly eight times cheaper than a written handoff on one task and four times cheaper on another. Compaction failed to arrive on one task because its summary flattened key findings, while Funes returned original passages.
What are the benefits of agent-agnostic memory for teams?
Memory becomes a dataset rather than a service, lowering switching costs between agents. New team members can query months of rationale and failed approaches on day one, and maintainers can publish queryable memory with releases, creating durable infrastructure.
