MurphyA/hacker-news huggingface dataset:
Show HN: Sleeping LLM – A language model that remembers by sleeping
by vbaranov87 | 2026-02-26 06:09:07+00:00
I built a system that gives LLMs persistent memory from conversations — not through RAG or databases, but by editing the model's actual weights. The knowledge lives in the parameters. The context window is empty.

During wake, facts from conversation are injected directly into MLP weights via MEMIT (a single forward pass, instant recall). During sleep, the system audits which memories degraded, refreshes them with null-space constraints (guaranteeing orthogonality to working memories), then progressively transfers knowledge into LoRA — like biological memory consolidation from hippocampus to neocortex.

The key problem was a hard capacity ceiling: the 8B model sustains 0.92 recall up to 13 facts, then crashes to 0.57 at fact 14 — a sharp phase transition, not gradual decay. And LoRA consolidation was blocked by what I call the "alignment tax": RLHF training fights back against injected knowledge (37% recall loss on 8B from a single LoRA pass).

The fix: per-fact graduated consolidation. Each fact independently tracks its own stage and advances only when LoRA proves it absorbed that specific fact. A dissolution schedule (1.0 → 0.5 → 0.1 → 0.0) gradually removes the MEMIT edit as LoRA takes over. And cumulative fusing — training each cycle on the already-fused model — reduces the alignment tax from catastrophic to negligible (starting loss drops 2.91 → 0.62 by cycle 2).

Results on Llama 3.1 8B (4-bit, 2×H100):
- 100% advancement rate at 5/10/15/20 facts
- 1.00 chat recall at all scales
- MEMIT edits dissolve on schedule, making the buffer renewable
- Effective lifetime capacity: unbounded

There's also a biological curiosity: individual facts consolidate at different rates. One synthetic fact ("Aria lives in Portland") is consistently the hardest across very run — some memories are just harder to absorb, same as in biological systems.

6 papers documenting the full journey from initial LoRA prototype to this result: https://doi.org/10.5281/zenodo.18779159

Built with: Python, PyTorch, PEFT, BitsAndBytes, Llama 3.1. Runs on MacBook Air (3B) or H100 (8B/70B).
by CodeBit26 | 2026-02-26 06:09:19+00:00
The biggest shift isn't the speed of coding, but the shift in 'seniority' expectations. You're no longer just a writer of code; you're an editor of high-volume output. The mental fatigue has shifted from 'how do I solve this' to 'is this generated solution actually robust for our scale'. Big tech feels more like orchestrating a fleet of junior agents than solo deep-work now.
by Panzerschrek | 2026-02-26 06:09:19+00:00
Since std::variant was introduced I use inheritance and virtual calls much less than before. It's faster, since variant dispatch (via std::visit) is basically a switch statement with all execution paths visible to the compiler and thus inlining is possible. Inheritance and virtual calls are nowadays only necessary in places where it's not possible to statically list all alternatives (where the set of derived classes is open).
by palmotea | 2026-02-26 06:09:48+00:00
> It's too well structured and the message is too clean. HN (and the whole internet) is allergic to proper writing. We praise human sloppiness now.

Yes. And it's only a matter of time that the model companies start to try to train in that "human sloppiness." After all, a lot of their customers want machines that can pass for humans.

> No, I'm not being sarcastic. People have given up em-dash, which is an official punctuation you use in proper writing. And it's all a downhill from there.

I wouldn't be surprised if the internet language of people devolves into a weird constantly-changing mish-mash of slang and linguistic fads. Basically an arms race where people constantly innovate in order to stay distinct from the latest models.

But the end result of that would be probably fragmentation, isolation, and a kind of dark ages. Different communities would have different slang, and that slang would change so fast that old text would quickly become hard to understand.
by CodeBit26 | 2026-02-26 06:09:55+00:00
Technically? Probably. But the 10% cost isn't where the battle is. It's the 90% trust and 'organizational gravity' that legacy companies hold. You can replicate the stack with AI agents in a weekend, but you can't replicate the compliance, the sales relationships, and the 'nobody ever got fired for buying IBM' safety net. AI has lowered the floor for entry, but it hasn't lowered the ceiling for enterprise trust.
by johnsmith1840 | 2026-02-26 06:10:30+00:00
Echoing the other comment they showed another big thing which is that the output if an AI model is the AI model. If you mass prompt scrape their AI you can recreate it almost exactly.

