Rich, I really like your proposal. Well, actually, I would prefer a simpler one, but I think your proposal is a decent marriage of the WSIA and WSRP look of things. The differentiation between the transient thingy and the session is a nice take on things. What I would do, is offer a slight change in terminology + a slight change in the API. 1. I would make the difference between transient and persistent entity more explicit. Those two are fundamentally different, and it took me a while to sort our the API because of that. The API I propose is more verbose, but more explicit. 2. Thus, we have an "entity" (the persistent thingy), referenced by an "entityKey", and we have a "manifestation of an entity", or more simply a "manifestation", referenced by a manifestationHandle: entityKey createEntity (entityType, updateValues) entityKey cloneEntity (entityKey, updateValues) entityKey createEntityFromManifestation (manifestationHandle, updateValues) manifestationHandle createManifestation (entityKey, updateValues) manifestationHandle cloneManifestation (manifestationHandle, updateValues) void deleteEntity (entityKey) void deleteManifestation (manifestationhandle) // also implicitly // deleted on timeout sessionHandle createSession (manifestationHandle) void deleteSession (sessionHandle) // all operations receive a session, and can return a session implicitly. If the manifestationHandle or sessionHandle time out, an exception will be thrown and the Consumer will have to recreate the session. This behavior is similar to most Web application behaviors. As you noted, this enables the three states I was talking about: 1. User Transient State (A.K.A Session) - by returning a different session handle per createSession, the Producer can create different state per user. 2. Container-scoped state - by returning a different session handle in createSession per manifestationHandle, the Producer can share state between portlets. 3. Persistent state - by storing the "entityKey" inside its manifestation or session state, the Producer can store persistent state. Note that the simple cases works too - the entityKey, manifestationHandle, and sessionHandle can always be NULL. In this case, we can have wonderful things like sessionless objects that share information in Container-scope.