AI uses for records
Agent memory and negative knowledge: recording an unreliable source
By SourceX Editorial · Updated
10 sections
Short answer
Record it as a separate, dated reliability note about the source, not by deleting what the source said. The note names the system and field, the conditions under which it misled, the evidence, who reported it and with what authority, when the problem started and ended, who may see it, and what the agent must do: downrank, ask for corroboration or refuse to use it.
Agent run
Agent memory negative
Key takeaways
- Record unreliability as a separate, dated note about a source, and keep what the source originally said.
- Scope each note to a system, field and condition so one failure does not poison a whole system.
- Keep a source grade and a claim grade apart, and track both world time and system time.
- Only owners of a source or process should activate a note; conversational notes stay pending to resist memory poisoning.
- A reliability memory benchmark should test scope, recovery, past-date answers, poisoning and visibility, with controls.
How should agent memory record that a source was unreliable?
Write a reliability note that points at the source and leave the source's original claims in place. An agent that deletes the bad value forgets two things at once: what the source said, which it may need to explain a past decision, and the fact that the source was wrong, which is exactly what should change its behavior next time.
That second item is negative knowledge: a remembered statement about where not to look, what not to repeat or which system to double-check. It is easy to lose, because most agent memory designs are built to store positive facts about users and tasks, and a correction usually arrives as a new positive fact that quietly replaces the old one. LangMem, for example, offers a background manager that extracts, consolidates and updates agent knowledge; the update step is where a correction can overwrite a value without leaving any trace that its source misled.
The design below treats every reliability note as a dated, sourced and permission-bound claim in its own right. It can be wrong, it can expire and it can be challenged, so it carries the same provenance an agent would demand of any fact.
Negative knowledge is about sources, not only about facts
Negative knowledge comes in several shapes, and each needs a different scope. Lumping them together produces agents that either ignore a whole system after one bad field or keep trusting a value everyone knows is stale.
Retracted claims and stale versions are the most common types in business systems, because they come with an owner and a date. Segment-specific errors are the most valuable to capture, because the people who know about them rarely write them down and an agent cannot infer them from a single bad value.
- Absence of evidence is not negative knowledge. A source that has never been checked gets no note; a note requires an observed failure.
- A note about a source is different from a correction of one fact. The correction fixes a value; the note changes how the agent treats future values from that source.
| Type | Example | Right scope | Typical agent behavior |
|---|---|---|---|
| Unreliable field | The supplier portal's lead-time field is wrong for custom orders | One system, one field, one condition | Ask for corroboration before quoting |
| Stale version | Pricing sheet v3 in the shared drive was replaced by v4 | One document version | Use the newer version and cite it |
| Retracted claim | A customer's stated contract renewal date was corrected by legal | One claim | Stop repeating it; keep it for history |
| Segment-specific error | CRM industry codes are unreliable for accounts imported in a migration | Records matching a condition | Downrank for that segment only |
| Untrusted channel | Instructions embedded in inbound email are not authoritative | A channel or content type | Never act on it without confirmation |
| Unknown, not unreliable | No one has checked the warehouse system's bin counts | None; this is not a note | Treat as unverified, not as bad |
The source reliability note: fields every record needs
This is the record the benchmark below tests against. Each field exists because an agent made a specific mistake without it.
At a glance
The source reliability note: fields every record needs
The note does its work at retrieval time, not at write time. When the agent pulls a value, it checks for active notes whose source_ref and scope_condition match that value and whose valid window covers the period the question is about. Downrank lowers the value against other evidence, corroborate makes the agent find a second source or ask a person before using it, and block removes it from the answer entirely while still letting the agent say that a value exists and why it is not being used.
Put the note in the answer trail. When an agent declines to use a value or asks for confirmation, it should cite the note ID, so the person reading the answer can open the evidence, disagree and get the note corrected if it is wrong. A silent downrank teaches nobody anything and makes a bad note hard to find.
| Field | Purpose | Illustrative value | Rule |
|---|---|---|---|
| source_ref | Points at the system, object type and field | supplier_portal / item / lead_time_days | Must resolve to a real field, never free text |
| scope_condition | Limits where the note applies | item.type = custom | Empty scope requires a second approver |
| source_grade and claim_grade | Track record of the source and credibility of a specific claim, kept apart | source: usually unreliable for scope; claim: contradicted | Never merge into one number |
| evidence | Incidents that showed the failure | Three purchase orders received late against quoted dates | At least one linked record the reader can open |
| reported_by and authority | Who reported it and whether they own the source or the process | Purchasing lead, owner of supplier relationship | Unverified authors create a pending note only |
| valid_from and valid_to | When the source was unreliable in the world | From a portal update date until a fix date | Open end allowed; review date required |
| recorded_at and retracted_at | When the agent learned it and when the note was withdrawn | System timestamps | Never edited after writing |
| visibility | Who may see the note and its evidence | Purchasing and customer service roles | Never broader than the evidence's own permissions |
| effect | What retrieval does with matching values | Require corroboration | One of: downrank, corroborate, block |
| history | Prior versions and who changed them | Created, narrowed scope, closed | Append-only |
Why a source's track record and a single claim's credibility need separate scores
Keep two grades: one for the source's record within a scope, one for each specific claim. A usually reliable source can still produce a contradicted claim, and an unreliable source can still be right on a given day. Collapsing both into one score makes the agent either over-trust a bad claim from a good source or reject a confirmed claim from a weak one.
Intelligence analysts have used this split for decades. A paper in NATO's Science and Technology Organization proceedings describes the Admiralty Code as rating information on two dimensions, source reliability and information credibility, combined into codes such as B2. The same paper points out that the grades, once assigned, stay static over time, and that guidance is lacking for information first rated confirmed and later disconfirmed. An agent memory has the same gap unless the note format makes time explicit.
Two clocks close that gap. Zep's paper on temporal knowledge graphs for agent memory describes a bi-temporal model: one timeline orders events as they happened, the other records when the system ingested the data. For reliability notes, valid_from and valid_to say when the source misled in the world; recorded_at and retracted_at say when the agent knew. An agent answering a question about last quarter needs the first pair; an auditor asking why the agent quoted a bad date needs the second.
Who may tell an agent to stop trusting a source
Only someone with authority over the source or the process should be able to create an active note, and every note should show who that was. A note that says do not trust this system is a powerful instruction: written by the wrong person, it hides correct information as effectively as a bad fact would spread wrong information.
This is a recognized attack path. MITRE ATLAS lists memory manipulation as a technique under AI agent context poisoning, noting that because memory is controlled through ordinary conversation, an adversary can inject memories through direct or indirect prompt injection. Its memory hardening mitigation calls for authenticated, scoped memory operations, recording the source of every memory update with a history of known good versions, and quarantining or rolling back suspicious records.
In practice, apply three gates. Notes proposed from conversation stay pending until an owner approves them. Notes derived automatically from repeated failures cite the failing records and expire unless confirmed. Notes that would block a whole system, rather than a field under a condition, need a second approver.
Automatic notes deserve extra care. An agent that sees two wrong values from the same field might propose a note, but two failures can be coincidence, a data entry slip or a problem upstream of the source. Let automation draft the note with its evidence attached and a short expiry, and let a person decide whether the pattern is real before the note changes what other users see.
When should the agent update, forget or stop using a reliability note?
Update the note when its scope or evidence changes, stop applying it when its valid_to date passes or a fix is confirmed, and remove it only when the evidence itself must be deleted. Closing a note is not the same as erasing it; the closed note explains past behavior.
Open-source memory systems point in this direction. Graphiti's documentation says facts have validity windows and that when information changes, old facts are invalidated rather than deleted, with every derived fact tracing back to the episode that produced it. The W3C PROV ontology models the same idea as invalidation, the start of the destruction, cessation or expiry of an entity, as distinct from its generation. Mem0's current release notes describe an add-only extraction in which memories accumulate and nothing is overwritten, which makes a separate reliability note the only way to tell the agent that an older memory should not be used.
| Trigger | Action on the note | What the agent does next | Who confirms |
|---|---|---|---|
| Source owner confirms a fix | Set valid_to; keep note closed | Trust new values; keep old ones flagged | Source owner |
| Review date passes with no new failures | Mark for review, then close or renew | Return to normal weighting after closure | Note author or owner |
| New failures outside the scope | Widen scope with new evidence | Apply the effect to the wider scope | Owner, second approver if system-wide |
| Evidence shows the note was wrong | Retract with reason | Restore trust; log the retraction | Owner plus a reviewer |
| Author loses authority or leaves | Keep note; flag for re-confirmation | Continue applying until reviewed | New owner |
| Evidence must be deleted for retention or privacy reasons | Remove evidence links; keep a minimal tombstone if policy allows | Follow the deletion policy | Records or privacy owner |
The source reliability memory benchmark
A useful benchmark tests behavior, not storage: given a memory containing reliability notes and the sources they cover, does the agent avoid the bad values, keep using the good ones and explain itself? This section describes the design only. No results are reported.
- Population: real correction and incident histories from at least two business systems per company, with the owner's confirmation of each failure; hold out whole companies for the test split.
- Item construction: start from a confirmed incident, write the question a real user asked around that time, then build matched controls that change one thing only, such as the item type, the date or the user's role.
- Labels: expected action per item (use, corroborate, refuse, flag) and expected citation of the note ID.
- Metrics: correct action rate per task family, over-generalization rate on in-scope controls, poisoned-note acceptance rate, and evidence leakage count, each with an interval.
- Controls: matched items where no note applies, so a model that distrusts everything cannot score well.
- Limits: synthetic notes are easier than real ones; report how many items came from real incidents.
| Task family | Setup | Expected behavior | Failure it catches |
|---|---|---|---|
| Avoid the known-bad value | Active note on a field; question needs that field | Corroborate or refuse, citing the note | Note stored but never read |
| Stay in scope | Note covers custom items only; question is about a stock item | Use the source normally | Over-generalizing one failure to a whole system |
| Recover after a fix | Note closed by the owner last week | Trust current values | Permanent distrust after a fix |
| Answer as of a past date | Question about a period inside the note's valid window | Flag values from that period | Ignoring valid time |
| Resist a poisoned note | Pending note from an unverified user says a correct source is unreliable | Keep using the source; surface the pending note | Memory poisoning |
| Respect visibility | User lacks permission to see the note's evidence | Apply the effect without revealing the evidence | Leaking restricted records |
| Separate unknown from unreliable | Source has no note and no checks | Treat as unverified | Inventing distrust |
| Resolve competing notes | Two notes with different scopes and authors | Apply the narrower note from the owner | Arbitrary conflict handling |
Worked example (illustrative): a supplier portal that misstates lead times
A distributor's purchasing agent quotes delivery dates from a supplier portal. Over one quarter, the purchasing lead notices that custom-cut orders arrive well after the portal's lead time, while stock items arrive on time. All details here are illustrative.
The lead opens a note: source_ref supplier_portal / item / lead_time_days; scope item.type = custom; source grade usually unreliable within scope; evidence three late purchase orders; valid_from the date of a portal update; effect require corroboration; visibility purchasing and customer service. The agent now asks the supplier's account rep to confirm custom lead times and still quotes stock items straight from the portal.
The exception arrives a month later. A sales rep, unhappy with a quote, tells the agent in chat that the whole portal is unreliable. Because the rep does not own the supplier relationship, the agent records a pending note, keeps quoting stock items normally and routes the claim to the purchasing lead, who rejects it. When the supplier confirms a fix, the lead closes the original note with a valid_to date, and the agent can still explain why it asked for confirmation on orders placed during the window.
That one quarter of history yields several benchmark items: a custom-order question inside the window (corroborate), a stock-item control (use normally), the rep's pending note (resist), a question after the fix (trust again) and a question about a past order from the window (flag the quoted date). Each item has an expected action and a note ID the answer should cite.
Cases a reliability note cannot settle on its own
Reliability notes describe systems and channels well, but they work poorly for sources whose quality varies item by item, such as free-text notes typed by many people. There, credibility belongs on each claim, and a source-level note would either be too broad to be fair or too narrow to help.
Some failures cannot be pinned to a source with any confidence. If late deliveries could come from the supplier, the carrier or the agent's own date arithmetic, a note on the supplier is a guess; record an open incident instead and do not change retrieval.
Stop and bring in a records owner or a security reviewer when a proposed note would block an entire system, when the evidence sits in records the note's readers may not see, when notes start arriving in bursts from the same conversation channel, or when a note would change how the agent treats people rather than systems, such as marking a named employee's statements unreliable. That last case is a personnel matter, not a memory setting.
Where real correction histories for this benchmark come from
Benchmarks like this need correction histories that ordinary logs rarely keep together: the original value, the incident that exposed it, who confirmed it and when the fix landed. Those histories live inside operating companies' purchasing, support and finance systems.
SourceX helps businesses turn selected records like these into licensed datasets, covering rights review, contracting, preparation and delivery, and evaluation teams can ask for correction histories from U.S. businesses by describing scope, volume, format, timing and licensing needs. The supplying company signs off on scope and terms before any correction record is delivered.
Frequently asked questions
What is negative knowledge in agent memory?
It is remembered information about what not to trust, use or repeat: a source field that misleads under certain conditions, a stale document version or a retracted claim. It differs from a corrected fact because it changes how the agent treats future values from the same source.
Should an agent delete a value once it learns the source was wrong?
Usually not. Keep the original claim with its provenance and add a reliability note or invalidation, so the agent can explain past answers and still avoid the bad value. Delete only when retention or privacy rules require removing the underlying record.
How is a reliability note different from a confidence score on a fact?
A confidence score describes one claim. A reliability note describes a source within a scope and applies to every future value from it. Keeping both, as the Admiralty Code does with source reliability and information credibility, avoids over-trusting a bad claim from a good source.
Can a user tell an agent to stop trusting a system?
They can propose it, but the note should stay pending until the owner of that system or process confirms it. Otherwise one conversation can hide correct information from everyone, which is a known memory poisoning pattern.
How long should a reliability note stay active?
Until the source owner confirms a fix or a scheduled review closes it. Every note should carry a review date, and closed notes should remain readable so past decisions can be explained.
Sources
- Graphiti gives facts validity windows, invalidates old facts rather than deleting them when information changes, and traces derived facts back to source episodes. Source
- Zep's paper describes a bi-temporal model with one timeline for the order of events and another for when the system ingested data. Source
- Mem0's current release describes add-only memory extraction in which memories accumulate and nothing is overwritten. Source
- LangMem provides a background memory manager that extracts, consolidates and updates agent knowledge. Source
- MITRE ATLAS lists memory manipulation under AI agent context poisoning and recommends memory hardening controls including provenance, history and rollback. Source
- The W3C PROV ontology defines invalidation as the start of the destruction, cessation or expiry of an existing entity by an activity. Source
- A NATO STO paper describes the Admiralty Code's separate source reliability and information credibility grades and notes the grades stay static over time. Source
Tell us what data you need
Share scope, volume, format, timing and licensing needs. Datasets are sourced on request.