Very dangerous if you think about it that the product itself is the raw building block for itself.

Openai spends 1B$ on their model, releases it and instantly it gets scrapped by a million bots to build some country or company their own model.
by libraryofbabel | 2026-02-26 06:10:47+00:00
I have come to think “predict the next token” is not a useful way to explain how LLMs work to people unfamiliar with LLM training and internals. It’s technically correct, but at this point saying that and not talking about things like RLVR training and mechanistic interpretability is about as useful as framing talking with a person as “engaging with a human brain generating tokens” and ignoring psychology.

At least AI-haters don’t seem to be talking about “stochastic parrots” quite so much now. Maybe they finally got the memo.
by OakNinja | 2026-02-26 06:11:17+00:00
For me personally, both at work and in my free time, I spend _more_ time on writing things _that matter_ since I’ve freed up time by using LLM’s for boilerplate tasks.

My motto is - If it wasn’t worth writing, it won’t be worth reading.

A good example of writing where I’d recommend using LLM’s is product documentation. You pass the diff, the description of the task, and the context (existing documentation) with a prompt ”Update the documentation…”.

Documentation is important but it’s not prose. However, writing a comment on hacker news is.
by dubbie99 | 2026-02-26 06:11:37+00:00
That’s not really how 3D modelling works. You can’t just improve some of the model. You have to improve all of it. Fixing to top of the paddle also changes how the junction at the handle goes and so on. That’s why no one has solved ai 3D modelling yet. It’s like asking a gymnast to learn how to do the second half of a handspring first, and then for step 2 they can learn the first half. It doesn’t work like that.
by giang_at_glai | 2026-02-26 06:11:37+00:00
Author here.

This post shows “concept algebra” on language model: inject, suppress, and compose human-understandable concepts at inference time (no retraining, no prompt engineering).

There’s an interactive demo on the post.

Would love feedback on:
(1) what steering tasks you’d benchmark,
(2) failure cases you’d want to see,
(3) whether this kind of compositional control is useful in real products.

Related: https://news.ycombinator.com/item?id=47131225
by rurban | 2026-02-26 06:11:38+00:00
Nonsense. He dislikes better security reports because they are verbose? I got many LLM generated security reports lately, and they were just better. Way better. Detailing every step. The better the report, the less time the maintainer needs to verify and fix it.

He is probably a cranky racist who dislikes LLM's. And celebrity-style security blog posts.
by spoaceman7777 | 2026-02-26 06:13:24+00:00
This assumes that it will only be scrupulous software engineers using these systems. Which is anything but the case.

Not to mention the many tales from Anthropic's development team, OpenClaw madness, and the many studies into this matter.

AI is a force of nature.

(Also, this article reeks of AI writing. Extremely generic and vague, and the "Skynet" thing is practically a non-sequitur.)
Show HN: Trust-gated developer communities with portable identity (AT Protocol)
by JohannaWeb | 2026-02-26 06:13:33+00:00
Hi HN — I've been working on Falcon, a developer collaboration platform built around portable identity instead of server ownership.
The core idea: communities shouldn't disappear when a platform, server, or admin does. Your identity and relationships should persist.
This latest iteration moves Falcon into a service-oriented architecture and introduces a trust-gated access model tied to AT Protocol identities.
What's new:

Identity-first access: entry to communities based on verified identity + trust signals, not invite links
Trust service: prototype for reputation/relationship-based gating
Gateway: auth + routing boundary for identity-aware services
Real-time infra: JetStream-backed messaging layer in progress
Mono-repo with bounded services: gateway, trust, messaging (SIV), client, protocol lexicons

