An Investor's Introduction to Urbit - Part 1

What is Urbit?

---

This is Part 1 of a multipart series on Urbit. Chances are, you’ve either never heard of Urbit, or you have but feel like you don’t fully understand it. Over the course of these posts, we will dive into what Urbit is, how it is useful, and why I think it has the potential to be so valuable. Urbit has something for everyone - whether you’re into crypto (Urbit is the answer to many of the problems in web3, in particular how you build rich applications that people actually want to use), Artificial Intelligence (Urbit is the most credible architecture that I am aware of for delivering on the promise of personal agents) or just like using a computer (Urbit allows for the creation of meaningfully better software and a customizable internet) - and once you see how powerful it is, it’s hard to unsee its applications. So no matter who you are, my hope is that by the end of this you will have a deeper appreciation for why Urbit is so important.

Disclaimer: This is not investment advice, and is for educational and entertainment purposes only. Do your own diligence before investing into Urbit (or any other risky asset, for that matter). 

---

An Investor’s Introduction to Urbit - Part 1

What is Urbit? It’s a great question, and it’s one that I am asked with increasing frequency these days. In part because Urbit is independently gaining mindshare out in the world, and in part because people tend to be surprised when I say it’s a product I use every day. 

It’s also not an easy question to answer. I can give a two minute overview to cover the basics, but I find myself consistently reaching for the blog post that clearly articulates what Urbit is and why it is important, only to continuously be frustrated by the realization that this blog post doesn’t exist. I have yet to read an explanation of Urbit that captures the full scope of the project in language a normal person can understand. 

This series aims to change that. 

A disclosure and a forewarning before we jump in.

Disclosure: 
My approach for evaluating Urbit is largely informed by my perspective as an investor (and I am currently invested in the project). I’d be lying if I said I wasn’t “talking my own book,” but the real thrust for me writing this has less to do with me as an investor, and more to do with me as a human (and thus a user of computers). I think Urbit is one of the most important pieces of technology to be developed in the last 20 years, and that it has the potential to shift our relationship with computing and the internet in meaningful (and positive) ways. Accordingly, my goal is to help people understand what Urbit is in order to accelerate our ability to live in the future it can unlock.

Forewarning:
Urbit is nuanced. It takes different shapes depending on the angle you approach it from, and its real beauty only comes into perspective as you appreciate the multiple facets of what it offers. The result is that there is no simple analogy to capture Urbit. 

“It’s a social network.” No, not really (although it is a network, and does have social features like messaging built on top of it).

“It’s a database.” Wrong again (but it does store your data for you).

“It’s a blockchain.” Kind of, but actually, not at all (despite the fact that it provides many of the same features). 

If I were to put it in one sentence, I would say “Urbit is what the personal computer would look like if it had been built from first principles today.” It is personal computing designed for a highly interconnected world, for the ever expanding role of software in our lives, for the inevitable presence of AI, and for the increasing importance of data to our digital existence. And as we will explore more below, this is a very big deal, as it unlocks an entirely new paradigm for building and using software. 

Don’t be frustrated if what that means doesn’t click immediately. Don’t be put off by the often esoteric language that is littered throughout the Urbit ecosystem. Don’t let the project’s complicated history distract you from its promise. Put in the time to understand it, and better yet, start playing with it. I guarantee it is worth the effort.

With that, let’s get started. I’m excited to go on this journey together.

What is Urbit?

Urbit is a personal computer that runs in the cloud and natively combines a unique identity (in the form of an NFT), data storage (via an integrated database), application execution (which is run server-side, i.e. by the individual user) and P2P networking. The result is a system in which users control all of their own data and applications, and can easily interact with all other users on the network without reliance on centralized companies. 

Urbit has been around for a long time. It started as an independent research project in 2002, and a company named Tlon was incorporated to formalize building it in 2014. Fast forward to today, and Urbit is an open source project, with core development being stewarded by the Urbit Foundation. Tlon still exists and is focused on creating infrastructure and products that make Urbit useful and usable, but they are no longer alone, as a blossoming ecosystem of companies has emerged that is building on top of Urbit (more on this later).

Okay, but like seriously, WTF is Urbit?

If you’re like me, the answer above won’t fully make sense right away, so a little more color may be warranted.

