Give Your Coding Agents a Memory You Own

The Background: Why Do Coding Agents Keep Forgetting?

Imagine you work on the same project using different coding agents across multiple machines. Last Tuesday, Claude Code helped you refactor a streaming parser. This Wednesday, you switch to Codex to continue development, and it has no idea about the previous decisions. You have to explain everything from scratch. This is not an isolated case; it is the common pain point of current coding agents. Every new session starts as a stranger to your codebase, and past reasoning disappears when the session ends.

Core Breakdown: What Does funes Actually Do?

Earlier this year, insights emerged that coding agents already leave behind detailed traces as they search codebases, experiment, encounter errors, consult documentation, and pivot. These traces capture not only what changed, but why. The problem is that session logs remain static archives. You cannot grep through ten thousand conversation turns to find why the team moved away from a streaming parser.

funes solves exactly this. It is a single-binary tool that provides a persistent memory layer for mainstream coding agents like Claude Code, Codex, pi, and Hermes. With one command, funes add claude, it builds an initial index, injects recall and get tools into the agent, and sets up incremental indexing. New conversation turns are appended continuously without re-embedding the entire history.

When a task relates to past decisions or findings, the agent automatically calls the recall tool. It returns original text rather than summaries, with precise provenance: which agent, what timestamp, which session, and which turn. Each result includes a get command to open the full conversation turn and its surrounding context.

Under the hood, funes uses a deterministic pipeline to parse diverse session traces into a unified turn-and-block structure. After chunking, it embeds them using a pinned local model and writes to a local Lance dataset. Queries combine vector search and BM25 retrieval, fuse rankings, rerank with a cross-encoder, apply recency weighting, and attach neighboring chunks. This architecture delivers three key properties: unified memory across agents, intact raw evidence, and default local execution for privacy.

Trend Insight: Memory Is Becoming Agent Infrastructure

This reveals a deeper trend: an agent's value depends less on raw model reasoning and more on the context it can access. When memory shifts from cloud services to local datasets, developers regain control over agent history. Memory is no longer a platform feature; it is a portable, synchronizable, versionable data asset.

Practical Value: What This Means for Developers

If you frequently switch machines or agent frameworks, funes significantly reduces repetitive communication overhead. All embedding and reranking run locally, eliminating code privacy concerns. More importantly, memory exists as a dataset. You can bind your own Hugging Face repository for cross-device sync, defaulting to private publishing, giving you complete data sovereignty.

Counterintuitive Perspective

Most assume agent memory requires complex cloud services or specialized databases, but funes proves a lightweight local approach works equally well. It needs no ML runtime; embedding and reranking run entirely on your machine, while the coding agent handles only reasoning. This design signals that agent infrastructure is evolving toward minimalism, localization, and composability. You might think memory is a built-in agent capability, but it should actually be an independent, pluggable data layer.