funes Agent Memory

Turn your past agent sessions into durable, searchable memory you can publish.

Stars
★ 570
Last updated
2d ago
License
Apache-2.0
Primary language
Rust

At a glance

How it runs
CLIMCP serverAgent plugin / skill
Works with
Universal · cross-platformCodex · Claude Code
Cost
Free, no paid service needed
Setup effort
Low · running in minutes
You'll need
Rust toolchain (build from source)protoc (build from source)glibc >= 2.35Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
A developer starts a refactor in Claude Code, resumes it a week later in Codex, and needs recall to surface why the original approach was chosen.
Not a fit if
  • Teams that must stay fully offline and never touch the Hub
  • Environments unwilling to run local embedding and reranking models
  • Single-agent users who never need to share memory across tools
Source review
68/100 · Some gaps

What does this agent do, and when should you use it?

funes is a Rust CLI from Hugging Face that gives AI coding agents a durable memory of earlier work. It indexes sessions from Claude Code, Codex, pi and Hermes into one local Lance dataset embedded with a pinned local model, then answers recall queries by fusing vector search with BM25 and reranking a pool several times larger than the hits. Because every hit is tagged with the agent it came from, you can switch tools mid-project and still recall the whole history, not just one agent's slice. The memory itself is a Hugging Face dataset: private by default, publishable to a repo you own, and readable by a teammate, another machine, or anyone if you make it public. Installing it in an agent is one command, after which recall and get appear as tools and hooks keep the index current every turn and publish at session boundaries. The raw text is retained in every row, so the memory is a disposable derived artifact you can rebuild when the embedding model changes.

funes runs one deterministic pipeline with two halves. On the index side, each agent integration converts that agent's transcripts (including subagent files such as .../subagents/agent-*.jsonl) into a shared turn/block shape, which is chunked, written to a local Lance dataset, and embedded by a pinned local model. On the query side, recall fuses vector and BM25 retrieval and reranks a candidate pool several times the number of hits; get reassembles any cited turn in full, while sessions, sketch and scan let you browse a memory by session, digest one, or find a literal inside it. ask borrows Claude or Codex to answer one question grounded in a memory, naming the sessions it drew on, with nothing installed. add wires recall and get into your agent as tools and, for Claude, Codex and Hermes, builds a first index, installs a per-turn hook, and publishes at each session boundary when a memory is bound. push redacts credentials at index time and a separate always-on gate refuses any chunk that still contains a secret. mcp exposes the memory to generic MCP clients.

  1. A developer starts a refactor in Claude Code, resumes it a week later in Codex, and needs recall to surface why the original approach was chosen.
  2. A team publishes its funes memory to a Hugging Face dataset repo so a new hire can search past decisions and dead ends from a fresh clone.
  3. Someone debugging an outage wants to know where a specific error string appeared before, and uses funes scan across historical sessions.
  4. Without installing anything, a reviewer asks a question against a public memory by borrowing an agent with funes ask claude ... --memory and gets an answer that names its sources.
  5. A team exposes funes mcp to a bespoke or third-party MCP client so non-Claude/Codex agents share the same cross-session memory.
  6. An integration author converts a homegrown agent's transcripts into funes turns files so its sessions join the same searchable memory.

How do you install or deploy this agent?

The documented install path is the installer script, which detects your platform, downloads the matching prebuilt binary, verifies its tagged release checksum and version, and puts it on your PATH (~/.local/bin by default):

curl -fsSL "https://huggingface.co/buckets/huggingface/funes/resolve/install.sh?src=readme" | sh

Tagged binaries can also be fetched directly from the release bucket (funes-x86_64-linux, funes-aarch64-linux, funes-arm64-apple-darwin) and checked against SHA256SUMS. An existing install is replaced in place with funes update (--force reinstalls the current build).

Building from source needs a Rust toolchain and protoc, since lance's build scripts compile protobuf at build time (the finished binary does not need it):

# Debian/Ubuntu
sudo apt-get install -y protobuf-compiler
# macOS
brew install protobuf
cargo build --release   # binary at target/release/funes
cargo test              # runs the suite

The default build embeds and reranks on a built-in backend (Accelerate on macOS, pure Rust on Linux), so it needs no ML runtime and runs on any glibc >= 2.35 (Ubuntu 22.04). An ONNX Runtime backend is available as an opt-in variant:

cargo build --release --no-default-features --features onnx

How do you use this agent?

After installing, add funes to your agent — this registers the tools, builds your first index, and installs the per-turn hook:

funes add claude    # or codex, pi, hermes

funes status tells you whether recall is reading your own memory yet. Bind a host to a memory so every agent recalls from it and keeps it current:

