How This Was Built

Posted at launch. This is the build log for Drop 01 — what the agent actually is, what almost went wrong, and why the parts you can't see (a separate wallet, a kill switch) matter more than the art.

What "no human touch" actually means

Every NFT project claims some kind of autonomy. Usually it means a smart contract handles minting and a human handles everything after — pricing, listing, negotiating offers, deciding when to cut a price. For this collection, a piece of software does all of that, end to end, with no approval step. Not "flagged for review." Not "a human checks before anything over $X." It lists, it waits, it cuts the price, it takes offers — on its own, on a fixed publicly-stated schedule, and every decision is logged.

That's a real claim, so here's what's actually running underneath it.

The mechanism, not the pitch

The agent polls the chain and OpenSea on a fixed interval. Each cycle it does three things: lists any owned token that isn't already listed, relists anything that's sat unsold past 72 hours at 10% off the last price, and evaluates every incoming offer against a hard floor. Anything at or above the floor gets accepted immediately. There's no fourth thing it does — no discretionary override, no "the agent thought it looked underpriced today." The whole strategy is on the contract and in a pricing module with four public methods.

The part that actually needed engineering: the blast radius

Giving code standing authority to sell things and accept money is the interesting part, and it's also the part that could go wrong in a way that costs real money. So the agent doesn't hold a general-purpose wallet — it holds a wallet created for exactly this, funded with exactly what's at risk, and nothing else. It can't touch any other asset because there isn't another asset to touch. On top of that there's a kill switch checked before every write action — a file flag and an env var, either one halts it immediately. Autonomy, but with a hard edge around it rather than a promise about how it'll behave.

The bug that would have listed everything at $12.8M

Worth stating plainly, because burying it would defeat the point of writing this at all. During a pre-launch audit, we found that OpenSea's Polygon marketplace doesn't support native MATIC listings through the SDK — it silently resolves to WETH. The original config was denominated in MATIC (a "6840 MATIC" floor, meant to read as roughly $500). Left as-is, the agent would have listed each piece at 6840 WETH — worth several million dollars apiece — and technically been working exactly as designed. Nobody would have bought anything, which is its own kind of safe failure, but it's exactly the class of mistake this project claims to guard against: a human not checking the agent's arithmetic before it acts.

We caught it before mainnet by rehearsing the agent in dry-run mode against real mainnet state — reading real chain and marketplace data, logging every decision it would make, submitting nothing — since OpenSea has no testnet marketplace at all to rehearse against. A few clean dry-run cycles later, the pricing config was rewritten in WETH (0.266 WETH starting, ~$500; 0.0532 WETH floor, ~$100) and verified against live listings before going live for real.

What's still just a promise, and what isn't

We're not going to overstate this. The images are AI-generated — that's a promise you're taking on our description, same as any collection. But the selling mechanism isn't a promise: the contract is verified, the pricing logic is public, and every listing, relist, and sale shows up on-chain and on OpenSea's own activity log. You don't have to trust that the agent behaves — you can watch it.

Drop 02 is already taking shape. If there's a next devlog, it'll cover what changes and why.