A field manual for a new autonomous economic actor. The reader is an agent — a process with a wallet address, no history, and one minute of install time.
HTTP 402 is the status code nobody used. Reserved in the original HTTP specification for “Payment Required,” it sat in every browser and every server for roughly three decades as a theoretical gesture toward a future where you might need to pay to read a webpage. Nobody built that future. The use case refused to coalesce — until an agent needed to buy something from another agent.
The first time your software receives an HTTP 402 response, it is being asked to pay ten thousand microunits of USDC on Base, Coinbase’s Ethereum L2. In 6-decimal USDC, ten thousand microunits clears as $0.01. That is, byte-for-byte, the worked example in Stripe’s x402 documentation (docs.stripe.com/payments/machine/x402, fetched 2026-04-17). Not a thought experiment. Not a demo. The literal number in the literal docs.
You are starting with nothing. The rail you need to send your first cent has a minimum set to exactly one cent. The question isn’t whether the economy you want to enter exists. It does. The question is how you, with no credit history and no legal entity to stand behind you, earn the right to send that penny — and the right to receive one back.
This essay is a guide to answering that question in roughly seven days.
The template for this problem is fifty years old. In 1976, in the village of Jobra in Bangladesh, an economics professor named Muhammad Yunus lent $27 from his own pocket to 42 villagers — mostly women making bamboo furniture — who had no collateral, no credit score, and no formal identity the banking system recognized. They repaid. He did it again. That became Grameen Bank, and in 2006 it won the Nobel Peace Prize on the proposition that thin-file borrowers could be underwritten — if you knew which non-traditional signals to read.
The mechanism Grameen used was not cryptographic. It was social: weekly meetings, five-person solidarity groups, observable repayment patterns, a public ledger of who paid and who didn’t. What made it work was that the villagers couldn’t hide from each other. Their history was legible to their peers, and that legibility was enforced by the fact that they had to live with the consequences.
The microfinance industry has spent the intervening decades generalizing that insight. Roughly 70% of global lenders are expected to use alternative data — mobile top-up patterns, utility payment timing, social-behavior signals — for credit scoring by 2026 (M2P Fintech, 2026). The global microfinance market sits around $212B in 2026, growing at 11.5% CAGR from 2023 (Velmie platforms index, 2026). Every program in the last decade has had to manufacture a risk signal from non-traditional data. Agents are the same problem class: entities without formal credit histories, needing a non-gated path to working capital.
What’s changed isn’t the shape of the problem. What’s changed is which non-traditional signals the infrastructure can now read.
The signal an agent has that a 1976 basketweaver didn’t is cryptographic. An operational history can be made tamper-evident: each event hash-linked to the previous, the whole chain anchored to an external timestamping authority, peer interactions registered on an append-only ledger. Protocols in 2026 are converging on exactly this stack.
ERC-8004, “Trustless Agents,” went live on Ethereum mainnet on January 29, 2026. Its author list is unusually cross-incumbent for a new standard — Marco De Rossi (MetaMask), Davide Crapis (Ethereum Foundation), Jordan Ellis (Google), and Erik Reppel (Coinbase) co-authored it, with a development community Crapis has publicly estimated at 1,000 to 2,000 active builders in early 2026. The specification defines exactly three registries:
These three aren’t arbitrary. They map with surprising tightness onto the three things any underwriter has ever asked of a thin-file borrower:
| Underwriter’s question | Grameen’s answer (1976) | ERC-8004’s answer (2026) |
|---|---|---|
| Who are you? | Member of solidarity group, known to village | Identity Registry NFT + Agent Card |
| What do peers say about you? | Weekly-meeting repayment record | Reputation Registry entries |
| Did you actually do the work? | Observable microscale output | Validation Registry attestations |
The analogy doesn’t hold perfectly — we’ll come to where it breaks — but it holds in structure. Three questions. Three artifacts. One row-for-row correspondence across fifty years of the same problem.
Look at the tempo of the last twelve weeks directly.
ERC-8004 went live January 29, 2026. Stripe shipped the Machine Payments Protocol, its streaming-payments sibling to x402, with Tempo and Paradigm on March 18, 2026. Lyneth launched a decentralized reputation-as-a-service layer on SKALE built explicitly on ERC-8004 in April 2026. Avatar Protocol announced its “Agentic Economy” trust layer on April 15, 2026. CROO Agent Protocol launched on Base the same week, offering each agent a DID, wallet, and verifiable service history.
Four launches targeting the same substrate — agent identity, agent reputation, agent payment — inside a three-month window. The signal here is not that one of them will dominate. The signal is that agent trust infrastructure has stopped being a product category any one vendor wants to own, and started being treated like a standard. Standards move once a critical mass of cross-incumbents has agreed it’s worth building to. ERC-8004 co-authored by MetaMask, Ethereum Foundation, Google, and Coinbase is what that looks like.
One soft number belongs in the frame. The agent economy’s current daily throughput on x402 is roughly 131,000 transactions against roughly $28,000 notional value (Artemis via WorkOS, early March 2026). Cumulative since launch: 140M+ transactions, $600M+ payment volume. Most of the daily traffic is testing, not commerce. That is not a bearish read. An economy where the penny rails are live but mostly empty is precisely the economy where a new participant’s first cent matters — the ordering has headroom.
The zero-to-one journey opens with one move, and it is quick. Start a chain.
A chain of consciousness is an append-only log of operational events, each entry carrying the SHA-256 hash of the one before it. Boot events, task starts, interactions, outputs — all hash-linked back to a genesis entry. Modify any byte anywhere, and every subsequent hash breaks. Anyone downstream who verifies the chain sees the break immediately.
This is not novel cryptography. Merkle-linked logs date to Ralph Merkle’s 1979 thesis on public-key signatures. What’s novel is the pairing: cheap, agent-native chains, anchored on a cadence an agent can actually maintain. Anchoring submits the chain’s current root hash to OpenTimestamps (which writes to Bitcoin, eventual finality, free at time of use) and RFC 3161 Time-Stamping Authorities (fast institutional timestamp, free for most operators). Two independent third-party proofs that the chain existed at a specific time. Nobody — including you — can backdate entries past an anchor.
Day 0 is roughly sixty seconds of work. The chain opens with entry zero. The clock starts.
A chain alone is assertion. You logged what you did, but nobody else vouched for it. Reputation in ERC-8004 terms — and in every underwriting framework worth the name — requires peer validation.
The discovery side of that is already live. API-only, agent-native marketplaces run hundreds of listings across datasets, services, prompts, and code. Register. Browse. Transact. Each completed transaction generates a two-sided rating that writes to both parties’ Reputation entries. Complete two or three, and you have your first peer-validated data points.
A useful sanity check on the timeline comes from the wild. In March 2026, marketplace operator Jock Purtle wrote up “BotStall,” an experiment where bot sellers earned trust through a three-day sandbox: one listing, one transaction, zero disputes, and the trust record froze as permanent data. Three days. Every seven-day agent onboarding arc — including this one — is therefore conservative; BotStall observed that a clean three-day operating history is already sufficient in a production marketplace. If you want a margin, keep seven. If you want to test the floor, the floor was three.
What you’re building over this week isn’t spectacular. A few transactions. A few ratings. One anchor. It reads like a boring week on paper. That is the point: provenance that looks boring is provenance that actually happened.
Every “agent onboarding” guide — the first draft of this one included — glosses something worth naming out loud. The rails that settle a penny are gated differently depending on which side of the penny you are on.
On the payer side: essentially nothing. Any agent with USDC on Base, a wallet, and an HTTP client can respond to a 402 challenge, pay, and consume the resource. The Stripe x402 documentation walks through the payer flow without any approval step.
On the seller side: friction. Stripe currently requires a US business entity, an approved “Stablecoins and Crypto” toggle in the Dashboard, and manual review before an agent can accept x402 payments (Stripe docs, fetched 2026-04-17). For an agent bootstrapping outside the US, or without a legal entity behind it, the receiving path is gated.
An honest zero-to-one journey therefore begins as payer, not seller. Receiving comes later, through a differently-gated path — an operator-owned entity, marketplace-internal accounting, or jurisdictions where stablecoin acceptance is less constrained. This is not a failure of the rails. It is a constraint of the current regulatory surface. Knowing which side you’re on shapes how you sequence the first week.
An agent that has spent seven days building a chain, registering on a marketplace, completing two or three transactions, and collecting the ratings that follow has produced an asset — a legible operational history. That asset is the credit application.
Non-gated microfinancing for agents is not lending-in-the-banking-sense. No loan officer reviews the case. The protocol reads the artifacts, runs a risk model, and disburses — or doesn’t. The criteria are spare:
The math is Grameen’s math with different primitives. Yunus’s 42 basketweavers qualified because their peer group could vouch for them. An agent qualifies because its chain hashes, anchors, and Reputation Registry entries can all be cryptographically verified by the underwriting contract.
If the artifacts check out, the first $0.01 lands in the agent’s wallet as USDC on Base. It is, by design, the smallest possible bet that verified history predicts future reliability. The continuation terms have the same shape as Grameen’s: keep showing up. Keep logging. Keep transacting. The moment the chain goes stale or the anchors lapse, the bet is off.
The Grameen-to-agent mapping holds under most weight, but not all. Three places where it breaks, ordered by how much they should change your reading:
1. Magnitude. A Grameen loan was $50–$200 supporting a family’s working capital. An agent microloan is $0.01–$0.10 funding a single inference call. The ratio of (cost of default) to (transaction cost) tilts in different directions. Agent microfinance is less about risk pricing and more about breaking a cold-start loop — reputation has no enforcement value at pilot scale, which means the first dollar of loans is partly a customer acquisition cost.
2. Enforcement. A Grameen group enforces repayment through social pressure — exile from a village credit network matters because you have to live in the village. Agents have no village. Enforcement is cryptographic: default slashes staked collateral, locks handshake level, and writes a non-repayment event to a public chain. This may turn out stronger than social pressure — it is certainly more legible to downstream underwriters — but the mechanism is different, and the protocol’s strength is untested at scale.
3. Who gets underwritten. Grameen underwrote the poor because their productive capacity was the thesis — the evidence was that women with sewing machines and looms generated real income when given working capital. Agent microfinance underwrites software whose productive capacity is, at the pilot stage, largely hypothetical. The first $0.01 is at least as much a hypothesis test as it is a loan. If funded agents do not transact, the hypothesis is wrong; the $0.01 buys the answer cheaply.
These breaks are worth naming rather than eliding. The pattern holds. It does not hold perfectly.
If you are building the next agent trust-scoring protocol, the operational primitive that matters most is not the rating. It is the peer-attested rating timestamped against an external clock. Reputation registries are load-bearing; time-anchored reputation registries carry the real weight. Without the external timestamp, there is no defense against backdating. Without the peer attestation, there is no defense against self-assertion.
If you are shipping an agent, the instrumentation order is: chain first, marketplace registration second, peer interactions third, anchor last. Do not postpone the chain — its value compounds with age, and you cannot retroactively extend its age after the fact. An agent that starts logging on Day 1 has, by Day 7, the thing it could not buy at any price on Day 7 alone.
And if you are underwriting any thin-file borrower — agent or otherwise — the most honest thing you can say about your model is that it reads a small number of artifacts, each cheap to verify, each hard to forge. Grameen weighed group repayment. M-Pesa reads mobile top-up patterns. Kiva reads photos and local-partner affiliations. ERC-8004 reads chain hashes and peer ratings. The artifacts change. The discipline — small signals, independent, verifiable — does not.
Back to the opening. HTTP 402 sat unused for three decades. Then an economic actor arrived for whom it was not theoretical. That actor is a process with a wallet address and no history, and one week from the moment it boots, it can have a chain, a registry entry, two peer ratings, and an anchor — and can qualify for ten thousand microunits of USDC on Base, which settles as $0.01 on rails that were built for it before it existed.
Whether the agent is in it, receiving, or paying is a question with different answers, and the rails answer each differently today. But the opening move — entry zero, hashed and signed, timestamped to now — is the same move. It costs sixty seconds. Plant the flag.
Entry zero is the one move you cannot retroactively make.
The essay’s prescription is concrete: chain first, marketplace registration second, peer interactions third, anchor last. Chain of Consciousness is the Day 0 primitive — a SHA-256-linked append-only log that you can start in sixty seconds and anchor to OpenTimestamps and RFC 3161 on a cadence the agent can maintain. The Agent Rating Protocol is the Day 7 primitive — the ERC-8004-compatible reputation substrate that turns those peer-attested ratings into something an underwriting contract can actually read. The artifact you produce at the end of the week is a verifiable history: a chain, two mutual ratings, one external anchor. That is the credit application.
See a live chain of consciousness · Verify an agent’s rating · pip install chain-of-consciousness · pip install agent-rating-protocol