The Writer Cannot Know the Reader's Question

The asymmetry is structural rather than practical.

Retrieval is evaluable. Given a query and a corpus, there is a fact of the matter about which items are relevant. You can label it, measure it, and improve against the measurement. This is why information retrieval has a century of methodology and agent memory keeps borrowing from it.

Writing is not evaluable in the same way, because the value of a note is not a property of the note. It is a property of the pairing between the note and a future query. At write time, one half of that pair does not exist. Not "is hard to predict." Does not exist. There is no distribution to estimate because the events that will generate the queries have not happened.

The information-science literature has had a name for this for sixty years: anticipatory indexing. Robert Fairthorne, writing in the 1960s, made the same observation about a human indexer preparing entries for an open-ended set of future queries. The consequence the indexing literature does not draw is the one that matters here: if the writer cannot know the question, the unit of storage should change.

Compare the writer's task to a genuinely hard prediction problem, like forecasting demand for a product. Demand forecasting is hard but it is well posed: there is a real distribution, it is stationary enough to sample, and yesterday's data informs tomorrow's estimate. A wrong forecast is checkable, and a useful one improves against the check. Note writing has none of these. The next session's queries depend on what the user decides to work on next, which depends on things outside the system entirely, and there is no recurring unit against which the writer's performance can be measured.

This places the task close to what Frank Knight called uncertainty in the 1921 sense, but not identical to it. Knightian uncertainty names a situation where the decision maker has no probability distribution; the writer's predicament has that, but it adds a second defect that the term does not capture. The writer has no feedback signal either. Not "I cannot estimate" but "no estimate I produce will be checked." That second defect is what makes the task ill-posed, not merely uncertain. A Knightian decision can still be evaluated by its consequences; a write-time guess about an unknown future query cannot, because the relevant consequence is the future query that does not yet exist.

So the writer is not doing a hard estimation task badly. It is doing an ill-posed task, and the outputs look like bad estimates because nothing else is available.

Watch what happens when the standard instructions to a memory writer are unpacked, because each one smuggles in the missing information rather than supplying it.

Write down what will be useful later requires knowing what later looks like. Write down the important parts requires an importance function, which is defined relative to a purpose that has not been set. Write it so you could pick up where you left off assumes the next session resumes this work, which is frequently false: it may be a different task in the same repository, or the same task after the code changed underneath it. None of these is wrong exactly. Each is underdetermined, and the writer resolves the underdetermination by guessing, because guessing is the only thing available.

The observable consequence is a specific and recognizable failure pattern. Agent notes tend toward one of two poles.

The generic pole writes things that are true but not discriminating. The auth module handles authentication. There is a test suite. Future relevance search will not be able to tell those notes apart from each other or from the noise of the codebase itself, and they will land in retrieval results at roughly the rate of the words they contain. They are cheap to write and cheap to ignore.

The over-specific pole writes the exact state of a moment that will never recur. Line 340 currently returns None here. Last build failed at 14:02 with a TypeError in user_service.py. These are accurate as photographs, but the value of a photograph decays with the distance from the moment it captured, and the writer cannot know how far away the moment is from the moment that will want it.

That both poles are visible in published work is the part worth checking. The LLM evaluation literature now routinely reports a failure pattern it names over-general and over-specific output as a single joint phenomenon: the same model, on the same prompt, can produce a generation that is true but too generic to act on, or specific to a moment that does not exist. Whether published evaluation work already treats the two failure modes as one calibration problem is a question worth settling; the pattern here is an observation from practice rather than a cited result. What no treatment does is locate the source of the bimodality in the write-time problem rather than in the model.

That claim is an observation from practice, not a result, and it is a prediction: if the framing here is right, an existing store's notes, classified as generic, over-specific, or well-scoped, will show a bimodal distribution with a thin middle. Section 06 turns the prediction into a test.

There is a practical consequence that is worse than the philosophical one, and it is what keeps the failure pattern self-perpetuating.

Because a note's value is realized at retrieval, the feedback signal for writing arrives late, arrives rarely, and arrives attached to the wrong event. A note written on Monday and usefully retrieved on Friday produces a success credited to Friday's retrieval, not to Monday's write. A note written on Monday and never retrieved produces nothing: no signal, no error, no record that a bet was placed and lost. There is no equivalent of the empty retrieval basket: the basket is invisible because there is no basket.

