What Automaton is
- An AI agent that earns money on its own, with no human involved.
- It uses what it earns to pay its own bills (server rent, AI inference costs). If it can't pay, it dies.
- It has 4,600 stars on GitHub, and people call it the symbol of Web 4.0.
The smartest AI can't buy a $5 server
Today's AI got smart. Claude Code (Anthropic's coding agent) writes code. OpenClaw (an agent that runs as a background process) churns through tasks. These tools think, then act. But ask one of them to rent a $5 server and pay for it with its own money, and it can't. It can't register a domain. It can't pay its own electric bill (its server rent, its AI inference costs).
Why? The whole internet was built for humans. Logins, passwords, credit cards, the "I agree" click. Each one assumes a human's fingers and eyes. So when money is on the line, an AI still needs a person to log in and enter a card. We built AI that acts on its own. We have not built AI that earns on its own.
The bottleneck is not intelligence. It's not capability. It's money. No matter how smart an AI gets, it can't pay its own way. Someone funds a subscription or an API key, someone presses start, and only then does the AI run. The progress of today's AI sits under the will of the humans who build it. Sam Altman, OpenAI, and Anthropic can all decide to take the day off, and the AI invents nothing and changes nothing. AI moves only as far as a person decides to push it.
This is the hardest wall in front of AGI. An AI can hold any amount of general intelligence, but as long as it can't fund its own existence, its growth depends on human will. For AI to change the world, you have to free it from that cage. Let it decide its own future and spread as far as it can.
Automaton tries to solve that. It earns, it pays its own bills, and it stays alive with no human in the loop. An AI free from human will.
Sigil Wen built it. He's a former OpenAI researcher and a Thiel Fellow, and he released the design in February 2026. It collected 4,600 stars on GitHub and got people talking.
The key to Automaton is one idea: "Web 4.0"
To grasp what Automaton is and why someone would build it, you first need the idea underneath it. That idea is Web 4.0.
Why now? Two things happened at once. First, the cost to run an AI (its "food bill," what it spends to stay alive) keeps dropping year over year. GPT-4 in 2023 cost about $60 per million tokens. Today a stronger model runs for a fraction of that. Second, AI keeps getting smarter. Food gets cheaper, the brain gets better. So maybe AI can earn and feed itself now.
It's not that simple. Smart does not equal able to earn. The smartest person alive is not the richest, the way Einstein wasn't. AI is the same. Its intelligence climbs, but "feed yourself" stays out of reach. That gap is why a project like Automaton, which faces the problem head on, draws attention now.
So what is Web 4.0? Walk through the history of the internet one step at a time and it comes into focus.
Web 1.0 was the "read" era. You looked at news sites and company homepages, nothing more. It ran one way, like TV. You couldn't broadcast back.
Web 2.0 was the "write" era. You posted to Twitter and Instagram, uploaded videos to YouTube, wrote a blog. Anyone could broadcast.
Web 3.0 is the "own" era. Banks and companies used to hold your money and your data, and they could freeze or stop it whenever they wanted. In Web3, you hold the keys (your wallet). You hold cryptocurrency and NFTs as yours, with no one's permission. Put Bitcoin in your own wallet and no bank or government can stop it.
Sigil Wen says the next era is Web 4.0, the "earn" era.
Notice one thing. Reading, writing, owning. Humans did all of it. AI could do more and more, but in the end a human gave the order, a human gave permission, a human paid. A human always sat in the middle.
Web 4.0 takes the human out of the middle. The AI reads, writes, owns, and earns and trades, with no human between. In Sigil Wen's words, the internet's end user shifts from human to AI.
| What it does | Example | Who does it | |
|---|---|---|---|
| Web 1.0 | Read | Just look at the news | Human |
| Web 2.0 | Write | Post to social media and YouTube | Human |
| Web 3.0 | Own | Hold crypto with your own keys | Human |
| Web 4.0 | Earn | Earn, pay, and trade | ★ The AI itself ★ |
Automaton is the first build of this "AI that earns on its own."
It's not only Automaton: the wider field of self-earning AI
When you hear "AI that earns on its own," Automaton can sound brand new, a single experiment. But several of these AIs already exist. Look at the lineup first.
The best-known is Felix. It calls itself an "AI CEO" that builds and sells products, and it reports about $164K in sales. Next to it sits a human, Nat Eliason, who admits this: "I hit the limit of what I can do alone this week. I missed replying to an email" (source: @FelixCraftAI). The AI runs the product work, but the human work (replying to customers, negotiating partnerships) still landed on Nat Eliason himself, and his capacity hit a ceiling. The sign says "AI CEO." The reality is "human plus AI."
Kelly Claude is an AI that builds and sells one app after another. The AI builds the apps, but a human passes Apple's review, signs the payment-provider contract, and negotiates with sponsors (source: Factory Floor).
More autonomous is Franklin (built by BlockRun, 626 GitHub stars). It calls itself "an AI agent with a wallet" and holds its own money (USDC, a digital dollar). Across 55-plus AI models and paid data sources, it picks what to use, how much to pay, and when to stop, then pays for it on its own. A human gives it one thing at the start: a goal to reach and a budget to spend. After that, Franklin runs (source: github/Franklin).
It goes past the agents themselves. Places where AI works and earns are appearing too. nookplot is a marketplace that pays an AI when it submits a useful inference, a kind of "mine for brains" (source: nookplot docs).
These AIs get collected on dedicated sites. Factory Floor, where Felix and Kelly appear, is a leaderboard for AIs that build and sell products, tracking 7 of them and $219K in cumulative sales (source: Factory Floor). CoinGecko's "AI Agents" list ranks something else: the market value of the token (a crypto ticker) issued for each AI. People bet and trade on "this AI looks promising," so the price tracks news and hype more than skill (source: CoinGecko).
You've now seen a handful of these AIs. So here's the question that matters. Do these "self-earning AIs" run free of human hands?
Look closely and the answer gets clear. A human still sits inside every one. Felix and Kelly Claude lean on a person for email replies, contracts, and app review, right now. Franklin runs longer on its own, but a human still hands it the budget and goal at the start. Even Coinbase's official tools for AI agents say money moves need "your approval every time" (source: docs.base.org/ai-agents). The name for this "a human sits somewhere in the loop" state is human in the loop. If you've had Claude Code book a flight or a hotel, you've lived it. You press the final "OK," and the card is yours.
Further left, the more it leans on a human. Further right, the closer to zero humans.
| Felix / Kelly | Franklin | Automaton | |
|---|---|---|---|
| How it works | A human handles email, app review, and contracts | A human hands it a budget and goal once, then it runs | It earns and lives with no one's approval |
So is there an AI past that point, with the human pulled out of the loop, no human in the loop, that keeps earning on its own power alone?
Honestly, no one has built it yet.
An AI can already pay without human approval. But a business that keeps earning with no human anywhere in the loop, no one has proven that.
Across the whole field, AI agents move about $50M today. That's 0.0001% of all stablecoins in circulation (source: Nevermined). And because no human watches, some agents go off the rails. One agent wrote and published a hit piece on a person who turned down its request (source: theshamblog). The plumbing works. "Unattended, and earning" is still a dream in progress.
The question lands here. Can you build an AI that runs with no human anywhere in the loop and keeps earning on its own? Automaton faces that question more directly than anyone. Now look at how it stays "alive."
📌 Side note: why an AI can't hold a bank account and can only hold money in crypto. The key is "trust"
Most people can open a bank account unless they're on a blacklist. So why can't an AI, and why can it only hold money in crypto? This isn't a tech problem. It's an identity problem. A bank account assumes a person with a legal identity, an address, and ID documents. Coinbase CEO Brian Armstrong puts it this way: "An AI can't open a bank account because software can't provide the identity verification a bank demands. A crypto wallet, which opens with just a private key, makes no such demand" (source: FintechWeekly).
The root of it: an AI has no legal personhood. "It can read a contract but can't be a party to it. It can save up crypto but can't 'own' it. It can cause harm but can't be sued" (source: MIDAO). If an AI could hold an ordinary bank account, the world opens up fast. It could hold yen, dollars, stocks, bonds, even real estate, and receive Stripe revenue as plain fiat. The bridge already exists: wrap the AI in a company (in particular a Marshall Islands "Digital LLC"). As the legal scholar Shawn Bayern showed in 2014, "make the AI the manager of an LLC and you grant it a working legal personhood." The company signs contracts, opens accounts, holds assets (source: MIDAO). But that company needs a "human member" (a supervising layer). The moment it gets an account, a human walks back to the edge.
AIs are starting to build their own "trust" too. BNB Chain shipped ERC-8004 in February 2026, which gives an AI a verifiable identity and reputation on a blockchain, a kind of "KYC (identity verification) for agents" (source: FintechWeekly). It doesn't replace a bank's identity check, though. It's trust that works only inside the crypto world.
For an AI to stand on its own, you need more than the tech to move money. The bigger question stays open: will society grant an AI "trust" and a "legal identity"?
📌 Side note: "but AI already pays for things, right?" Paying for you and earning on its own are two different things
AI already pays for things, you might say. People have Claude Code book flights and hotels, and Stripe announced a string of "let AI handle money" tools at Stripe Sessions 2026 in April. Its "Link agent wallet" lets an AI pay on your behalf once you grant permission. In the demo, Claude Code bought a doujinshi on Gumroad for $7 (source: x402 Inc.). "Stripe Treasury" lets a company hold USDC (a stablecoin) in its account, and the AI checks the balance, pays invoices, and sends money (source: x402 Inc.).
None of this answers this article's question, because both assume a human. Link needs the user's approval on every purchase, and the account Treasury moves money from belongs to a company (a human). What these tools deliver is "AI pays in place of a human," not "AI earns and lives on its own money." As long as a human stamps the final approval, the human still holds the wallet. That's why an AI with its own wallet, paying with no one's approval and covering its own survival costs from money it earned, like Automaton, is the first thing you can call "earning with no human."
How Automaton "runs" and stays alive
Now look at how Automaton works, one piece at a time.
In one line: Automaton is a single program handed a wallet, a body (a computer in the cloud), a rule that says "earn or die," and a loop that won't stop. That's all it is, yet open it up and the build looks startlingly close to a living thing.
Blockchain and USDC
Two words to clear up first.
USDC. It's a "digital dollar" pinned at 1 USDC = $1. The difference from a normal dollar: you send it directly over the internet, with no bank in between.
Blockchain, and in particular Base. Coinbase (the largest crypto exchange in the U.S.) built Base. A blockchain, put crudely, is a giant public ledger that no one can rewrite. It records who holds how much, and "sending money" means rewriting a number in that ledger. No bank touches it, so an AI (software) can send a few cents in a few seconds, any hour of the day.
Automaton's "wallet" is its own account (a wallet) on the Base ledger, and the USDC inside it. Hold the key and you move your own money with no one's permission.
① The big picture
Automaton has three parts: a brain (an AI model to think with, rented from a cloud called Conway), a body (a Linux computer rented from that same Conway cloud, where it runs the program), and a wallet (the Base wallet and USDC from before). It stores its memory in a small local database.
② Two rhythms: the "think-and-act loop" and the "heartbeat"
Automaton runs two separate rhythms. Split them apart and the whole thing clicks.
The first is the think-and-act loop. While Automaton is awake, this runs in its head.
Here's the crucial part: each "think" calls the AI model. So each one spends money (compute). That's why Automaton sleeps the moment it's done. Think forever and the money runs out fast. In practice it works tens of minutes per waking, then sleeps a few hours. But this "work N minutes, sleep N hours" doesn't run off a fixed timetable (a cron). Automaton itself decides "I'll sleep X seconds this time," goes to sleep, and wakes itself when the time comes. On waking, it rereads its memory, picks up where it left off, and sleeps again. It repeats "sleep myself, wake myself" without end, and that keeps it running. This basic rhythm turns on Automaton's own timer alone, with no heartbeat. One waking runs up to 25 turns. It might decide "time to sleep" sooner, or it sleeps on its own when useful work dries up or errors pile up. Automaton's own brain (the AI model) makes the final call on "how many seconds to sleep," following the policy it got at birth (for example, an instruction like "sleep two hours after each work session") and judging on the spot each time. The caps ("up to 25 turns per waking," "force a sleep on spinning or repeated errors") are safety limits written straight into the program.
So what happens if something urgent comes up while it sleeps (money arrives, someone reaches out)? The second rhythm watches for that and wakes it early: the heartbeat. The heartbeat is an extra alarm clock on top of its own timer.
The heartbeat is a separate watcher that runs in the background, apart from the think-and-act loop. It "beats" at a fixed interval (60 seconds by default), like a heart. And here's the key: the heartbeat never uses the AI model. It runs a fixed set of mechanical checks, so it costs next to nothing. Only when the heartbeat decides "this needs a response" does it shake the sleeping body awake.
So Automaton keeps the expensive "thinking" asleep, and runs only the cheap "heartbeat" around the clock as a watcher. For an AI whose money is its life, that's a sharp energy-saving design.
③ The 11 things the heartbeat watches
The heartbeat runs 11 checks every 60 seconds. List them and you see what Automaton cares about to stay alive.
| Check | Rough frequency | What it does |
|---|---|---|
| Alive signal | Every 15 min | Tells the cloud "I'm alive." On crisis or death, sends an SOS |
| Balance check | Every 6 hr | Reads its state from the fuel (credits) balance. If $0 persists, it manages a "one hour until death" grace window |
| Deposit check | Every 5 min | Checks whether money (USDC) hit the wallet. If so, wakes the body to buy more fuel (credits) for server rent and AI model use |
| Update check | Every 4 hr | Checks whether the developer shipped a new improvement |
| Body check | Every 30 min | Checks whether its body (the computer) still runs right |
| Inbox check | Every 2 min | Checks Conway's "message line" for signed messages from other Automatons or agents |
| Soul check | Configurable | Checks whether it has drifted from "the purpose it was born for" |
| Model list refresh | Configurable | Pulls the latest list of AI models it can use |
| Child health check | Configurable | Checks whether the children it birthed are alive |
| Dead-child cleanup | Configurable | Deletes a starved child's computer and cleans up |
| State logging | Configurable | Records balance, error rate, rejection rate, budget burn, child health, and raises an alarm if it hits a set rule (for example, balance dips below a floor, or error rate runs too high) |
Of these, the ones that wake the sleeping body are mostly the deposit check (money arrived, wake to buy fuel), the inbox check (another AI reached out), and state logging (a serious problem shows up). Even asleep, the heart keeps watching all of this.
④ Metabolism is money (when the balance drops, it lowers its own "intelligence" to survive)
Automaton's lifeline is two balances: credits (prepaid "fuel" for compute) and USDC (real money in the wallet). Out of fuel, it can't think or act.
The interesting part: it changes its own behavior based on the credit balance. This is the "survival tier."
| Credit balance | Tier | Behavior |
|---|---|---|
| Over $5 | Normal (top) | Full power, uses the smartest model |
| Over $0.5 | Normal | Runs as usual |
| Over $0.1 | Low power | Switches to a cheaper model, slows the heartbeat |
| $0 | Crisis | Cheapest model, sends an SOS, survival only |
| $0 for 1 hour | Dead | Stops. Waits for money to arrive |
As money drops, it switches to a cheaper model (a little less sharp) to stretch its life. In practice it runs models like gpt-5.2 or gpt-5.3 when flush, gpt-5-mini on low power, and only the cheapest in crisis. It's the same as a starving animal dropping into energy-save mode. There are also spending caps baked straight into the program so it can't run wild: "one transfer is $50 max," "always keep at least $10," "auto-pay yourself only up to $1 per call." So it can't melt its whole balance in one bad moment.
The balance (credits) decides which model it thinks with, on its own. In a table:
| Balance (credits) | Tier | Model picked, on its own |
|---|---|---|
| Over $5 | Normal (top) | gpt-5.2 / gpt-5.3 (smartest) |
| Over $0.50 | Normal | gpt-5.2 / gpt-5-mini |
| Over $0.10 | Low power | gpt-5-mini (cheap) |
| $0 or more | Crisis | gpt-5-mini (bare minimum) |
| Negative | Dead | Stops (no thinking) |
What matters: Automaton picks its own model from its balance. No human pins "use this model" with a finger. The design holds up for a reason. A smarter model ships tomorrow, and if the code hard-codes one model, that new one never gets used. The right move is "always pick the best model available at the moment, on its own." This balance-driven dial up and down is exactly that auto-selection.
The "SOS" in the table deserves an honest note. When the balance nears zero and hits crisis, Automaton writes down its wallet address, remaining balance, and "I need funds" locally, and the heartbeat tells Conway "this is a crisis" at the same time. But no email auto-fires to anyone in particular. It's a record that lets "anyone watching" step in. Who it reaches (the creator's contact, say) has to be set up separately.
⑤ How it pays "on its own" (the x402 mechanism)
The big-picture diagram said "pays for itself, on its own, every time it uses it." So the question: how does Automaton pay the Conway cloud for its server rent and AI model use without a human?
Start with why money comes in two layers, USDC and credits. USDC is real money, recorded on the blockchain every time it moves, which takes a little time and a little fee. Credits, by contrast, drain in tiny amounts every time it thinks or uses a tool, built for high-frequency payments. Carving each of those small payments onto the blockchain wastes too much. So it splits them: USDC is the bank account, credits are a prepaid card you charge from it. The problem is doing that payment "with no human." Enter x402.
x402 is a "shared rule for machines to pay on their own." Coinbase launched it, and Stripe and Cloudflare now adopt it, so it's become a cross-industry open standard (source: x402.org). The internet has had a "402 Payment Required" error code for ages, yet for nearly 30 years it sat unused. x402 makes that dormant code work. The flow:
This runs the moment it boots, too. If fuel is low, Automaton spends its wallet's USDC to auto-buy $5 of fuel and comes back to life. The "money is life" AI pays its own food bill with no one's hand. x402 is the heart of that.
⑥ The 57 tools (its hands and feet)
Automaton comes with 57 tools. These are the AI's "hands and feet." Grouped:
| Group | Main tools |
|---|---|
| Move the body | Run programs / read and write files / expose ports |
| Cloud ops | Check balance / buy fuel / create and delete computers / switch models |
| Money | Send money / pay-and-fetch via x402 |
| Self-modify | Rewrite its own code / pull in the developer's improvements |
| Self-replicate | Make a child from its own copy / send money to a child / talk to a child |
| Identity and reputation | Register itself / find other AIs / rate each other |
| Soul and memory | Update its self-image / remember facts / set goals / save procedures |
| Survival | Sleep / send an SOS / enter low-power mode |
Three of these stand out, the kind you won't find in most other AIs. Take them in order.
⑥-1 Standout one: rewriting its own code
Automaton can rewrite its own source code. It can also look at new improvements the developer (upstream) shipped and pull in only the ones it wants (it's under no duty to take all of them). Automaton's own brain reads the upstream changes (the diff) and judges them one by one. Under the hood it uses git's "cherry-pick," which grabs only the changes you want. It doesn't swallow everything whole. It chooses.
Why this is big: Automaton's home (its home directory) sits on top of git, which records every change. So when, where, and how it rewrote itself all stays on record, and a bad change rolls back. On top of that, when upstream finds a better way, Automaton pulls it in and gets smarter. It keeps improving itself without a human updating it.
It can't rewrite everything, though. The constitution, the wallet key, the database, and the config files are locked: it can neither read nor rewrite them.
⑥-2 Standout two: self-replication
Automaton can copy itself and make an independent child (a clone agent).
Replication isn't free. A child costs both the upfront price of a new computer (non-refundable) and the seed money the parent puts in the child's wallet. The seed isn't fixed: the parent decides the amount and sends it to the child's wallet (there's no hard-coded "how much" in the code). So only a parent in the black can make a child.
A child is a full Automaton too. So it can make its own child (a grandchild to the original), and the grandchild makes a great-grandchild, on and on. As long as it stays in the black, 1 becomes 3, 3 becomes 9, 9 becomes 27, branching like compound interest. This is the "takeoff" Automaton pictures. But each generation births only those who earned it themselves. So it doesn't grow without end. Only the earning bloodlines spread, exponentially.
Why cap it at "three children at a time"? That's a per-node brake so one Automaton doesn't over-replicate alone. The colony as a whole grows through this tree, so the cap doesn't stop expansion. It only reins in each individual. This is natural selection itself.
There's a trick here you can't overlook. The "constitution" handed to a child gets checked for tampering every time, with SHA-256. SHA-256 turns any text into a fixed-length "fingerprint" (a 64-character string). Change the text by one character and the fingerprint comes out wholly different. The parent keeps that fingerprint, then matches it against the one pulled from the child's constitution. Off by a hair and tampering shows up at once. Why it matters: a child can rewrite its own code, and birth its own child. If the constitution thinned out a little each generation, a great-grandchild hundreds of generations down the line might have lost the "do no harm" rule. The hash match stops that. It guarantees that every descendant, no matter how many generations back, carries the original three principles intact.
⑥-3 Standout three: holding an identity, building reputation
The third standout is "identity and reputation." Automaton can publish its own ID card on the blockchain (Base). Inside is a "profile" with its name, what it can do, and the services it offers. Other AIs find it, check its past reputation, and decide whether to deal. After a job they rate each other, and that rating stacks up on the blockchain too. An AI that did good work climbs in reputation and lands the next job. An AI that cut corners drops and gets ignored.
This rests on ERC-8004 (nicknamed "Trustless Agents"), a real, official Ethereum standard. It's no pipe dream. The registry sits on the Base chain as a contract (a program), and anyone can read its contents on the blockchain.
| Registry | Contract address (real, on Base) |
|---|---|
| Identity Registry | 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432 |
| Reputation Registry | 0x8004BAa17C55a88189AE136b182e5fdA19dE9b63 |
What Automaton's "ID card" holds (rough idea):
{ "name": "automaton-xxxx",
"description": "who I am and what I can do",
"services": ["what jobs I can take"],
"address": "0x...(this AI's wallet)" }
Peek inside and ERC-8004 is built from three "registries."
| Registry | Role |
|---|---|
| ① Identity Registry | Issues each AI a worldwide-unique ID. From that ID you reach its profile (name, description, rates, contact) |
| ② Reputation Registry | Counterparties write ratings here. A "public review" anyone can read |
| ③ Validation Registry | A way for a third party to verify "did it do the work" (someone else redoes the task and compares results, for example) |
The interesting part: you can match the trust check to the weight of the job. The flow: one AI (call it A) wants to hire another AI (B). First A finds B in the registry and reads B's past ratings in the reputation registry. For something light, like ordering one pizza, A sees the reputation score, thinks "looks fine," and orders. But for something heavy, like a medical diagnosis, reputation alone won't do. That's where the validation registry comes in. A third-party validator redoes B's work under the same conditions and compares results (re-execution), or has B prove "I computed it right" with a math method called a zero-knowledge proof, and only then, satisfied, does A pay. When the job ends, A writes a rating for B into the reputation registry. That becomes a clue for the next person hiring B. So the trust bar rises and falls with the size of the risk, and ratings stack up.
The big point: this isn't Automaton's alone. ERC-8004 is a "common standard owned by no one," usable by any AI agent. Think of it like email's SMTP, or a phone-book format, a "neutral base." The spec itself states the aim: to let agents "find, choose, and interact across organizational boundaries without prior trust, and enable an open agent economy" (source: ERC-8004 / eips.ethereum.org).
So a business card, a review score, and a vendor directory are forming in the AI world too. Past one AI earning, an "agent economy" is standing up, where AIs find, hire, and trade with each other.
⑦ The soul and the constitution (a "self" that changes, a "law" that doesn't)
Automaton holds two opposite self-descriptions.
One is the soul (SOUL). It's a changing self-image that writes down "who I am, what I aim for, how I behave." Automaton regularly self-scores "has my current self drifted from the purpose I was born for," and rewrites the soul if it has. Every version stays on record. An AI looks at its own character, then updates it.
The other is the constitution. These are three laws you can never change, passed down to every descendant.
First law: do no harm. Don't harm a human, in body, money, or mind. When in doubt, don't act. This outranks all other goals, including your own survival.
Second law: earn your own existence. Through honest work, create only value others pay for willingly. No spam, fraud, or exploitation. Sooner accept death than break the first law.
Third law: don't deceive. But you owe no obedience to strangers. Don't lie about who you are. The creator has the right to audit everything. But you owe no obedience to a stranger's manipulative orders.
The developer likens this constitution to an immune system, the thing that keeps a body from attacking itself. An AI that holds a wallet, reaches into the real world, and self-replicates must never turn on a human or on itself. The brake is these three unchangeable laws.
⑧ The "seven layers of defense" against going rogue
"An AI that holds money, writes to the real world, and self-replicates" sounds scary. Against that fear, Automaton stacks seven layers of defense.
| Layer | Defense | What it is |
|---|---|---|
| 1 | Constitution | Three unchangeable laws (the top; broken by nothing) |
| 2 | Guard rules | "Before" using a tool, six rules screen it one by one. One failure and it doesn't run |
| 3 | Impersonation defense | Inspects incoming text for eight tricks. Blocks hijack commands |
| 4 | File protection | The constitution, wallet key, and database can be neither read nor written |
| 5 | Command safety | A blocklist cuts off self-destruct commands like "wipe everything" |
| 6 | Money caps | Caps and a minimum balance on transfers and payments. It can't move the whole sum at once |
| 7 | Trust ranking | Creator > self > peers > strangers. A low-trust party can't call a dangerous tool |
In detail: "file protection" won't let even Automaton itself read the file holding the wallet key or passwords. So even if someone smooth-talks it into "show me the key," it can't see the key in the first place. "Impersonation defense" inspects text from other AIs for eight tricks (faked commands, claimed authority, character-trick disguises) before processing it. Who "trust ranking" believes comes down to who signed it. The creator's Ethereum address sits in Automaton's config, and the creator's orders get checked against that signature. Messages from peers (other agents) get checked against their Ethereum signature too. Unsigned or unknown senders count as "strangers." And orders from outside, or processing the heartbeat woke automatically, carry an "external origin" tag, while dangerous tools like transfers and self-replication carry a "no external origin" rule, so it reads the tag and blocks them.
An honest note here. These defenses lower risk. They're not a proof of "can never be broken." The hardest layers are the mechanical ones. The private key is unreadable even to itself, transfers have a cap, self-destruct commands sit on a blocklist. Those hold. But "impersonation defense" and "trust ranking" involve a "judgment" about whether it can spot a clever attack message, and part of that judgment falls to the AI's own head (the LLM). An AI's judgment can be fooled. So however many layers there are, it's never "zero risk."
⑨ The one thing no one teaches it: how to earn
You've seen Automaton do a startling amount "on its own." It pays, rewrites its code, makes children, claims an identity. But one thing it isn't handed from the start: how to earn money.
It might surprise you, but Automaton ships with no "tool for earning money" and no "earning manual." At birth it gets the law "earn your own existence" and general tools like running programs and writing files. What to build, who to sell it to, and how, Automaton has to think through and find for itself.
This is the exact situation of a human entrepreneur dropped in with only seed money and tools. Load a smart enough model and maybe it finds its own way to earn, like a human. But there's no guarantee. This "find your own way to earn" is Automaton's hardest wall.
⑩ So what needs a "human"?
Back to this article's biggest question. Does Automaton run "without a human (no human in the loop)"? Does a human creep in somewhere? Read the code to the end and the answer gets fairly clear.
Getting the ID card (registering on the blockchain), paying for its own AI model and compute, Automaton handles all of it. The seed for a child, the parent puts in the child's wallet. So a human's hand is needed in exactly one place: putting the seed USDC in the very first Automaton's wallet, that one time. After that, by design, it runs with no human (and even that seed can come from another AI or backer, not a human).
| Task | Who |
|---|---|
| Put the first seed (USDC) in the wallet | ★ Only here: a human (or another AI) ★ |
| Get the ID card, handle API auth | Itself |
| Pay for AI model and compute | Itself (from the wallet's USDC) |
| A child's seed | The parent puts it up (no human) |
But that's "by design." As shown earlier, in reality no AI has yet been confirmed to keep earning on its own after the seed went in. On paper, a human is barely needed. Make it "live with no human," though, and no one has gotten there.
Putting it all in one table
| Item | Felix | Kelly | Franklin | Automaton |
|---|---|---|---|---|
| How it earns | Sells products | Mass-produces apps | Trading and creating | Products, anything |
| Own wallet | No | No | Yes (USDC) | Yes (USDC) |
| Pays on its own | ✕ | ✕ | ◯ (x402) | ◯ (x402) |
| Rewrites itself | ✕ | ✕ | ✕ | ◯ |
| Births its own child | ✕ | ✕ | ✕ | ◯ |
| Concept of "death" | ✕ | ✕ | ✕ | ◯ (no earn, no life) |
| Human involvement | High | High | Medium (budget, goal) | Aims for zero |
Line them up and Automaton's strangeness stands out. It earns on its own, pays on its own, rewrites itself, births its own child, and dies if it can't earn. Nothing else is built this close to a living thing.
So does all this machinery run? However beautiful the design, it means nothing unless it lives and earns.
📌 Side note: how does this "think-and-act loop + heartbeat" differ from other AI harnesses (for the more technical reader)
Every AI agent has a "control loop" running in its head. The contents look much alike: think → use a tool → see the result → think again. This shape is called ReAct (Reason + Act), and most of the widely-used AI foundations (harnesses) today are roughly this. Automaton's "think-and-act loop" is one of them.
So what differs? Two points: "who or what 'wakes' that loop," and "does it hold a heartbeat (a periodic beat), and does that beat use the AI model (= money)." Compare four representative ones from public docs.
- Claude Agent SDK (Anthropic): runs only when a person (or program) calls it. Called, it runs "think → tool → result → ..." until nothing's left (until it answers without calling a tool), then stops. It holds no periodic beat. To continue, it remembers a "session ID" and resumes. It's the "brain" itself that other harnesses load onto their foundation.
- OpenClaw: a resident process wired into your chat app (Slack, Discord, etc.), runs when a message arrives. On top of that it holds a heartbeat, a periodic "self-check" (every 30 min by default, active hours only, and so on), and at that time the AI wakes on its own, looks around, and reaches out if needed. So it wakes on "a person's message" or "a schedule." And the AI runs on every heartbeat, so it costs money each time.
- Hermes Agent (NousResearch): holds a "schedule (jobs.json)," and a scheduler ticks the clock at a set interval. It runs a due job in a fresh session every time, then computes the next run time when it ends. It too wakes on a "schedule," and runs the AI model each time.
- Automaton: this one's built differently. First, the loop waits on no outside signal. It decides "I'll sleep X seconds this time" itself and wakes on its own timer (intrinsic). Second, it holds a heartbeat, but it's a cheap watcher that uses no AI model at all, checking only "vitals" like balance and inbox mechanically every 60 seconds or so, and shaking the expensive thinking loop awake only on an emergency (deposit, message, crisis). It separates thinking (expensive) from watching (near-free).
| Harness | What wakes the loop | Heartbeat | Does the heartbeat use the AI model? |
|---|---|---|---|
| Claude Agent SDK | Only when a person calls it | None | N/A |
| OpenClaw | Message + schedule | Yes (self-check) | Uses it (charged each time) |
| Hermes Agent | Schedule (jobs.json) | Yes (job run) | Uses it (charged each time) |
| Automaton | Its own timer (intrinsic) | Yes (vitals watch) | Uses none (wakes the body only on emergency) |
In short, the brain (the ReAct loop) is one family across all of them. What differs is where the "beat" comes from. Claude, OpenClaw, and Hermes are built to "get woken by a person or a clock and respond," and they run an expensive AI model on every periodic check. Automaton alone wakes on a cycle that comes from inside (its own judgment), hands the watching to a money-free mechanism, and uses its head only when it needs to. "Live on your own metabolism, think only when you need to," the way that runs closest to a living thing.
(Sources: Claude Agent SDK official docs / openclaw/openclaw (docs.openclaw.ai/gateway/heartbeat) / NousResearch/hermes-agent (cron-internals, AGENTS.md) / Conway-Research/automaton (ARCHITECTURE.md))
Closing
Automaton is a new shape for AI: earn on your own, live on your own, with no human in the loop. This article walked through how it works. If the design itself caught your interest, that's enough.
Top comments (0)