Synapse Brings Graphiti + FalkorDB to Hermes Agent - Salience-Based Decay Over the Endless MEMORY.md

witcheer flagged a new community-built memory provider for Hermes Agent on June 28: Synapse. The pitch is one line. Memory that forgets by design. Instead of MEMORY.md growing endlessly, low-salience facts decay while key details remain. The post drew 90 likes and 24 retweets in 24 hours.[^1] The deeper technical detail came from Max Petrusenko three hours later: it uses a temporal knowledge graph (Graphiti + FalkorDB, self-hosted via Docker) that tracks when facts were created and how relevant they still are.[^2]

This is a different shape than the eight memory providers Hermes ships with out of the box (Honcho, OpenViking, Mem0, Hindsight, Holographic, RetainDB, Byterover, Supermemory, Memori).[^3] Those providers store facts and retrieve by semantic similarity. Synapse adds a temporal dimension and a salience decay function, so the same query a year from now returns a different answer than today.

The pitch: memory that forgets

MEMORY.md is a flat markdown file. Every fact the agent considers important gets appended. After six months of use, it contains duplicate entries, stale preferences, and project-specific facts from long-finished work. Hermes's retrieval layer ranks by recency and keyword, not by whether the fact is still useful.

Synapse replaces the flat file with a graph. Each fact is a typed edge between two nodes (people, projects, tools, concepts), tagged with a valid_from timestamp and an explicit valid_to. The graph engine is FalkorDB, a Redis-compatible graph database with vector search, run in Docker alongside Hermes. The framework on top is Graphiti, Zep's open-source temporal knowledge graph engine.

The combination is what makes it different from the other Graphiti-based plugin for Hermes (p1s4/hermes-graphiti-plugin, 14 stars, last updated May 27). That plugin uses Graphiti over Neo4j and stores facts with timestamps. Synapse adds a salience decay function and runs on FalkorDB's lighter footprint, which suits self-hosted personal use.

What Graphiti actually does

Graphiti is not a vector store. It is a temporal context graph engine: every piece of information is an episode, episodes are processed into entity nodes and relationship edges, and edges carry valid_from / valid_to timestamps so the graph can answer "what did we know as of date X" and "what is the current truth about entity Y."[^4]

The retrieval layer combines three signals:

• Semantic similarity (vector embeddings)
• BM25 keyword search
• Graph traversal from the most relevant node

Results are merged with reciprocal rank fusion. The framework handles entity resolution automatically ("Ryan", "Ryan U.", and "Ryan Underdown" collapse to a single node), and it invalidates edges that contradict a newer episode. When the user says "I switched from Postgres to SQLite for the side project," the old "uses Postgres" edge gets valid_to = now and a new "uses SQLite" edge is written.

The Hermes integration is a memory provider plugin. Hermes ships a MemoryProvider interface with hooks for prefetch() (run before each turn), sync_turn() (run after each turn), on_session_end(), and on_memory_write(). The plugin implements those hooks against Graphiti, so memory operations look native to the agent loop.

Why FalkorDB instead of Neo4j

FalkorDB is the graph database built by the team that previously built Redis Graph. It runs as a single Docker container (docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest), speaks RESP, and exposes a Cypher-compatible query interface. The benchmark published by the team claims 496x faster P99 latency and 6x better memory efficiency against comparable workloads.[^5]

For a personal Hermes deployment, the practical difference is operational. Neo4j needs a JVM, has a separate memory model, and wants dedicated resources. FalkorDB runs in 256 MB of RAM, persists to disk, and starts in under a second. The Graphiti + FalkorDB pairing is a one-liner:

docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest

The agent talks to it over falkor://localhost:6379, Graphiti builds the schema on first use, and the rest is Hermes config.

Salience decay: the part that justifies the name

Flat markdown memory has no notion of "this fact is more useful than that one." A knowledge graph can score edges by how often they get retrieved, how recently they were accessed, and how central the connected nodes are. Synapse reportedly weights edges by these signals and downgrades facts that have not been relevant to any query in N days. High-salience facts (the user's name, primary stack, security posture) stay permanently. Low-salience facts (a library version mentioned once in passing) decay.

This is the inverse of what most retrieval systems do. Vector stores rank by similarity, not by salience over time. The temporal graph makes it cheap to know that a fact was last accessed three months ago and never since, and the decay function uses that signal.

The pre-existing Graphiti plugin

The Synapse announcement does not name a public repo at the time of writing, but the underlying pattern is already public. p1s4/hermes-graphiti-plugin is a working Graphiti provider for Hermes that ships a Docker Compose file with Neo4j, exposes the standard MemoryProvider hooks, and supports three search strategies (fast BM25, balanced BM25 + cosine, quality cross-encoder reranking). It is tagged beta and explicitly not actively maintained, but it is the reference implementation that Synapse builds on.

A second project, yepyhun/Brainstack, is a composite provider that combines Hindsight (continuity), Graphiti (graph truth), and MemPalace (corpus retrieval) under one memory owner. It supports embedded Kuzu as the L2 graph backend, so it can run without a separate database container, but loses the temporal edge features that drive Synapse's pitch.

The honest read: Synapse is a fresh wrapper around Graphiti + FalkorDB with a stronger framing around decay. If the repo materializes with the salience function, it is the cleanest "set it and forget it" memory story for self-hosted Hermes. If the decay function turns out to be the default Graphiti retrieval path, the differentiation is just the backend choice (FalkorDB over Neo4j).

When temporal memory is the right shape

Temporal graphs are not always the right tool. For an agent that works on a single project for a week, MEMORY.md is fine. For an agent that switches between three client repos, six side projects, and a personal infrastructure setup over the course of a year, the temporal dimension pays off. The "what did we know as of date X" query is something a flat file cannot answer, and the "this preference expired when the project ended" pruning is what keeps the long-term memory from drowning in noise.

The pitch fits exactly that use case. The implementation is small enough to self-host. And it is the first community plugin to bring Graphiti's temporal model to Hermes Agent with a self-contained Docker footprint.

[^1]: witcheer. "a Hermes community builder shipped Synapse..." X. June 28, 2026. [^2]: Max Petrusenko. "Hermes community contributor launched Synapse: memory that forgets by design..." X. June 28, 2026. [^3]: Nous Research. "Memory Providers." Hermes Agent Docs. [^4]: Zep. "graphiti." GitHub. [^5]: Zep. "Graphiti: FalkorDB support and 14K GitHub Stars." Blog. March 2025.