At this point many smarter people than me have already written responses to Moxie (Vitalik, Dan Finlay, Suzuha), but I’ve tried to focus mine more on the high-level implications for the Web3 space. I was hoping to keep this to a Twitter thread but I’m not Adam Cochran. And besides, this was a good excuse to write on Mirror for the first time. Off we go then.

Moxie’s piece is a very articulate distillation of some thoughts I (and many others) have had recently about some of the fundamental tensions in Web3. I don't come to the same conclusions as the Signal founder, and my outlook on Web3 is much brighter, but I think it's worth taking seriously.

For example, it's a much more thoughtful and precise critique than Jack's a little while ago. And as Dan Finlay points out, it comes off as non-adversarial, genuine, and constructive.

First, the key points:

People don’t want to run their own servers, and never will...Even nerds do not want to run their own servers at this point. Even organizations building software full time do not want to run their own servers at this point.

Basically, the internet runs on AWS, and blockchains (through Infura and Alchemy) do too. This is true and the proof is right there in front of us. However, as Vitalik points out here, that might not really be the most useful way to conceptualize this problem, and it might not really be a problem at all as long as users have (by default) good tools to verify that the data they receive is being correctly validated.

A protocol moves much more slowly than a platform.

This is something that a lot of people in crypto struggle to come to terms with, and while many projects try to be decentralized from the start, most realize that starting in a more centralized, structured (potentially even hierarchical) way enhances productivity and increases the pace of development. Most teams hedge by making promises for decentralization down the line (and it's worth pointing out promising examples of this approach, such as ENS, which has done a remarkable job), but the problem is many of these teams will bump up against a compelling source of friction, which ironically comes as a natural consequence of their success: users like and prioritize fast, seamless UX and a company that can deliver on features quickly. Shipping high quality fast > decentralization.

Almost all dApps use either Infura or Alchemy in order to interact with the blockchain. In fact, even when you connect a wallet like MetaMask to a dApp, and the dApp interacts with the blockchain via your wallet, MetaMask is just making calls to Infura!

I think most people in crypto should already know this, but worth spelling out again for those who don't. More importantly:

These client APIs are not using anything to verify blockchain state or the authenticity of responses. The results aren’t even signed."

And regarding privacy:

All write traffic is obviously already public on the blockchain, but these companies also have visibility into almost all read requests from almost all users in almost all dApps.

Summarizing the last two points: when you use your MetaMask (or any similar) crypto wallet, you trust Infura to send you the right data, and to do so you also let Infura see all the requests you make via their API. The next point should make sense as a matter of consequence:

If your NFT is removed from OpenSea, it also disappears from your wallet. It doesn’t functionally matter that my NFT is indelibly on the blockchain somewhere, because the wallet (and increasingly everything else in the ecosystem) is just using the OpenSea API to display NFTs.

Basically, your MetaMask is just a view onto data that is being relayed from the blockchain through centralized third parties like Infura and, for NFTs, OpenSea. If OpenSea stops relaying that metadata, your NFT is—for the mainstream user—gone in a practical sense. Not really, of course, but this matters when you think about users’ motivations for interacting with NFTs (which we will return to below).

Ok this requires its own image because it's one of the more profound observations in the post. However, I think it’s not entirely correct. It’s true that “these technologies immediately tended towards centralization through platforms in order for them to be realized, ” but the reason for that is because a whole cohort of builders were attracted to the basic premise of technologies like Ethereum and wanted to build applications for Ethereum’s aspirational endstate. Shortcuts had to be taken to enable that building “now,” but it’s certainly not reflective of a complete lack of interest from the builders, quite the contrary. It’s also true that “decentralization itself is not actually of immediate practical or pressing importance to the majority of people downstream,” but there’s a distinction between what the users (their desired solution) and what the builders need to build (the solution they know actually fixes the problem at hand). I will come back to this sentence: “the only amount of decentralization people want is the minimum amount required for something to exist.”

You can't stop a gold rush: The people at the end of the line who are flipping NFTs do not fundamentally care about distributed trust models or payment mechanics, but they care about where the money is.

Yes, there are plenty of people who really care about artists and supporting creators, and yes NFTs are an important innovation to align interests and appropriately reward creators. But the vast majority of OpenSea’s volume has nothing to do with that. People are in it for the money, and it’s the big boys who are moving the money around, making a disproportionate amount of the profits, while the other 90% of retail traders scan Discord channels in hopes of making a flip before being left with the hot potato (read: flaming pile of doo doo).

And finally, two conclusions: a) We should accept the premise that people will not run their own servers by designing systems that can distribute trust without having to distribute infrastructure. And b) We should try to reduce the burden of building software.

