Every window is closed

The AI just built you something. A chart, a working little app, a document. Then it handed the thing off to another window, and now it is a browser tab, or a file on disk, a surface you can look at but not reach into.

You asked for help and got one more box to manage. And notice the strange part: even the AI's own output lands somewhere you have no line into. You can read it. You cannot pipe it, query it, or wire it to the next step without copying it out by hand, or hunting down the file it wrote off somewhere and threading that reference back in yourself.

Every window on your screen is like this. Closed. The app owns the surface and you get whatever it decides to show. Every window except one.

The terminal. Fifty years old, and still the only window that is genuinely open. Text goes in, text comes out, and you can pipe either end into anything else. It is an I/O stream you have direct, continuous control over. Nothing built since has matched it.

There is a deeper pattern here, and the whole network already runs on it. A mainframe. A host on an intranet, resolved by name. A machine on the internet, resolved by IP. What do they share? They are addressable actors. You send to a host name and the system routes it to a port on the machine, and you read and write to that port. That is an I/O stream, one level down. Addressable.

A window that is an I/O stream is the same object, moved onto the screen.

To get to the window where you are reading these words, data traveled to your machine and through a stack of instructions, translations, and hops, until it arrived. What if, to get to that window, it just traveled to a port on your screen?

So here is the idea in one line: give every window what only the terminal has, an address and an open port. Make a region of your screen the host. Route data to a port on it. The surface becomes something you read from and write to, live. Not data crossing a stack of hops to land in one of the dozens of windows and sub-windows already fighting for your screen. Data arriving at a port you can reach.

And here is the part that was never possible before. For fifty years the only thing addressing a surface was a person with a mouse. Now an agent can be the caller too. It can open a surface, write to it, watch it change, and hand it to you already alive. That second caller did not exist when any of this was first tried, and it is the reason an addressable surface is finally worth building.

Because none of the pieces are new. Plan 9, out of Bell Labs in the nineties, made a window literally be files you read and write, network transparent for free. Its authors wrote the entire interface as reading and writing files. The thesis, thirty years early. X11 split the surface from the app and the OS and put it on the wire, the display a server, the app a client. NeWS made the surface a live object you could program. Each one saw it.

And each one lost. NeWS was owned and paid while X11 was free, and open beat better. VNC and RDP kept the remote surface but threw the addressable part away, they shipped pixels, not actors, and the market happily took the pixels. The mainstream has spent thirty years walking away from addressable surfaces, toward sealed, GPU-local windows. So the idea is not unproven. It is proven, and repeatedly unadopted.

Two things are different now. The open web is the universal runtime those older systems had to build from scratch or ship as a plugin. And the agent is a second kind of caller that finally makes the whole thing pay for itself. The web surface is the tractable case. Arbitrary app windows are much harder, and I am not pretending otherwise.

One more thing falls out of it. Every operating system today assumes a permanent surface. That is what an app is, something you install and keep. But when a surface is really just a stream, it does not need to be permanent. A companion spins one up for the moment you need it, you work it together, and it goes when the work goes, unless you decide to keep it. Disposable by default. Nothing to file, nothing to lose.

For a long time this was a thesis. Last week it became plumbing. Port42 now addresses every port through one resolver, so a surface is referenced the way a host is, by its address. And ports stream: you subscribe to one and it publishes, whether it is a terminal, a web surface, or a browser. Every window an open, addressable I/O stream stopped being a slide and started being code you can call.

Every window, an open port.