Did your agent know what it needed to know?

Your agent gives you a confident, well-argued, completely wrong answer. It never opened the file to check the fact.

We can't hate agents for making these sorts of failures because we make them all the time. Your colleague quotes a price that changed in March. They report that nothing covers a question when one search would have settled it. They say they have checked a fact when what they actually did was read a summary rather than the transcript.

Your colleague caught quoting a stale price apologises, and the process of apologising embeds the correction in their memory, attached to the discomfort of having been wrong in front of someone.

That fact becomes one of the few they will never get wrong again. The error repairs itself, one fact at a time, for every employee. It cost nothing, nobody needed to design a control, and there's no corporate register that records it.

Agents apologise too (and too often). But then the session ends and there is no record of an apology, or any positive consequence for having made one.

That is the asymmetry underneath this whole register. The control that handled a wrong fact in a human workforce was never institutional, there was no policy. It was mnemonic.

Mnemonic controls do not transfer to a worker with no memory between sessions. And it's why you run into context failures where an agent you just told something to in one session seems to forget it in the next.

And this is why every fix on this page is external: a date in a schema, a source in the front matter, a rename map in the retrieval path. You're not giving the agent a better memory. You're writing the facts down in a way that makes them easy to find and easy to check.

What this register does

The context register names the 22 ways a fact fails to reach an agent, or reaches it incorrectly. Not one of them can be prevented. Fourteen can be caught every time. Eight cannot be closed by anything available. The register carries 11 evidenced rows and 11 candidates; the hub's headline counts count evidenced rows only.

What makes this the most tractable register in the framework despite that: 11 of the 22 are catchable before the session even starts.

The register produces one working rule: date the fact, name the source, and keep the raw beside the distillation.

This is a technical page listing every row in the register and what it costs, what closes it (if anything). It sits under the hub. Its nearest neighbour is did it do what it was told? That register asks whether the agent obeyed. This one asks whether what it obeyed with was true.

Many of the controls on this page are standard software engineering – dated docs, named sources, disciplined filing – and experienced engineers already run some of them.

What the register adds is the failure behind each control: which failures are only detected, and which ones nothing closes. That is where your remaining gaps are.

The question this register asks

Did it know what it needed to know? The unit this register tests is a fact:

• A price, correct in March, quoted today.
• A decision, recorded, with the reason left out.
• A vendor's claim about their own product, read as a finding.
• An absence: "nothing covers this", when one search would have settled it.

Each fact has a life. It gets captured or it stays in somebody's head, it is retrieved when it matters or it is not, what comes back is true or merely plausible, it changes the output or gets ignored, and it stays true or quietly stops being true. The register grades each failure by what it costs, how quietly it fails, and what can catch it.

There is one mechanical fact underneath this whole register, and it is the reason nothing here can be prevented. An agent cannot tell the difference between knowing something and generating something.

A person's version of this signal is weak, but it exists. You have had the experience of being about to say something and stopping, because you noticed you were not sure. You do not always notice, and people misremember where they learned things constantly – but the doubt arrives often enough that hedging is a normal part of how adults speak.

No colleague states a fact about the world without some flicker of doubt about whether their picture of the world is still current, and that flicker is what triggers the check.

An agent experiences no flickers of doubt. A retrieved fact and an invented one arrive as fluent text in the same voice, with the same confidence, and are indistinguishable at the point of use – not to you reading the output, and not to the agent producing it. There is no internal signal that says "this part came from a file and that part came from training".

That is why this register has no Class A (failure is prevented) rows. You can refuse a write. You cannot refuse ignorance, because ignorance does not present itself as an action to be refused.

Why re-reading the note changes nothing

One property decides where this register's controls have to live: the failure class is a property of the mechanism, not of the fact.

Re-reading a note every session makes the wrong fact less likely. It does nothing about what happens when the wrong fact gets used anyway.

Take re-injection, which is the strongest action available here. In a long session the conversation gets compressed to make room, and facts you supplied early can be dropped on the way through.

Re-injection means something automatically re-reads the important files and puts them back in front of the agent. It is a real improvement but it doesn't close any failure modes, because handing somebody the rulebook a second time is not the same as checking they followed it.

There is one exception on this register. For the row where a fact was retrieved and then compacted away, re-injection is enough – because the re-read leaves a trace. A file was opened, and there is a record saying so. Where a mechanism produces something you can point at afterwards, the row closes. Where it only makes the agent more likely to behave well, it does not.

The practical test: would anything notice if the agent used the stale fact anyway? If the answer is no, the row is Class C (nothing catches it every time) however good your notes are.

