An agent conversation spends almost all of its life waiting: for the next message, or for a model to finish thinking. Keeping a warm process alive per idle session costs tens to hundreds of megabytes each, around the clock. As of this week, a SCUA session does not have to.
A host can freeze a session actor to a blob of roughly a hundred kilobytes, drop the partition from memory entirely, and rehydrate it when something happens. State, history, everything survives; the script cannot tell it was gone. While it sleeps, the session costs a file in object storage and nothing else. This is the economics of a thousand idle agents as a thousand blobs rather than a thousand processes.
The sharper trick is freezing mid-call. A handler parked on a slow
request, model inference being the motivating case, can be frozen with
the call in flight. When the answer arrives, possibly hours later,
possibly on a different machine, the host rehydrates the session and
hands the answer into the parked call. The handler resumes inside its
Ok(answer) arm as if the call had taken five milliseconds.
And when nobody holds the answer, a genuine crash, the call resumes as
Error("interrupted") under the reload rule from July: never
re-issued, so the script reconciles instead of double-firing a side
effect. The safe path is the default path.
None of this required new machinery in the language. A partition was already one relocatable blob; hibernation is that fact, pointed at a session lifecycle. There is a guide ("Hibernate a session"), a runnable C example covering both the idle and mid-call flows, and a cost-curve benchmark in the repo, because a claim about economics should come with numbers.