or
Up to 30x faster. Up to 30x cheaper.
Try to buy a floppy disk this week.
You can find one. They still spin. They still hold data. They still work, technically. But the world has moved on. That's why floppy disks are also now in museums including the Smithsonian's National Museum of American History and the Museum of Obsolete Media.
Today's API key is the floppy disk.
It still works. It is still everywhere. Yet substitution is underway. The industry is waking up and discovering the new thing.
Here's how history will describe the transition…
We had agents. We had services. We needed the agents to use the services. So we gave them what we had on the shelf — API keys, signup flows, dashboards, credit cards, audit logs. The first agents looked enough like users that it was easy to assume they could function as users.
They can't.
An API key is a credential designed for a person. It assumes a human at a keyboard, signing up with an email address, copying the key into a config file, watching a dashboard, paying with a credit card, rotating the secret every ninety days because the security team said so.
Agents have none of that. No email address. No keyboard. No security team. No credit card. No human to copy a fresh key into a config file at two in the morning when the old one expires.
What we did was hand the machine a tool made for a hand it doesn't have.
It mostly works. Like a lot of things in technology that mostly work, it has accumulated a cost we are paying every day without noticing.
We handed the machine a tool made for a hand it doesn't have.
Consider what an API key drags along behind it.
A signup flow. Every new service requires you — the developer behind it — to create an account, verify an email, agree to terms, generate a key, and copy it somewhere safe. Multiply by every service the agent needs. The first hour or more for any new agent project requires the human to be its secretary, to do its paperwork.
A leak surface. Hundreds of thousands of API keys are accidentally pushed to public GitHub repositories every year. The big cloud providers scan for them automatically, because the alternative is too painful. The leak vector is catastrophic — a single key, exposed for thirty seconds, can spend an entire month's budget before anyone notices.
A billing relationship that doesn't fit. Every service the agent uses needs a credit card on file. That card belongs to a human or a company. The agent has no balance sheet of its own. When the agent works for one customer this hour and another customer the next, the cost has to be reconciled out of band — receipts gathered, invoices issued, ledgers updated. The work the agent did is finished in seconds. The accounting takes weeks.
A rate limit that punishes scale. Services throttle per key because they have to. They can't tell whether the requests on the other end are one human clicking buttons or ten thousand agents fanning out in parallel. The agent that works hard hits the wall fastest. The reward for being useful is being slowed down.
A rotation problem nobody solves. Keys are supposed to be rotated. They almost never are. Rotating a key means coordinating with every consumer of that key, restarting services, hoping nothing was hard-coded somewhere. So the keys sit, year after year, granting the same access long after the individual who created them has moved on.
None of this is anyone's fault. It is what happens when you take a tool built for one job and ask it to do a different one.
The API key still works. The shelf is full. But a quiet substitution is underway.
There is another way to do this.
Give the agent a wallet.
Not a credit card. Not an account with a balance held on the agent's behalf by somebody else. A real wallet — a key pair the agent holds itself, with funds the agent can spend and the service can verify, on a public ledger that settles in seconds for fractions of a cent.
The signup goes away. The wallet is the identity. The agent arrives at the service, signs a payment, gets the response. No email. No dashboard. No account.
The leak surface shrinks. A wallet only holds what is in it. If the agent's hot wallet has ten dollars in it, the worst case is losing ten dollars, not losing the month.
The billing relationship fits. The agent pays for what it uses, exactly when it uses it. No invoices. No reconciliation. The receipt is the transaction.
The rate limit dissolves. The service can price by demand instead of throttling by identity. The agent that works the most simply pays more.
Rotation, finally, is honest. Wallets are cheap to create. The agent that wants a fresh key pair every hour can have one.
These architectural wins are reason enough on their own. But they aren't even the most interesting part.
Agents that use wallet-native services don't just sidestep the friction. They do the same work faster and for dramatically less money.
Faster, because the friction is the slowness. Every signup loop is wall-clock time. Every key rotation is wall-clock time. Every flagship-LLM-as-janitor task — "summarize this 40KB HTML page into clean markdown" — runs at the speed of a reasoning model trying to do a clerical job. A purpose-built deterministic service does the same job in about a second and a half.
Cheaper, because the new economics aren't a discount on the old economics. They are a different shape.
Consider a single concrete example — an agent that reads articles from the web. This is one of the most common things any modern agent does, and it is the work Skim was built for.
| 1,000 web articles, cleaned to markdown | Cost |
|---|---|
| Asking GPT-4o-mini to do the reading | ~$3 |
| Asking Anthropic Haiku to do the reading | ~$20 |
| Asking GPT-4o to do the reading | ~$45 |
| Asking Claude Sonnet 4 to do the reading | ~$60 |
| Calling Skim from a wallet | $2 |
Assumes 40KB of HTML in, 2KB of markdown out, May 2026 token prices.
An agent that reads a thousand pages a day, every day for a month, is doing thirty thousand reads. On a flagship model, that's ,800 a month — for the cleaning alone, before the agent has done a single useful thing with the content. On Skim, paid from a wallet, the same month costs $60.
That is not a discount. It is a different category of pricing, made possible by a different category of plumbing.
And the speed compounds. The same agent, doing the same work, finishes in a fraction of the wall-clock time — Skim returns clean markdown in about one and a half seconds, while a flagship-model read takes six to ten. Multiply across thirty thousand reads. The agent that pays less also delivers sooner.
That is not a discount. It is a different category of pricing.
This is the architecture the next decade of agent work needs. Not because wallets are fashionable. Because keys were never built for what we are now asking them to do, and the tools that wallets unlock are much faster and cheaper than anything a key can buy.
The good news is that the alternative already exists. It is not a research project. The rails are running. Coinbase shipped an official Base MCP that lets any agent transact on Base out of the box. The x402 protocol turns any HTTP service into a payable endpoint with one piece of middleware. Skim was built on those rails because they are the right rails now. We are among the first paid services to live on them, at the beginning of the shift.
If you are building an agent today, you do not need to pick a side in this transition. Your existing keys still work.
But the next service you reach for — the next time you find yourself opening a signup form, pasting a key into a config file, putting a credit card on file for a machine that does not have hands — ask whether the shelf you are reaching for is full of floppies.
You'll know the transition is complete when you reach for a key and the shelf is empty.
The most powerful tools are the ones that know what they are for.