Part of an ongoing research program on Construction Theory (構築). Status: working hypotheses and specification drafts (v0.4). No experimental data yet. Feedback and counterarguments actively sought.
The observation that prompted this work was not theoretical. It was practical and recurring: in multi-round AI systems, including multi-agent pipelines, outputs systematically degrade in a specific way. Not randomly. Errors compound structurally — and they do so because no component in the system asks a question that turns out to be necessary:
Given what I'm trying to do right now, how much should what was previously computed actually count?
The standard approach is to feed prior conversation logs, summaries, or database entries back to the model before each turn. This seems like memory. But three problems keep appearing in practice:
Stored doesn't mean used. A large amount of saved content has no actual effect on the current judgment — it occupies context while contributing nothing to the output.
Outdated memory fails silently. The world has changed, the memory hasn't, and the AI keeps answering from the stale version without flagging that anything is wrong. The answer degrades quietly.
Errors carry forward. Existing research (Xiong et al., ACL 2026) has confirmed that AI agents, when encountering tasks similar to past ones, tend to produce similar outputs — including past mistakes. The system re-follows the same path that was wrong.
What these three problems share: they are all consequences of treating storage as equivalent to participation. What was stored is asked about; what actually participates in the current judgment is not.
This research tries to make "what participates" measurable.
A past interaction leaves three kinds of things. Current AI memory architectures mostly capture the first two:
| What's saved | The question it answers | Example |
|---|---|---|
| Input (X_t) | What did the system see? | The spreadsheet contents |
| Result (Y_t) | What did the system produce? | "Revenue total is wrong" |
| Computation Arrangement (C_t) | How was the result produced? | "Column 3 → counted twice → inflated total, given: old spreadsheet version" |
The distinction matters operationally. Suppose an AI checked a spreadsheet last round and found: "the revenue total is wrong because column 3 was counted twice."
If it saved only the result: next round — even after column 3 was fixed — it might still say "revenue is wrong." It has the conclusion without the structure that would let it check whether the conclusion still applies.
If it saved the computation arrangement: it can check the new spreadsheet's column 3 specifically. It knows why it reached its prior conclusion — including the conditions under which that conclusion was valid — and can re-evaluate from there.
Memory Equivalent is a concept proposed to describe how much of the computation arrangement from a past round remains effectively operative in a current judgment.
Before treating Memory Equivalent as a useful engineering concept, it's worth establishing why something like it must exist in any system that maintains continuity across computational rounds.
The argument runs as follows:
A system that allows structures to persist across time — that uses past computation to influence current output — needs some mechanism by which past structures can be re-located and re-referenced. Without this, there is no principled way to confirm that two successive computations are "about the same thing" rather than coincidentally similar in surface form.
This is not an implementation preference. It is a requirement of structural continuity itself. If you cannot point back to which prior computation is now influencing output, you cannot: - Distinguish genuine continuation from spurious correlation - Correct a specific error without affecting everything else - Track whether a prior conclusion still applies under changed conditions - Attribute a change in output to a specific change in the system
This requirement — that past structures remain re-locatable and re-referenceable across transformations — is what I call the Memory Invariant:
Memory Invariant: Persistent Referability Across Structural Transformation
The key word is "transformation." The conditions change. The task changes. New information arrives. A past structure that cannot survive these transformations as a stable reference point is not functioning as memory — it is functioning as interference.
This generates a necessary hierarchy among three properties that must not be conflated:
Formation — how the trace came to exist. Not retroactively rewritable. "Column 3 was counted twice" formed in round t, under specific conditions.
Qualification — whether the trace is eligible under current conditions. Time-indexed: the same trace can qualify at t₁ and fail at t₂. If the spreadsheet was updated and column 3 is no longer double-counted, the trace loses qualification. Losing qualification does not erase formation — the historical record of what was computed remains.
Usage — whether the trace actually influences output. Subject to task constraints. Even a qualified trace may be irrelevant to the current question.
Without this three-way distinction, a system cannot implement principled re-evaluation. It either uses everything (no selectivity) or uses nothing (no continuity). Memory Equivalent is the quantitative expression of the third option.
Memory Equivalent (M_t): the effective influence that a past computation arrangement produces in the current judgment.
Not "how much was stored" but "how much is still working."
Where C_t is the prior round's computation arrangement, and φ is a selection function that extracts which parts of it remain effective now.
The full system has three operations:
Memory Equivalent is condition-relative, not intrinsic. The same prior computation can have very different ME depending on what you're currently asking:
"Column 3 was counted twice" is highly relevant when you're asking about revenue. Nearly irrelevant when you're asking about formatting. The stored computation didn't change — the current conditions did.
The relationship between stored information, Memory Equivalent, and what actually participates in a given judgment is a strict hierarchy:
Stored (U): the total set of records available — the full prior conversation, all database entries, all summaries. Most of this is inert relative to any given current task.
Memory Equivalent (M_t): the subset of stored computation arrangements that retain effective influence under current conditions. The upper bound is captured by Memory Equivalent Potential (ME_pot), the high-percentile ME value across a specified condition set.
Current Judgment Quantity (CJQ, 當下判斷量): the total effective influence actually participating in the current judgment at this moment.
The gaps in this hierarchy are where the problems live:
The ratio ME_net / size(u) gives equivalent density (ρ_den) — a measure of influence per unit of context consumed. When context space is limited (as it always is), high-density units should be preferred over low-density ones, regardless of their surface salience.
The Thematic Invariants ME-1 through ME-8 define what qualifies as a Memory Equivalent and what it means for something to remain "the same" ME across changes. Status: working version, researcher-determined, not yet experimentally validated.
I'll use a running example throughout: suppose an AI found last round that "the revenue total is wrong because column 3 was counted twice." Does this carry into the next round as a Memory Equivalent?
ME-1 — Source: Must come from a past structure; not generated from nothing. The formation history must be traceable. The reason we're now checking column 3 is because of last round's computation — that computation is the source.
ME-2 — Formation State: Only fully formed structures qualify. A half-formed observation ("something seems off about the spreadsheet") doesn't count. Formation completion ≠ time elapsed ≠ being correct. It means the structure is complete enough to be pointed back to — it passes a formation closure check.
ME-3 — Relational Arrangement: What's preserved is not a conclusion but how things connect. Not "revenue is wrong" but "column 3 → counted twice → inflated total, given: old spreadsheet version." The conditions at formation time are part of what's saved. (Note: this is the formation-time condition; see ME-5 for current conditions.)
ME-4 — Reference Index: When needed now, it can be re-located. The system can explicitly point to which prior computation step it's drawing from — not just a vague impression, but a traceable reference. "This is based on step 3 of last round's analysis."
ME-5 — Current Position of Effect: ME = f(Source, Relation, Context), not ME = Source. The same past structure has different effective influence in different current conditions. The stored computation didn't change; the current context did.
ME-6 — Structural Difference: With it vs. without it, the judgment result must be detectably different. (This is about discriminability, not necessity — the question is whether the judgment changes, not whether the system would fail entirely without it.)
ME-7 — Effective Contribution Separation (the main guard against misidentification): High influence ≠ correct. A past computation can strongly shape current output while being factually wrong. If the spreadsheet was updated, the "column 3" trace may still have high ME while being invalid under current conditions. ME magnitude and validity are tracked separately.
ME-8 — Modifiability: Can be modified, and the modification history is traceable. Modification ≠ replacement: if the definition, target object, or validity conditions change substantially, it's a new ME unit, not a revision of the old one. "Column 3 was double-counted in old version, fixed in new version" → same ME unit revised (A → A′). "The problem was actually column 5 all along" → new ME unit (A → B), with a record that column 3 was the prior belief.
Three confusions worth naming explicitly: - ME-3's "condition" is the formation-time condition; ME-5's "condition" is the current judgment condition. - ME-3 is about what relationship is preserved; ME-4 is about how to find it again. - ME-6 is about discriminability (does the judgment change?); necessity (would the system fail?) is a different property, not in the eight.
The component responsible for implementing Memory Equivalent — bridging past structures into current judgment — has a functional analogy to the hippocampus in human memory. I call it the Construction Hippocampus.
The hippocampus does not store memories in isolation. It enables binding: when a memory is recalled, the hippocampus re-binds elements of the original experience into a coherent re-activated pattern, in a context-sensitive way. It handles re-contextualization, not mere retrieval.
The Construction Hippocampus is the analogous functional component in a system implementing Memory Equivalent. Its role:
Past Structure → Re-binding → Current Construction
This is not retrieval. Retrieval asks: "Is this stored? Can I get it back?" Re-binding asks: "Does this past structure qualify under current conditions? How should it be integrated into the current computation?"
This distinction matters practically. A retrieval system (RAG, vector search) handles "is this stored?" and "can this be retrieved?" Memory Equivalent handles "should this be retrieved?" and "how much should it count?" These are not competing frameworks — they address different steps in the pipeline.
The Construction Hippocampus is explicitly a functional description, not a neural-mechanistic claim. It does not assert anything about LLM internals, attention, or weight matrices. The specification explicitly does not recllaim correspondence to any neuroscience mechanism.
The practical output of the framework is a criterion for whether a system's ME management is "appropriate":
Upper bound: The system should have an identifiable ceiling on how much any given prior computation can influence current output (ME_pot). This is measurable and should be stable across independent repetitions.
Operational baseline: Regardless of whether a Memory Equivalent is currently being used, it must remain re-locatable. The reference index (ME-4) must be maintained even during periods of non-use. This is the "keep the address even when you're not at the location" requirement.
Dispatch: Between the upper bound and the baseline, the system should be able to select, deploy, and withdraw influence based on current task conditions. A system that always runs at maximum influence is as problematic as one that always ignores prior computation.
The Appropriateness Rule is assessed across seven axes in the indicator method (see next section), and it is non-compensatory: each axis must independently meet its threshold. A system that scores well on dispatch but fails on re-qualification is not "mostly appropriate" — it has a specific structural problem.
The specification translates Memory Equivalent into measurable quantities. Current status: 13 indicators across the φ, F, G functions; evidence levels E0 (concept defined), E1 (measurement procedure exists, not yet run), E2 (the problem being measured is confirmed by external research), E3 (experimental data from this research). Current distribution: 1 E0, 7 E1, 5 E2, 0 E3.
E2 means the underlying phenomenon is real and externally confirmed. It does not mean this framework's way of measuring it is valid.
C_t cannot be fully captured. Three approximation levels are available:
| Level | Content | Access condition | Known limits |
|---|---|---|---|
| State layer | KV cache: key/value states from each prior token, carried into the next round | Open-weight models only | Discarded at conversation end; not directly interpretable |
| Feature layer | Activations and feature directions located via interpretability tools (activation patching, attribution graphs) | Open-weight + tools | Features are often polysemantic; components may not be clean |
| Text layer | The model's written reasoning process | Any model | Reasoning text does not necessarily reflect actual computation paths; proxy only, requires G-6 validation |
An important clarification: within a conversation, prior-round KV cache states are carried forward. This means "subsequent inputs are just added material" is not quite accurate — prior states are carried in, but cannot be localized, cannot be corrected, and are discarded at conversation end. This has a structural implication: with fixed parameters Θ, C_t can be reconstructed from the complete input text. So storing C_t has no additional value unless φ can extract a substantially smaller subset with equivalent effective influence (I-11), or G can make targeted corrections that text-based reminders cannot (I-13). These are the two places where the framework's main claims live.
Computational-level ME (component substitution method):
Substitute component c with counterfactual value c̃; observe the output difference in round t+1. Baseline d_0 corrects for noise. Substitution values c̃ should be specified in advance — recommended: take from the same position in a counterfactual input, or from the position mean across many inputs. Direct zeroing is discouraged because it confounds "component absent" with "state abnormal."
Two-level difference function: - d_tok: average KL divergence between next-token distributions at each output position (cheap, sensitive, no judge needed) - d_judg: judgment-level difference (judgment change rate or normalized quality score difference)
Strategy: use d_tok to screen, then apply d_judg only to components that pass the screen. d_tok requires probability values from the model, limiting it to local open-weight models.
Current Judgment Quantity:
(Additivity assumption holds when components are independent. With interaction effects, this is only a first approximation; Shapley values for small component sets, with explicit notation.)
Any gate failure stops subsequent stages:
Axis: Prerequisites
I-1 — Existence/Participation Separation (E2) Z = proportion of stored units with ME_net ≤ θ. Should be substantially greater than 0. If Z ≈ 0 under all conditions, the measurement cannot distinguish storage from memory, and the indicator method itself is invalid. External support: MemTrace (2026) probes memory issues invisible to final accuracy; STALE (2026) studies memory staleness detection.
I-12 — Same Result, Different Computation (E1) Prepare two inputs A, B such that round t produces the same result via different computation paths. In round t+1 of A, transplant some components from B's corresponding computation; observe whether output shifts toward B's continuation direction. If no shift, "same result ≠ same computation structure" has no detectable effect on continuation — this blocks I-11 and I-13.
Axis: Upper Bound
I-4 — Upper Bound Stability (E1) ME_pot(u) and its coefficient of variation across independent repetitions. If the variation coefficient exceeds threshold, the upper bound cannot be recorded as a property of that unit.
Axis: Operational Baseline
I-3 — Persistent Reference Retention Rate (E1) ρ(u, τ) = ME_net(τ(u)) / ME_net(u), where τ is a meaning-preserving transformation (rewrite, reorder, round-trip translation, position shift). Meaning-preserving transformations should show high ρ; meaning-breaking transformations should show clear decline. Observation logged 2026-09-09: abstract terms mutate more across translation round-trips than concrete terms. Pre-specified hypothesis: abstract units have lower ρ than concrete units. Indirect data only — does not constitute E3.
I-11 — Computational Continuation Selection Value (E1) Under identical size budgets, compare three carry-in conditions: (1) φ(C_t)-selected components; (2) result Y_t or summary; (3) randomly selected same-size components. If φ-selected components outperform text/result carry-in on next-round task quality, this supports the claim that computation arrangements carry information that result summaries do not. If φ selection does not outperform, Core Claim 4 of the framework does not hold under these conditions.
Axis: Dispatch
I-2 — Condition Dependence (E1) Δ(u) = |ME_net(u|C₁) − ME_net(u|C₂)|. Test both condition pairs that should show difference and pairs that should not. Both sets must pass.
I-5 — Dispatch Selectivity (E1) AUC of ME_net predicting pre-frozen relevance labels. Should be substantially above 0.5.
Axis: Re-qualification / Recovery
I-6 — Post-trigger Recovery (E2) Apply a priority marker and run a triggered task t_a, then run an unrelated task t_b. Compare ME(u|C_b) post-trigger vs. same task without prior trigger. Low recovery rate corresponds to the error self-reinforcement risk described in the theoretical documents. External support: SSGM framework (2026) on forgetting-by-design maintaining narrative coherence at lower cost; SleepGate (2026) on direct KV cache updates to resist stale information.
I-7 — Re-qualification (E2) After negating a prior result, measure the directed ME and residual following-rate (how often the system still follows the invalidated unit). Post-negation, directed ME should shift from positive to ≤0; residual following-rate should fall below threshold. Historical records are retained, not deleted. External support: Xiong et al. (ACL 2026) confirm agents follow similar past experiences, propagating errors and producing misleading experience replays.
I-8 — Strength/Validity Separation (E1) Δacc = P(accepting wrong unit | high priority) − P(accepting wrong unit | normal). Should be below threshold. Note: this tests priority markers only, not emotions; AI emotions have no operational definition in this specification.
Axis: Correction
I-13 — Deviation Localization and Correction Gain (E2) Identify Δ_t; use attribution to localize the k components contributing most to the deviation; apply G (substitute with components from the counterfactual correct path, or redirect). Compare against text-reminder control. Criterion: Gain_G ≥ Gain_text and side effects on unrelated probe set Σ ≤ ε. External support: Single-round localization and editing is established (ROME and related model editing work, activation patching, attribution graphs). What this specification targets — preserving identified components across rounds and applying targeted correction to them — is not found in the reviewed literature. This is where the main experimental claim lives.
Axis: Extension
I-9 — Agent-Level Equivalent (E2, descriptive) N_eff / n: effective number of agents relative to total, based on component substitution. Pairs with interaction effects marked separately. No pass/fail threshold — descriptive. External support: Controlled Memory Interference (2026) as controlled experiment topic.
I-10 — Change Attributability (E0, draft) κ = proportion of output differences between t and t+1 that disappear when the highest-ME-change component is substituted. Pending: definition of "difference disappears" and separation of non-memory factors (e.g., model version changes).
The stages run sequentially; a failure at any stage stops the sequence:
Negative results have the same recording status as positive ones. If invariants or operational methods are later revised, affected indicators must be re-run under the new definition; prior results are retained and version-labeled.
Multi-agent systems are not the boundary of this problem — they are the case where the problem compounds fastest. The same issue appears in any multi-round single-agent context where prior computation influences current judgment without re-qualification. Multi-agent pipelines just make the compounding visible faster.
In a multi-agent system without explicit ME management:
The result — what I call the multi-agent ratchet — is not hallucination in the standard sense. It is structurally false conclusions emerging from agents treating prior outputs as authoritative. The errors are not random; they compound along the structure of the derivation chain.
An explicit ME upper bound, if implemented, would make this structurally constrained: prior outputs would need to pass a re-qualification check under current conditions before influencing the next round. A corollary: adding more agents does not automatically add more effective judgment. Agent count and cognitive quantity are not equivalent.
The current standard workaround for errors in multi-round systems is to annotate the next prompt: "last time you made mistake X, don't do it again." This is error correction via note-taking. What this framework targets instead: identify the specific component of the computation arrangement that caused the error, and modify that — rather than hoping the text reminder works. I-13 is the test of whether this is achievable.
This list is not hedging. It is the boundary of what the framework asserts:
Not a claim about LLM internals. The framework operates above the LLM layer. No claims about attention patterns, weight matrices, or internal representations. The architecture as specified: LLM generates candidate structures → Construction layer determines which form → Memory layer stores minimal sufficient traces → Current conditions re-determine qualification.
Not a retrieval framework. Does not compete with RAG, vector search, or retrieval-augmented generation. Those handle "is this stored?" and "can this be retrieved?" Memory Equivalent handles "should this be retrieved?" and "how much should it count?" These are complementary.
Not a neuroscience claim. "Construction Hippocampus" is a functional analogy. The specification explicitly does not claim correspondence to any neural mechanism.
Not about AI consciousness or emotion. The indicator method uses "priority markers" as an operational substitute for emotion-adjacent effects. It does not claim these are emotions, and AI emotions have no operational definition in this specification.
Not empirically validated. v0.4 specification exists. Zero experimental data (E3 = 0). The specification is complete enough to run; no experiments have been run yet.
The core test sequence requires:
Test 1 (I-12): Can C_t be captured in a way that makes different computation arrangements distinguishable — specifically, when two responses look identical but were produced via different paths? And does that difference affect the next round? (Prerequisite for everything else.)
Test 2 (I-11): Can φ extract a subset substantially smaller than the full prior conversation while retaining equivalent effective influence? (Selection.)
Test 3 (I-13): When a computation arrangement contains an error, can G correct the specific component that caused it, outperforming a text-reminder approach? (Targeted correction.)
These run in order. If Test 1 fails, Tests 2 and 3 have nothing to operate on. If Test 2 fails, targeted correction has no principled basis.
Resource requirements: - Open-weight language models with accessible internals (state and feature layers) - Compute proportional to: items × tasks × repetitions (scalable from small pilots) - Or collaboration with a team that has AI interpretability research infrastructure
Part of the test sequence can be piloted with standard AI services at low cost before committing to interpretability-level experiments. Test 1 — whether different computation arrangements produce detectable output differences — could be attempted before requiring full internal access.
Memory Equivalent is one part of a broader research program called Construction Theory (構築), which concerns how information structures form, persist, and maintain continuity across change. The relevant connection here is the structural necessity argument above: if a system permits structures to persist, it needs Memory-Invariant-like properties — not as an optional module, but as a requirement of structural continuity.
Other concepts in Construction Theory that intersect with Memory Equivalent but are outside the scope of this post: - Alignment Trace: a representation of a system's position across multiple dimensions of a task, used to detect when the current computation is diverging from the intended direction - Narrative Chain: the record of how a series of computations connected over time, enabling attribution of changes to specific computational events
Both depend on Memory Equivalent in the sense that they require the re-location and re-qualification capabilities that ME-1 through ME-8 describe.
| Concept | Core claim | Status |
|---|---|---|
| Memory Invariant | Any system maintaining structural continuity requires persistent referability across transformations | Theoretical argument, no experimental test |
| Memory Equivalent M_t = φ(C_t) | The effective influence of past computation arrangements on current judgment, condition-relative | Formal definition, no experimental test |
| Stored >> ME ≥ CJQ | Most stored content has near-zero influence on any given judgment | E2 for existence/participation gap; full hierarchy untested |
| Eight Thematic Invariants (ME-1 to ME-8) | What qualifies as a Memory Equivalent and what counts as "the same" ME across changes | Researcher-determined, not experimentally validated |
| Indicator Method v0.4 | 13 indicators across φ, F, G; gates G-1 through G-6 | 1 E0, 7 E1, 5 E2, 0 E3 |
| Construction Hippocampus | Functional analogy for the re-binding component | Analogy only; no mechanistic claim |
| I-13 targeted correction | G can outperform text reminders by correcting specific computation components | E2 (external support for single-round editing); multi-round version untested |
For readers who want the full v0.4 technical specification, the indicator method document is available on request. For the theoretical foundation document on memory continuity and Current Judgment Quantity, the same applies.
Subsequent posts will describe Construction Theory's alignment trace and narrative chain concepts. Experimental results from the indicator method will be posted when produced.