Urbit for Crypto Natives

Let’s start with an explanation that frames Urbit in the context of the crypto landscape (to be clear, Urbit is not a traditional crypto project, but I find the comparison to be useful, especially for people that are already crypto-literate).

If you’ve fallen down the crypto rabbit hole, then you understand the concept of a blockchain. Simply put, blockchains are global state machines, and they allow a distributed group of computers to arrive at global consensus (i.e. agreement) on the state of a network without reliance on a centralized authority. 

Global consensus is an incredibly powerful tool, and most enthusiasm about crypto / web3 is rooted in the capabilities blockchains can in theory provide, including digitally native scarcity, ownership of one’s data, and fully interoperable and composable software. These things are all incredibly powerful and worthy of excitement. There’s just one problem: running computation through a global consensus mechanism is very inefficient. 

Global consensus is absolutely necessary for things where it is important for everyone to agree on the state of the network (money being a great example), but most of your digital existence doesn’t require this unified agreement. For example, you don’t need the whole world to agree on the state of the journal entry you’re writing, the photo you took of your friend, or the text messages you exchange with your mom. 

Those building in crypto today implicitly recognize this issue and are actively trying to remedy it. The primary mechanism for accomplishing this is shifting computation away from L1s (like ETH) to L2s (optimistic roll-ups like Arbitrum and Optimism, ZK-roll ups like Starknet and zkSync, etc.). While I generally don’t hear people in the crypto world speak about it this way, I effectively think of L2s as a “regionalization” of state. They shift computation away from the global state layer to a “region” where it can operate more efficiently, and then that region checks back with the global layer as needed.  

If you extend this move towards regionalization to its logical conclusion, you eventually realize that the most powerful version of it would be to push computation out to the individual. You realize that the most compelling complement to a blockchain would be a personal state machine: a computer that provides you with all the same affordances of a blockchain (ownership of data, software composability, etc.), but that maintains its state independently and entirely under the user’s control. 

This is what Urbit has built: a personal state machine. It is like the odd cousin of a blockchain. Blockchains are decentralized infrastructure for shared state. This is incredibly important in contexts where a group needs to agree on something for it to be usable, like who owns a scarce digital asset (e.g. digital dollars are worthless if they can be double spent). Urbit is decentralized infrastructure for everything else. Everything from where you store your personal files, to where you host the front end to your application, to where you collaborate with your friends and colleagues.

Once you see this, it is hard to unsee. It is hard to not look at many of the problems in web3 and say “Urbit is the right answer to that” (a concept we will explore in more depth below). It may seem like a bold statement, but the moment Urbit clicked for me is reminiscent of the moment that BTC and ETH clicked - and in my opinion, Urbit is similarly as impactful. In fact, an (admittedly provocative) view I have is that it’s possible all of the promise of web3 can be delivered strictly by those 3 building blocks: BTC, ETH and Urbit. 

While the crypto comparison is helpful, as I noted above, Urbit isn’t really a crypto project. It’s much bigger than that, and it has relevance for a much broader audience. So let’s approach it from a more generalized lens and see if that helps paint a more complete picture of why it is worth our attention.

Urbit for the rest of us (or, why will anyone use this thing?)

Let’s go back to the high level definition of Urbit that we shared above and unpack what it means and why it’s important.

Urbit is a personal computer that runs in the cloud…
You know what a personal computer is, and you likely have multiple; your laptop and mobile phone being prime examples. It’s easy to conceptualize that you own these devices (e.g. the laptop on your desk is yours and is controlled by you). Urbit enables this same concept of owning your computer, but rather than having that computer be tied to the device that is sitting on your desk or in your pocket, the computer exists in the cloud. 

This is different from how the internet, software and cloud computing work today. In the current paradigm, you have a virtual presence, but you don’t own any of it. Your data sits on a Google server, your identity sits split across Facebook and Twitter, and the software you run isn’t actually owned by you (you’re using it as a service provided by someone else). 

To further illustrate this point, it’s worth framing Urbit in the broader context of the history of computing.

