Suppose there was a website called Optimal Kickstarter. Like the actual Kickstarter, it lets people propose projects to be funded, and it lets people crowdfund projects. But there are two differences.

First, Optimal Kickstarter only funds *public goods*: successful projects are made freely available to all. Second, Optimal Kickstarter has a benevolent patron who supplements the contributions of the crowd in a pre-specified formula. When you fund a project through Optimal Kickstarter, it essentially lets you buy support for a project with someone else’s money.

The way the website works is that every project has a calculator to explain how much patron money you can purchase for the project. For example: maybe there’s an open source software program that you think would be really useful. It is currently funded at $88,209. The site tells you that you can increase the funding to this project by $595 for the price of $1, $1,333 for $5, $1888 for $10, and so on (you need a calculator because the price of patron money is not constant).

Why is it called *Optimal* Kickstarter? Because the formula determining how much of the patron’s money you can “buy” for a project is from a paper by Buterin, Hitzig, and Weyl (2019) (preprint), which optimally funds public goods.

## The trouble with Public Goods

Why so complicated? Public goods are projects that are, by their nature, enjoyable by many users at once and costly to exclude people from using them. Think open source software, art, research, national defense, herd immunity, etc. These goods cannot be efficiently provided by the private market. Since the good can be simultaneously enjoyed by many at once, efficient provision would make it free. But if the good is given away for free, it is impossible to cover the fixed costs necessary to create it. And if you try to charge a price greater than zero (to cover fixed costs), it’s doubly inefficient since it’s costly to prevent people from accessing the good. You have to waste more effort wrapping the project in IP, DRM, etc.

Such goods can be crowd-funded, but under standard economic models, they’ll be drastically underfunded. This is because individuals only consider the private benefits they derive from contributing, not the benefits that accrue to other users. Suppose, for example, for $1,800 programmers can optimize the program mentioned above and make it run 50% faster. Let’s say the value of that is $10 per person. If there are 180 users, the total value of that optimization justifies the cost.

But each user only derives $10 of value themselves so no one has an incentive to provide the full $1800 worth of funding. All the users could band together and provide $10 each, but if contribution is voluntary, this doesn’t solve the problem either. For any individual, if they withhold their $10, the project only raises $1790. That’s nearly $1800, enough to optimize the program by nearly 50% and generate, say, $9.95 worth of value to every consumer. Given this, a selfish individual should just free-ride on the contributions of others, enjoying $9.95 in value for free, instead of spending $10 to get $10 in value. But it doesn’t stop there. The next user can save $10 and enjoy a bit less than $9.95 in value by not donating either. Indeed, this logic continues all along the chain and the project ends up getting a tiny fraction of the funding it should.

## Solving the Public Goods Problem

But notice that Optimal Kickstarter doesn’t have this problem. If I chip in $10, the project’s funding rises by $1888, because the patron supplements my contribution. This is enough to fully cover the cost of optimizing the software, meaning I enjoy the full $10 of benefit. If I don’t chip in $10, the software isn’t optimized and I don’t get to free ride on the improvement. So I might as well spend the $10.

The actual formula linking the contributions of the crowd to the funding level of the project is derived from Buterin, Hitzig, and Weyl (2019), who propose a decentralized way of optimally funding public goods. The actual formula isn’t that complicated, but neither is it very intuitive. Let *c1* be the contribution of person 1, *c2* be the contribution of person 2, and so on. The formula for *N* contributors is:

Essentially, you take the square root of everyone’s contribution, add all those up, then square that.

In the example I’ve been using, I assumed there were 99 funders, each of whom contributed $9. The square root of $9 is $3, so the total funding of the project is (99 x $3)^2 = $88,209. When you throw in another $10, the square root of $10 is $3.16, so the total funding of the project rises to (99x$3 + $3.16)^2 = $90,097, which is $1,888 more than $88,209. Hence, for $10, you buy $1888 in support for the project.

This formula lets the crowd provide information to the patron about how valuable the public good is, via their contributions. The more contributors, the more funding the patron provides. Notice that if there were just one person who benefited from the public good, and therefore one contributor, the patron doesn’t provide any support:

No more support is needed in this case: the whole problem is when others benefit from your contribution. If it’s just you that benefits, then it’s easy for you to decide how much to fund.

But as the number of contributors grow, there is a stronger and stronger signal that more people benefit from this public good. If there are two contributors each contributing $9, the patron supplies an additional $18. If there are three $9 contributors, the patron supplies an additional $54. If there are 99 contributors ($9 each), the patron supplies an additional $87,318.

Meanwhile, this system ensures people give credible signals about the benefits they receive from the public good since, at the end of the day, they do actually have to spend money to purchase patron support. And the fact that your contributions are supercharged sidelines the free rider problem.

## It’s Complicated

In the real world, such a system would have some complications.

For one, each person’s decision about how much to contribute should actually depend on how much others are submitting. But, done properly, this should all be done simultaneously. If I’m the first person to contribute to a project, it is hard to know how much patron support my contribution actually buys, because it will depend on what other people ultimately give. Buterin, Hitzig, and Weyl suggest the program would have to be iterative, with some initial guesses about how what the other contributions would look like, followed by some rounds of fine-tuning in response to better information about how much everyone else actually gives.

Second, the patron’s funds are not actually unlimited. Buterin, Hitzig, and Weyl discuss ways the formula can be modified to take into account the reality that project support may be limited. That shifts you away from the optimal solution, but you still end up with something much better than crowd-funding, and where the patron learns a lot about the value of public goods through contributions.

Third, there are ways to game this system. Splitting contributions among several sock puppet contributors, for example, is a way to buy more support than is warranted. Indeed, a fraudster able to funnel his money through multiple “contributors” could use Optimal Kickstarter as a money pump, if they are able to create projects that simply pay the fraudster from patron money. Fraud detection mechanisms would need to be implemented in a real world implementation.

There are many other issues to be considered. But one of my favorite things about Glen Weyl’s work is that in this, and his many other radical proposals, he always tempers utopian visions with advocacy for an incremental implementation. Start small. See how it works. Correct problems and move forward.

Unfortunately, Optimal Kickstarter doesn’t exist. But I think it’s a cool idea. It would be a great public good. Just the kind of website that I bet would get a lot of funding from Optimal Kickstarter.

**Update:** I was wrong! Since writing the post, I’ve learned there are, in fact, a few platforms that use the Buterin, Hitzig, and Weyl algorithm to fund public goods.

### Appendix

If there are any curious and mathematically inclined readers out there, here’s a short proof for why Optimal Kickstarter is indeed optimal (warning: calculus).

Denote total funding for a project by *F*. The value of the public good to person *i* is *Vi*(*F*), and the total value of the project is the sum of *Vi*(*F*) across all individuals *i*. Assume *Vi*(*F*) is concave, continuous, etc. The optimal level of funding *F* for the public good satisfies:

This is just the level where a dollar of funding buys a dollar of value (when we add up the value of the public good across all people).

An individual using optimal kickstarter only considers the value they receive, but also only cares about the cost of their own money. They are maximizing *Vi*(*F*) - *ci*, which at the optimum satisfies:

This is where a dollar of individual *i’*s money buys a dollar of value to individual *i. *The key idea is that a dollar of individual *i’s *money raises total funding *F* by more than $1.

The partial derivative of *F* with respect to *ci*, comes from the optimal funding formula, and is:

Using this, we rearrange the individual’s optimality condition to yield:

Last, we add up these conditions across all individuals *i*. That gives us:

Which is the precisely the condition for the optimal level of funding *F*.