The goal isn't "decentralization for its own sake." It's to test whether developer communities would coordinate differently if identity and membership weren't locked to a single platform like Discord or Slack.
Still early:

prototype stage
infra evolving quickly
no production deployment yet

I'm a solo founder with 10 years of backend experience, building this because my community needs it.
I'm especially looking for feedback from OSS maintainers, infra/protocol engineers, and teams running private dev communities.
Main question: Would identity-portable, trust-gated communities actually change how dev groups collaborate — or is platform gravity still too strong?

repo: https://github.com/JohannaWeb/ProjectFalcon
by daxfohl | 2026-02-26 06:13:49+00:00
Well there's the whole race to ASI thing. Whoever gets there first, the world is theirs. The thing will learn how learn, an intelligence feedback loop, make its own apps, find more efficient algorithms, deploy itself to more locations, bankrupt all competitors, embed itself in everyone's lives, and create a complete monopoly for the parent company that can never be touched. Until it goes rogue anyway.

(Aside, it's interesting how perceptions of these things have changed in one year: a whole article on OpenAI's future that makes no mention of AGI/ASI)
by themafia | 2026-02-26 06:14:09+00:00
> but do not have even a theory about how the behavior emerges

We fully do. There is a significant quality difference between English language output and other languages which lends a huge hint as to what is actually happening behind the scenes.

> but how exactly does anthill behavior come from ant behavior?

You can't smell what ants can. If you did I'm sure it would be evident.
Show HN: SendView – Mail merge from Airtable/GSheets, sends through your email
by jbrake | 2026-02-26 06:16:59+00:00
I built a mail merge tool that connects to Airtable views, Google Sheets, or CSV files and sends personalized emails through your own Gmail or SMTP account.

The problem I was solving: I had contact lists in Airtable and needed to send personalized emails — but didn’t want to stitch together something with Zapier + SendGrid and I didn’t want my data flowing through a third-party email service. I wanted something that reads from the spreadsheet, lets me write a Handlebars template with variables and conditionals, preview every email, and send directly.

Tech: Electron + React + Express. Desktop mode encrypts credentials locally with safeStorage, forks the Express server as a child process. Airtable integration parses view URLs and respects view filters/column visibility. Fuzzy matching (Fuse.js) auto-maps template variables to column names.

One-time purchase, 14-day free trial.
by JohannaWeb | 2026-02-26 06:17:58+00:00
I’m already using GPLv3 — I want Falcon to stay open and for improvements to remain in the commons rather than becoming closed forks.

The README wasn’t AI-generated. I wrote it and iterated on it a lot — though I’m sure it still reads rough. The goal right now is clarity over polish.

Re: AT Protocol — the main reason is identity portability.

Most dev communities today are anchored to a platform (Discord/Slack), not to an identity layer. If a server disappears, the community graph fragments. AT gives:

DID-based identity

portable handles

a protocol-native social graph

I’m exploring whether that can support communities that aren’t tied to a single host.

Still very early — a lot of this is experimental.
by fc417fc802 | 2026-02-26 06:19:01+00:00
> but do not have even a theory about how the behavior emerges from among the math

Actually we have an awful lot of those.

I'm not sure if emergent is quite the right term here. We carefully craft a scenario to produce a usable gradient for a black box optimizer. We fully expect nontrivial predictions of future state to result in increasingly rich world models out of necessity.

It gets back to the age old observation about any sufficiently accurate model being of equal complexity as the system it models. "Predict the next word" is but a single example of the general principle at play.
by JohannaWeb | 2026-02-26 06:19:19+00:00
This is super helpful — thank you. And I agree with the “pressure before architecture” principle.

Right now Falcon is still very early — message volume is basically zero outside of local testing. The service split isn’t driven by traffic yet, it’s more about separating identity/trust from messaging so I don’t entangle community membership logic with transport.

The internal normalization point you mentioned is something I’m trying to do early: the goal is a single internal message/event model that adapters (WebSocket, future federation, etc.) translate into, so the core pipeline stays stable if/when the runtime topology changes.