A quick recap of the history of computing…
The first computers were mainframes - large, monolithic machines (often the size of entire rooms) that operated as a centralized hub for computational work. Different parties could use the mainframe to leverage its capabilities, but no individual user could customize it to their specific needs. Then, in the 1970s, the first personal computer was born. The PC was a device that an individual could own, operate and modify however they saw fit. Users were no longer beholden to a centralized machine, and they could build a PC to serve their specific wants and needs. This was a revolutionary advance, and the PC marked a major inflection point in how humans interact with the digital world. 

Computing’s next major inflection point occurred a little over a decade later, as the PC went from operating independently to becoming networked via the emergence of the internet. I don’t need to elaborate on the ways in which the internet has impacted the world; its influences on daily life are seemingly endless. The internet didn’t just impact the ways in which we use computers though, it sparked a fundamental shift in the structure of how they operate by catalyzing a massive migration of the software we use from being local (run on your personal machine, or “on prem” in the business context) to online and in the cloud. 

Fast forward to today, and it becomes clear that we have returned to a system design that looks not too dissimilar from the world of the mainframe. Individual users (whether they be people or enterprises) don’t really own their “internet computer”¹ (meaning their data or the software that they run) and instead rely on 3rd party servers sitting in centralized data centers for their computing needs. It’s the same structure as the mainframe, just in a context where we connect remotely (i.e. via the internet) to the centralized computing resource rather than locally (e.g. actually physically connecting to the mainframe). To be clear, this isn’t necessarily a bad thing: data centers are tremendously powerful and offer meaningful benefits to us as users of software. But, the current paradigm has in many ways taken us away from the world that the PC created - one where users could own their computer and customize it however they see fit - and brought us back to a world where we are reliant upon something that is more monolithic.

Back to Urbit…
This is where Urbit comes in. As I said in the intro, Urbit is what the personal computer would look like if it had been built from first principles today. It is the personal computer, but built in an internet native way. It is (for those of you who are more technically inclined) a personal server - a server that you own, that can be customized to your needs, and that (very importantly) doesn’t require you to run your own hardware and instead allows you to leverage existing cloud infrastructure (e.g. data centers and the modern internet).

[Note: I recognize that I use the words computer and server somewhat interchangeably in this post. I have chosen to frame Urbit as a personal computer rather than a personal server because I’ve found that the average person’s head explodes when you start talking about servers. That being said, I realize the term server is more technically accurate.]

This is a very big deal. In the same way that the original PC sparked a revolution in computing, it turns out that creating a cloud based personal computer that you own opens up an entirely different orientation for your digital existence, and it provides the foundation for some really powerful capabilities.

What does that actually mean? To unpack it, let’s examine the second part of our definition for Urbit further. Urbit natively combines:

A unique identity (in the form of an NFT)...
On Urbit, you have an identity that you own, and that identity is tied to your personal computer. This is great for you as a user, because you only need one identity to engage with all of your applications. This is also great for others on the network, because your identity is apparent to everyone that interacts with you, resulting in the creation of a persistent reputation that is valuable across contexts.  

Data storage (via an integrated database)...
On Urbit, you can store information in your own personal database (that you run, or that someone runs on your behalf…more on this below). This means that all your data sits in one place (a place that you own and control), and you can do with it what you want. 

Application execution (which is run server-side, i.e. by the individual user)...
On Urbit, all software “comes to you” and interacts with the data on your personal server. You’re never sending data to a company/app, and all software is designed to interact around your data. If this sounds familiar, it’s because it’s how software used to be distributed (CD-ROMs purchased from the store, installed on your personal computer), but adapted for an internet-connected world. 

P2P networking…
On Urbit, your personal computer can easily be connected to everyone else on the network in an encrypted way. You can send a message, a photo, or a piece of software directly to a friend without worrying about where to find them or the security of that communication. 

Why is all of this important? 

Talk to the OG Urbit crowd, and you’ll likely hear that the killer differentiator unlocked by Urbit’s architecture is the ability for users to own their data (aka data sovereignty). You’ll hear a passionate articulation of how computing on Urbit means you no longer have to rely on large corporations for your online existence. This is true, and data sovereignty is an incredibly important component of Urbit, but stopping there misses the full picture - both of why Urbit is so powerful, and of why it will be relevant for everyone (not just those concerned with online data privacy, which we all know is a pretty small portion of the population today). 

The truly exciting thing about Urbit is that it unlocks an entirely new paradigm for building and using software. 