In summarized format, that all looks a bit morose, although certainly pointed. So first, in response, why I’m optimistic:

• By now many (most?) people building at the protocol layer are aligned on the idea that people don’t want to run their own servers and that blockchains are better as data availability machines than as execution engines. Ethereum is building in this direction through its rollup-centric roadmap, Celestia is prioritizing this direction, etc.
• Moreover, light clients will allow for most people to only “lightly” verify state when they interact with the blockchain. Again, the latest iteration of the ethereum roadmap is very conscious of this. Lots of chatter on this recently with good highlights from Suzuha / Fiskantes / Zaki, and I’m excited about Rick Dudley’s Laconic Network.
• Also, and this is where Moxie's claim that little cryptography is involved in "crypto" befuddles a bit—there is a huge amount of effort going into building ZK systems that will allow regular users to rely on cryptography to verify blockchain state. This is undeniably an important pillar of crypto going forward and a real advance in the state of cryptography.
• Finally, even at the infrastructure layer, there are projects that aim to decentralize the stack from the bottom up - projects like The Graph and Pocket Network, the latter being a direct decentralized competitor to Infura and Alchemy. I want to put a pin in this one, however, as I'm not entirely convinced that this is a scalable answer (not really talking about technically scalable, but more so socially).

What the above points start to depict is a world where different levels of decentralization are possible at different levels of the stack, and at the very least we should all be able to fall back on a minimum level of decentralization through a combination of data availability chains, ZK rollups, and light clients.

However, there are higher-level points here to reflect on. For one, the idea that people don't want to run their own servers remains important at an abstract level, in that most people simply do not care about how decentralized the underlying tech is, unless they feel the direct consequence of centralization when things go sour. (I’m being literal here, I don’t mean most people in crypto - I mean the majority of humans.)

This brings me to something that Vitalik mentioned in his Bankless podcast interview just a week ago. Which crypto network do most people use as a payment system in Argentina? Binance. Not Binance Smart Chain, but Binance the exchange. Because guess what? The majority of people don't care about the idea of crypto - they just want a currency and payment system they can use that retains its value and can be used in everyday transactions as well as for savings. And Binance fills that need (for now) by offering what are essentially bank accounts where you can hold stablecoins like USDT and use them to pay other Binance account holders instantly and for free.

