AI does benefit from learning to use skills, and being instructed with good structures (like “save [specific important kind of detail] in memories” and “plan before implementing anything”). But none of these memory solutions seem better than any other, they’re basically just different folders. Your CLAUDE.md can say “see AGENTS.md” and AGENTS.md can say “write memories to .agent/memories/“, and I’d be interested in a measurement, but I assume it performs almost the exact same as native CLAUDE.md and .claude/memories.
One thing I’ve noticed AI does much better than me, is not have OCD over the “perfect” solution.
It's even worse when applied to LLMs, which are more unpredictable.
I usually read the comments before deciding if the article is worth my time.
This has no value because noone can separate what was designed by a human from design details that the LLM made up on the spot. That's fine for one-off generated stuff like web pages, but as a proposed standard for everyone to build on? No.
Yes it is and it's not a technical one: https://digital-strategy.ec.europa.eu/en/policies/eu-icons-l...
Given that the author could already have just inserted the text “hey I generated this via AI”, I see absolutely no reason why they’d go to the effort of adding an “AI label”.
Honestly I do not care if article was written letter by letter by human or written by agent steered by human.
I care about knowledge and quality, it it is there then it doesn't matter how was it written. I too hate LLM slop but I understand that not everything done by LLM have to be slop.
Yes the style is annoying and bombastic, but the objection goes deeper than that; it's annoying to have someone generate text with an LLM from a small outline or prompt, not even edit it for sense, and dump it on readers.
At the point where you read enough LLM written text with zero substance narrating wikipedia article or heard that voice on youtube restating the same thesis over and over for 15 minutes.
The rule of thumb: if I can detect it's an LLM without trying to detects it's an LLM and the feeling doesn't go away, it's a slop.
The sections, points, ideas are by me :)
Besides, do we really want memory of user A's agents to co-exist with memory of user B? Not really. So the argument for collaboration and sharing is quite slim, at least for coding agents. The repository specific context can be encoded into a docs/ or architecture/ directory, just like it's been done pre-agent times as well.
For monitoring deployed agents: maybe. For this I built (yet another) memory management tool slivingdoc.dev, with this it's possible to pull down the durable context of all agents. But here the problem is a distributed system one, not format of the memories.
It would be like trying to accomplish something as a human but all your reference material is always in a different format, it would be maddening.
Only it's not read by agents, and largely ignored.
From Anthropic's recent self-congratulatory article:
---start quote ---
Injected memories use up valuable tokens, and an incorrect note can be carried into every session. Loading a note also doesn’t guarantee that Claude acts on it: our documentation on Claude Code warns that longer instruction files reduce adherence
...
It loads only the first 200 lines or 25 KB of MEMORY.md
https://www.anthropic.com/research/components-of-agent-memor...
--- end quote ---
The agent actually did pretty well managing and searching it with grep.
A lot of these memory systems are reaching for the stars and I sort of suspect we’re way past the Pareto point for coding there.
Like what are you store there that text files aren't enough.
The notes for v1 probably don’t apply to v2.
Maybe different if you’re doing a global memory instead of a per-project memory.
While there have been many attempts to structure how agents operate, a recent Anthropic article showed that when they didn't tell Claude how to use memory, it actually used its memory better. Ultimately, we have to come to terms with how little is required from us when LLMs are this intelligent. often doing things better in ways that we sometimes cannot comprehend.
The bytedance team makes it. I often wonder if it does not get attention here in America b/c it is Chinese?
but is were going to make the memorys portable.. we need to make the things they are pointing to portable also..
I don’t think “oh it’s lines 10-50 in file A that has this code I’m looking for”. It’s much looser, something like:
- maybe I can’t fully remember file A’s name but I can fuzzy search for it based on what I do remember
- I search for a function or variable name that I remember, again kind of fuzzy searching. Or if I can’t find it,
- I start quickly scanning the whole file for relevant variable/function names
Obviously storing exact references will be more efficient at lookup time but to your great point, the environment is changing too much, especially now. Having just a) a starting point on where and what to search and b) an understanding the code base will and should change , feel like some of the principles a memory system should assume. Not that it’s mutually exclusive with what you said - just not sure the juice is worth the squeeze to make the thing memory is pointing to portable.
Imagine how humans would function if we carried our memories around in overflowing notepads and had to consult them every time we wanted to know a fact or remember a person we had met, it would be exhausting and inefficient.
What are some real issues now? Auth? You want to retroactively implement boundaries? Is version control the problem?
This looked interesting, unfortunately it feels far too long for humans to spend time reading.
People might really be starting to write like LLMs, it’s why reading books is the single biggest anti-slopping protection for the human brain.
The “shape” of the article was a word generator performatively generating larger words where simpler ones would do. “That holds”
This has the benefit of being something you can easily read over every now and then to make sure the model hasn't baked in some random comment you made about a specific circumstance a month ago and made a weird religion out of it.
“Oh damn look its recommending something that looks like hexagonal architecture. I guess hexagonal is a really good - hey wait a second …”
Memory just ensures there is a fairly high level of drift and inaccuracy in your context. Unless YOU are manually curating it.
Its similar to wiki systems where your agent produces tons of documentation and decision records, etc. Its a bunch of assertions about your codebase that you aren’t vetting and which is at most 90% correct. Thats good enough for a feature or bug fix that you can validate with tests but for the love of god throw the details away. You don’t want to codify that. It’s polluting the context and gimping the model.
We only have OpenTelemetry because of years of people working out what metrics and logging look like.
It’s too early in my opinion to standardise agent memory.
The best version of memory I've experienced is when I give my agent a memory directory and just let it do what it wants in there, with minimal rules on my end.
Index it all. Embed it all. Give your agents the ability to query it all. Eval different configurations to figure out what works best for you.