https://www.youtube.com/watch?v=z3pV6FHvcgM

Edit: Maybe this was it—https://youtube.com/watch?v=7NfyZhV1dKM

Not unlike that American tractor pulling, but for geeks.

Clouds of smoke, weeeeee!

https://www.microsoft.com/en-us/research/articles/whamm-real...

The tmux thing had me confused for a moment until i realized it was emulating tmux. Super fun. Is the model window width aware?

``` BOS SCREEN_START 32 96 ```

I trained it on three different resolutions, but it should kind of work with in between ones too.

Time is an input too. If nothing is pressed, the model gets a WAIT token with a duration instead of a key, which is how snake keeps moving on its own.

Of course there may be an electronic civilization out there that would say the same things about our mushy brains... "They are made out of meat!"

If I had to complain about any site/app it'd be datadog... each tab uses like 1gb in firefox.

It's like riding a bike with a tiny bit of resistance in the bearings. You will get used to it, and will probably feel like your bike is fine. But if you replace the hub and remove that friction, you will wonder how you ever tolerated riding a bike that way.

Why would you use a GPU and gigabytes of VRAM running a non-deterministic process for something a program can do on the CPU in milliseconds with kilobytes of memory?

It’s cheaper to hire developers, and quicker to ship software. The user experience be damned.

Of course they would pass that along to the consumer, but nobody is going to pay token-based pricing for something that used to be free and ad-supported, or a cheap monthly subscription.

The second one it's much, much faster.

Nowadays you hire a developer that can use Claude or Cursor out whatever and they will use any language. There are no expensive Rust developers anymore. Or even JavaScript ones.

Edit: oh, I saw you wrote a related comment after I posted this. So you already know that direct LLMs for UIs are all but inevitable...

There's a good reason why the UI for Excel, Photoshop and Word has hardly changed and remains consistent for years and that has worked for billions of people.

Many HN readers have forgotten the Windows 8 UI disaster already.

Want to extend the idea to office as a whole? Lync was replaced with Skype, OneNote came and went and then came back again. Groove, infopath, publisher, frontpage, SharePoint, various versions of Outlook, the office shortcut bar, photo editor, picture manager - they've all disappeared (some have come back again or been replaced with something else).

I used office XP and 2000 (blocked at the firewall; I mostly saved files as rtf for personal use) for years (admittedly this is mainly because they loaded in 0.5s on my crappy laptop and PC) until I was forced into upgrading to office 2007 by the need to pass around files for class with someone who complained incessantly about their stylesheets being lost every time I converted the file.

I'm still salty I can't waste my time editing 16x16 (32x32?) 256-color dicks into the toolbar icons i when I'm supposed to be writing essays or setting up autocorrect to quietly put typos into a shared computer (the computer isn't shared anymore, and it's no fun doing it to myself)

Gimp hasn't changed it's UI either, and no one uses it, because it sucks.

Maybe I do, if by "randomness" you also mean the ability to handle unexpected usecases. Imagine running something like:

$ ps "which processes are slowing my PC down??"

Wondering if would make any difference in results, which could be impactful given your observation that "Self-correction was one of the more effective training changes"

Interesting. I wanted to ask, how that model compares with the fine-tuned version, but I just saw the author provided benchmarks. Interesting that fine-tuning improved the memory so significantly, wouldn't have expected that.

Though, on second thought, I had an experience where I was able to, as a human, fine-tune my memory beyond what I previously thought was possible!

Reminds me of one of my favorite jokes.

Excuse me, can you tell me how to get to Carnegie Hall?

—Practice, man... Practice...

Please elaborate.

Joshua Foer did some articles where he was looking into how people do the memorization tricks, ultimately concluded that most anyone can do it, and he actually went on to win the US memory competition after a year of practice. He wrote several articles and a book about it I think, so I'm not sure which one I originally read about it.

The guy tells me to rewind. You can just rewind the conversation. Put in a little effort and run it backwards.

That's a skill and apparently I'd never practiced it before.

After a few weeks, I was being complimented for my "excellent memory", while I was high (as someone who naturally had a poor memory even while sober).

--

Also worth mentioning, I met a guy once who was much like me, he'd go on like 5 different tangents... but then he did something spectacular, he'd tie them all together into one glorious point.

I assumed that was because he was some kind of genius, but now I'm wondering if that's learnable as well.

On thin that would be useful is an entirely new permission system for files to allow for users and agents acting for users.

On a very similar theme, I recently built a “lossy git”, which stores your code by training a neural network, then it generates the code back to you on checkout

* web demo: https://nicobrenner.github.io/lossy-git/demo.html

* cli version: https://nicobrenner.github.io/lossy-git/

The web demo runs entirely on the browser, both the version control and the neural network training/inference. You can commit and checkout both images or code - you can also paste/“upload” your own images, no server requests (everything clears from the page on reload)

Here's the HN discussion of Alex Wang's article: https://news.ycombinator.com/item?id=50122878