funes bind <user|org>/funes-memory

Without binding, you can operate on memories directly:

funes push <user|org>/funes-memory                    # publish your local memory's new chunks
funes recall "..." --memory <user|org>/funes-memory   # read any remote memory for one call

Try a public memory with nothing installed:

funes recall "why is funes append-only" --memory huggingface/funes-memory
funes ask claude "why is funes append-only" --memory huggingface/funes-memory

Build, update or shrink a memory as needed:

funes index [path]
funes compact [memory]

Telemetry is an anonymous install UUID kept in ~/.funes/install-id and sent only to the Hub; set DO_NOT_TRACK=1 or FUNES_NO_TELEMETRY=1 to omit it.

What are this agent's strengths and limitations?

Pros
  • One memory spans Claude Code, Codex, pi and Hermes, so switching agents loses nothing and every hit shows which agent it came from.
  • The memory is itself a Hugging Face dataset: push it to the Hub for teammates or other machines, or read someone else's published memory with a single flag.
  • Retrieval is more than a vector store: fused vector + BM25 search with reranking over a pool several times the hits, using pinned local embedding and reranking models.
  • Publishing is guarded twice — credential redaction at index time plus an always-on gate that refuses chunks still containing a secret — and funes-created datasets are private by default.
  • The pipeline is deterministic and the raw text is retained in every row, so a memory can be rebuilt from transcripts when you change embedding models.
Limitations
  • The default install and update path depends on the network: the script and funes update download binaries and checksums from Hugging Face, and since both live in the same bucket the checksum does not authenticate the bucket itself.
  • A memory holds exactly one embedding model's vectors; funes refuses to push another model's vectors into it, so changing the model means rebuilding the whole memory from transcripts.
  • Building from source requires a Rust toolchain and protoc, and the prebuilt binaries need glibc >= 2.35, which rules out older distributions.
  • It ships no generative model of its own, so funes ask still borrows Claude or Codex and the answer quality depends on whichever agent you borrow.
  • Native indexing covers only Claude Code, Codex, pi and Hermes; any other agent needs a community integration or a funes JSONL / .parquet trace export.

How does this agent compare with similar options?

The README says docs/RATIONALE.md compares funes to other memory tools, but it names no specific alternatives, so no concrete comparison is given here.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
funes Agent Memory This agent 68 · Some gaps CLIFree ★ 570 2d ago Rust Codex · Claude Code
myc Local Agent Memory 87 · Good CLIFree ★ 14 today TypeScript Codex · Claude Code
ECC Engineering Harness 66 · Some gaps Agent plugin / skillFreemium ★ 283k 3d ago JavaScript Codex · Claude Code
Caura 70 · Some gaps Self-hosted serviceFreemium ★ 502 today Python Codex · Claude Code · Claude.ai

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
68/ 100 5-point scale 3.4 / 5
Trust 21/29
Reliability 8/14
Adaptability 14/18
Convention 13/18
Effectiveness 7/13
Verifiability 5/8
Why each dimension lost points
Trust21 / 29 · 3.6/5

Trust is generally strong but with deductions. least_privilege: README and SECURITY.md state everything runs locally by default and nothing leaves the machine unless you run push or bind a shared memory, and recommend fine-grained tokens (write only for pushing machines, read-only elsewhere); however the installer is a curl | sh remote script and the updater replaces the binary in place, so the privilege boundary is not minimal — 2. user_confirmation: there is an always-on secret gate before push, datasets are private by default, and directory installs ask for trust once, but hooks bound to a memory push automatically at session boundaries, an ongoing implicit egress — 2. data_flow_transparency: README discloses the User-Agent carrying version and an anonymous install id stored at ~/.funes/install-id, that it derives from nothing and can be disabled via DO_NOT_TRACK/FUNES_NO_TELEMETRY; SECURITY.md explains remote recall caches locally and the Hub only stores — 3. sensitive_data_handling: three layers (index-time redaction, fail-closed trufflehog gate at publish, funes scrub) plus a documented rotation and rebuild procedure after a leak — 3. dependency_security: Cargo.toml pins lance/lance-io/lance-index to =11.0.0 and object_store to =0.13.2 with a comment about the IVF scratch-dir leak in 11/12, and CI pins third-party actions by commit, but the dependency surface is large with no audit or SBOM evidence — 2. external_effects: push creates/writes Hub dataset repos and update replaces the binary and refreshes integrations; private-by-default and gating help, but no explicit second confirmation for update/push is shown — 2. rollback: README notes the memory is a disposable derived artifact that can be rebuilt and update --force reinstalls, but there is no documented way to unpublish a remote memory, roll back a version, or revert the binary — 1. source_attribution: recall hits name which agent and session they came from and ask names its sources, but publisher identity is unverified and the LICENSE copyright line (2026 The HuggingFace Team) needs independent checking against the repo owner — 2.

