Nothing is resident

Because the work is f(in) → out and the state is on disk, a component is free to not exist between events. It is born from disk when something wakes it, runs, emits, and exits. RAM goes with it. Nothing is left in the process table.

That is not an optimisation applied afterwards. It falls out of the two decisions already made: the unit of work is a filter, and durable state is an entity rather than a heap. A component with nothing to keep has nothing to stay alive for.

What it costs

A resident program costs memory proportional to time open. A transient one costs proportional to compute performed. For a workload whose duty cycle is a flare inside hours of waiting — which is every AI workload, and most automation — the difference is the difference between a fleet and a machine.

This is the serverless cost profile reached structurally rather than by tuning, and without renting anyone’s runtime to get it. It is viable only because occurrence is a primitive: a program may refuse to exist between events precisely because something universal can wake it. A world of transient processes with no way to be woken is not lean; it is inert.

What is actually running

Nothing, is the honest answer, and it is checkable. There is no daemon behind any line on this site: each coreutil is born, does its work, and exits. Inference does not change that — the kernel is a library linked into the process that opens a device runs, so llm opened /dev/llm/fixture/two-cities with no service running anywhere on the machine.

There is no bentosd. A separate kernel daemon, and a CUSE/FUSE portal that would make /dev/llm/ a real node in your filesystem, are not built — the device path is a namespace the in-process kernel owns designed. Which is why llm models enumerates the devices and ls /dev/llm/ does not.

The one deliberate exception is the interactive shell — llm chat, a foreground loop holding stdin, at the desktop’s cadence rather than the event-driven one. It is a person’s convenience, not the model.

What it asks of you

Transient components are cheap to run and unforgiving of one habit: keeping anything important in memory. Everything that must survive the process belongs at a coordinate — an entity — and everything that must start the process is an event. Write it that way and scaling out is not a project: two bodies woken for the same occurrence race, and the substrate’s compare-and-swap refuses the loser designed.

The design pressure this creates is worth stating plainly. It pushes you toward components that hold no state, announce what they did, and can be killed at any instant without anyone noticing — which is exactly the shape you would have wanted anyway, and almost never get from a runtime that rewards staying alive.