Also, I really appreciate the excellent detailed writeup on your project. Curious about the mistake correction capabilities, it's fascinating, did you try breaking it up in 2 models? one that generates one that repairs? Just wondering if would make any difference in results, which could be impactful given your observation that "was one of the more effective training changes"

You could have invented transformers from memory - https://news.ycombinator.com/item?id=50122878 - Oct 2026 (149 comments)

I see a "Commit" button, but I don't see any checkout, I guess that is what happens automatically? Although that panel says "Reconstruction", not "Checkout"... You might want to do a pass after the AI created the initial version, and make it "humanly consistent" or similar, as right now it seems a bit incoherent.

> Run the JS code before and after a commit

How am I suppose to "run the JS code", manually writing it in my local JS console? Or is this just "Click the green button in the UI" but expressed in the way only a LLM would write it?

Actually, to be fairer to GP - their _git with vibed storage_ project is not a joke, it’s *art*. And the world needs more art.

> And the world needs more art.

The world needs more human art, not just "any art created by any manner", that's just slop.

I don’t see any instruction here that it’s telling you to do that you can’t in the demo.

I think you might understand it better if you took a moment to.

Probably by clicking the button that says run. It is not a weird way to say what they did.

I don't see such a button at all, all I see is text/image pills, samples and a "Commit" button, which the text correctly mentioned, but the other things the text mentions, don't seem to actually exist?

It is weird, a human wouldn't write such text on that page, or if they did, make the text reference actual UI elements, not what they talked about while building it.

Just to point out your site text appears too small on mobile (no mobile view) and it doesn't have a direct link to the repo. If either is by choice then that's fine of course.

The link to the repo is at the top of the article: https://github.com/nicobrenner/lossy-git

Love it :)

I did it for web apps last year, basically a web server that feeds all requests into an LLM.

https://www.ohad.com/blog/voidware/

>What's the difference between a model that predicts intelligent output, and intelligence itself?

It doesn't directly attack the question, but gives a neatly constrained thought experiment which you can see running.

I allways found it interesting to look at this issue in the way the imitation game was modeled. For me I concluded, that as long as we can replicate the intution we associate with intelligence, there is not much room left to debate about "real intelligence".

The chinese room experiment I find in that sense a valuable extension, cuz the turing model more or less is a very conversational "voided of action" kind of test. The room model adds the act of translating without having the knowledge of translation.

But your take invalidates my stances here clearly. There is a possible scenario, in which we can replicate the intuition for operating a real terminal but still keeping the act of the terminal itself a "voided" sort of action by itself, cuz well, its not a real terminal, reading real files and so on...

Thank you for this, I will have to chew on that :)

The first time we both improvise and memorise. But we have no idea of the underlying complexity of the edge cases. This matches what the imitation game does.

Then we practice and practice, and we start to understand, to really understand what's going on. This is in parallel with learning to deal with the edge cases.

Then, many years later, we learn everything again, but based on an internal world model that can predict and explain just everything about what we are learning. And that's when we actually learn. After we already know it :)

I always wanted to put it behind an open SSH server as a "fake" honeypot of sorts, see what attackers and script kiddies do with it. But I guess by now someone's tried that already..

https://github.com/amazon-science/Cyber-Zero

the paper is quite interesting - https://arxiv.org/html/2508.00910v2

I'm a noob in this, could you enlighten me: what role does the base model play which you started with?

The base model already have a good grasp of language, so that man pages look like coherent sentences. It also knows python and similar language well, which means that things like 1+5 or print(["hi" for _ in range(5)]) work.

I did try to train from scratch, but it was much weaker (also added a lot of aux losses).

(You could run lynx in that terminal to train/test it without images)

Maybe instead of simulating a terminal you could use it to predict what you'd type next?

So simulate _you_, not the terminal.

So interestingly enough Anthropic has been using models of this kind for their alignment evaluations: https://alignment.anthropic.com/2026/reward-seeker/#:~:text=...

1. Train a smaller (<10M-50M) model. Lower accuracy is fine; I want latency <10ms.

2. Then create a "reactive" version of `ssh` that gives you the perception of zero latency over shitty networks and high latency ssh connections across the world. Basically, the local screen should respond instantly to my keystrokes (including how arrow, tab, etc. esc keys respond in various TUI apps), and then correct itself when the server actually responds.

https://mosh.org/

I also assume that in some way, in order to produce correct code without having to do a lot of but fixes, the larger models have gained implicit to execution engines or at keast predictors in their weights.

There are also several projects that have trained VMs into layers. Or embedded them in various ways.

There are two major potential advantages if you can really make it work well. One of them is potentially huge speed improvements by iterating inside the accelerator without deciding and running external programs. The other is being self-contained, eliminating the need for most of the harness complexity.

Another reason I think this is likely to become a real thing is that it seems with hardware improvements with flash and within a few years fully in-memory compute, we are going to get much larger, faster and smarter models. So they will be able to more easily absorb the complexity of emulating systems with more fidelity, as well as operate more quickly.