Reliability8 / 14 · 2.9/5

self_consistency: README command table, docs links, Cargo.toml examples, and CI workflows are mutually consistent, and version 1.9.0+dev matches the update/status description, but many referenced docs/*.md and scripts/install.sh are not provided, so full cross-checking is impossible — 2. dependency_availability: Cargo.toml lists dependencies and optional features clearly, and README states the Rust toolchain plus protoc requirement, no ML runtime dependency for the default backend, and a glibc >= 2.35 floor; however hf-hub is pinned to a 1.0.0-rc.1 pre-release and first run downloads ~1.2 GB of weights — 2. failure_messages: CI and SECURITY.md mention the gate failing closed and exiting non-zero, but the repository material shows no user-facing error message design, diagnostic output examples, or troubleshooting section — 1.

Adaptability14 / 18 · 3.9/5

audience_and_scenarios: README targets developers using Claude Code, Codex, pi, and Hermes and covers cross-agent memory, cross-machine sharing, team collaboration, and trying a public memory, with concrete scenarios — 3. capability_boundaries: README states funes has no generative model of its own, only embeds and reranks, that a memory is bound to one embedding model and refuses vectors from another, and that changing it requires a rebuild; boundaries are clear but unsupported capabilities and failure modes are not systematically listed — 2. trigger_precision: docs describe recall/get as tools the model invokes on its own, per-turn indexing hooks, and session-boundary publishing, which is fairly precise, but there is no discussion of false triggers, duplicate triggers, or rate limits — 2. environment_fit: README lists prebuilt binaries for Linux x86_64/aarch64 and macOS Apple Silicon with a glibc floor, which is specific, but Windows, other architectures, and container environments are not covered — 2.

Convention13 / 18 · 3.6/5

information_architecture: README is well structured with feature overview, install, command table, how it works, building from source, notes, and license, plus a docs index link — 3. install_notes: README gives curl install, funes add, funes update, and source-build instructions including protoc, and explains checksum verification and its limitation — 3. naming_stability: command names (add/bind/remove/index/recall/get/push/update) and config paths (~/.funes) are consistent across README and CI, but Cargo.toml comments reveal a workdir rename and schema migration scripts, indicating past naming/structure churn — 2. examples_and_faq: README provides several command examples and GIF demos, but there is no dedicated FAQ and examples are mostly one-liners rather than full end-to-end walkthroughs — 2. known_limitations: README Notes cover single-embedding-model binding, rebuild-to-change, and subagent transcripts being indexed, and SECURITY.md covers untrusted remote memories and prompt injection, but performance, scale, and platform limits are not consolidated — 2. license: a full Apache-2.0 LICENSE file is present and Cargo.toml declares license = "Apache-2.0", matching the metadata — 3. versioning_changelog: Cargo.toml shows 1.9.0+dev and README mentions funes update and status checking for newer releases, but there is no CHANGELOG file or version history in the provided material — 1. maintenance_responsibility: SECURITY.md gives [email protected] and Huntr as disclosure channels and CI/nightly workflows indicate ongoing maintenance, but publisher identity is unverified and there is no maintainer list or support commitment — 1.

Effectiveness7 / 13 · 2.7/5

output_usability: recall prints ranked passages, get reassembles a cited turn in full, and ask returns a grounded answer naming sources, which is usable for agent consumption, but README explicitly says output is shaped for agents rather than people, so direct human use requires ask — 2. marginal_value: unified cross-agent memory, publishable Hub datasets, local embedding and reranking, and a secret gate differentiate it from generic memory tools, but the space is crowded and value depends heavily on the user already having substantial session history — 2. cost_benefit: ~1.2 GB of model weights, continuous per-turn indexing and reranking compute, and a heavy lance/arrow dependency stack make the benefit-to-cost ratio unremarkable for light usage — 1.

Verifiability5 / 8 · 3.1/5

claim_traceability: key README claims about redaction, the gate, the anonymous install id, and checksum verification point to specific files or commands (SECURITY.md, Cargo.toml, scripts/install.sh), which is good, but some claims (e.g., the model spontaneously calling recall) rest only on GIF demos and cannot be statically verified — 2. cross_source_corroboration: README, SECURITY.md, Cargo.toml, and CI workflows corroborate each other on trufflehog version, model names, platform matrix, and DO_NOT_TRACK, but docs/*.md and scripts/install.sh are absent, preventing full cross-checking — 2. fact_inference_separation: README separates design intent from factual description and SECURITY.md clearly states the gate stops future rows but cannot unpublish, so the boundary is reasonably clear, though some performance and effectiveness statements lack quantitative support — 2.

Risks and how to mitigate them
  • Install and update run a remote script via curl | sh and replace the binary in place; the checksum and binary share the same bucket, so the bucket itself is not authenticated — verify the release source and checksum independently.
  • Once a memory is bound, hooks push automatically at session boundaries, an ongoing implicit egress; confirm dataset repo visibility before pushing and prefer fine-grained tokens.
  • Recalled remote memory is inserted into the agent context and is untrusted input with prompt-injection risk; bind only trusted memories and prefer the per-call recall --memory form for third-party memories.
  • The secret gate only stops future rows and cannot unpublish; on a leak, rotate credentials immediately and delete/recreate the dataset repo.
  • Publisher identity is unverified and the LICENSE copyright line reads 2026 The HuggingFace Team; verify repository ownership and maintenance responsibility yourself.
  • First run downloads roughly 1.2 GB of model weights, and per-turn indexing and reranking add continuous compute cost; assess resource impact.
  • The repository material provides no CHANGELOG, docs/*.md, or scripts/install.sh, so some claims could not be verified in this static review.
Evidence confidence: Low Reviewed Oct 15, 2026 Reviewed revision b16a192188cf New commits since this review; the score may not cover them
See the full review method →

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. v1.9.0 v1.9.0: GPU indexing and host binding
    Release notes excerpt
    What's Changed The main changes are indexing on the GPU in https://github.com/huggingface/funes/pull/225 and the host binding in https://github.com/huggingface/funes/pull/239. - On macOS 15 or later, funes index embeds on the GPU through Metal, and falls back to the CPU where no GPU starts. Recall queries stay on the CPU. - funes bind <memory> binds this host to a memory: every installed agent recalls from it and publishes to it. funes bind local unbinds. - funes add <agent> <memory> binds the host first. A bare funes add <agent> installs on the host's memory. …
    View on GitHub ↗
  2. v1.8.0 v1.8.0: multinlingual embedder
    Release notes excerpt
    What's Changed The main change is the addition of a multilingual embedder in https://github.com/huggingface/funes/pull/221. - The first funes add asks whether your sessions are English or multilingual. The default is multilingual when your locale (LC_ALL, LC_MESSAGES, then LANG) is in another language than English. Off a terminal, funes takes that default without asking. - funes index --multilingual creates a multilingual local memory by hand, before anything is indexed. …
    View on GitHub ↗
  3. v1.7.0 v1.7.0: Memories compaction
    Release notes excerpt
    Memories compact themselves Every write to a memory adds fragments, and a memory written turn by turn piles up thousands of them. Recall slows down as they accumulate, and a remote memory heads for the Hub's limit of 10k files per folder. funes now compacts a memory: it merges the small fragments, adds their rows to the search indexes, and deletes the old versions. - funes index compacts the local memory at the end of each run that writes, and deletes the versions older than ten minutes. Past 256 small indexed fragments, it rewrites them all. …
    View on GitHub ↗

FAQ

Does using funes cost anything?
funes is free and Apache-2.0 licensed, and embedding plus reranking run on built-in local models, so no API spend is involved. Cost only appears if you use funes ask, which borrows Claude, Codex or another agent and is billed by that agent.
Does my session data leave my machine?
Indexing and recall are local; the memory is a local Lance dataset. Data reaches Hugging Face only when you run push against a dataset repo you specify, and funes-created repos are private by default. Its Hub requests carry a random install UUID used solely for install counting, which you can suppress with DO_NOT_TRACK=1 or FUNES_NO_TELEMETRY=1.
Why does changing the embedding model require rebuilding the memory?
Each memory names its embedding model and funes embeds a query with the model of the memory it searches, so it refuses to push another model's vectors into it. Because the memory is a disposable derived artifact with the raw text kept in every row, you just re-index from the transcripts. This is separate from the model you reason with, which is free to change.
Can I use it with an agent that has no native integration?
Yes. Another agent can join by writing its sessions as funes JSONL turns files or through a compatible .parquet trace export, since the indexing and query pipeline already reads that format. You can also publish your own integration and install it with funes add <id> --from ….
How safe is publishing a memory?
There are two layers: funes redacts credentials at index time, and a separate always-on gate refuses to push any chunk that still contains a secret. Repositories funes creates are private by default, and making one public is a deliberate change on the Hub.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents