At Crosshatch we represent the changing shape of people depending on the data that’s shared. We do this to represent how each application we use, even combinations of them, only know a portion of us.
Outside of the digital world we’re whole.
Even combinations of the many apps we use only see a piece of us. They could know these pieces because that’s all we’ve decided to share. Or had time to share? Maybe these applications leave us to act a certain way.
Flirty? Serious? Organized! Distracted? Luxurious.
Contingent.
There is a wound that won’t heal at the center of the internet.
On the internet our identity is de-facto contingent. Contingent on the bounds of any application.
At Crosshatch we’re building an interoperable unified context layer for hyper-personalization anywhere on the internet. We wish for this layer to be both humanistic and of great ergonomics for developers and control of users (or their authorized agents).
Of course, creating a unified context representation is a tall order. In this blog we share our thinking in deriving our first one.
So commercial
A simple place to start is just how the industry treats this problem today. How do businesses today create representations of their customers for analysis and activation?
Most businesses track and represent customer behavior using industry standard action-object framework e.g.,
clickedproductviewed hotelupdatedcart
and associate these events to an identity. [Increasingly the identity that underwrites these events is going away.]
The framework is popular because it clearly describes the actions a user has taken and onto what objects.
Objects can be assigned additional properties to further characterize the nature of the product or hotel object that received the action, like category, price or description. These additional properties can serve as important metadata for easy retrieval or analysis that enable better understanding of a user’s journey within a business.
Of course, this representation is only what a given business sees of us.
Other businesses might collect other viewed or clicked or purchased or liked events, but against only the universe of objects they govern.
While this helps define user-application state locally, it doesn’t define the user’s global (cross-application) state, which could be given by the union of tracked events over all applications a consumer uses.
Suppose a consumer could (effortlessly!) assemble all of these events. Taken together could they represent the user?
Do you know who I am?
To try to go deeper here, we take a quick look at philosophy, namely theories of reference.
Given that we’ll use language as a medium for representation, it’d be quite convenient if we could assume that there is a general correspondence between language and reality. To properly represent someone all we need to do is choose the right words.
Bertrand Russel sought to deliver this link via logical atomism, or the supposition that “reality is composed of logical atoms which are not further analyzable.” If this were the case, to represent someone all we’d need to do is recall their unique description, composed of these logical atoms.
Unfortunately, Russel later soured on logical atomism.
It has a few problems. What exactly is a logical atom? If you think you’ve found one – something no longer further analyzable – how do you know? And for a given description, how do we know it’s necessary – something describing a person’s true essence – and not just possible?
We’ve spent the last decade shifting culture to honor our respective pronouns – to treat each other the way we want to be treated. The last thing we want is to build on a representation that’s merely possible.
We want a representation that’s necessary – uniformly true – not possible or contingent.
Intuitively, names appear rigid and not contingent on anything. Einstein. Rachmaninov. Any representation we devise shouldn’t be contingent either.
Saul Kripke formalized this idea in his 1972 Naming and Necessity, proposing the notion of rigid designators, a proper name that denotes an object in every possible word that it exists.
Kripke went on to reject Russel’s descriptivism, proposing instead that proper names are declared or “baptized” and carry meaning via every reference to the name since the initial naming ceremony, each reference based on the previous – a causal chain.
Under Kripke, reference is secured by this causal chain.
Every interaction the user has with the world could constitute a path to representing Kripke’s causal chain. And constitute representation that’s necessary, not merely possible.
Social butterfly
Ideally our representation could also be humanistic or reflect how we naturally treat identity.
For instance, ever since we were kids, we’ve been identity switching. We shift our vibe when we’re with friends, to when we’re with friends we trust, to our parents, to professional circles.
Social psychology calls this social identity – the switching of images of ourselves across contexts. In professional contexts we’re charming, interested, and focused. With friends we’re funny, sharp, and more relaxed.
Some identities are stigmatized. We shift to those more rarely or only in environments that feel safe.
Some social identities we cannot hide. Other people in our group just know, or think they know, even just seeing us on the street. A quick glance gives it away. Social identity isn’t always actively switched on or off. Vibes carry.
So it’d be great if our representation could also accommodate the dynamic nature of our identity as we navigate digitally.
Personal timeline
Putting this all together, we take our first user context representation to be a personal timeline.
Crosshatch enables consumers to effortlessly assemble – take the union of – data from across applications.
Each of these applications has its own data representation. On the other hand, irrespective of the representation, we can see some of the actions enabled in each application may actually carry equivalent meaning to the user.
One place to see how this could work is bottoms up – if you’re creating a protocol for decentralized social network applications, how might you define the interaction semantics that could work with every client? We look to Farcaster, which standardizes a set of available message types
cast: public messagereactions: Bob liked Alice’s `cast`links: Bob follows Alice- Profile data: Alice published a profile pic or display name
Now going top down, seeking to find a similar unified set of actions that consumers might take across apps, we might axiomatically declare
- A
clickis aclick, whether it happened on Amazon or Kroger - A
likeis alike, whether it happens on Instagram or Spotify - A
runis arun, whether it happens on Strava or Apple Health - An
utteranceis anutterance, whether it happens on ChatGPT or Claude
While not necessary, axioms of this flavor could help furnish a user data layer with nice ergonomics focused on user actions, irrespective of the data source channel that observed it. Taking the data layer as a sequence of all actions a user has observed or personally taken, we get closer to creating Kripke’s causal chain, a sequence of all interactions between you and the world. And with objects of the action-object framework enriched with metadata, it could enable fine-grained, context-aware permissioning and control for effortless extensions of social identity.
This representation isn’t perfect. Characterizing objects with metadata is descriptivist as of early Russel. Ideally we’d wish for objects to accrue their own causal chain of reference (e.g., among all the users that act on it the object). Further, it’d be convenient if all object metadata of the same references had the same representation (e.g., ‘New York City’ v ‘NYC’). This could allow for easier retrieval and processing when data are activated, but guaranteeing this sort of uniform entity resolution across all possible object entities we might observe could be challenging, especially since language models have looser consistency requirements.
We’re excited to continue in the path of many who’ve hoped for a user-governed interoperable data layer respectful to and delightful for humans and easy to use for developers.
