The kinds of objects in a pool can be made arbitrary. Future simpleton families can then be created to work on those new object families. For example, we could have a Person object inside the system that stores someone's picture, names, nicknames, phone numbers, email addresses, userids, addresses, sleeping habits, schedule, spouse's name, children's names, friends, personal likes and dislikes, bad habits, employers, and workplace address.

The Person object may also know which emails that person sent the user, which webpages that person recommended to the user, which emails the user sent that person, which webpages the user recommended to that person, what that person's rating of a particular website is, what movies that person likes, and what other people are associated with that person. Each Person object could also have a link to that person's own information manager.

Further, when we have Persons inside the system the user can browse them, search them, organize and reorganize them, and navigate through them just like Pages.

In short: We can make Persons into Objects.

Entities

Similar arguments could be made for any other class of objects that the user might find interesting. There's no reason to only allow Pages, Attributes, Pools, Simpletons, Clusters, and Persons inside the system. We can also have Organizations and Courses and Websites and Movies and whatever else the user cares about.

Those objects mirror objects in our world that we organize information in our heads around. But we then have to break up all that information into tiny bits and pieces because our information handlers each understand only one thin slice of it.

Having a Person (or a Movie, or a Course, or an Organization) inside the system gives the system a place to put (and to find) information related to those kinds of objects. That isn't possible if all the information is divided into little fiefs by today's separate information handlers (phone book, email reader, news handler, web browser, ftp client, image displayer, and so on).

For uniformity, all of those objects should be of one general type: Entity.

Sideband Entities

To let simpletons "communicate" without being aware of each other's existence the system might need a mechanism to store metadata besides the attributes attached to entities. These "sideband" entities can store this metadata so that it can be analyzed and clustered and evaluated just as other entities are. Sideband entities and clusters of sideband entities should also have their own attributes, which would allow simpletons to attach to them and modify them just as they can attach to normal entities.

There's no limit to the classes of objects the system could have. New entities might eventually even be made dynamically createable by the system itself.

Entity Clusters

Once we allow Entities other than Pages into the system it's natural to want to cluster them, too. A cluster of Persons, for example, is a natural thing to want once you already have a collection of Person objects. Some subcollections will be more interesting for some purposes than for others, so clustering Persons via sets of predicates that their attributes satisfy is a natural activity. The same goes for any other Entity we add to the system, including clusters themselves. So we could have clusters of clusters, clusters of clusters of clusters, on and on, forever.

Clusters as Entities

Allowing multiple classes of objects to be stored in datapools makes it a natural transition to see clusters of entities as just another entity. A cluster is simply an entity that has a special set of attributes signifying that those entities are contained within the (cluster) entity. A cluster entity could then be distinguished from other entities simply by having a special attribute that says that it's a Container Entity.

Consequently, even when we add clusters, we still only have one kind of object inside a datapool: namely, entities.

Entity Attributes

Entities can have other entities as attributes and still not be cluster entities. For example, a webpage can contain an image or an applet, which itself may be a separate entity in the system. The image or applet entity is an attribute of the webpage but it also has a separate existence as an entity. Similarly, a user may attach a comment or note or annotation to an entity, and that comment may itself be a separate entity in the system.

Attributes may even contain computations by referencing an object and one of its methods (an example would be a search for other objects of some particular type or some computation that gets triggered whenever a certain attribute is added or changed or deleted).