On Redis/pub-sub: totally fair. I’m not running multi-instance yet. JetStream is more experimental at this stage — mostly exploring how identity-aware events propagate, not solving scale today.
by wavemode | 2026-02-26 06:20:32+00:00
> the kind of analysis the program is able to do is past the point where technology looks like magic. I don’t know how you get here from “predict the next word.”

You're implicitly assuming that what you asked the LLM to do is unrepresented in the training data. That assumption is usually faulty - very few of the ideas and concepts we come up with in our everyday lives are truly new.

All that being said, the refine.ink tool certainly has an interesting approach, which I'm not sure I've seen before. They review a single piece of writing, and it takes up to an hour, and it costs $50. They are probably running the LLM very painstakingly and repeatedly over combinations of sections of your text, allowing it to reason about the things you've written in a lot more detail than you get with a plain run of a long-context model (due to the limitations of sparse attention).

It's neat. I wonder about what other kinds of tasks we could improve AI performance at by scaling time and money (which, in the grand scheme, is usually still a bargain compared to a human worker).
by antonvs | 2026-02-26 06:21:20+00:00
The well-documented scientific basis for the “calming” claim for ADHD medications is that by stimulating brain regions involved in attention, motivation, and regulation of behavior, it can reduce impulsivity and restlessness, giving the appearance of calming a person down if they have deficits in the latter areas.

This has been shown to help many people (a large majority) with ADHD, and it’s also been shown to not provide general neurocognitive benefits to people without ADHD.

IOW, the benefits come from improving attention and reducing impulsivity in people who have deficits in those areas.

See e.g. https://pmc.ncbi.nlm.nih.gov/articles/PMC6165228/ and then e.g. the three references it cites here:

> “It is important to note that a robust body of literature exists that supports the positive effects of prescription stimulants on neurocognitive functioning in children and adults with ADHD (e.g., [14,54,55]), underscoring the importance of baseline impairments in performance relative to improved effects.”

Reconciling this with your opinions on the matter is left as an exercise, but there’s some pretty clear and unambiguous science here.
by schopra909 | 2026-02-26 06:21:23+00:00
It’s a great question. In terms of pre-training even if they were was enough data at that quality, storing it and either demuxing it into raw frames OR compressing it with a sufficiently powerful encoder likely would cost a lot of $. But there’s a case to potentially use a much smaller subset of that data to dial in aesthetics towards the end of training. The gotcha there would come in terms of data diversity. Often you see that models will adapt to the new distribution and forget patterns from the old data. It’s hard to disentangle a model learning clarity of detail from concepts, so you might forget key ideas when picking up these details. Nevertheless maybe there is a way to use small amounts of this data in a RL finetuning setup? In our experience RL post training changes very little in the underlying model weights — so it might be a “light” enough touch to elicit the the desired details.
by cyberrock | 2026-02-26 06:23:16+00:00
>If a client asks, "Can you make the handle slightly longer?", on the human model, I can select a loop of polygons and pull. The edit is done in 10 seconds.

>On the AI model, I cannot. There are no loops. I would have to sculpt it like clay, destroying the texture in the process. It is actually faster to rebuild the entire model from scratch than to try and fix the AI's topology.

To play devil's advocate for a second, it seems like you didn't provide a requirement to the AI on how the handle should be made, then got frustrated that the result doesn't conform to unspoken norms. If I made you this model by just starting with a sphere and sculpting it in ZBrush, you'd get frustrated by the same problem too.

On the other hand, I would expect that the AI could perform the task if you just elongated the handle in the reference image. The same procedure would probably work if the client wanted to add cat ears to the top to make a Mario Tennis clone game, while it might be a whole new commission for human modelers.

