Reframing this point: Some good books aren’t borrowed because they’re not discoverable, not because they’re boring.
The library is highlighting a few titles for increased visibility to ask, “would this pique a reader’s interest if they knew about it, or is this generally bad?”
Without this stage, the library would expunge more genuinely interesting titles.
I’ve always kinda felt the role of a library is for recall rather than precision
Good points, makes me reconsider. Than you. 100% keep going—this is how you learn! I hope my complaining about the commoditization AMA individualism of AI doesn’t add too much elitism or discouragement to the discussion, though rereading my post I definitely see how it could.
In a sense, sharing products in threads like this helps future people see what else has been done!
It’s insidious! I used Claude code at my last job enough for it to influence my writing and speaking style without me really noticing, even though I tried to be wary of that.
Oh pardon, I’m trying to sarcastically complain how a lot of comments in this thread have a similar form: “I used this pattern in my own agent, which is different from (all the other agents which use the same representation)”
Agentic development tends to encourage siloed individualistic development, so a lot of engineers reinvent similar patterns from first principles. It’s easier to write your own new thing than survey other approaches, so you’re more likely to perceive good ideas as original to your session.
Agree with your critique. I think this work is presenting common ideas as novel without thinking through existing problems. Defining a provider-agnostic event graph that enables full session branching replay was the whole point of pi: https://mariozechner.at/posts/2025-11-30-pi-coding-agent/ , though the language around it perhaps didn’t click until a bit later. I don’t even think pi was the first to do this.
Another critique: the abstract mentions how their system allows for “branch[ing] a run at any event without re-executing the shared prefix,” but that’s only possible with very careful KV caching. Generally, rerunning inference from an earlier point still incurs O(n) input token cost and this paper is working at the wrong layer to see that. In this work, execution refers to tool calls but token generation is the expensive part.
Very cool work!! This is the same pattern we used at $MY_STARTUP to develop $MY_HARNESS which persists the entire graph to disk, unlike all the other agent harnesses which only store the graph nodes and edges.
Event graphs aren’t just the agentic foundation for $MY_HARNESS — they’re the working cognitive substrate, native to what our favorite toolcall gremlins actually consume.
(Looking for lead investors for our angel syndicate btw! DM me if interested)
posters upthread are talking about comprehension and value systems, not literacy.
"functionally illiterate" is the brush that one paints with when describing people of opposing political viewpoint or lower socioeconomic status, for example.
This page starts flickering madly when I pinch-to-zoom. Until a11y details like this are figured out, I don’t think this should be considered for general use beyond a cool prototype.
I could write a program to generate the first 100MB of pi in a couple kilobytes. That certainly counts as “data compression” but isn’t useful outside this particular problem instance.
There are two forms of compression relevant to LLMs:
1. Reduce the number of parameters
2. Reduce the resolution of each parameter (quantization)
For 1, changing the architecture is typically only possible by the labs producing the models, which is why each OSS model release tends to feature a small number of carefully chosen model sizes (for example, Gemma4 comes in e2B, e4B, 12B, 26Ba4B, and 31B sizes).
Generally, models with higher parameter counts have more world knowledge. For coding models, this shows up as a stronger command of uncommon libraries/languages. Very small models (<20B) also lack “smarts.”
Reducing the resolution of each parameter is easier which is why lots of practitioners have their own quantizations, but this makes it harder for a model to “think” fluently. Interacting with heavily quantized models feels like interacting with someone who didn’t get any sleep the night before.
Models that have higher-fidelity quantization take more RAM and have higher “smarts,” but don’t necessarily have more world knowledge. Models with aggressive quantization tend to be more likely to make rookie mistakes, emit malformed tool calls, get stuck in loops, or even exhibit signs of “neuroticism” / “distress” in their thinking tokens.
Parameter counts = world knowledge, quantization = “smarts.”
This is a soft rule of thumb, the difference isn’t very strong.