Our Approach

Take 5 minutes. See why we're doing things differently.

There's a lot happening to try and make the internet more open. ActivityPub, AT Protocol, Matrix, Solid, and efforts to build bridges between some of these different ecosystems.

We think there's a more fundamental opportunity that's getting overlooked.

Rather than developing separate systems for social media, messaging, and other kinds of applications, and then figuring out how to connect them, more of the common functionality should exist underneath the applications in the first place. That's what we've been working on with the Bona Fide Connection Protocol, or "Bonafide."

Software is built in layers. Generally, when something is useful across many different kinds of applications, it makes sense to standardize it at a lower layer. That way, developers don't have to keep building their own versions of the same thing, and applications can work together more easily.

We started with a few basic building blocks common to almost everything people do online. You have information. You have connections to people, businesses, and organizations. You decide what you're willing to share with them and what you're willing to receive from them.

None of those things are specific to social media, messaging, or any other category of software. Yet much of the machinery for managing them today lives inside individual applications, where it's done differently, leading to fragmentation.

There are a few important architectural differences in how Bonafide works.

First, each person has their own database. Their data and connections belong to them, independently of any one application.

Second, we built a connection-based network without publicly addressable identities and resources. You establish individual, consent-based connections with people. There's no need for a universal address that anyone can use to reach you, and you can present yourself differently to different people.

Third, we moved data access control down to the base layer of the protocol.

When you use an app, you're doing more than just storing data under a username or account. You're making all sorts of decisions about who can see what, what you want to receive, and who has permission to do different things. Today, most of that is managed inside each application, using mechanisms its developers made. That's why even if you can export all your data, you can't necessarily take all those arrangements with you. And even if you could export that level of detail, another application won't necessarily be able to understand or use it. So having your data is useful, but if you still have to reconstruct all your connections, sharing arrangements, and permissions every time you switch apps, you're still pretty much stuck.

With Bonafide, the underlying mechanisms for connections and access control are common. They're part of the protocol rather than something each application has to invent. You might share photos with someone, exchange messages, or do business together. Those activities can use the same underlying connection, with different permissions appropriate to each situation.

Independent databases, connections, and data access control are all handled at the first layer of the protocol.

Then we have a second layer made up of domains. A domain is just the common vocabulary and rules for a particular kind of application. We've developed a domain for Pools, our private social-sharing app, and we're developing another for messaging that we'll release soon.

Different developers can build interoperable applications using the same domain. They can offer different interfaces, features, and business models, while sharing a common way of exchanging information. New domains can also be introduced for entirely different kinds of apps, without having to reinvent the underlying network.

What we're doing is making the network and data independent of the applications.

Your data and connections don't belong to any app. You own and control them, while the underlying rules for sharing information are common across applications. Those applications can then compete to offer different ways of using that shared foundation, instead of having to own the network themselves.

Take photo sharing. Imagine two competing applications built on the same Bonafide domain. Normally, if someone builds a new photo-sharing app, they have to persuade people not only to try their software, but to bring their friends along. That's so much harder than just making a good app. Since both applications are using the same domain, they can exchange information through the connections that people already have, respecting the permissions those people have chosen. The interoperability is already built into the design.

You could use one application, your friend could use another, and you could still share with each other. You wouldn't need to convince everyone to switch apps just because you prefer something else.

The developer still has to win customers. They just don't have the added task of convincing those customers to abandon their existing network and history to try something new.

Network effects are incredibly useful. Right now, much of that value gets captured by the platform owner. We want to change who benefits. If people own and control their data and connections, and applications operate on a common foundation, those benefits can extend across competing companies.

As more people participate, the network becomes more useful. That creates opportunities for all the companies building on it, not just the one that got there first. A new developer can build something better for people who are already participating.

An established company won't be able to rely so heavily on trapping its customers. It'll have to keep earning their business. This could change the economics of building software, and improve the competitive dynamics of the whole industry. Maybe we'll eventually look back on the platform era and wonder how we managed to let so few companies build enormous businesses around owning the networks that everyone else depended on.

This also changes the importance of being first. In today's platform model, there's a massive advantage to getting there before everyone else. If competing platforms don't talk to each other, then the race is to become the biggest platform, because that's where everyone else will eventually have to go.

Now think about a city as a network. There's an advantage to opening the first coffee shop. You can establish relationships and build a loyal following. When another person wants to set up shop down the street, there's nothing you can do about it. You don't own the residents or the streets they use to get around, so you just compete for customers. As more people move to the city, it's an opportunity for both shops, and for others that haven't opened yet.

Online, we've gotten used to this weird situation where opening a competing coffee shop is more like having to build another city. It's as if the customers who have been to Starbucks aren't allowed to go to any other coffee shop. It's extra absurd when you consider that software has the potential to be far more interoperable than the physical world. We have barely explored what's possible because so much of the internet's activity has been locked into these privately controlled networks.

We're not just thinking about social media. The same problem exists across the internet in ride hailing, food delivery, online marketplaces, professional networks, etc.

If we can flip who owns those relationships, the barriers to entry could be considerably lower, and those spaces could be much more competitive. In food delivery for example, restaurants wouldn't necessarily have to choose between participating in the biggest delivery network and trying a smaller service with better terms. Customers and drivers could have more choices too. In a common domain, the delivery apps would still have a business to run, but they'd face more competition. They'd have to compete on the fees they charge, and couldn't rely on their control of the network to keep them high. Everyone else in the network would benefit.

Think about how many more independent software companies might be viable if they didn't have to build a network around every new idea. Imagine how many people could try something different when an incumbent having the biggest network wasn't such an overwhelming advantage.

We've already developed the Bonafide protocol, published its specification, and built Pools, our first application. Our next application is focused on contacts and messaging. There's still important work ahead, including independent hosting, migration, and demonstrating interoperability with applications built by others.

We want to make it possible to build a successful software business without having to own the network of people that makes it useful. We think that could lead to a much more interesting internet.