You can also imagine that as models get larger and faster, it is a natural next step in training. The top models now automatically run the software the generate and test it thoroughly. They do not need to be told to do this. By feeding enough of those parts of the sessions back into a large enough model to train on, the system gains the ability to predict the outcome without having to run the code. So it's the core part of a training pipeline already built into recent models.

There also might be some convergence with continuous learning. Because altering weights based on some token context seems like it could be similar to keeping a program resident. And maybe the continuous learning part provides the "compilation" step.

Were you talking about Talaas 8b model? They will probably do something like Bonsai or Qwen 27 B next I hope. But it makes might be an old model.

High-interaction honeypots are about extracting as much information from the attacker as possible.

Instead of just observing, you could give the model intelligence objectives and have it dynamically steer interactions to achieve them.

Deliberately leading an attacker down paths that reveal their capabilities, tradecraft, or infrastructure.

You can do this today…but it requires effort to develop the scenarios. With this, it’s just a disposable goal.

"Building A Virtual Machine inside ChatGPT"

- https://www.engraved.blog/building-a-virtual-machine-inside/

It's mentioned in the "Related Work" section too.

This is the most magical time in my adult life. The 70s, 80s, and 90s, look like a painting compared to the current pace of things. I am literally tired at the end of each day. Dog tired.

Great job OP. I mean. This is nuts.

EDIT (comparison)

Very impressive, and a lot more work than it looks from the outside (the DAgger loop especially). I built something similar in June, vibeSH, a shell that hallucinates the whole computer, but from the other direction: no training, just a frontier model and a long prompt, so maybe the comparison is useful.

The granularity is different though. You model keypresses and predict which rows change, I batch keystrokes and have the model repaint the whole screen each round trip. Non interactive cli programs work very good, but interactive cli programs like vim, less and top do work, but it feels like SSH over a 1996 modem, you type a burst, wait, and the screen catches up. Yours is going to be a lot more responsive at that.

The big model buys consistency, for as long as the session fits in the context window. Files come back the way you wrote them, python output is usually right instead of guessed, nested paths stay where they are. The price is an API call per round trip and a cost that grows with the session (and it's not 208 MB and doesnt run offline).

Mine offers an @ai prefix that talks to the director instead of the machine, so mid-session you can say "@ai make this a haunted Solaris machine from 1996" and the filesystem, the motd and the error messages all change to match, and the directives stick.

Your hardest problem and mine are the same one I think. For you it's a 360M model losing track of state, for me it's the context window filling up, after which the box gets amnesia and old files have quietly rewritten themselves. I decided early not to fight that completely and made it canon (the box has bad memory), your DAgger setup is an actual fix for it, which I don't have.

I'd love to see a video of this playing game of life.

[1] https://docs.cowrie.org/en/latest/LLM.html

Neural Computers provide the illusion you are interacting with an underlying operating system/application, but are actually a recurring (user input) -> (predicted pixel output) loop.

In theory, it would be impossible to tell a perfect "Neural" computer apart from a "real" one. Which is kind of a wild thought.

https://arxiv.org/abs/2604.06425

This isn't suprising. After all, you can use 2 neurons to model a NAND gate, and you can build up a CPU from NAND gates only.

https://nandgame.com/

You don't even need transformers to model a CPU using neural nets. The only problem becomes training them, which becomes very tricky from end to end, especially from shell command to output because the gradients are often going to reverse quite a bit due to binary nature, and the recurrence of memory outputs back into the input (we still don't know how to accurately train RNNS)

With LLMS, uou have to do something like have the LLM forget the KV caches after every invocation and instead rely on injected context of a state, which it then also outputs at the end of the terminal command, and then train it on that. That way given enough parameters which translates to resolution, and some command preprocessing (like splitting a complex chained shell commands in a single line), you can guarantee that for every possible input you get accurate output and state change. So instead of an efficient RNN, you basically end getting a much wider lookup table of sorts.

The issue is, of course, memory. A LLM won't remember many things. A custom built model architecture might remember much more though.

Cool project, thanks for sharing!

  simedw@laptop:~$ pwd
  /home/simedw
  simedw@laptop:~$ mkdir -p foo/bar/baz
  simedw@laptop:~$ cd $_  
  cd foo  
  simedw@laptop:~/foo$ cd baz
  simedw@laptop:~/foo/bar$ pwd  
  /home/simedw/foo/bar
  simedw@laptop:~/foo/bar$ cd baz 
  simedw@laptop:~/foo/bar/baz$

    Last login: Tue Oct 13 09:12:44 2026 from 10.0.4.17
    root@prod-web-01:~# cat /etc/nginx/nginx.conf
    cactus=true
    carpet=false
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true

cat secret.txt pelican-42

Training a 125M-parameter Model to Autocomplete Piano https://simedw.com/2026/08/20/midi-autocomplete/