We all buy AI tokens in the dumbest possible way.
One developer opens an account with an LLM provider.
Another developer does the same.
Then another.
We each put $5, $10, $20 into separate accounts. We each get retail pricing, separate limits, separate balances, and absolutely zero purchasing power.
Meanwhile, most of us don't even consume AI compute consistently.
One week we're burning tokens on an agent experiment.
The next week we're barely using the API.
So I started wondering:
What if we stopped buying AI inference individually?
Imagine 1,000 developers putting $5 into the same pot
That's $5,000 every month.
Not venture capital.
Not a startup subscription.
Not another “AI platform.”
Just 1,000 developers collectively funding a shared pool of LLM inference.
You contribute $5.
You authenticate with GitHub.
You get an API key.
export OPENAI_BASE_URL=https://api.tokenpot.example/v1
export OPENAI_API_KEY=sk_...
And that's it.
Use it from your scripts.
Use it from your agents.
Use it from your applications.
Use it from whatever already speaks the OpenAI-compatible API.
Behind that endpoint, the community pool purchases inference from one or multiple providers.
I call the idea TokenPot.
The interesting part isn't the API
Building an OpenAI-compatible proxy isn't particularly interesting.
We already know how to do that.
The interesting part is the economics.
Suppose 1,000 people contribute:
1,000 × $5 = $5,000/month
Instead of pretending that every $5 buys some arbitrary fixed number of tokens, TokenPot would look at how much compute the community can actually afford.
For example:
Monthly contributions $5,000
LLM providers $4,300
Infrastructure $200
Community reserve $500
The available compute is then distributed among members according to public rules.
No mysterious “unlimited*” plan.
No hidden fair-use policy.
No magic.
Just a pool.
And then something interesting happens
Not everybody uses their allocation.
Alice may be building an agent this month and consume everything she can get.
Bob might make three API calls.
Carol could be on vacation.
At the individual level, AI consumption is extremely irregular.
At the community level, it starts becoming a pool of capacity.
Unused capacity doesn't need to become somebody's margin.
It can become somebody else's inference.
That's the part I find fascinating.
Now imagine 10,000 developers
The pot becomes:
10,000 × $5 = $50,000/month
Something changes at that point.
You're no longer 10,000 tiny customers buying inference independently.
You're one community purchasing tens of thousands of dollars of inference every month.
That potentially means negotiating volume pricing, committed spend, reserved capacity or direct agreements with inference providers.
And here's the crucial difference between this idea and a traditional AI company:
if the community obtains a better price, the community gets more compute.
The goal isn't:
maximize(revenue - compute_cost)
It is closer to:
maximize(compute_per_member)
while:
pool_is_sustainable == true
I want the numbers to be public
Imagine opening TokenPot and seeing:
Active members 1,284
Monthly contributions $6,420
Provider spending $5,430
Infrastructure $240
Reserve $750
Pool utilization 71.3%
And perhaps the most interesting number:
Average contribution $5.00
Retail-equivalent compute $17.40
Community leverage 3.48x
If that leverage is 1.01x, the experiment isn't particularly useful.
If it's 2x, things become interesting.
If a sufficiently large community can consistently turn $5 into $15 or $20 worth of individually purchased inference, then we've demonstrated something.
Not an AI breakthrough.
A purchasing breakthrough.
Why GitHub?
Because this is intended for developers and open-source communities.
The simplest experience I can imagine is:
GitHub Login
↓
$5 monthly contribution
↓
Generate API key
↓
Start calling the API
Your API key should be boring.
Create it.
Use it.
If you accidentally publish it:
burn it.
Generate another one.
No enterprise IAM dashboard required to call a language model from a weekend project.
Better yet: create your own pot
TokenPot shouldn't necessarily mean one giant global pool.
That's where the open-source part gets much more interesting.
I want the software itself to be deployable.
A group of friends could create a pool.
An open-source community could create one.
A university lab could create one.
A hackerspace could create one.
A company team could create one.
Bring your own providers, define your contribution model, define your allocation rules and run your own pool.
So there are really two invitations:
Create your own TokenPot with your friends or community.
Or:
Join the public pool, contribute $5/month, and use the shared compute for your work, experiments, agents and APIs.
There are hard problems
Of course there are.
Provider terms need to permit this kind of multi-user inference gateway.
Abuse needs to be controlled.
A leaked API key must not be capable of burning the community's monthly budget.
Accounting and taxation need to be handled correctly.
“Donation”, “sponsorship”, “membership” and “paying for a service” aren't interchangeable words just because the project is open source.
Rate limiting needs to be fair.
The reserve needs clear rules.
And the allocation algorithm needs to work when somebody inevitably tries to consume half the planet's GPUs for their $5.
These aren't details to hide.
They're part of the experiment.
And I think the rules should be developed in public.
Maybe this doesn't work
That's another reason I want to build it.
There's a very simple hypothesis underneath TokenPot:
Can 100 developers putting $5 each into a transparent shared pool obtain materially more useful LLM inference than 100 developers independently spending those same $5?
We don't need one million users to answer that.
We might not even need one thousand.
Start with 100.
That's a $500 pot.
Measure everything.
Publish everything.
See what happens.
If the economics don't work, we'll have numbers showing why.
If they do work...
then things get interesting.
AI models are centralized. Purchasing doesn't have to be.
We're spending a lot of time discussing which model is smartest, which agent framework will win and which provider has the cheapest tokens this week.
Maybe there's another layer worth experimenting with.
Not another model.
Not another agent.
Not another wrapper.
Collective purchasing infrastructure for AI compute.
The models can remain where they are.
The providers can compete.
The community simply becomes a smarter buyer.
TokenPot
Pool your budget. Share the compute.
Would you put $5 into the pot?