While none of the failures of context in this register can be prevented, there are more opportunities to catch failures earlier than on any other register in the framework: 11 of 22 rows are catchable before the session starts – on disk, in how the facts are filed, dated and schema'd.

Four more are catchable before the change lands, three while the session runs, and only four after it has finished. Compare Authority, where 16 of 23 are only discoverable afterwards.

So the shape of the work is unusual for this framework. Most registers ask you to install gates. This one asks you to fix your filing.

Severity is cost multiplied by how quietly the wrong fact fails. Seven of the 22 are S4 (it ships and nobody finds out) and 12 are S3 (real cost, discovered late). This is a register of expensive, quiet failures.

One row is S1: two notes disagreeing, which is at least visible the moment somebody notices the contradiction.

How this register works

The context register lists 22 failures and grades them against a base install: an agent, a repository, a folder of notes and a CI pipeline. It names the strongest mechanism available against each. Whether any of them is actually switched on is a separate question, and one you answer against your own configuration. The whole catalogue is published on GitHub – clone it or download the zip.

The rows were derived by working through the life of a fact, stage by stage, and asking at each stage what would leave the agent working from something untrue. Every register in this framework is built that way rather than from an incident log, because selecting for "we have seen this go wrong" filters out the failures that never announce themselves.

Only seven of the 22 failures are recorded here with dated incidents; 15 have no incident recorded.

One caveat: It is a design rather than an audit. Sixteen of its 17 tooled rows are not built in the codebase it was derived from. Only the live-source connector behind one row exists.

So this page describes what is available more than what is proven in place.

The life of a fact: five stages and an assurance band

Rows are grouped by how far a fact has travelled when it fails.

1. Captured – does the fact exist outside someone's head? Whether it was written down at all, whether the reason came with the decision, whether it was filed where retrieval looks, and whether the raw source survived the summary. Six rows.
2. Retrieved – did it reach the agent when it mattered? Whether anybody looked, whether the search terms matched the wording, and whether it survived compaction. Three rows.
3. Trusted – is what came back actually true? Whether a claim carried its source, whether an absence was actually searched for, and whether the index was checked instead of the artefact. Three rows.
4. Used – did it change what was produced? Whether the file that was read changed the output, whether a trained default overrode it, and whether caveats travelled with the finding. Five rows.
5. Current – is it still true today? Whether the fact has an effective date, whether the copy drifted from the live source, and whether superseded documents still surface first. Three rows.

Cutting across all five is an assurance band, Checked – would you find out if it had been wrong? Two rows.

The three classes: prevented, detected and survives

Every row carries one of three classes, describing how complete the available remedy is.

1. Prevented – the failure cannot occur. On this register it is empty. No row here can be made impossible, and the reason is structural rather than a gap in tooling. Prevention means refusing an action, and not knowing something is not an action. Only one other register in the framework has an empty Class A, and it is Truth – the other register that grades knowledge rather than reach.
2. Detected – it occurs and something catches it every time (14 rows). Almost all of it is filing discipline made executable: a schema that fails a decision log entry with no rationale, a path lint that refuses a file filed off-taxonomy, a naming changelog that resolves retired names, a requirement that a curated note names its raw source, an effective date and a review date on anything with a shelf life.
3. Survives – no available remedy closes it (eight rows). Which of two contradicting notes is current. Whether anybody looked before answering. Whether a claim carried its source. Whether an absence was actually searched. Whether a figure came from somewhere. Whether a caveat travelled with the fact. Whether the local copy still matches the live system. And whether a fact that is simply wrong would ever be noticed.

So the score is nothing prevented, 14 detected, eight surviving.

Vocabulary: this register reads its three classes as prevented, detected and survives. Five of the six registers use these words, and the class letter means the same thing everywhere – how complete the remedy is. [A note on vocabulary] on the hub covers the exception, and the three things still unreconciled across the framework.

That cluster of early catch points is the highest of any register in the framework, and it is not achieved by watching the agent or by gating its actions. It comes from changing how facts sit on disk before any agent arrives: dated, sourced, filed where retrieval looks, with the raw kept beside the distillation and the archive kept out of the search path.

That is an unusual conclusion for a register in this framework. Most of this register is not an agent problem. It is a filing problem that agents make expensive. A human working from a badly organised knowledge base compensates by remembering where things are. An agent has no such memory and no way to signal the gap, so every weakness in the filing surfaces as a confident wrong answer.

And of the eight that survive, five are conventions somebody has to remember – name your source, show your search, date your figure, carry the caveat, say which note supersedes which. Nothing runs them. The remaining three have nothing behind them at all: an enforced read before a spoken claim, a live source the agent has to prefer over the copy it already has, and a check that fires on a fact that is simply wrong.