Now, would the material mapping still be poor, and would it be a questionable use of electricity? Guilty on both counts, but it's exciting to anyone who just wants to make 3D printed items or low-fidelity video games/mods.
by aakresearch | 2026-02-26 06:23:18+00:00
I am in agreement with many commenters here (https://news.ycombinator.com/item?id=47158240, https://news.ycombinator.com/item?id=47158573 and others) that this article is a clear illustration of failure on part of AI to capture the structure of material in a useful way. As addressed in the article, the effect is very visible in visual space, 3D modeling. I would argue it is very much present in LLM space too, just less prominent due to certain properties of the medium - text-based language. I also believe the effect is fundamental, rooted in the design of those models.

I'll leave here the note I've written down recently, while thinking about this fundamental limitation.

- The relationship between sentient/human thinking and its expression ("language") is similar to the one between abstract/"vector" image specification and its rendered form (which is necessarily pixel-based/rasterised)

- "Truly reasoning" system operates in the abstract/"vector" space, only "rendering" into "raster" space for communication purposes. Today's LLMs, by their natural design, operate entirely in the "raster" space of (linguistic) "tokens". But from outside point of view the two are indistiguishable, superficially.

- Today's LLMs is a brute force mechanism, made possible by availability of sheer computing power and ample training material.

- The whole premise of LLMs ("Large" and "Language" being load-bearing words here) is that they completely bypass the need to formalize the "vector" part, conceptualize in useful manner. I call it "raster-vector impedance".

- Even if not formalized, it can be said that internal "structures" that form within LLM somehow encode/capture ("isomorphic to" is the word I like to use) the semantics ("vector"). I believe the same can be said about "computer vision" ML systems which learn to classify images after being fed billions of them.

- However, I believe that, by nature, such internal encoding is necessarily incomplete and maybe even incorrect.

- Despite the above, LLM can still be a useful tool in many domains. I think language translation is a task that can be very successfully performed without necessarily "decoding" the emerging underlying structures. I.e. a sentence in source language can be mapped onto a region of latent space; an isomorphic region of latent space based on target language can be used to produce an output in the target language which will be representative of an equivalent meaning, from human perspective. All without explicit conceptual decoding of underlying token weight matrices. "Black-box" translation, so to speak. I am amazed (and disturbed, and horrified too!) that producing a viable code in a programming language from casual natural language prompt turned out to be a subset of general translation task, largely. Well, at least on lower levels.

- To me it is intuitive that such design (brute-force transforms of "rasterized" data instead of explicitly conceptualizing it into "vector" forms) is very limited and, essentially, a dead-end.
by arjie | 2026-02-26 06:24:53+00:00
I might not have bought NVDA or timed BTC correctly, but at least I have 512 GB of DDR5 in my server and 128 GB in my Macbook Pro haha. The reality is that these are insanely huge amounts of RAM. I'm glad to have them because I don't need these tab suspender extensions a bunch of my friends use, but really I'd prefer if GPUs were a bit cheaper, and server hardware was generally easier to get. An SXM5 based motherboard is really hard to get these days despite the fact that you can get super powered Epyc 9755s for comparatively nothing.

It reminds me of the heady days of Thai floods when hard drives were inaccessible.
by callmeal | 2026-02-26 06:25:07+00:00
The "predict the next word" to a current llm is at the same level as a "transistor" (or gate) is to a modern cpu. I don't understand llms enough to expand on that comparison, but I can see how having layers above that feed the layers below to "predict the next word" and use the output to modify the input leading to what we see today. It is turtles all the way down.
Show HN: I Made an AI Skill to Help Write Tlaps Proofs
by youio | 2026-02-26 06:25:45+00:00
One-shot prompt: "$tlaps-workbench Model simplified Raft leader election (terms, votes). Prove leader uniqueness per term and monotonic term growth."

TLAPS Proof: https://github.com/younes-io/tlaplus-workbench-examples/blob...
by trimethylpurine | 2026-02-26 06:25:55+00:00
I'm not sure if it's accurate, but according to the summary on Wikipedia at least, the law "provides mechanisms for the companies or the courts to reject or challenge these if they believe the request violates the privacy rights of the foreign country the data is stored in."[0]

If that's accurate, your country's privacy laws would supersede US law. That said, as things are going, it's unlikely that they do.

[0] https://en.wikipedia.org/wiki/CLOUD_Act