All that's happening here is that one centralized provider (Binance) is using another centralized provider's (USDT) “tech” (ie. balance sheet) based on another centralized provider's (the Fed) currency to provide people banking and payment services that are superior to the country's own centralized providers (Argentina's central bank and banking institutions). Very little of this activity (arguably none) is passing through decentralized rails, yet one of the core problems crypto is meant to solve is being addressed by Binance.

This example is similar to Moxie's example about OpenSea and NFTs. Most people do not really care that the .jpgs they are purchasing live on some servers they can't control and could be turned off any minute. As long as it all keeps functioning on the surface right now, and they can make money off of these NFTs, it's all gravy.

Both of these examples, however, reflect a state of affairs where things are generally going well. What crypto is really about is optimizing for adversarial conditions. History shows us that there will always be episodes where users do care about the aims of decentralization. And since users don’t care to put in the work of getting there, it's up to the builders to carry the torch of decentralization forward, and to build systems that are good and usable enough that they can become the default for anyone building or using applications built on top. In my opinion, that’s why building in Web3 is valuable. It’s about resetting the standard upon which everything else is built and doing it the right way, despite the inevitable disinterest of the majority. As such, I would have to modify Moxie’s statement to make it comprehensive and enduring: “the only amount of decentralization people want is the minimum amount required for something to exist” and to persist under adversarial conditions.

This leads to a series of questions:

Can we really decentralize every layer of the stack? And is it even worth doing so?

I think it’s worth trying, but we should be realistic about what motivates choices in the technology stack. My sense is that we will never reach full decentralization at every layer of the stack, because there will always be quicker, cheaper centralized alternatives. As a result, there will always be some percentage of the network running through Infura-like services. And even when we do decentralize, there’s always a layer deeper we could go, as the lower you go in the tech stack, the more commoditized it becomes, and the more important economies of scale become. A case in point is something like Pocket Network. I think it’s a fantastic project and a very worthy experiment. But it brings up questions: are we going to get the same QOS as Infura? Does it always solve the privacy issues brought up by Moxie? And when it comes to the servers themselves, are those actually being run by individuals? (From the Discord, it seems like many people are just running their nodes on AWS. I could be wrong about this and would love to see a breakdown of node types, but that’s what I gleaned from scanning the Discord.) In any case, it seems much more reasonable to place more emphasis on having verification by default in every person's wallet - that's what we should be aiming for.

What should we focus on?

First, as Dan Finlay puts it eloquently, it’s about the “right to exit.” Users, even if they are not generally interested or aware, must have the ability to fall back onto robustly decentralized infrastructure, as that is their way out of the pitfalls of centralization. It’s true, “the right to exit doesn’t matter when you can fully trust your provider, forever.” But that is unrealistic over a long enough period of time, at least for a non-trivial part of the global population. It means that a user should be able to choose speed and efficiency when the times are good, and always have a fallback that guarantees safety when times are not. For example, in the case of Argentina, the goal should be to provide a UX similar (if not better) than what Binance provides, while enabling users to always have self-custody of their assets and fall back on a secure public mainnet when their centralized provider of choice turns either faulty or malicious—all of this, by default.

Second, I think we tend to lose sight of the real objectives of Web3 - sometimes because the financial opportunities that present themselves are too strong a motivator (not so good), and other times because the technical complexity of the work is so alluring (at least this is sometimes productive). We need to remember that the user and the use case motivates the technical work. If you’ve had to make any global wires recently, if you have a global team on payroll, or if you live in Argentina, it should be fairly obvious why cryptocurrency—the original Web3 use case—just makes sense. And yet, the state of crypto today does not lend itself to fulfilling that basic, obvious use case satisfactorily. As developers, operators, researchers, and investors, we must not lose sight of what really matters.

On the other hand, however, we should be proud of what we’ve accomplished. The decentralized, disorganized nature of the crypto ecosystem has produced a wide range of compelling projects, from DeFi to NFTs to DAOs. Most of these are still in their “experiment” phase, but it’s precisely through these experiments that we’ve pulled (rather than pushed) the infrastructure forward. Protocols might be slower than platforms, but they incite more creativity and produce a broader design space for experimentation, which is only compounded by the composability these protocols exhibit by default (something Moxie barely touches on). Even their technical limitations force constraints that breed creativity.

The primitives of crypto have inspired and enabled builders to dream up a whole new series of applications that are designed for the endstate of Web3. I would argue these builders want to build on minimally-viable decentralized rails, they want to provide a “right to exit” - but the infrastructure has not kept up with the application layer - and as more builders come in to the space and congest the Ethereum network, builders have moved on to the next best thing, blockchains that provide a different tradeoff space: less decentralization, more performance. Yet the motivations are still there, and the reality of adversarial conditions still exists. It’s up to all of us building and investing in the space to stay cognizant of that reality and keep our north stars in sight.

I think we’re on the right track, and it never hurts to be reminded of our objectives by thoughtful critics.