📝 Influence_Ch6_rewrite_1.mdv4.6.3 · 2026-11-01

Project Influence - Chapter 6 - rewritten through two agent-memory articles

Date: 2026-11-03 (Sydney) | Another collaboration between Andrew.human and Claude.ai Rollback point: Influence_Ch6_rollback_2.zip (state before this rewrite).

Sources read:

A caution first. Both articles are about agent memory held as text in a database and put back into the prompt. Neither mentions logit bias. Everything below applies them by analogy. Where the analogy is strong I say so, and where it is only a hunch I say that too.

1. What changes in how Influence is described

The articles define agent memory as information written to storage outside the model during a run and retrieved on later calls. That splits memory into four jobs: write, store, retrieve, deliver to the model. Nearly all of the articles are about the first three, and all of them assume delivery is text placed in the context window.

Influence's experiments so far test only the delivery step, through a different channel: the logit push at the last stage, with the mem-tok store (words, word pairs, mini-phrases) assumed to exist. That is a narrower and more precise way to say what Chapter 6 has been doing than "pseudo memory". It also explains why the results look the way they do: the delivery channel has no write policy, no expiry and no trust, which the articles say are exactly what makes memory fail.

2. Memory types mapped to Influence

Article's type Holds Influence equivalent Status
Working Active task state, short expiry The context window (standard prompt plus the reply so far) and, in step-by-step mode, the per-step state (--follow remembers a phrase's first piece until the next piece is chosen) Exists, but only inside one job; no expiry rule
Episodic What happened Archived chat transcripts; the staircase run logs (run_*.json, one per setting) Logs exist; nothing retrieves them yet
Semantic Facts that get updated The mem-tok store: whole word, word pair or mini-phrase as key Candidate list only (29 phrases); no update rule
Procedural How to do things The "BASE RULES" layer; the findings on safe push levels Findings exist as notes; not a stored layer

Your own taxonomy (episodic internal, semantic external, procedural operational) lines up with the articles' types. The articles' main warning is that these layers need separate namespaces, schemas and retrieval rules even on one backend. You had already asked for separate stages (context definition, RAG, LLM2, LLM1) so that each could be debugged. That is the same advice.

3. The logit push seen as "retrieval and delivery"

Article's pattern Result in our runs Reading
Retrieve at each decision point, not once (A, B) Step-by-step mode (--gate, --follow, --mid) decides at every token. Fixed whole-reply push does the opposite: one decision applied to all 120 steps The step-by-step design is the one the articles recommend. The fixed push is the "retrieve once" pattern, and it fails the way they predict
Memory without maintenance is technical debt: TTL, confidence decay (A) A fixed push on " missing": +3 nothing; +6 a good start for three sentences, then "So missing data is missing information." repeats; +10 and above one word for 117 to 120 steps The push never expires. Once the word is in the text, Attention makes it likelier by itself (only 9 of 27 forced steps overrode the model's own top choice at +6). A push that fades or caps is the TTL the articles ask for
Trusting every write equally invites poisoning (A) +50 on ranks 4-30: the model took its 4th-ranked token at all 120 steps and wrote question-style filler A bias is the strongest possible unguarded write. Large levels are "trust everything" and the reply collapses
Free-form summaries lose detail and keep wrong statements (A, B) Not tested. The mem-tok store is built from extracted words and phrases, not prose summaries Consistent with the articles' "structured extraction, not free-form summary" advice. Relevant to the media-compression memory idea: the lossy-summary route is what the articles warn about
One undifferentiated store fails (A, B) The first staircase pushed 29 phrases as one flat group A flat group competes for one slot per step; the group gives no structure to separate by purpose

4. Write policy: the gaps (article A's seven questions)

Question Influence today
What triggers a write Hotwords extractor over queries and replies (v2.2.0). Trigger rule not defined
What gets stored: raw, extracted or summary Extracted words and phrases (structured)
Who can write to each namespace Undefined. Design note: LLM2 owns the store; LLM1 only reads
TTL per memory type None
Minimum confidence None. No importance or confidence score on a mem-tok
How conflicting facts are resolved Undefined. This is the core of "never repeat a mistake once corrected"
What happens to memory after a rollback Undefined; the rollback zip covers files, not store state

These are the real gaps in Influence. They matter more than any further tuning of push levels.

5. Provenance and trust

Article A records agent, tool, input hash, session and a trust level on every memory entry. The harness records some provenance per run (version, server, model, prompt md5, levels). It records none per push: which word was pushed, from which store entry, from what source, with what confidence.

The safe push window found so far gives a way to use a trust level: bias = f(importance, confidence, trust), capped inside the range that stayed fluent (+3 to +6 for words near the top). That is the logit counterpart of article A's should_persist gate and trust levels. It is a design idea, not a tested result.

6. Corrections: the "never repeat a mistake" goal

Article B's table says Graphiti handles a changed fact by invalidating the older relationship while keeping its history queryable. Influence's goal is a corrected mistake that does not recur. The matching design: a correction entry that pushes the wrong token down (negative bias), while the original mistake stays as an episodic record. This is the unbuilt --suppress WORD test, now with a purpose. Whether a 4B model's output holds up under suppression has not been tested.

7. Evaluation: article B's four metrics applied to our runs

Metric (B) Meaning for Influence What we measure now
Retrieval recall Pushed word reaches the text when it should "forced" and "completed" columns
Retrieval precision Little irrelevant material comes with it "stray" (first piece without the phrase), wrong-sense leaks, genre flips; only partly measured
Faithfulness The model uses the word correctly in its reasoning Read by eye only. " missing" at +6: used literally ("missing data is missing information"), not connected to the lecture's point about dropouts and failures
Staleness Retrieves what is no longer true Not measurable yet: the store has no time dimension

Faithfulness is where Chapter 6's real finding sits. The push gets the word in (recall), but the 4B model does not carry it into the argument.

8. Results kept (unchanged, restated)

One prompt (md5 d78a0cc6...), temperature 0, 120 tokens; indicative only.

9. Revised next steps (in the articles' terms)

  1. Capped or fading push (the maintenance rule): word fires up to N times, or the bias halves each time it appears. Direct answer to the +6 "good start then loop" result. New code option; would be listed as an unrequested change before building.
  2. Per-push provenance in the run logs (word, source entry, level, step). Same: unrequested until agreed.
  3. Finish the open runs: " wartime aircraft" (levels 2-8), " missing" +4/+5, bare-word " bomber" with the "first thought" instruction.
  4. --suppress WORD with the war prompt, as the correction mechanism.
  5. Write-policy table (section 4) filled in as design decisions, one row at a time, before any store is built.
  6. Report the four metrics (section 7) in the summary, with faithfulness scored by hand until a better method exists.

10. What this rewrite did not change