For developers, Urbit simultaneously expands the design space for the types of software that can be built and dramatically lowers the friction to create that software. 

For users, Urbit not only gives you control of your data (sovereignty!), it allows for the creation of products that are personalized to your specific needs (whether you are an individual person, group or company). 

Expanding on this a bit more, Urbit makes software composable, interoperable and much lower friction to build.

• Composable: Building software on Urbit is like playing with application legos, where an open architecture allows one application to easily build on top of others. What does this mean in practice? Imagine how awesome it would be (as both a developer and a user) if every new iOS app could access all other iOS apps and the data that was generated on them. I could order a meal from Uber Eats and have the specifics of my order automatically captured in my meal tracker on Noom, I could have my payment methods auto embedded on every commerce app I download, and I could have my friend list from Instagram transported to every app that I use. This is what Urbit allows for.

• Interoperable: Software on Urbit is interoperable, meaning that developers can create custom products that meet the needs of a specific user base and still have that product easily interact with everyone else on the network. This is the equivalent of me being able to use Telegram to directly message my friends on iMessage, or of allowing competing clients/user interfaces on Twitter to all be connected by a unified messaging protocol and shared social graph. We can each use the products that we prefer without there being a resultant fragmentation of our experience. 

• Low Friction: We often take it for granted, but shipping software on the existing internet requires a ton of back-end infrastructure (known as DevOps) to go live. This is because today’s internet does not incorporate core primitives like identity and encryption at the protocol layer. The result is that you need to worry about things like authentication, user data security and GDPR compliance in order to serve customers. Some estimates suggest that this DevOps work can account for +40% of a software application’s engineering resources. On Urbit, this DevOps burden doesn’t exist. It’s all automatically integrated into the network: identity is native to the protocol, networking is already handled, and you never touch user data (as the software goes to the user, rather than the user coming to you). The result is the ability for you to build an application over the weekend, for that application to be “production ready,” and for you to easily ship that software directly to your community and the network at large.

The insight here is that data sovereignty, while valuable in its own right, is actually a prerequisite for this improved computing experience. You need to have all of your data in one place (along with all of the other infrastructure that Urbit has built) to be able to offer the capabilities outlined above. The result is an architecture that delivers on how computing and the internet were actually intended to work. It gives you not only data sovereignty, it provides you with “compute sovereignty” and the ability to run whatever software you want, however you want, in perpetuity.

If you are like me, examples are helpful for taking abstract concepts (of which most of what I just wrote likely qualifies) and making them more tangible. I’ll go into more depth about the potential use cases of Urbit in a future post, but the implications are near endless. As a preview, imagine:

• Healthcare: Your Urbit computer (often called a “ship”) becomes the home for your personal health data. It automatically ingests all the relevant info from your connected applications (everything from your continuous glucose monitor, to your step tracker, to the prescription history from your pharmacy) and gives you a unified view of the results (a view that you can customize however you see fit). You permission that data to your doctor as needed, or to a pharma company running a clinical trial, and can remove that permission at any time.

• Personal Finance: You download an application for payment processing and add your methods of payment (wallet, credit card data, bank account, etc.) onto your ship. Your payment methods can now be auto embedded into every other application you use (think an infinitely extensible version of ShopPay), so you never have to deal with a clunky checkout flow. You then connect a personal budgeting application into the mix, and it auto aggregates and categorizes your spending, letting you know when you go over a limit that you specified in a particular category.

• SMB/Enterprise: You run a start-up and use a wide range of productivity tools to operate your business. You used to stitch them all together via a combination of Zapier and manual processes, but on Urbit they all speak to each other automatically. Every tool you use is default collaborative, and that collaboration can be unified across applications. You change the status of your customer pipeline in a spreadsheet and it automatically updates a slide for your upcoming sales meeting. You easily permission access to a data set to the relevant people at your company and an external contractor. You supercharge your productivity with AI agents that run on your company’s proprietary data, and you never worry about that data leaking. 

And for those of you that are more crypto-native, you’ll find that Urbit solves many of the problems that currently exist in web3. Urbit retains the properties of decentralization (the composability, interoperability and trustlessness that make web3 appealing), but delivers it in a way that is superior for both application developers and users. For example, Urbit allows for:

• Customer engagement without customer data: OpenSea (and other Dapps) would love to be able to engage with their customers while never actually storing customer information. The OpenSea email leak is a clear example why. If an app wants to send marketing content to its users today, there is no ability to do that in a crypto native way. They either have to take an email address (which is a liability, and which many users don’t want to give) or engage with an ETH wallet address (which you can’t easily send a message to, and it would be quite expensive if you wanted to). Urbit fundamentally alleviates this issue.

• Dynamic and personalized customization: Today a trader goes on Uniswap and sees a generic interface where they execute a trade. Uniswap knows very little about that customer, other than what is publicly available (e.g. if that wallet has traded on Uniswap before), and they have no ability to customize what the interface looks like for the specific user (given the front end is a browser based application). If Uniswap was on Urbit, each user could have a custom interface—a dashboard with all historical trades, graphs showing assets of interest, tools for specific trading strategies, etc.—all run by applications that sit on top of Uniswap and pull from the user’s private data. Sound too good to be true? Things like this are already being built (e.g. learn more about an Urbit native Uniswap UI here).

• No central point of failure risk: Gnosis Safe is a multi-sig wallet provider (i.e. wallet requires M-of-N signatures to execute a transaction vs. traditional wallet where you just need 1 private key). The company has designed Gnosis Safe to have gasless signatures, which means that transactions don’t hit the blockchain until the full transaction is ready to be executed. They do this by creating a partial signature from members and waiting on the other signatures to come in before the action is executed. This requires Gnosis to operate software on their servers that index/route the signature requests between the different addresses prior to pinging the blockchain. The result is that, if Gnosis went down, the multi-sig functionality would not work anymore. This is more than just a philosophical problem, it has real implications for user adoption and security. On Urbit, gasless signatures could be accomplished with no reliance on any centralized party or server.

The State of Urbit Today - Where are we?

Urbit has been around for over a decade, so you may be wondering, why does it warrant attention today. As an investor, this is one of the most important questions I ask myself when evaluating an early stage investment - what is the “why now” for the opportunity? The simple answer is that Urbit very recently went from being a seemingly impossible mad science project to reinvent computing to a usable product. What changed? At a high level…

It is more accessible: Up until early 2023, the only way to launch your ship was to set up your own personal server. Setting up your own server is a huge burden (at least for the average person), and the result was that only people that were highly motivated and highly technical made it onto the network. Fast forward to today, and there are now hosting providers that will manage your ship for you.² For instance, through Tlon or Red Horizon, you can now get a ship up and running in just a few clicks. A process that was historically like eating glass is becoming increasingly seamless, and thus accessible, to everyone.

It is more reliable: For those who were brave enough to make it onto the network prior to hosting, they faced another issue - network reliability. Prior to ~2021, Urbit was notorious for going down all the time. Since then, the network has been hardened and has become significantly more reliable. There are still a lot of improvements to be made to the underlying technical infrastructure (things like increasing your ship’s database size), but over the last few years the project went from the “will this thing work?” phase to the “it works, now how do we optimize it?” phase.  

It is more functional: So, you made it onto the network and it’s working. Now what? Until recently, there was essentially nothing to do on Urbit once you arrived. That all began to change at the end of 2021 when Tlon released Landscape, which is an operating system for Urbit. Landscape opened up the ability for developers to easily build and ship applications on the network, and for users to engage with those applications. The resulting experimentation since then has been astounding. Since its release, Landscape has gone from 0 applications launched to there being an estimated +100 applications, many of which are being developed by VC-backed teams. This is what Landscape currently looks like. There are applications for everything from messaging, to engaging with an AI bot, to playing chess, to listening to music with friends (reminiscent of one of my favorite old school websites, turntable.fm).

The result of all this has been continued growth in both developers and users on Urbit. 

On the developer front, there has been a steady upward trend in monthly active developers, currently reaching ~90.

While 90 may not seem like a very large number, it’s actually quite an accomplishment. To contextualize, it’s equal to about the number of active devs on Ethereum in 2017, and is equivalent to many much larger protocols today.³  This is despite building on Urbit requiring you to learn an entirely new programming language called Hoon.⁴

Source: Shout out to the team at Electric Capital and their excellent Developer Report