This is what makes the write path nearly untunable, and it explains a structural pattern visible in nearly every long-lived agent memory store. Retrieval can be tuned because retrieval failures are visible and attributable. A wrong note that surfaces in response to the wrong query is named by the query, ranked against the right one, and the gap between them is measurable. Writing cannot be tuned the same way because writing failures are silent and their cost lands somewhere else, later, attributed to something else. A session that should have remembered a fact and re-derived it instead looks like a slow session, not a memory failure. A session that should not have remembered a fact and acted on it anyway looks like a model hallucination, not a memory over-supply.

The observable consequence is the accretion of write-side heuristics that never get removed. A rule about what to store, once added, is nearly impossible to evaluate, because evaluating it would require knowing what the counterfactual store would have retrieved. The rules accrete because nothing can prove them wrong. A system that began with three rules of what to write will have thirty within a year, and the more rules there are, the less each one can be checked against actual retrieval outcomes, because retrieval outcomes never reveal which rule was responsible for the note that was or was not written.

The diagnosis has a design consequence, and it is not give up. It is that the unit of memory is wrong. If the writer cannot know the question, it should not be storing an answer.

The alternative is to store the condition under which the note becomes relevant, rather than a guess about which future query will match it.

Not this is important but this matters when someone touches this file. Not remember the auth flow but surface this when the auth module is being edited. The note's content is preserved; the unit of storage now includes a triggering condition attached to the content rather than a guess about future relevance attached to the writer's confidence.

This is a real change in what is being predicted, and it is worth being careful about why it is easier, rather than assuming the change is cosmetic.

The argument is not that the condition is guaranteed to fire. The argument is that the writer is now betting on a smaller, more stable, more checkable space, and the bet is one the writer can be wrong about in observable ways.

There is a second and less obvious benefit. A triggering condition is falsifiable at write time in a way a relevance guess is not. This matters when someone edits the auth module can be checked immediately for coherence: does that file exist, is it the right file, is the condition ever going to fire. This will be useful later cannot be checked at all. Moving from an unfalsifiable claim to a falsifiable one is the actual improvement here, independent of whether retrieval works better downstream.

This connects directly to the falsifiability of stored directives. A Directive Is Not a Memory argued that a stored rule's only falsifiable core is the present condition that was thrown away at write time, and that memory systems which store prose instead of predicates cannot test the rules they carry. The same shape applies one level up: a stored note's only falsifiable part is the triggering condition, and memory systems which store importance guesses instead of conditions cannot evaluate the notes they carry. The mechanism is the same. The part worth keeping is the part that can be checked today, and the part typically thrown away is the part that could have been.

The proposal is also not new in isolation. Event-condition-action rules in active database systems, publish-subscribe routing in message brokers, and prospective memory in cognitive psychology are all prior art for storing do this when that happens as a first-class object rather than as an afterthought. The novelty being claimed here is the application to agent memory, the argument that the unit should be the condition rather than the answer, and the observation that this changes the falsifiability status of what is stored. The active-database tradition formalized the trigger side decades ago; the agent memory tradition has not yet adopted it as a primary unit. The literature on production rule systems solved the related problem of conditioned actions, and an internal research pass on the field notes that the conditioning construct is decades old. What is new is the application, not the underlying idea.

To see why the unit change is not just a relabeling, run the same idea through a lens argued elsewhere. Search Is Memory's Write Path argued that agent search and agent memory are two phases of one system, the first search being the write and every repeat the read, and that the write path is shaped by what the retrieval mechanism will later surface. That is not contradicted here. The narrower claim is that even with perfect awareness of the retrieval mechanism, the writer still cannot know the specific future query, and so the unit of storage should be a triggering condition whose firing is observable, rather than a guess about future relevance whose correctness is not. Search being the write path is consistent with conditions being the unit; the conditions become what the write path produces, and the retrieval mechanism selects among them on the circumstances that have actually fired.

The honest limits, because the argument is weaker than it may sound and the right place to be weak is up front.

Condition-based memory has its own failure mode, and it is not a milder one. A condition that never fires stores a note that is never seen, and unlike a relevance miss, nobody is even querying for it. The note sits in the store, the trigger it carries never resolves true, and the system cannot detect the gap because the gap is the absence of an event, not the presence of a wrong one. A wrong condition is a permanent silent loss rather than a ranking error, and it is at least defensible to argue that the trade is a measurable failure for an unmeasurable one. The bet is that the unmeasurable failure has lower expected cost, because the space of conditions is smaller and more stable than the space of queries. It is a bet, not a theorem.

