Existing distributed reference mechanisms have serious shortcomings when it comes to supporting dynamically shared objects. We are looking at support for type safety and fragmented objects, i.e. object groups for persistence, replication, or distributed data management. Our position is that a single binding protocol should take care of these needs in a flexible and general fashion. When objects are shared dynamically, it is in the general case impossible to decide at compile time whether a reference is type-safe. Furthermore, new types and classes are created while the system is running. This creates a need for dynamic instantiation of objects, dynamic linking of code, and dynamic type checking of references. Objects are often fragmented i.e. constructed as a group of sub-objects in separate locations. For instance, a persistent object is composed of an on-disk image and zero or more in-memory images. To reference a fragmented object, we reference a specific “factory” fragment. At bind time, the factory selects one of its fragments as the target. The ability to redirect the reference to another fragment is essential, even after binding has been made. We are currently specifying a general binding protocol that supports the needs stated above. It is designed to support late binding and language- or application-specific policies. It is conceptually simple but recursive. An actual implementation may terminate the recursion at any point, trading off performance and simplicity against completeness