In the story of how ST/ORM came to be, we kept saying that an entity is a plain record. That sounds too simple to matter, yet the rest of the design leans on it.
A record, or an immutable Kotlin data class, is a value. It has no object identity beyond the fields it holds, and two of them with the same contents are equal. You can copy one, put it in a set, hand it to another thread, or pass it to a serializer without risk, because nothing hidden is there to disturb and it has no lifecycle to violate. The source shows everything that exists at runtime. An entity in ST/ORM is exactly this and nothing more, the same plain shape we followed to its conclusion in a first-principles look at the data layer.
A managed entity comes with a vocabulary: attached and detached, the persistence context, flush, merge, cascade. Those words describe the machinery that tracks a mutable object across a session, so the framework can work out what changed and when to write it, and none of them says anything about your data. When the entity is a value, most of that machinery has nothing to attach to, and the words drop out of your codebase. What you reason about is the data itself.
Because the entity carries no session and no persistence state, you can pass it anywhere: out of the repository, through your services, into a controller, across a coroutine boundary, and back. A service that returns an entity does not also return an invisible dependency on an open session. There is no session for it to outlive, so the error a managed model throws after its session closes cannot happen here. You can cache an entity, since it will not change under you, and serialize it, since it consists of its fields.
Two worries usually come up at this point, dirty checking and lazy loading, and immutability costs you neither. You change an entity by producing a new copy, and ST/ORM writes only the columns that differ by comparing the value you saved against the one you read, with no proxy involved. When deferring a load is the right call, you declare the field as a Ref and load it with a call you make, in code a reviewer can see. Both are still there. They are explicit where a managed model keeps them hidden, which is much of the reason to want plain values in the first place.
That is the bet behind ST/ORM. The database owns the data model, and the application gets plain typed values it can pass around, test, and cache without asking what session they belong to.