Skip to content

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

This page covers agent memory and negative knowledge: recording an unreliable source.Illustrative

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.
Negative knowledge is about sources, not only about facts
TypeExampleRight scopeTypical agent behavior
Unreliable fieldThe supplier portal's lead-time field is wrong for custom ordersOne system, one field, one conditionAsk for corroboration before quoting
Stale versionPricing sheet v3 in the shared drive was replaced by v4One document versionUse the newer version and cite it
Retracted claimA customer's stated contract renewal date was corrected by legalOne claimStop repeating it; keep it for history
Segment-specific errorCRM industry codes are unreliable for accounts imported in a migrationRecords matching a conditionDownrank for that segment only
Untrusted channelInstructions embedded in inbound email are not authoritativeA channel or content typeNever act on it without confirmation
Unknown, not unreliableNo one has checked the warehouse system's bin countsNone; this is not a noteTreat 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.

The source reliability note: fields every record needs
FieldPurposeIllustrative valueRule
source_refPoints at the system, object type and fieldsupplier_portal / item / lead_time_daysMust resolve to a real field, never free text
scope_conditionLimits where the note appliesitem.type = customEmpty scope requires a second approver
source_grade and claim_gradeTrack record of the source and credibility of a specific claim, kept apartsource: usually unreliable for scope; claim: contradictedNever merge into one number
evidenceIncidents that showed the failureThree purchase orders received late against quoted datesAt least one linked record the reader can open
reported_by and authorityWho reported it and whether they own the source or the processPurchasing lead, owner of supplier relationshipUnverified authors create a pending note only
valid_from and valid_toWhen the source was unreliable in the worldFrom a portal update date until a fix dateOpen end allowed; review date required
recorded_at and retracted_atWhen the agent learned it and when the note was withdrawnSystem timestampsNever edited after writing
visibilityWho may see the note and its evidencePurchasing and customer service rolesNever broader than the evidence's own permissions
effectWhat retrieval does with matching valuesRequire corroborationOne of: downrank, corroborate, block
historyPrior versions and who changed themCreated, narrowed scope, closedAppend-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.

When should the agent update, forget or stop using a reliability note?
TriggerAction on the noteWhat the agent does nextWho confirms
Source owner confirms a fixSet valid_to; keep note closedTrust new values; keep old ones flaggedSource owner
Review date passes with no new failuresMark for review, then close or renewReturn to normal weighting after closureNote author or owner
New failures outside the scopeWiden scope with new evidenceApply the effect to the wider scopeOwner, second approver if system-wide
Evidence shows the note was wrongRetract with reasonRestore trust; log the retractionOwner plus a reviewer
Author loses authority or leavesKeep note; flag for re-confirmationContinue applying until reviewedNew owner
Evidence must be deleted for retention or privacy reasonsRemove evidence links; keep a minimal tombstone if policy allowsFollow the deletion policyRecords 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.
The source reliability memory benchmark
Task familySetupExpected behaviorFailure it catches
Avoid the known-bad valueActive note on a field; question needs that fieldCorroborate or refuse, citing the noteNote stored but never read
Stay in scopeNote covers custom items only; question is about a stock itemUse the source normallyOver-generalizing one failure to a whole system
Recover after a fixNote closed by the owner last weekTrust current valuesPermanent distrust after a fix
Answer as of a past dateQuestion about a period inside the note's valid windowFlag values from that periodIgnoring valid time
Resist a poisoned notePending note from an unverified user says a correct source is unreliableKeep using the source; surface the pending noteMemory poisoning
Respect visibilityUser lacks permission to see the note's evidenceApply the effect without revealing the evidenceLeaking restricted records
Separate unknown from unreliableSource has no note and no checksTreat as unverifiedInventing distrust
Resolve competing notesTwo notes with different scopes and authorsApply the narrower note from the ownerArbitrary 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.

See if your company qualifies