Up to this point, UML has implemented a classical virtual machine. This involves creating strict boundaries between the virtual machine, the host and everything else running on the host, including other virtual machines. The future development of UML is, in large part, going to blur, or completely eliminate these boundaries.
In a small way, this has started to happen. The hostfs filesystem allows UML to access the host filesystem as though it were its own. The boundary between the host and virtual machine are going to blur further as hostfs is used to access other host resources, such as databases, processes, and services. Other host resources will be virtualized within UML as processes within the virtual machine, allowing them to be manipulated in the same way as UML processes.
The distinction between the virtual machine and host will become even more hazy when UML becomes a library and is linked into applications. Then, the running image is both a normal application and a virtual machine running a Linux kernel. It will act as an application when it's running its own code, and as an operating system when it is making use of the capabilities of the UML library.
Boundaries between applications will become hazy as they export their UI structure and other internal state as filesystems where processes on the host can monitor and manipulate them. They'll be able to do such things as copy data from one application to another and use information taken from one to determine how to manipulate the other. As this process becomes extensive, it will be increasingly unclear what application really ``owns'' a particular piece of data. The data will start acquiring a existence independent of the applications that used to have sole control over it.
Similarly, the implementation of UML clusters is going to eliminate the boundary between different hosts, as spreading a single virtual machine instance across multiple hosts will allow all of the resources of all the hosts to be accessed from within a single machine. Almost as a side-effect, this will provide a convenient platform for developing SSI clustering technologies for Linux as a whole, not just for UML. In addition, the genesis of this general clustering in virtual machines will mean that Linux clusters will be able to arbitrarily mix physical and virtual nodes, providing a new level of flexibility in clustering.
Taking all of these together, it is possible to see a future where kernel code and user-level code are arbitrarily mixed together, where a process may be running on a single machine or spread over several machines, which may be both physical and virtual. It will be possible for several processes to be transparently operating on and presenting to the user the same data. Breaking down boundaries always opens up new possibilities and the most interesting ones will be ones that no one had predicted beforehand.