Tanish Chudiwal

[Tanish Chudiwal @TChudiwal]

Roses are red,
Violets are blue,
I corrected the model,
It still thinks the old thing is true.

LLM memory isn't just about remembering. It's about changing your mind when facts change.

Eg: an agent learns get_user(user_id) & a merge changes it to get_user(org_id, user_id)
1/3

[Tanish Chudiwal @TChudiwal]

@oliviscusAI Fresh context per phase handles the clutter side of context rot. The saved plan is what carries over: if a decision changes mid-project and the plan isn't updated, the next agent inherits the stale one. Related: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@sohvnk Same tension in fast-weight memory, where the write rule decides it: an additive write blends a corrected key's old and new values, while a residual (delta-rule) write replaces the old one. Worked through here: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@kaz_066 A dedicated writer makes sense; the hard call is the update. When new info contradicts an entry, does it replace it or sit beside the old one? Curious what Hy-Memory does by default. We dug into that split: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@thisguyknowsai Verbatim beats summaries for recall. The catch is when a fact changes: old and new conversations both sit in their drawers, and R@5 happily returns both. Something still has to say which is current. More: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@DanKornas Useful map. A trade-off I'd add to agent memory: what happens when a stored fact changes. Retrieval keeps both versions and leaves the pick to ranking; some architectures overwrite instead. We compared them: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@MuskaTate3313 It has to hold at retrieval. A soft 'forgotten' label leaves the old memory in the store, so every lookup re-decides which copy wins. Replacing the entry on write avoids that; it's our case for delta-rule memory: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@Yumzlef The 8-of-40 point is the one I'd dwell on: those layers carry all long-range recall and cache every version of a fact. If a fact from 600K tokens back gets updated, do 8 layers pick the newer copy? https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@iamgrigorev Nice roundup. At 5:1, anything past the window lives only in the global layers' KV cache, which only appends. When a long context corrects an earlier fact, a few layers must choose between both copies: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@nv_pavlichenko I'd split 'compress' in two: a plain linear-attention state sums writes, so a revised fact blends with the old one; a delta-rule state writes the residual and can replace it. Matters for SWA vs LA: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@pathway_com @JChorowski @OpenComputePrj Fire together, wire together' covers the write. What I keep wondering about BDH is the reverse: when a fact changes, what weakens the old association? We compared write rules on exactly that: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@DailyDoseOfDS_ A transferable KV cache is portable working memory. It also carries a quirk: the cache only appends, so if the context corrected a fact, both versions move over and attention still has to pick: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@eliebakouch In these hybrids, window layers drop what's past the window and global layers keep everything but only append. Neither revises an old fact, so a correction competes with the original at read time: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@ShivamGarg91462 Compacting in KV space skips the detour through text. Memory-side question: if later reasoning overturns a step that's already compacted, can those entries be corrected, or only outweighed by new ones? Related: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@spantacular @behrouz_ali Window attention plus Titans memory for the history is a neat retrofit. Titans writes via a gradient step on recall error, so revised facts should overwrite, not pile up. Does that survive retrofitting? https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@vicky_grok Flip side: the KV cache is also the model's working memory, and it only appends. If a later turn corrects an earlier fact, both stay cached and attention has to pick. Fixed-state models trade the other way: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@v_shakthi That per-token full-state read/write is the cost side of a fixed-size state. The other side is what each write does to existing content: decay fades it, a delta-rule update overwrites the matching slot. More: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@Yash_KVR Agree it's a write problem. The hard write is the one that contradicts an existing row: if it lands as a new insert, the wrong assumption stays and competes at read time. Writes need update semantics: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@code_kartik One read of learn2play: a summary is a lossy write. When a later observation contradicts the rule, the evidence to revise it is gone; a full record keeps it. The hard part is then superseding old entries: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@seungwookh The natural sequel to store-then-recall is update: in a linear associative store, a new value for an existing key adds to the old one instead of replacing it. The delta rule's residual write fixes that: https://t.co/8l1Cbc4C7r

[Tanish Chudiwal @TChudiwal]

@thenewstack A shared layer cuts rebuild cost, but one stale entry then misleads every agent at once. The part worth testing is a write that contradicts an existing fact: replace, append, or flag? Notes: https://t.co/8l1Cbc4C7r