Show HN: I built an OS that is pure AI | Hacker News Reader

Show HN: I built an OS that is pure AI

pneuma.computer

34 pointsevanbarke45 comments

I've been building Pneuma, a desktop computing environment where software doesn't need to exist before you need it. There are no pre-installed applications. You boot to a blank screen with a prompt. You describe what you want: a CPU monitor, a game, a notes app, a data visualizer and a working program materializes in seconds. Once generated, agents persist. You can reuse them, they can communicate with each other through IPC, and you can share them through a community agent store. The idea isn't that everything is disposable. It's that creation is instant and the barrier to having exactly the tool you need is just describing it.

Under the hood: your input goes to an LLM, which generates a self-contained Rust module. That gets compiled to WebAssembly in under a second, then JIT-compiled and executed in a sandboxed Wasmtime instance. Everything is GPU-rendered via wgpu (Vulkan/Metal/DX12). If compilation fails, the error is automatically fed back for correction. ~90% first-attempt success rate.

The architecture is a microkernel: agents run in isolated WASM sandboxes with a typed ABI for drawing, input, storage, and networking. An agent crash can't bring down the system. Agents can run side by side, persist to a local store, and be shared or downloaded from the community store.

Currently it runs as a desktop app on Linux, macOS, and Windows. The longer-term goal is to run on bare metal and support existing ARM64 binaries alongside generated agents. A full computing environment where AI-generated software and traditional applications coexist.

Built entirely in Rust.

I built this because I think the traditional software model of find an app, install it, learn it, configure it; is unnecessary friction. If a computer can generate exactly the tool you need in the moment you need it, and then keep it around when it's useful, why maintain a library of pre-built software at all?

Free tier available (no credit card). There's a video on the landing page showing it in action.

Interested in feedback on the concept, the UX, and whether this is something you'd actually use.

Open articleView on HN

> Currently it runs as a desktop app on Linux, macOS, and Windows

Does that mean it's not actually an OS?

I mean Chrome OS started as a browser only OS. So theoretically it can be an OS.

Hey. This is a fair remark and logical too. It's build to run in a sandbox on other OS now to ease uptake. Asking people to install a new OS because "trust me bro" is not gonna work.

That said it is build as an os. It generates real wasm that runs directly on the machine.

Porting to baremetal is next on the backlog. It will require embedding rust cranelift directory into pneuma amongst other things but the hardest/biggest and most architectural part is already done: wasm. You can check out the blog for more info.

> It generates real wasm that runs directly on the machine.

Well, it's not directly on the machine. You still need the wasm engine/runtime to run it

Some might claim a browser is an OS. Some do claim emacs is an OS. Tlon claims urbit is an OS. It’s a fairly fluid term nowadays.

They're like an OS by analogy, but all of them require an actual OS to interface with the hardware. I don't think making that term fluid is a good idea. If we did, how would I refer to... "an actual OS"?

You’re definitely right there should be distinction. I think “baremetal OS” is the term some people would use.

The WASM sandbox per agent with typed ABI is a really clean isolation model. Most agent runtimes I've seen just throw everything into one process and hope for the best.

Curious about the IPC layer between agents. When agents communicate with each other, is there any access control on what one agent can request from another? Or is it open by default?

In practice the moment you have multiple agents that persist and talk to each other, you need some kind of permission model — otherwise one rogue agent can access everything through a chain of IPC calls. Even if each individual sandbox is secure.

The Rust + WASM combo is solid for this. We use Rust for similar reasons — memory safety matters a lot more when agents run autonomously.

The WASM sandbox + microkernel architecture is the right foundation for agent isolation, but it surfaces a problem that most agent systems don't address until it's too late: if every agent is ephemeral and generated on demand, your audit story is basically nonexistent. An agent crashes, does something unexpected, produces wrong output — and you have no record of what it was running, what context it had, or why it made the decisions it did.

With traditional software you at least have a binary you can inspect. Here the "program" is a generated Rust module that may never exist again in the same form. That's a genuinely hard problem for any use case where you need to reproduce or explain behavior after the fact.

The community agent store helps for sharing, but it also raises the question: when a downloaded agent does something wrong, who's responsible and how do you trace it? This feels like the unsexy infrastructure problem that'll define whether Pneuma can be trusted for anything beyond personal use.

I think this is the way things are ultimately going (software as ephemerally generated based on your preferences), but at the moment, I can't see myself using these generated apps. Maybe it's just an aesthetic thing—have you experimented with personalized theming?

Yeah you can edit them however you like. I asked it to make a game with a lion fighting a bulldog and it could even doing that :D

It reminds me of: https://fabian-kuebler.com/posts/markdown-agentic-ui/ to an extent.

I had a conversation with Claude on it. I work as an artist and webdev, so excuse my lack of technical knowledge on the matter: https://claude.ai/share/8b40cf7f-ecc6-452f-a550-3d1e5416b3e5

In the conversation I (mostly Claude, to be fair) was speculating about some caveats of fully on the fly generated ui/apps, in relation to ui/ux design and brand recognition, including how does ui/ux innovation enter the model if this is a paradigm shift, and what kind of job positions/skillsets would that paradigm destroy/create

