The feedback dilemma: your agent's memory learns most from a signal it almost never sends
TL;DR
- Explicit feedback is the strongest learning signal in Mnemoverse's reinforcement-aware memory, by design — and live agent traffic rarely sends it.
- In our August 2026 production measurements, benchmark-grown memory had 94.8% of edges touched by feedback; the live tenants we sampled ranged from 0% to 12.8%.
- The measured result is structural, not a retrieval-quality proof: feedback-grown memory was denser, less hub-dominated, and more resistant to dissolution.
- The practical lever today is not forced ratings. It is a standing instruction in
AGENTS.md,CLAUDE.md, or the system prompt that tells the agent when to report outcomes.
An AI agent with learning memory should get better the more you use it. That is the promise. In practice, the mechanism that does the heaviest lifting — explicit outcome feedback — is almost entirely absent from production traffic, at least the traffic we measured. Agents read memories constantly. They almost never report back on whether those memories helped.
Explicit feedback is an outcome report that tells a memory system whether a recalled memory helped, misled, or should be ignored after use.
This is not a bug in any one implementation. It is a structural gap between how learning memory is designed to improve and how agents actually operate. The dilemma is simple: the strongest signal is the least natural one to receive.
Benchmarks can call feedback after every query. Production agents usually do not. We measured the structural difference in one production store on 2026-08-12. The same engine produced two different shapes of memory.
Agent memory feedback is not just another event
The Mnemoverse engine's public model — a three-factor Hebbian graph with valence, decay, and an explicit feedback loop — is documented in the API overview and the Hebbian memory article. Associations strengthen through three kinds of events.
First, a write creates co-occurrence evidence. Storing a memory links the concepts that appear in it. There is no outcome yet at write time.
Second, a read creates weak co-activation between the query and what it retrieved. The read signal is deliberately faint — an exploration signal, damped so that mere retrieval does not entrench itself.
Third, feedback reports outcome. The feedback endpoint accepts a float from -1.0 to +1.0 through POST /memory/feedback, described in the API reference as "Report outcome (success/failure) for memories. Updates valence and Hebbian associations." Feedback is the strongest reinforcement channel by design: it is the only channel that carries an outcome, and the outcome gates how much associations strengthen. Positive outcome amplifies. Negative outcome suppresses.
Three-factor learning is a learning frame in which co-activity is not enough; a third factor such as reward, surprise, or outcome gates durable change.
That frame comes from neuroscience, but here it is an engineering rule, not a biological-fidelity claim. Frémaux and Gerstner describe three-factor learning rules in Frontiers in Neural Circuits (DOI:10.3389/fncir.2015.00085); Gerstner and colleagues review the experimental support in 2018 (DOI:10.3389/fncir.2018.00053).
One property makes the production analysis possible: only feedback carries an outcome, and the recorded outcome polarity — an edge's valence — is not erased when weights decay. So a nonzero valence is a durable per-edge fingerprint: explicit feedback touched this edge.
Production measurements: benchmark memory and live memory diverged
Our August 2026 production measurement covered one engine, one production store, 359,388 concept-graph edges, and 65 tenants with at least 100 concepts. The tenant classes were one benchmark tenant, one mixed account, one bulk-ingest tenant, 57 live tenants, and 5 shared rooms.
The benchmark tenant came from benchmark ingest and query campaigns. Our benchmark harness calls the feedback endpoint between queries by design: it is a feature of the algorithm, kept enabled in comparisons, and stated here rather than left implicit. The important point is regime difference: benchmark traffic exercised memory in a near-supervised setting, while live traffic mostly did not.
The structural contrast was visible at the class median level:
| Metric, August 2026 production measurement | Benchmark | Live tenants, n=57 |
|---|---|---|
| Edges per concept | 22.0 | 7.5 |
| Hub share, top concept degree / edges | 0.004 | 0.033 |
| Largest-component share after cutting edges below tenant p90 weight | 0.539 | 0.107 |
Benchmark-grown memory was about three times denser by edges per concept. It was also much less hub-dominated and about five times more resistant to dissolution when weak edges were cut. Live memories were heterogeneous; raw largest-component share ranged from 0.115 to 1.0.
This is not a claim that benchmarks are useless. It is a claim that a benchmark can exercise a memory system in a feedback-rich regime that production agents rarely reproduce.
The mixed account made the attribution sharper. The largest live-looking tenant turned out to include a benchmark campaign: 71.4% of its 60,872 edges were born on one day, during 3,566 reads and 3,550 feedback calls. Removing the edges born in that four-day benchmark window cut the account's edge count by 73.1%. Edges per concept moved from 15.64 to 7.89, and percolation p90 moved from 0.363 to 0.057. Those values landed inside the live distribution, whose medians were 7.53 and 0.107.
The dose-response pattern followed the same direction: benchmark 0.539, mixed 0.363, ingest-only 0.154, live 0.107 for percolation p90.
Methodology. One production store, measured in two passes (2026-08-10 and 2026-08-12; 358,130 and 359,388 concept-graph edges), 65 tenants with at least 100 concepts each. A tenant's class comes from its activity history (benchmark campaigns, bulk ingest, organic use), not from its id alone. A "feedback-touched edge" is an edge with nonzero valence; valence changes only on the feedback path and is never decayed. "Percolation p90" is the share of a tenant's concepts remaining in the largest connected component after removing edges below that tenant's own 90th-percentile weight. The valence fingerprint covers the profiled tenants in the table below, not all 57 live tenants. Tenant identifiers are pseudonymous.
The valence fingerprint shows where durable weight came from
Because valence only moves on feedback, it separates feedback-touched edges from untouched edges after the fact.
| Tenant class, August 2026 production measurement | Edges touched by feedback | Weight p90, touched | Weight p90, untouched |
|---|---|---|---|
| Benchmark | 94.8% | 0.261 | 0.002 |
| Mixed account | 66.1% | 0.295 | 0.016 |
| Live tenant that uses feedback | 12.8% | 0.085 | 0.000 |
| Read-heavy live | 0.6% | — | 0.015 |
| Large live / bulk-ingest | 0.0% | — | — |
On the benchmark tenant, touched edges had p90 weight 0.261 against 0.002 for untouched — more than a 100-fold difference. On that tenant the touched edges were also the overwhelming majority, 94.8%, so the heavy edges and the feedback-touched edges were nearly the same set.
Reinforcement counts told the same story. The benchmark median edge was reinforced 10 times, uniformly. The live median edge was reinforced once, with a Zipfian tail: p99 reached 980 and the maximum reached 4,919 on hot topics. One read-heavy live tenant, with almost no feedback (0.6% of its edges touched), grew large counts but not durable weights. Reads explored. They did not consolidate.
An ingest-only control reinforced the point. A tenant with 2,112 writes in a day and almost no reads built edges from concept co-occurrence, but not durable weights: reinforcement median 1, weights near zero, percolation p90 0.154. An earlier one-day ingest test produced 222 edges from 590 memories. Bulk import alone does not produce a learned graph.
The measured claim stops there. We measured structural difference. We did not measure whether more feedback causally improves retrieval quality for live users. "Agents that give feedback get structurally stronger memory" is a hypothesis, not a finished quality result.
AI memory vendors expose feedback, then retreat from ratings
Feedback scarcity is not specific to one engine. Hu, Koren, and Volinsky framed the asymmetry for recommender systems in 2008: implicit signals are abundant, explicit ratings are scarce (DOI:10.1109/ICDM.2008.22). Nielsen's participation inequality essay describes the "90-9-1" shape of online contribution (NN/g, 2006). Christiano and colleagues built deep RL from human preferences around the cost of human feedback (arXiv:1706.03741); Ouyang and colleagues showed a model tuned on curated human preference data being preferred over a far larger untuned one (arXiv:2203.02155).
Agent-memory vendors show the same tension in product shape, based on documentation observed on 2026-08-12. Mem0 documents a per-memory feedback API (POSITIVE, NEGATIVE, VERY_NEGATIVE plus an optional reason) and advises customers to track their own "feedback completion rates" — while publishing none (API reference; feature page). Zep's fact ratings were assigned automatically against developer-supplied instructions, never by end users — and Zep listed them in its February 2026 deprecation wave (facts docs; deprecation page). Letta exposes feedback on agent steps, not memories (steps feedback). LangMem documents no memory feedback or rating API; its feedback surface belongs to prompt optimization (LangMem). ChatGPT memory offers remember, forget, and delete, not grading (OpenAI memory FAQ). Anthropic's memory tool gives the model six file-like commands and no rating command (memory tool docs).
Across those documented surfaces, no vendor publishes data on how often feedback channels are actually used. The pattern is not that vendors ship feedback channels and users ignore them. On the surfaces we can check, explicit memory ratings are not becoming standard: the strongest learning signal has no published usage data, and at least one vendor is deprecating its rating mechanism.
Community evidence points at what silent failure looks like when no quality signal exists. A production audit in Mem0's tracker reported that 97.8% of 10,134 memory entries were junk (issue #4573); a separate feature request argues users lack structured ways to measure memory behavior (issue #5235).
The feedback dilemma: force, ask, or prescribe
There are three obvious ways to get more feedback. Two are weaker than they look.
Option 1: force feedback
You can gate reads on a feedback call. That makes the metric look complete. It also changes the meaning of the signal: the value of explicit feedback comes from the agent or user deciding an outcome was worth reporting. Coerced ratings can degrade toward noise, and every read gains a round trip. Recommender systems moved toward implicit feedback partly because explicit ratings are sparse and costly, as the Hu-Koren-Volinsky and Nielsen sources above show.
For a learning memory engine, forced completion can protect a dashboard while damaging the label.
Option 2: ask for feedback
You can add UX prompts: thumbs up, thumbs down, "was this useful?" That helps when a real user chooses to answer. It does not solve participation inequality. In agentic systems the problem can be worse: the agent may complete the task without ever surfacing a rating moment to the human.
Option 3: prescribe feedback in standing instructions
The lever that fits today's agent tooling is prescription.
Anthropic's memory tool already uses this pattern for memory writes. Enabling the tool auto-injects a "MEMORY PROTOCOL" instruction that tells Claude to check and update memory, and the docs tell developers to shape memory behavior through prompt instructions (Anthropic memory tool). Claude Code loads CLAUDE.md each session, noting that compliance depends on how the instruction is written (Claude Code memory). The official MCP Knowledge Graph Memory server ships a suggested system prompt prescribing proactive memory behavior (MCP memory server). AGENTS.md is an established standing-instruction format — "a README for agents," used by more than 60,000 projects, stewarded under the Linux Foundation (AGENTS.md).
The pattern is not universal: popular memory MCPs such as mcp-mem0, Basic Memory, and Redis's agent memory server document their tools without proactive-usage prescriptions (mcp-mem0, Basic Memory, Redis agent memory server).
Two honest caveats. No official Anthropic document prescribes rating memories — their tool has no rating command, so prescribing feedback extends the documented instruction pattern rather than following an industry norm. And Mnemoverse's own MCP instructions prescribe rating recalls with memory_feedback after use — that is our practice, not independent evidence.
Here is the instruction block I would put in AGENTS.md, CLAUDE.md, or the system prompt for any agent with learning memory and a feedback endpoint:
## Memory feedback
After acting on recalled memories, report the outcome:
- if a recalled memory was used and helped, send feedback with a
positive outcome for those memory ids (`atom_ids` in the Mnemoverse API);
- if a recalled memory was wrong or misleading, send negative feedback;
- skip feedback for recalls you did not use.
One feedback call per acted-on recall is enough.This keeps the signal voluntary at the account level. It makes behavior auditable. It avoids forcing fake labels. And the goal is not more ratings in the abstract — it is outcome feedback only when a recalled memory actually affected an action.
Memory graphs reflect the signals agents actually send.
Common questions
What is agent memory feedback?
Agent memory feedback is an explicit outcome report that tells a memory system whether a recalled memory helped, misled, or should be ignored after use.
Why does explicit feedback matter for AI agent memory?
In the Mnemoverse engine, feedback is the strongest reinforcement channel by design: it is the only channel that carries an outcome, and the outcome gates how much associations strengthen.
Do production agents send enough memory feedback?
In our August 2026 production measurements, the live tenants we sampled had 0% to 12.8% of edges touched by feedback, while the benchmark tenant had 94.8%.
Does more feedback prove better retrieval quality?
No. Our measured claim is structural: feedback-touched memory became denser and more dissolution-resistant. Whether feedback causally improves live retrieval quality remains an open question.
How should I get agents to send memory feedback today?
Use standing instructions in AGENTS.md, CLAUDE.md, or the system prompt. Tell the agent to send positive feedback for recalled memories that helped, negative feedback for memories that misled, and no feedback for recalls it did not use.
Related
- Hebbian memory for AI agents
- AI agent memory
- Rescorla-Wagner agent memory
- Agent memory deduplication
- Memory MCP servers compared
- Mnemoverse API reference
- Benchmarks
— Edward Izgorodin · Last updated 2026-08-12
— Mnemoverse is a persistent-memory API for AI agents. Free key: console.mnemoverse.com · Docs: Getting Started