You have dozens of applications installed on your computer right now. How many did you use today? This week? How many are silently running background processes, consuming memory, checking for updates you don't care about?
We've inherited a model of computing where software is a permanent fixture. You find an app, install it, configure it, update it, and eventually uninstall it when you find something better. This lifecycle — acquire, maintain, discard — treats programs as possessions. But most software isn't something you want to own. It's something you want to use, briefly, for a specific purpose.
The weight of permanent software
Permanent software carries costs that we've learned to accept as normal:
- Disk space — the average Windows installation has 50+ GB of applications, most rarely used
- Updates — every installed app is a maintenance burden, a source of "update available" notifications, a potential breaking change
- Security surface — every installed binary is an attack vector, every dependency tree a supply chain risk
- Cognitive load — finding the right app, learning its interface, remembering where it puts things
We tolerate this because there was no alternative. Building software was expensive, so it made sense to build once and distribute widely. But that constraint no longer holds.
What ephemeral means in practice
In pneuma, a program exists in memory only while it's running. Close it, and the compiled binary is gone — freed from memory, no trace on disk. The source code is saved on the server (so you can reopen it), and any persistent state lives in a scoped database (so you don't lose your data). But the program itself — the compiled WebAssembly module — is transient.
This changes the relationship between user and software in subtle ways.
You stop accumulating. There's no app drawer filling up with tools you used once. Each session starts clean. If you need something, you ask for it. If you don't, it doesn't exist.
You stop configuring. A generated program doesn't need a settings page. It already does exactly what you asked for. Want it to work differently? Say so — the source is rewritten, recompiled, and the agent restarts. Configuration is replaced by conversation.
You stop updating. There's no version to manage because there's no persistent binary. Every time you reopen an agent, the code is regenerated from the saved source or regenerated fresh from your original prompt. The "latest version" is always whatever the system generates right now.
But what about state?
Ephemeral software doesn't mean ephemeral data. pneuma separates the two cleanly:
- The program (WASM binary) is ephemeral — exists only in memory while running
- The source (Rust code) is persistent — saved on the server, downloadable, shareable
- The state (user data) is persistent — stored in a scoped key-value database per agent
A todo list agent generates a fresh binary each time you open it, but your todos are still there because they're in the database. A notes agent can be closed and reopened a week later — the compiled program is new, but the notes are exactly where you left them.
This separation is what makes ephemeral software practical. The expensive thing to recreate is data. The cheap thing to recreate is the program. So we persist the data and regenerate the program.
The security argument
Permanent software is a security liability. Every binary on your system is code you're trusting to not be malicious, to not have exploitable bugs, to not have compromised dependencies. The history of computing is littered with supply chain attacks, backdoored updates, and vulnerabilities in software nobody remembered installing.
Ephemeral software sidesteps this in several ways:
- No supply chain — generated code has zero dependencies. It's a single file that imports only host-provided functions.
- Sandboxed execution — every agent runs in a WebAssembly sandbox with enforced memory limits and capability-based permissions. It literally cannot access anything it hasn't been granted.
- Inspectable — the source code of every agent is visible. It's 50-400 lines of Rust, readable in a minute. No minified bundles, no binary blobs, no node_modules.
- No persistence — a compromised agent can't survive a restart. Close it and the code is gone. There's no resident binary to backdoor.
What ephemeral software can't replace
Let's be honest about the limits. You're not going to generate Photoshop from a prompt. Complex software with years of domain-specific engineering — IDEs, video editors, CAD tools, databases — will remain pre-built for the foreseeable future.
But these are the exceptions, not the rule. Most software people use daily is simple: a calculator, a timer, a converter, a dashboard, a note-taking surface, a tracker. These are programs that could be written in an afternoon by a junior developer. They can certainly be written in 5 seconds by an LLM.
The long tail of simple, personal, task-specific software is where ephemeral generation wins. And that long tail is longer than most people realize.
A different default
The question isn't whether ephemeral software is better than permanent software in every case. It's whether "permanent by default" is still the right default. We think the answer is no.
Most of the software on your computer doesn't need to be there permanently. It's there because installation was the only delivery mechanism. Now that generation is fast enough to be a delivery mechanism, the default can flip: ephemeral by default, persistent by choice.
That's what pneuma does. Every agent is generated on demand and exists only while you need it. If you want to keep one around, you save it. If you want to share it, you publish it. But the default is transient — software that appears when needed and vanishes when it's not.
Your computer gets lighter. Your attack surface shrinks. Your relationship with software changes from "manage a collection" to "state an intent."
That's what ephemeral software looks like in practice. And once you've used it, permanent installation starts to feel like carrying around every book you've ever read, just in case you need one of them again.