Explain how an importance gate prevents noise accumulation in persistent agent memories.

An agent that saves everything it hears fills up fast. Within a week its store holds "The deployment region is Dublin." three times, a reworded copy twice, a dozen "ok, thanks" and the JSON of every tool call. Ask where you deploy, and copies of one fact take the top results. Nothing was retrieved wrongly. The store accepted writes it should have refused.

The short answer: an importance gate is a test on the write path that decides whether an incoming write is stored at all, so noise is refused before it can pile up and crowd later reads. It prevents only the noise its test can see. A sameness test refuses repeats, a written list refuses the noise it names, a model's judgement against criteria you write refuses chatter at the cost of inference, and declared types refuse what falls outside your schema. The name does not tell you which of these you have.

A gate decides storage, not ranking

A write gate is a decision on the write path about whether an incoming write is stored at all. It does not rank memories at read time. Two distinctions matter:

• Refusing a write is not filtering what is extracted from it. A product can drop an extracted entity and still keep the text it came from.
• The name does not fix the test. Mnemoverse (the author's company) defines the write response field stored in its API reference as "True if the atom passed the importance gate", and that gate scores novelty against the nearest memory in the same domain. Mem0's OpenClaw integration describes "a structured protocol with importance gates and domain overlays": in its triage protocol the agent judges every candidate fact against four gates, and Gate 2, NOVELTY, checks it against memories already recalled. One phrase, two tests.

Match the test to the noise

The noise you have	A test that matches it	What it costs
The same text twice	A hash of the content, or a novelty comparison	A lookup, or a comparison with nearby memories
The same fact reworded	A similarity or novelty comparison with stored memories	An embedding of the write and a search of nearby memories
Chatter you can name	A written list of patterns	A list to maintain
Chatter you cannot name	A model's judgement against criteria you write	Model inference, and the occasional miss
Anything outside your schema	Declared types	A schema to maintain; only what you declared is caught

A sameness test asks the wrong question about chatter: a new "ok, thanks" restates nothing stored, so it passes. Named junk is a list. Unnamed junk is a model, and you pay for the call, including the miss.

What six products test on the write path

Each row is a named, documented path as the vendor's own page states it, not every path a product has. Nothing here is a measurement.

Product and path	What the test asks	What a refused write becomes
Mem0: add path, OpenClaw triage	Is the fact already stored? In the plugin: does it pass all four triage gates?	A recognised duplicate is not stored again; triage writes nothing; a message matching a noise pattern is dropped
Cognee: session distillation, folder presort	Not rated harmful, with confidence through the distillation gate? Does a writer, checking existing lessons, accept the lesson? Which scanned groups do you approve?	A rejected lesson is dropped; presort ingests only the groups you approve
Letta: Letta Code reflection pass	Lasting rather than ephemeral, not already captured, generalizable?	No change and no commit
Supermemory: LLM filter	Does new content meet your organisation's written criteria, with shouldLLMFilter set to true?	Can be filtered out of what gets indexed
Zep: episode ingestion, strict ontology	Within the size limit? Does an extracted entity match a declared type?	Oversized episode rejected, not truncated; undeclared entity dropped while the episode stays
Mnemoverse: write API	How novel is the write against the nearest memory in the same domain?	Nothing stored: stored false, a null atom_id, a reason

Mem0 checks related memories on its add path "so it can avoid storing the same fact again" (How Mem0 works). Its open source pipeline lists "Hash-based deduplication (MD5, prevents exact duplicates)" (v2 to v3 migration), and its hosted platform reaches further, per its Dream page: "most exact or near-duplicate restatements of a fact you already have are recognised and deduplicated as the memory is added". Its custom instructions add a model's judgement against criteria you write. The OpenClaw triage protocol says: "Most turns produce zero memory operations. That is correct and expected." The plugin's filtering.ts drops whole messages that match "Patterns that indicate an entire message is noise", among them acknowledgements, timestamps and tool output.

Cognee states its gate on the improve page: "Guidance is eligible only when it has not been rated harmful and its confidence passes the distillation gate." Proposed lessons then go to a writer/rejecter, which "checks them against existing lessons and graph entities". Its folder presort "reports what is junk, duplicated, versioned, personal, or already in cognee, and then ingests the groups you approve", so the refusal comes back as a report. Its add operation says "Cognee uses content hashes to avoid duplicates".

Letta puts the decision with the agent: "Your agent updates memory when it learns something durable" (memory page). The reflection prompt that Letta Code ships includes an already-captured check, "If memory or skills already contain this information adequately, skip it.", an instruction to a model rather than a threshold in code.

Supermemory takes a filter prompt you write (customization): "Tell Supermemory what content matters during ingestion. This helps filter and prioritize what gets indexed." Its graph memory page lists noise filtering under automatic forgetting, as a tendency: "casual, non-meaningful chatter is less likely to become durable memory".

Zep shows the difference between filtering extraction and refusing a write. With strict ontology on, an entity that does not match a declared type is dropped, while "the raw source material remains searchable and retrievable" (how graph creation works). Its ingestion guide adds a sameness test on extraction, "When Zep extracts entities from episodes, it deduplicates them primarily by name.", and a hard refusal on size: "Zep rejects an episode larger than 10,000 characters rather than truncating it".

Mnemoverse says what its gate does on its getting started page: "The write gate compares each write with the nearest existing memory in the same domain and refuses only a write the embedder cannot tell apart from one already stored: stored is then false. The number in importance is that novelty score; the gate does not judge how important or how true a memory is." A refused write has no id: the API reference defines atom_id as "UUID of the stored atom, or null if filtered" and reason as "Why stored or filtered". So the field called importance is a novelty score, and this gate belongs to the sameness family: it stops a domain from filling with copies the embedder cannot tell apart, and it does not judge whether a new line is worth keeping. Chatter that differs from everything stored has to be kept out by what the agent chooses to write, or by a list or a model in front of the write.

Check it with a control

Four writes in a fresh domain, with mnemoverse 0.4.0:

from mnemoverse import MnemoClient

client = MnemoClient()  # reads MNEMOVERSE_API_KEY

writes = [
    "The deployment region is Dublin.",
    "The deployment region is Dublin.",             # identical
    "Deployments run in the Dublin region.",        # reworded
    "The staging database is backed up nightly.",   # control: a new fact
]
for text in writes:
    r = client.write(text, domain="project:gate-check")
    print(r.stored, r.atom_id, round(r.importance, 2), r.reason, "|", text)

The identical sentence is the case the docs describe as refused: expect stored False, no id and a reason. Record the reworded line rather than assume it. The last write is the control: a new fact has to come back stored; if it is refused, the check is broken.

Then write a correction phrased like the fact it corrects, "The deployment region is now Frankfurt.", because a sameness test has to tell a correction from a restatement; on Mnemoverse the correction can name what it replaces with supersedes. Run the same cases on any store and insist on a reason for each refusal: a silent filter is a write path you cannot debug.

The library page has the full comparison with every source and carries the film that goes with it. Which noise does your store keep that its gate was never built to see?