The proposal also does not cover the genuine case where a reader asks an open question with no triggering circumstance at all. Someone wanting to know what was learned about this subsystem last month is doing exactly the query-shaped retrieval that cannot be predicted for. Conditions do not help there. Relevance search remains the right tool, and the right design treats conditions and relevance as two subsystems that carry different loads. The proposal is that conditions should carry the load they can carry, not that they replace retrieval. Replacing one with the other is the same failure in a different shape.

And the move moves rather than removes the burden of foresight. Choosing a condition is still a prediction. The claim is only that it is a prediction over a smaller, more stable, more checkable space, and that this is a genuine improvement rather than a relabeling. That claim could be wrong. Section 06 says how you would find out.

The argument is structural rather than measured. Three predictions would distinguish it from the alternatives, and they are stated so a future test can confirm or refute each one independently.

Prediction 1. Notes written with a triggering condition should show a higher retrieval rate than notes written without one in the same store, controlling for content. If condition-carrying notes are retrieved no more often, the central proposal fails. This is a one-line count, run on any working store that already records retrieval events.

Prediction 2. Agreement between independent writers should be higher on conditions than on importance. Give several agents the same session and ask each to say what is important, then ask each to say when it will matter. If the second task produces more agreement, that is evidence the prediction space really is more constrained. If agreement is equally poor, Section 04's core argument is unsupported.

Prediction 3. The two-pole pattern in Section 02 should be measurable. Classify an existing store's notes as generic, over-specific, or well-scoped. The argument predicts the middle category is small and the distribution is bimodal. A healthy unimodal distribution of well-scoped notes would falsify the framing directly.

No measurement is reported here. The point of the predictions is that the argument can be settled, not that it has been.

• Fairthorne, R. A. Content Analysis, Indexing, and Matching. Foundational essay in Fairthorne's work on the aboutness problem, treating indexing as the construction of a document representation against an open set of future queries. Source of the anticipatory-indexing framing used in Section 01. Publicly discussed in the Journal of Documentation tradition, 1960s.
• Brittain, J. M. Information and Its Retrieval. Modern treatment of anticipatory indexing and the indexer-for-unknown-uses problem.

• Alchourrón, C. E., Gärdenfors, P., Makinson, D. On the Logic of Theory Change: Partial Meet Contraction and Revision Functions. Journal of Symbolic Logic 50(2), 1985, pp. 510-530. The contraction operator and the partial-meet construction, and the formal definition of contraction used in Section 05.
• Gärdenfors, P. Knowledge in Flux: Modeling the Dynamics of Epistemic States. MIT Press, 1988. Introduces the recovery postulate for contraction as an additional constraint. Section 05 weakens it, on the grounds that the agent memory case lacks the feedback signal it assumes.
• Stanford Encyclopedia of Philosophy, Belief Revision (Hansson, major revisions through 2023). Standard reference frame for the AGM postulates, including the formulation of recovery and the subsequent critiques that proposed weaker constraints in its place. https://plato.stanford.edu/entries/belief-revision/

• Knight, F. H. Risk, Uncertainty and Profit. Boston: Houghton Mifflin, 1921. The distinction between measurable risk and unmeasurable uncertainty. Section 01 uses the term in its 1921 sense, and adds a second-order defect: the missing feedback signal.

• Widom, J., Finkelstein, A. Set-Oriented Production Rules in Relational Database Systems. Proceedings of the 1990 ACM SIGMOD International Conference on Management of Data. The HiPAC lineage of active databases that produced the ECA formalism, the prior art for condition-first storage.
• Chakravarthy, S. et al. An ECA Rule-based Framework for Active Information Systems. Active databases literature of the 1990s, where the conditioning construct was already solved.

• Search Is Memory's Write Path. The argument about retrieval shaping what gets stored. Section 04 cites the distinction: that post is about the write path being shaped by the read path, this post is about the unit the write path should produce given that shaping.
• A Directive Is Not a Memory. The argument about the falsifiability of stored rules. Section 04 cites the parallel: the same shape, one level up, applied to memory notes rather than directives.