On the end user front, while it is building from a small base, numbers have been growing ever since hosting providers opened up. This may not look like an exponential curve (yet!), but the reality is that the network isn’t ready to support tens of thousands (let alone 100s of thousands or millions) of users. It will be soon, but the result is that the major hosting providers are actually limiting access to the network at this moment in time (e.g. Tlon only releases ~30 new ships a day, all of which get snapped up).

Total Booted Ships (i.e. activated users) // Source: https://network.urbit.org

What the user numbers don’t fully convey, however, is the incredibly passionate community that exists around Urbit.  It’s hard to describe, but energy in the ecosystem feels “special” - reminiscent of the Homebrew Computer Club for the PC computing wave, and BTC + ETH communities for crypto. There are people who are almost religious about Urbit, and that passion is authentic. It’s not about trying to shill a project to make a buck (although I do think there is a lot of money to be made in the ecosystem), and is instead driven by their belief that Urbit is creating something truly special. 

Interestingly, there isn’t one generalizable stereotype that is engaged in the community. At Assembly (Urbit’s annual conference) you’ll find a nerdy developer that loves Urbit for the power of its code, a die-hard libertarian that values Urbits principles of sovereignty, and a liberal artist that is attracted to Urbit’s infinite design space for creative expression all hanging out together. It’s intangible, but the best way I have heard it put is that relative to everything else being built out there (certainly in crypto, and arguably more generally in software), it is the only project that has a soul.

Conclusion (for now)

Okay! You’ve made it this far. Hopefully the picture is starting to become a little clearer. If it’s still fuzzy, don’t fret! I haven’t met a single person for which Urbit fully clicked upon an initial review. 

We’ll pause here for now. In the next post, we’ll explore in more depth the ways in which Urbit is useful. We’ll attempt to better understand its current functionality and the interesting things you can do with Urbit today, as well as squint into the future to imagine all the ways in which it can manifest into the most important (and delightful) computational platform in the world. In particular, we’ll dive into why Urbit is so important for the future of AI and the creation of personal agents. From there, we’ll examine Urbit more directly from the lens of an investment (yes, you can invest in the project, and yes, I think there are exceptional returns to be made in doing so). 

Until next time.

PS - Want to get on the network? Shoot me an email at basho@deeperknowing.co, and I will get you a link for a hosted ship (FYI that you may hit a waitlist when you sign up, but it shouldn’t take long for you to get access). Once you’re on, you’ll have an invite waiting for you to the Deeper Knowing group, and we can continue the conversation there. Also, for those of you with an iPhone, I would recommend you download the mobile app Small Talk (still in TestFlight), as this is the best way to use Urbit messaging + groups on mobile. 

1. Hat tip to The Browser Company (as an aside for fans of the Arc Browser, check out this UI for Urbit built on Arc).

2. I can imagine some of you are thinking “doesn’t third party hosting undermine the value of Urbit, as I’m now reliant upon another entity to hold all my data?” I will address this in more depth in a future post, but the short answer is no. Urbit’s architecture explicitly ensures that you can take your ship (and thus all your associated data) with you at any point (i.e. go from one hosting provider to another, or take it from a 3rd party and hold it directly). This is because the entire Urbit OS, including the software that runs on it, can be represented as a single piece of data. Accordingly, the entire thing (both your apps and your data) can be easily transported to any system that can run Urbit and picked back up as though nothing changed. This is part of the beauty of Urbit’s design - it can leverage centralized cloud infrastructure while retaining the benefits of a decentralized system.

3. While relative valuation comparisons in crypto are a fool’s errand, it is worth noting that Urbit’s monthly active developer count puts it in line with protocols like Avalanche (~$5B network value), Filecoin ($2B), Aptos ($1.5B), and Optimism ($1B).

4. A new programming language!? Yes, and we will dive into what it is and why it’s interesting at another time. For now, all you need to know is that Hoon is a top 50 language pull on Github and that AI copilots just reduced the barriers to using a new programming language dramatically.

---

This post is for informational purposes only. It does not constitute investment advice or a recommendation or solicitation to buy or sell any investment and should not be used in the evaluation of the merits of making any investment decision. It should not be relied upon for accounting, legal or tax counsel or investment recommendations. This post may feature entities in which Basho has invested.