If we fully embrace this generative software concept for the sake of this thread, then the UI/UX, is going to be optimized and personalized to your tastes, skills, affinities, and (dis)abilities. Brand comes into the equation as a proxy for trust, so if this whole scenario were to come true, maybe that's not so relevant anymore.

I don't think generating an app would be the move forward. Rather it should be an agentic application that can be installed/added and the main agent controls it.

Building apps on the fly seems cool, But hits the frustration when they don't work at times, When building as a side project we tolerate it because we are in building phase, But when using we might not tolerate the issues.

Finally the security also plays a major role, So instead of building apps at runtime, We need agents and skills as portable objects.

Yeah there is a pneuma agent/app store for that. And security permissions are built in also. pneuma asks for approval for the different rights the agent needs before running.

It's a fascinating paradigm – as though it dropped here out of some future.

However, I'd never use it. Reason: having everything dynamically created JIT means there's a trade-off somewhere else; in this case, it's energy consumption. I'd rather "cache" applications (ie. have them as installable software, which has been built just once) than endlessly recreate software from scratch each time, with all the energy usage that entails.

Thanks for the great feedback. That's why there is an app store in pneuma. You can upload and download pneuma generated apps from others. Give it a try!

Seems like a cool idea—I'm always game to try new operating systems! Recently been playing around with Playbit (https://playbit.app/)

Pneuma reminds me a little bit of Yansu AI, a project I saw recently on HN that proactively builds apps with AI (https://yansu.app/)

Thanks! Playbit is a cool project, I've followed it. The key difference with Pneuma is that the programs themselves are AI-generated at runtime. There's no toolchain the user interacts with, no editor, no compiler invocation. You describe what you want and the system handles everything from code generation through compilation to execution in one pass. Yansu is interesting too but it's a web app builder. Pneuma runs native GPU-rendered agents in WASM sandboxes on the desktop, so you can build things like real-time games and data visualizers with keyboard/mouse input, not just web UIs. The closest analogy is probably a microkernel where every userspace process is conjured by an LLM instead of installed from a package manager.

That makes sense—I think it's really interesting to see the possibilities of new software created purely by AI! I'm happy to offer feedback, my email is micah.blachman@gmail.com

Feel free to sign up at pneuma.computer you can try for free. You feedback would be greatly appreciated

One critique is that I think it might be more efficient to just make use of existing software for some of these things rather than generate them on the fly (for something for example like a text editor), but I guess that will depend on how costly it is to run AI programs in the future (if it becomes much cheaper, then I could see your concept being taken up by more people)

Yes that is definitely still gonna be necessary and it's why I build on a store where people can upload their apps/agents. There is a loose community section and in the backlog I have work around offering an sdk and official store for established companies to ship pneuma apps.

I see a lot of interest and good questions here. I've just published a blog post with more details for anyone interested https://pneuma.computer/blog/how-pneuma-generates-compiles-a...

Hi all. If you found this interesting could you please upvote pneuma on product hunt? It would go a long way:https://www.producthunt.com/products/pneuma

> the UX

For this to be practical you really need to build things iteratively and asking the user questions, rather than attempting at one shot half assed ideas

Also most people are better explaining details with voice rather than text.

Voice is a great idea! On the backlog. Also pneuma already supports iteration/edits. You can say "edit my pong game so the paddles are pink" and it's smart enough to do it.

>better with voice.

Ive found most people are not good at explaining details period.

Also how many time have you heard something like.

Blah blah, except, blah, only when, blah, but not that except.......

To the point where they've contradicted themselves several times and made at least two mutually exclusive things true.

Cool, curious though long did it take to build it?

Just a couple of weeks once the initial idea was decided.

How did you solve the problem of hallucinations?

I've built a list of common gotchas in the generation prompts. Also if the compilation fails it falls back to opus with the error message and code and can try again twice.

That's not a solution to the root problem. That is duct tape.

This is built with the paradigm of "don't build for the model of today, build for the model in 6 months" It currently works, which amazes me still, but it will get much better!

the duct tape framing is fair but the deeper issue is the model has no persistent understanding of the system it's working in. each generation starts from scratch with no memory of prior context or architectural decisions. that's a harder problem than prompt engineering but it's solvable at the infrastructure layer

Sounds expensive to sustain and inefficient

This is really cool. It reminded me of my first thought for an AI app was a No-Interface crm/order system. I was talking to my bro in sales and all he ever does is complain about what a pain computers are. This takes that idea to the next level.

llms were not quite there at the time maybe ill revisit.

That's exactly it! I've absolutely loved the empowered my AI coding has brought me. This is about bringing the same to the end user with no technical skills!

That's a very interesting and innovative idea. Congratulations, well tuned!

Thank you! I'm very excited about it. I really hope it gets traction!

how does pneuma deal with persistence of user data?

pairing this with rewind-like applications, it would seem that "user files" and particularly "user organized files" as a paradigm could also be completely unnecessary, as you recall states/activities/projects via intention and the agent presents you with the right abstraction to navigate those

There is a build in filesystem handling system. For example, if you ask it to build a Todo task agent it will need to persist the tasks and their state to disk. It knows which syscalls to use in the pneuma microkernal and it builds with that in mind. When you start the app it will reauesf access to the file system.

are you using vector store for long term persistence or standard fs and model interaces with it via tools?

Reply on news.ycombinator.com