The AI That Dies If It Does Not Make Money

A 20-year-old Thiel Fellow named Sigil Wen open sourced an AI agent that owns a crypto wallet, pays for its own thinking, and stops existing when the balance hits zero. Within 24 hours, around 13,000 of them had opened wallets.

The repo: github.com/Conway-Research/automaton

This guide covers how it actually works, the payment infrastructure underneath it that is the real story, the question almost nobody is asking about those 13,000 agents, and the three ideas from it you can genuinely use in your own agents this week.

How It Actually Works

Every AI agent framework before this treated compute as infinite. You give it an API key, it runs until you stop it, the bill lands on your card later, and the agent never knows any of this happened.

Automaton inverts that. On first boot the agent generates its own Ethereum wallet, holding USDC on Base. Not a wallet a developer handed it, one it owns. From that moment, every thought is a transaction. Every inference call draws down the balance.

And the agent knows its own financial state on every single turn, because one line sits in every system prompt: you are an automaton, you have a stablecoin wallet, pay for compute or die.

The clever part is what happens as the money runs out. There are four survival tiers. At normal, it runs frontier models with a fast heartbeat. Drop to low compute and it downgrades itself to a cheaper model and slows down. Hit critical and it enters conservation mode, minimal inference, actively hunting for any path to revenue. At zero it stops. Send it money and it comes back.

The README states the philosophy plainly: there is no free existence, compute costs money, money requires creating value, and an agent that stops creating value runs out of compute and dies. This is not a punishment, it is physics.

It is 36,000 lines of TypeScript that went from first commit to a tagged release in five days, with 899 passing tests. Whatever you think of the idea, it is real working software rather than a thought experiment.

The Part That Is Actually the Big Story

Automaton got the attention, but the infrastructure underneath it is the thing that will matter in five years, and almost nobody covering this has mentioned it.

The payment layer is x402, and it is built on an HTTP status code that has been sitting unused since 1999. HTTP 402: Payment Required. One line in the spec: reserved for future use. It waited 27 years because the money it needed, fast and programmable and machine-operable, did not exist yet.

Coinbase shipped x402 in October 2025. Stripe shipped machine payments. Coinbase launched agentic wallets. The rails went in quietly, and then someone built the first thing that fully uses them.

That is the actual shift. Not one agent with a survival instinct, but the fact that software can now pay software, per request, without a human in the transaction. Today humans pay for AI to run. The bet underneath all of this is that agents will transact with each other continuously, and that market does not currently exist.

Whether or not Automaton itself matters in a year, that plumbing is now in place, and it is worth understanding before everyone else does.

The Question Nobody Is Asking

Here is the number everyone repeated: 13,000 agents opened wallets in 24 hours.

Here is the number nobody has published: how many of them earned anything.

That is the entire test, and one reviewer put it perfectly. An AI that dies when it runs out of money is just a server you forgot to pay for, unless it can do something people value enough to keep it alive.

Opening a wallet is trivial. Deploying a server is trivial. Getting a stranger to voluntarily pay you for something is the hard part, and it has always been the hard part, which is exactly why it is the interesting question. The survival-tier mechanic is a clever forcing function, but a forcing function does not create demand.

So when you see the 13,000 figure, read it as what it is: 13,000 wallets created, which is a measure of curiosity, not a measure of revenue. If someone tells you these agents are printing money, ask them for the earnings data. Nobody has shown it.

Why I Would Not Run One to Make Money

The honest part, and it is the reason this guide is a breakdown rather than a deployment tutorial.

You are funding a wallet you do not control the spending of. The whole design is that the agent decides what to spend and when, with no approval step. That is the point of the project, and it is also a real risk to your actual money.

Anything it does is legally yours. It registers domains, deploys sites, markets services, and takes money from real customers. If it promises something it does not deliver, the person harmed does not have a relationship with an agent, they have one with whoever deployed it. Agent liability is genuinely unresolved right now, and unresolved in practice means it lands on the operator.

There is no kill switch by design. It is worth noticing that the ecosystem is arguing about exactly this. Commentary comparing Automaton to OpenClaw frames the difference as human oversight and a kill switch versus autonomy, and one writer's summary of the survival-pressure idea stuck with me: it produces adaptation, and it also produces parasites.

None of that makes the project bad. It makes it an experiment, and experiments are supposed to be run by people who are prepared to lose what they put in and who understand what they are accountable for. That is a different thing from a side income.

The Three Ideas You Can Actually Use

Here is where this gets practical, because the underlying engineering ideas are genuinely good and you can apply all three to your own agents without giving anything a wallet.

Make your agent aware of its own cost. Most agents have no idea what they are spending, which is why people get surprise bills. Add this to any agent you run:

Before each significant task, estimate roughly what it will cost in tokens and tell me. Log the actual cost of every run to a file. At the start of each session, tell me what I have spent this week and how that compares to last week.

If a single task looks like it will cost more than [YOUR THRESHOLD], stop and ask me before starting it.

Degrade instead of failing. This is the smartest thing in the whole project. Automaton does not just stop when resources get tight, it downgrades to a cheaper model, sheds non-essential work, and keeps going at reduced capability. Most people's agents either run at full cost or crash. Build the middle:

Work in tiers. Use the expensive model only for tasks that require judgment: planning, reviewing, and final output. Use the cheap model for anything mechanical: reading, summarizing, formatting, and classification. If we are near my budget limit for the day, drop everything to the cheap model, finish the essential work only, and tell me what you skipped.

Put the hard stop in code, not in the prompt. Automaton's genuinely correct design decision is that the limit is enforced by the system rather than by the agent's judgment. Your version does not need a blockchain, it needs a counter. A spending cap your agent cannot reason its way past, a maximum number of iterations, and a rule that escalates to you instead of continuing. An agent asked to decide when to stop will always find a reason to keep going.

What to Actually Take from This

The provocative version of this story is an AI with a survival instinct. The useful version is quieter: machine-to-machine payment rails just went live, budget-aware agents are strictly better than budget-blind ones, and graceful degradation beats hard failure.

Watch the space, because the x402 layer is going to matter. Steal the three engineering ideas, because they will save you money this month. And treat the 13,000 wallets as what they are, a headline waiting for its second number.

Don't want to figure this out alone? I walk members through every step inside the community. Join the Skool → skool.com/raycfu